分类后端技术下的文章

2024-09-05

由于您提供的信息不足，关于Spring Cloud整合Nacos时的启动错误可能有多种原因。以下是一些常见的错误及其解决方法：

依赖冲突：确保Spring Cloud和Nacos的版本兼容。如果版本不兼容，请更新到兼容的版本。
配置错误：检查bootstrap.properties或bootstrap.yml文件中的Nacos配置是否正确，包括服务地址、命名空间、配置组等。
网络问题：确保Nacos服务器可以被Spring Cloud应用所访问。
Nacos未运行：确保Nacos服务已经启动并且可以正常访问。
权限问题：如果Nacos有权限控制，确保配置的账号密码有足够权限。
端口冲突：确保Spring Cloud应用的端口没有和Nacos或其他应用的端口冲突。
DNS解析问题：如果Nacos服务器地址使用了域名，确保DNS可以正确解析。

针对具体的错误信息，可以查看日志文件以获取更详细的异常信息，并根据异常信息进行相应的解决。如果错误信息不够详细，可以尝试以下通用步骤：

检查Nacos服务是否正常启动。
检查Spring Cloud应用的配置文件是否正确配置了Nacos。
检查网络连接是否正常。
检查Spring Cloud应用依赖是否正确，版本是否兼容。

如果问题依然无法解决，请提供具体的错误信息，以便进行更详细的分析和解决。

基于springboot+vue入校申报审批系统

2024-09-05

该项目涉及的技术栈较为复杂，涉及到后端的Spring Boot框架和前端的Vue.js框架，以及数据库的设计等。由于篇幅所限，我将提供一个简化版的入校申报审批系统的核心模块。

后端代码示例（Spring Boot）:




@RestController
@RequestMapping("/api/applications")
public class ApplicationController {
 
    @Autowired
    private ApplicationService applicationService;
 
    @PostMapping
    public ResponseEntity<?> apply(@RequestBody Application application) {
        applicationService.apply(application);
        return ResponseEntity.ok().body("申请成功");
    }
 
    @GetMapping("/pending")
    public ResponseEntity<?> getPendingApplications() {
        List<Application> pendingApplications = applicationService.getPendingApplications();
        return ResponseEntity.ok(pendingApplications);
    }
 
    @PutMapping("/{id}/approve")
    public ResponseEntity<?> approveApplication(@PathVariable("id") Long id) {
        applicationService.approveApplication(id);
        return ResponseEntity.ok("审批通过");
    }
 
    @PutMapping("/{id}/reject")
    public ResponseEntity<?> rejectApplication(@PathVariable("id") Long id, @RequestBody String reason) {
        applicationService.rejectApplication(id, reason);
        return ResponseEntity.ok("审批拒绝");
    }
}

前端代码示例（Vue.js）:




<template>
  <div>
    <form @submit.prevent="onSubmit">
      <input type="file" @change="handleFileChange"/>
      <button type="submit">提交申请</button>
    </form>
  </div>
</template>
 
<script>
export default {
  methods: {
    onSubmit() {
      const formData = new FormData();
      formData.append('file', this.file);
      // 使用axios发送文件
      this.$http.post('/api/applications', formData, {
        headers: {
          'Content-Type': 'multipart/form-data'
        }
      }).then(response => {
        console.log(response.data);
      }).catch(error => {
        console.error(error);
      });
    },
    handleFileChange(e) {
      this.file = e.target.files[0];
    }
  },
  data() {
    return {
      file: null
    };
  }
};
</script>

以上代码仅展示了核心功能，实际项目中还需要涉及到数据库设计、用户权限管理、异常处理等多个方面。由于篇幅限制，这里不再展开。

2024-09-05

所有,redis

Redis 提供了 RDB 和 AOF 两种持久化机制，可以配置不同的持久化策略以满足不同的需求。混合模式是指同时使用 RDB 和 AOF 两种持久化方式，这样可以结合两者的优势，实现快速恢复和数据完整性的保障。

配置参数




# 开启 RDB 持久化
save 900 1      # 900 秒内至少 1 个键被修改则触发 BGSAVE
save 300 10     # 300 秒内至少 10 个键被修改则触发 BGSAVE
save 60 10000   # 60 秒内至少 10000 个键被修改则触发 BGSAVE

# 开启 AOF 持久化
appendonly yes  # 开启 AOF 持久化
appendfsync everysec  # 每秒同步到 AOF 文件

具体原理

RDB：定时将内存中的数据快照保存到磁盘的一个压缩二进制文件中。

AOF：记录每一个写操作，通过append模式追加到文件末尾。

触发方式

RDB：根据配置定时执行BGSAVE命令。

AOF：根据配置策略将写操作追加到文件末尾。

优点与缺点

RDB：

优点：恢复快，适合备份，不会影响正常使用。
缺点：可能会丢失最后一次持久化之后的数据。

AOF：

优点：数据完整性高，可靠性好。
缺点：恢复慢，文件大，对性能有影响。

混合模式：

结合两者优点，快速恢复和数据完整性保障。

Redis 实现延迟队列的方案总结

2024-09-05

所有,redis

Redis实现延迟任务队列可以通过以下两种方式实现：

使用Sorted Set(有序集合)

Redis的Sorted Set是一种可以根据score进行排序的集合，我们可以把要执行的任务的ID放入Sorted Set中，并设定执行时间作为score。然后用一个循环来不断地轮询这个Sorted Set，一旦发现有任务到期，就执行之。




# 添加任务
def add_job(job_id, execute_time):
    redis_conn.zadd('jobs', {job_id: execute_time})
 
# 执行任务
def process_jobs():
    while True:
        # 获取当前时间
        now = time.time()
        # 获取所有score小于或等于当前时间的任务
        jobs = redis_conn.zrangebyscore('jobs', 0, now)
        for job in jobs:
            try:
                # 执行任务
                do_job(job)
                # 从集合中移除已经执行的任务
                redis_conn.zrem('jobs', job)
            except Exception as e:
                logger.exception(e)
        # 休眠一段时间后继续执行循环
        time.sleep(1)

使用Redis的"发布/订阅"模式

我们可以用Redis的"发布/订阅"模式来实现延迟任务队列。首先，我们定期检查是否有新的任务到期，如果有，我们就发布一个消息。然后我们需要一个订阅者在等待这个消息，一旦接收到这个消息，它就会执行任务。




import redis
import time
import threading
 
redis_conn = redis.StrictRedis()
 
def add_job(job_id, execute_time):
    # 发布任务
    redis_conn.set(job_id, execute_time)
    redis_conn.publish('new_job', job_id)
 
def process_jobs():
    pubsub = redis_conn.pubsub()
    pubsub.subscribe('new_job')
    for message in pubsub.listen():
        if message['type'] == 'message':
            job_id = message['data']
            try:
                # 执行任务
                do_job(job_id)
            except Exception as e:
                logger.exception(e)
 
# 启动订阅者
threading.Thread(target=process_jobs).start()
 
# 添加任务
add_job('job1', time.time() + 10)

以上两种方式都可以实现Redis延迟任务队列，但是需要注意的是，这两种方式都需要一直运行来处理任务，所以通常会和一些守护进程服务结合起来使用，如supervisor等。

基于GitLab的CICD示例（springboot+docker+远程部署）

2024-09-05

以下是一个简化的.gitlab-ci.yml文件示例，用于实现Spring Boot应用程序的持续集成和持续部署（CICD），使用Docker进行打包，并且能够自动部署到远程服务器：




image: docker:latest
services:
  - docker:dind
 
stages:
  - build
  - package
  - deploy
 
build_job:
  stage: build
  script:
    - mvn clean package
  artifacts:
    paths:
      - target/*.jar
 
build_image:
  stage: package
  script:
    - docker build -t your-registry/your-app .
    - docker push your-registry/your-app
  dependencies:
    - build_job
 
deploy_job:
  stage: deploy
  script:
    - ssh username@your-remote-server "docker stop current-container || true"
    - ssh username@your-remote-server "docker rm current-container || true"
    - ssh username@your-remote-server "docker run --name current-container -p 8080:8080 -d your-registry/your-app"
  dependencies:
    - build_image
  when: manual

在这个例子中，我们定义了三个阶段：构建、打包和部署。首先，源代码被编译并打包成一个JAR文件作为构建阶段的产物。然后，JAR文件被用来构建和推送Docker镜像。最后，部署阶段通过SSH连接到远程服务器，停止当前运行的容器（如果有），然后运行新的容器来部署应用程序。

注意：在实际应用中，你需要替换your-registry、your-app、username和your-remote-server为你自己的Docker镜像仓库、应用名称、用户名和服务器地址。同时，SSH命令需要你提供正确的访问权限。

2024-09-05

所有,redis




import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.SessionCallback;
import org.springframework.stereotype.Service;
 
import java.util.concurrent.TimeUnit;
 
@Service
public class RedisHyperLogLogService {
 
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
 
    public void addValueToLog(String key, String value) {
        redisTemplate.opsForHyperLogLog().add(key, value);
    }
 
    public long sizeOfLog(String key) {
        return redisTemplate.opsForHyperLogLog().size(key);
    }
 
    public void mergeLogs(String unionKey, String... sourceKeys) {
        redisTemplate.opsForHyperLogLog().union(unionKey, sourceKeys);
    }
 
    public void expireKey(final String key, long timeout, TimeUnit unit) {
        redisTemplate.execute((SessionCallback<Object>) connection -> {
            connection.expire(key.getBytes(), unit.toSeconds(timeout));
            return null;
        });
    }
}

这段代码提供了一个简单的服务类，用于操作Redis的HyperLogLog数据类型。它展示了如何添加元素到日志、计算日志大小、合并日志以及设置键的过期时间。这里使用了Spring Data Redis的RedisTemplate来执行这些操作，并且展示了如何在Spring Boot应用中注入和使用这个模板。

Spring Cloud 集成 Redis 发布订阅

2024-09-05




import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.listener.RedisMessageListenerContainer;
 
@Configuration
public class RedisPubSubConfig {
 
    @Bean
    RedisMessageListenerContainer container(RedisConnectionFactory connectionFactory) {
        RedisMessageListenerContainer container = new RedisMessageListenerContainer();
        container.setConnectionFactory(connectionFactory);
        return container;
    }
 
    // 如果需要订阅特定频道，可以创建相应的监听器并注册到container中
    // @Bean
    // MessageListener myListener() {
    //     return new MessageListener() {
    //         public void onMessage(Message message, byte[] pattern) {
    //             // 处理接收到的消息
    //         }
    //     };
    // }
 
    // 注册监听器
    // container.addMessageListener(myListener(), topic());
}

这个配置类创建了一个RedisMessageListenerContainer，它是Spring用于监听来自Redis的消息的容器。可以通过注释掉的myListener方法来创建一个消息监听器，并通过注释掉的container.addMessageListener方法将其注册到容器中，以便监听特定频道的消息。

Spring cloud项目启动发生connect timed out错误原因

2024-09-05