1. 首页
  2. 分类
  3. java
springboot集成websocket持久连接（权限过滤+拦截）
System
2024-09-05
所有,java



import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.Message;
import org.springframework.messaging.MessageChannel;
import org.springframework.messaging.simp.config.ChannelRegistration;
import org.springframework.messaging.simp.config.MessageBrokerRegistry;
import org.springframework.messaging.simp.stomp.StompCommand;
import org.springframework.messaging.simp.stomp.StompHeaderAccessor;
import org.springframework.messaging.support.ChannelInterceptor;
import org.springframework.messaging.support.MessageHeaderAccessor;
import org.springframework.security.core.Authentication;
import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker;
import org.springframework.web.socket.config.annotation.StompEndpointRegistry;
import org.springframework.web.socket.config.annotation.WebSocketMessageBrokerConfigurer;
 
@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {
 
    @Override
    public void configureMessageBroker(MessageBrokerRegistry config) {
        config.enableStompBrokerRelay("/topic")
              .setRelayHost("localhost")
              .setRelayPort(61613)
              .setClientLogin("guest")
              .setClientPasscode("guest");
        config.setApplicationDestinationPrefixes("/app");
        config.setUserDestinationPrefix("/user");
    }
 
    @Override
    public void registerStompEndpoints(StompEndpointRegistry registry) {
        registry.addEndpoint("/ws").withSockJS();
    }
 
    @Override
    public void configureClientInboundChannel(ChannelRegistration registration) {
        registration.interceptors(new ChannelInterceptor() {
            @Override
            public Message<?> preSend(Message<?> message, MessageChannel channel) {
                StompHeaderAccessor accessor = MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class);
                if (StompComm
- 阅读更多 -
【Spring Boot 5】Spring Boot Jpa 的使用
System
2024-09-05
所有,java



import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
 
// 定义一个用户实体类
@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    // 省略其他字段、构造函数、getter和setter方法
}
 
// 定义一个UserRepository接口继承JpaRepository
public interface UserRepository extends JpaRepository<User, Long> {
    // 这里可以定义一些自定义查询方法，Spring Data JPA会自动生成实现
    List<User> findByName(String name);
}
 
// 使用UserRepository
@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;
 
    public List<User> getUsersByName(String name) {
        return userRepository.findByName(name);
    }
}

这个代码示例展示了如何在Spring Boot项目中使用Spring Data JPA。首先定义了一个实体类User，并使用了JPA注解来映射数据库表。然后定义了一个继承自JpaRepository的UserRepository接口，以便自动提供基本的CRUD操作。最后，在UserService中注入UserRepository，并使用其提供的方法来查询用户。这个例子演示了Spring Data JPA的基本用法，是进一步学习Spring Boot Jpa的一个很好的起点。

- 阅读更多 -
Spring Cloud Alibaba微服务实战三十三 - 实现网关的灰度发布
System
2024-09-05
所有,java

在Spring Cloud Alibaba微服务实战中，要实现网关的灰度发布，可以通过定义不同版本的路由规则来实现。以下是一个简化的示例代码：




@Configuration
public class GatewayConfiguration {
 
    @Bean
    public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
        // 灰度发布版本
        String grayVersion = "v2";
 
        return builder.routes()
                .route("service-provider", r -> r.host("*.provider.com")
                        .and().header("version", grayVersion)
                        .uri("lb://SERVICE-PROVIDER")
                        .id("service-provider-gray")
                )
                .route("service-provider-normal", r -> r.host("*.provider.com")
                        .and().header("version", "!^" + grayVersion + "$")
                        .uri("lb://SERVICE-PROVIDER")
                        .id("service-provider-normal")
                )
                .build();
    }
}

在这个配置中，我们定义了两条路由规则：service-provider-gray 和 service-provider-normal。service-provider-gray 规则将匹配带有自定义头 version: v2 的请求，并将这些请求路由到服务提供者的灰度版本。service-provider-normal 规则将匹配不满足 service-provider-gray 规则的其他请求，并将它们路由到服务提供者的常规版本。

在实际部署中，当你想要发布服务提供者的灰度版本时，你只需要在发送到服务提供者的请求中加上自定义的头 version: v2，Gateway就会将请求路由到对应的灰度版本的服务提供者。

- 阅读更多 -
【SpringCloud】这一次终于使用MQ解决了Eureka服务下线延迟感知问题
System
2024-09-05
所有,java



@Component
public class EurekaEventToRabbitMQPublisher {
 
    private static final Logger LOGGER = LoggerFactory.Logger(EurekaEventToRabbitMQPublisher.class);
 
    @Autowired
    private RabbitTemplate rabbitTemplate;
 
    @Autowired
    private ObjectMapper objectMapper;
 
    @Autowired
    private Environment environment;
 
    @Autowired
    private DiscoveryClient discoveryClient;
 
    @RabbitListener(queues = "#{T(com.netflix.appinfo.InstanceInfo).InstanceStatus.DOWN}")
    public void handleInstancesChangeEvent(Message message) {
        try {
            InstanceInfo instanceInfo = objectMapper.readValue(new String((byte[]) message.getPayload()), InstanceInfo.class);
            String serviceId = instanceInfo.getAppName();
            List<ServiceInstance> instances = discoveryClient.getInstances(serviceId);
            if (instances.isEmpty()) {
                rabbitTemplate.convertAndSend(environment.getProperty("spring.rabbitmq.exchange"), 
                                              serviceId, instanceInfo.getAppName());
            }
        } catch (Exception e) {
            LOGGER.error("处理Eureka服务下线事件异常：", e);
        }
    }
}

这段代码示例展示了如何使用RabbitMQ来替代Eureka的服务下线延迟感知问题。通过定义一个RabbitMQ的监听器来处理服务下线事件，并且只有在服务实例列表为空时，才发送一个消息到RabbitMQ交换器。这样就可以避免Eureka服务器的下线延迟问题，实现即时的服务状态感知。

- 阅读更多 -
springboot整合gateway网关
System
2024-09-05
所有,java

Spring Boot整合Spring Cloud Gateway作为API网关，可以提供路由转发、权限校验、负载均衡等功能。以下是一个基本的Spring Boot整合Spring Cloud Gateway的示例：

  1. 在pom.xml中添加依赖：



<dependencies>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-gateway</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-webflux</artifactId>
    </dependency>
</dependencies>
 
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>${spring-cloud.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>
  1. 配置application.yml：



spring:
  cloud:
    gateway:
      routes:
        - id: route_to_service1
          uri: http://localhost:8081
          predicates:
            - Path=/service1/**
        - id: route_to_service2
          uri: http://localhost:8082
          predicates:
            - Path=/service2/**

在这个配置中，我们定义了两条路由规则：

  • 当请求路径以/service1/开头时，转发到http://localhost:8081
  • 当请求路径以/service2/开头时，转发到http://localhost:8082
  1. 启动类：



@SpringBootApplication
public class GatewayApplication {
    public static void main(String[] args) {
        SpringApplication.run(GatewayApplication.class, args);
    }
}

这样就配置了一个基本的Spring Cloud Gateway网关，它会根据配置的路由规则将请求转发到相应的服务。当然，实际应用中可能需要更复杂的路由配置、过滤器链配置等，以实现权限校验、限流控制等功能。

- 阅读更多 -
SpringBoot3整合MyBatisPlus
System
2024-09-05
所有,java

在Spring Boot 3整合MyBatis Plus，你需要做以下几个步骤：

  1. 在pom.xml中添加MyBatis Plus的依赖。
  2. 配置application.properties或application.yml文件中的数据库连接信息。
  3. 创建实体类（Entity）、映射器接口（Mapper）及其XML文件。
  4. 配置MyBatis Plus的配置类，如分页插件等。
  5. 启动类上添加@MapperScan注解，扫描Mapper接口。

以下是一个简单的示例：

pom.xml中添加依赖：




<dependencies>
    <!-- MyBatis Plus Starter -->
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>3.x.x</version>
    </dependency>
    <!-- 数据库驱动，以MySQL为例 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.x.x</version>
    </dependency>
</dependencies>

application.properties配置：




spring.datasource.url=jdbc:mysql://localhost:3306/your_database?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=yourpassword
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

创建实体类：




@Data
@TableName("user") // 指定数据库表名
public class User {
    @TableId(type = IdType.AUTO) // 主键策略
    private Long id;
    private String name;
    private Integer age;
    private String email;
}

创建Mapper接口：




@Mapper
public interface UserMapper extends BaseMapper<User> {
    // 这里可以添加自定义方法，或者使用BaseMapper提供的方法
}

配置MyBatis Plus配置类：




@Configuration
public class MyBatisPlusConfig {
    @Bean
    public PaginationInterceptor paginationInterceptor() {
        return new PaginationInterceptor();
    }
}

启动类：




@SpringBootApplication
@MapperScan("com.yourpackage.mapper") // 指定Mapper接口所在包路径
public class YourApplication {
    public static void main(String[] args) {
        SpringApplication.run(YourApplication.class, args);
    }
}

以上代码提供了整合MyBatis Plus的基本框架，你可以根据自己的需求添加更多的配置和功能。

- 阅读更多 -
【Spring Boot】网页五子棋项目实现，手把手带你全盘解析（长达两万3千字的干货，坐好了，要发车了......）
System
2024-09-05
所有,java

由于篇幅所限，我无法在这里提供完整的项目解决方案。但我可以提供一个概览和关键点的指导。

一、项目概览

  1. 使用Spring Boot作为后端框架。
  2. 前端使用HTML、CSS、JavaScript以及JQuery等技术。
  3. 使用WebSocket实现双向通信。
  4. 数据库可以使用内嵌的H2数据库，也可以使用MySQL等。

二、后端关键点

  1. 创建Spring Boot项目，并配置Maven或Gradle依赖。
  2. 定义五子棋的数据模型，比如棋盘、玩家等。
  3. 实现业务逻辑，如棋盘的创建、棋子放置、判断胜负等。
  4. 使用WebSocket实现与前端的实时通信。
  5. 提供RESTful API供前端调用。

三、前端关键点

  1. 使用HTML、CSS构建页面布局。
  2. 使用JavaScript（或者React、Vue等）实现游戏逻辑。
  3. 使用WebSocket与后端通信。
  4. 调用后端API完成玩家的下棋等操作。

四、数据库设计

  1. 创建五子棋游戏的数据表，如玩家信息表、棋盘记录表等。
  2. 使用Spring Data JPA或MyBatis等ORM框架操作数据库。

五、部署与运行

  1. 打包Spring Boot应用为可执行的JAR或WAR包。
  2. 部署到服务器，并确保服务器端口正确开放。
  3. 启动应用，确保WebSocket服务正常运行。
  4. 打开浏览器，访问对应的URL进行游戏。

这只是一个概览，实际项目中会涉及到很多细节，比如棋盘的显示、棋子的放置逻辑、胜负判断、用户认证、游戏记录存储等。在具体实现时，还需要考虑性能优化、异常处理、安全性等问题。

- 阅读更多 -
springboot+netty+mqtt客户端实现
System
2024-09-05
所有,java

以下是一个使用Spring Boot、Netty和MQTT协议实现的简单示例，用于创建一个MQTT客户端。

首先，添加依赖到你的pom.xml：




<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>io.netty</groupId>
        <artifactId>netty-all</artifactId>
        <version>4.1.69.Final</version>
    </dependency>
    <dependency>
        <groupId>org.eclipse.paho.client.mqttv3</groupId>
        <artifactId>org.eclipse.paho.client.mqttv3</artifactId>
        <version>1.2.5</version>
    </dependency>
</dependencies>

然后，创建一个简单的MQTT客户端：




import org.eclipse.paho.client.mqttv3.MqttClient;
import org.eclipse.paho.client.mqttv3.MqttConnectOptions;
import org.eclipse.paho.client.mqttv3.MqttException;
import org.eclipse.paho.client.mqttv3.MqttMessage;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
 
@Service
public class MqttClientService {
 
    private MqttClient mqttClient;
 
    @Autowired
    public MqttClientService() throws MqttException {
        // 创建客户端实例
        mqttClient = MqttClient.create("tcp://your-broker-address:1883");
 
        // 设置连接选项
        MqttConnectOptions connOpts = new MqttConnectOptions();
        connOpts.setCleanSession(true);
        connOpts.setUserName("your-username");
        connOpts.setPassword("your-password".toCharArray());
 
        // 连接到MQTT代理
        mqttClient.connect(connOpts);
 
        // 订阅主题
        mqttClient.subscribe("your-topic", (message)->{
            // 处理接收到的消息
            System.out.println("Received message: " + new String(message.getPayload()));
        });
 
        // 发布消息
        MqttMessage message = new MqttMessage("Hello MQTT".getBytes());
        mqttClient.publish("your-topic", message);
    }
}

在这个例子中，你需要替换your-broker-address为你的MQTT代理地址，your-username和your-password为你的认证信息，your-topic为你想要订阅和发布消息的主题。

这个简单的服务会在初始化时连接到MQTT代理，订阅一个主题，并发布一条消息。它还会打印接收到的每条消息。

要注意的是，这个例子没有包含完整的异常处理和资源清理逻辑，它只是为了展示如何在Spring Boot应用中集成Netty和MQTT。在实际应用中，你需要确保客户端正确关闭和清理资源。

- 阅读更多 -
Spring Cloud Alibaba 同时兼容dubbo与openfeign
System
2024-09-05
所有,java

Spring Cloud Alibaba 提供了对 Dubbo 和 OpenFeign 的支持，使得在微服务架构中，可以选择使用 Dubbo 进行 RPC 通信或者使用 OpenFeign 进行 RESTful 风格的服务调用。

以下是一个使用 Dubbo 和 OpenFeign 的示例：

Dubbo 服务提供者：




@Service
public class DubboServiceImpl implements DubboService {
    @Override
    public String sayHello(String name) {
        return "Hello, " + name;
    }
}

Dubbo 服务消费者：




@DubboReference
private DubboService dubboService;
 
public void consumeDubboService() {
    String result = dubboService.sayHello("world");
    System.out.println(result);
}

OpenFeign 客户端：




@FeignClient(name = "remote-service", url = "http://remote-service-provider")
public interface RemoteService {
    @GetMapping("/api/hello")
    String sayHello(@RequestParam(value = "name") String name);
}

使用 OpenFeign 客户端：




@Autowired
private RemoteService remoteService;
 
public void consumeFeignService() {
    String result = remoteService.sayHello("world");
    System.out.println(result);
}

在 Spring Cloud Alibaba 中，你可以同时使用 Dubbo 和 OpenFeign，并且它们可以和 Spring Cloud 的其他组件（如 Netflix Feign）无缝集成。通过定义 Dubbo 服务接口和使用 @DubboReference 或 @FeignClient 注解，你可以轻松地在你的微服务应用中进行服务间通信。

- 阅读更多 -
如何在Spring Boot中配置数据库密码加密
System
2024-09-05
所有,java

在Spring Boot中配置数据库密码的加密，可以使用Jasypt（Java Simplified Encryption）库来实现。以下是配置和使用Jasypt进行数据库密码加密的步骤：

  1. 添加Jasypt的依赖到项目中：



<dependency>
    <groupId>com.github.ulisesbocchio</groupId>
    <artifactId>jasypt-spring-boot-starter</artifactId>
    <version>3.0.3</version>
</dependency>
  1. 使用Jasypt的命令行工具或在线工具生成一个加密密码。例如，使用命令行工具：



java -cp jasypt-1.9.3.jar org.jasypt.intf.cli.JasyptPBEStringEncryptionCLI input="your-database-password" password=encryption_key algorithm=PBEWithMD5AndDES
  1. 在application.properties或application.yml配置文件中使用加密的密码：



spring.datasource.password=ENC(加密后的密码)
  1. 设置Jasypt的主密码，这将用于解密配置中的数据库密码：



import com.ulisesbocchio.jasyptspringboot.annotation.EnableEncryptableProperties;
import org.springframework.context.annotation.Configuration;
import org.jasypt.encryption.StringEncryptor;
import org.jasypt.util.text.BasicTextEncryptor;
 
@Configuration
@EnableEncryptableProperties
public class JasyptConfig {
    @Bean
    public StringEncryptor stringEncryptor() {
        BasicTextEncryptor textEncryptor = new BasicTextEncryptor();
        textEncryptor.setPassword("encryption_key"); // 与生成加密密码时的密钥相同
        return textEncryptor::encrypt;
    }
}

现在，即使配置文件暴露，数据库密码也将安全地保存在其加密形式。Spring Boot应用程序在启动时会使用提供的StringEncryptor实例来解密配置中的加密值。

- 阅读更多 -
Copyright © 2025 Tech Blog
All Right Reserved | 京ICP备19053165号