分类 java 下的文章

2024-09-03

Spring Boot 使用 WebSocket 的几种方式：

使用 Spring 原生的 WebSocketMessageBrokerConfigurer 接口。
使用 STOMP 子协议。
使用 SockJS 库提供跨浏览器支持。

高并发问题及解决方案：

连接数过多：WebSocket 连接本质上是长连接，会占用服务器资源。高并发场景下，服务器可能无法处理所有的连接。
- 解决方案：使用服务器集群或者负载均衡，分散连接压力。
消息广播性能瓶颈：如果需要广播消息到所有客户端，性能可能会下降。
- 解决方案：使用分布式或者消息队列来缓解消息压力，客户端订阅相关的 Topic。
内存泄漏：长时间运行的 WebSocket 会话可能导致内存泄漏。
- 解决方案：定期清理无效的会话，或者使用有状态的服务来管理会话状态。
网络问题：网络不稳定可能导致 WebSocket 连接断开。
- 解决方案：实现重连机制，网络恢复时自动重新连接。
安全问题：WebSocket 可能被用于 DDoS 攻击。
- 解决方案：实现合理的连接限流，例如同一个 IP 的连接数限制。

具体代码示例：




@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {
    @Override
    public void configureMessageBroker(MessageBrokerRegistry config) {
        config.enableSimpleBroker("/topic");
        config.setApplicationDestinationPrefixes("/app");
    }
 
    @Override
    public void registerStompEndpoints(StompEndpointRegistry registry) {
        registry.addEndpoint("/ws").withSockJS();
    }
}

在这个配置中，我们定义了一个 /topic 的消息代理，所有以 /app 开头的消息都会通过这个代理进行广播。同时，我们定义了一个 WebSocket 的端点 /ws，客户端可以通过这个端点与服务器建立 SockJS 通信。

Nginx+Tomcat负载均衡、动静分离集群

2024-09-03

以下是一个基于Nginx实现的Tomcat动静分离和负载均衡的配置示例：

Nginx配置文件（nginx.conf）:




user  nginx;
worker_processes  1;
 
events {
    worker_connections  1024;
}
 
http {
    include       mime.types;
    default_type  application/octet-stream;
 
    # 日志格式
    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';
 
    # 访问日志
    access_log  logs/access.log  main;
 
    # 静态文件缓存设置
    sendfile        on;
    keepalive_timeout  65;
 
    # 用于动静分离
    server {
        listen       80;
        server_name  localhost;
 
        # 静态内容
        location ~* \.(jpg|jpeg|gif|png|css|js|ico|html)$ {
            root   /path/to/static/files;
            expires 30d;
        }
 
        # 代理动态内容到Tomcat服务器
        location / {
            proxy_pass http://tomcat_server;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        }
    }
 
    # 负载均衡配置
    upstream tomcat_server {
        server tomcat1.example.com:8080;
        server tomcat2.example.com:8080;
    }
}

在这个配置中，Nginx作为反向代理服务器接收客户端的HTTP请求，并根据location指定的规则来处理静态文件请求或将动态内容代理到Tomcat服务器。upstream模块定义了一个名为tomcat_server的服务器组，该组包含两个Tomcat实例，Nginx将动态内容负载均衡地分发到这两个实例上。

确保Nginx配置没有错误：




nginx -t

如果没有错误，重新加载Nginx配置：




nginx -s reload

这样，Nginx就会按照新的配置来接收和处理请求，实现动静分离和负载均衡。

超硬核解析Mybatis动态代理原理！只有接口没实现也能跑？

2024-09-03

MyBatis 动态代理是一种技术，它允许你在不编写实现类的情况下，通过接口调用数据库操作。这是通过使用 Java 的动态代理功能实现的。

MyBatis 动态代理的基本原理是：

使用 JDK 动态代理，为 Mapper 接口创建一个代理对象。
当通过代理对象调用方法时，MyBatis 会生成对应的 SQL 语句并执行。

这里是一个简单的例子，演示如何使用 MyBatis 动态代理：




// Mapper 接口
public interface UserMapper {
    User selectUserById(int id);
}
 
// 测试代码
SqlSession sqlSession = sqlSessionFactory.openSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
User user = mapper.selectUserById(1);

在这个例子中，我们没有为 UserMapper 接口提供任何实现类，但是我们仍然能够通过 sqlSession.getMapper(UserMapper.class) 获取到 UserMapper 接口的代理对象，并调用 selectUserById 方法。

MyBatis 会在内部处理这个调用，生成相应的 SQL 语句，并执行。这就是 MyBatis 动态代理的工作方式。

Spring Boot 指定外部配置文件

2024-09-03

在Spring Boot中，你可以通过以下方法指定外部配置文件：

命令行参数: 启动Spring Boot应用时，可以通过--spring.config.location参数指定外部配置文件的路径。




java -jar yourapp.jar --spring.config.location=file:/path/to/config/

环境变量: 可以设置环境变量SPRING_CONFIG_LOCATION来指定配置文件路径。




export SPRING_CONFIG_LOCATION=file:/path/to/config/
java -jar yourapp.jar

在application.properties或application.yml中指定: 可以在Spring Boot的默认配置文件中指定外部配置文件的路径。




spring.config.import=file:/path/to/config/application.properties

或者使用YAML格式：




spring:
  config:
    import: file:/path/to/config/application.yml

在程序中指定: 在程序启动的时候，可以通过Java系统属性来指定配置文件。




System.setProperty("spring.config.location", "file:/path/to/config/");

确保路径指向正确的配置文件，并且文件必须是一个有效的Spring Boot配置文件，可以是application.properties或application.yml。

2024-09-03

在Spring Cloud Alibaba中，Gateway网关是一种提供统一的路由 capability 的服务，它基于Spring WebFlux框架实现，并且可以非常容易地与Nacos配置中心集成，从而实现路由配置的动态更新。

以下是使用Spring Cloud Alibaba Gateway与Nacos作为配置中心的基本步骤：

引入依赖

确保在项目的pom.xml中引入了Spring Cloud Alibaba Gateway和Nacos配置中心的依赖。




<dependencies>
    <!-- Spring Cloud Alibaba Gateway -->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-gateway</artifactId>
    </dependency>
    <!-- Nacos Config -->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
    </dependency>
</dependencies>

配置文件

在application.yml或application.properties中配置Nacos作为配置中心，并设置Gateway相关配置。




spring:
  cloud:
    nacos:
      config:
        server-addr: 127.0.0.1:8848 # Nacos服务器地址
        namespace: 命名空间ID # Nacos的命名空间ID，非必须
        group: DEFAULT_GROUP # Nacos的group，默认为DEFAULT_GROUP
        file-extension: yaml # 配置内容的格式，可以是yaml或properties
    gateway:
      routes:
        - id: user-service
          uri: http://localhost:8080
          predicates:
            - Path=/user/**

动态路由配置

在Nacos中创建配置，例如gateway-dynamic-route.yaml，并设置Gateway的动态路由配置。




spring:
  cloud:
    gateway:
      routes:
        - id: user-service
          uri: http://localhost:8080
          predicates:
            - Path=/user/**

确保Nacos中的配置文件能被Gateway正确读取，并且具有合适的权限。

启动类

确保启动类上有正确的注解，例如@SpringBootApplication和@EnableNacosConfig。




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

运行和测试

启动Gateway服务和Nacos服务器，确保网络通畅，然后通过Gateway服务转发的路由进行测试。

当需要更新路由配置时，只需在Nacos中更新对应的配置文件，Gateway会自动更新其路由规则。

SpringBoot实现登录接口！！！

2024-09-03

下面是一个简单的Spring Boot登录接口示例，使用了Spring Security和JPA来处理用户认证。

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




<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-security</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
</dependencies>

创建一个用户实体（User.java）：




import javax.persistence.*;
 
@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
 
    private String username;
 
    private String password;
 
    // 省略getter和setter
}

创建一个用户仓库（UserRepository.java）：




import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
 
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    User findByUsername(String username);
}

创建一个安全配置类（SecurityConfig.java）：




import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
 
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .antMatchers("/", "/home").permitAll()
                .anyRequest().authenticated()
                .and()
            .formLogin()
                .loginPage("/login")
                .permitAll()
                .and()
            .logout()
                .permitAll();
    }
 
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication()
            .withUser("user").password("{noop}password").roles("USER");
    }
}

创建一个登录控制器（LoginController.java）：




import org.springframework.web.bind.annotation.PostMapping;
import org.springframewor

【Spring 篇】MyBatis中的CRUD魔法：数据之美的四重奏

2024-09-03




// 假设有一个UserMapper接口，并且已经有了MyBatis的Mapper扫描配置
public interface UserMapper {
    // 插入用户
    int insertUser(User user);
 
    // 根据ID删除用户
    int deleteUserById(int id);
 
    // 更新用户信息
    int updateUser(User user);
 
    // 根据ID查询用户
    User selectUserById(int id);
}
 
// 示例代码，展示如何使用UserMapper进行CRUD操作
public class UserService {
    private final UserMapper userMapper;
 
    public UserService(UserMapper userMapper) {
        this.userMapper = userMapper;
    }
 
    public void createUser(User user) {
        userMapper.insertUser(user);
    }
 
    public void deleteUser(int id) {
        userMapper.deleteUserById(id);
    }
 
    public void updateUser(User user) {
        userMapper.updateUser(user);
    }
 
    public User getUser(int id) {
        return userMapper.selectUserById(id);
    }
}

这个示例展示了如何在实际的应用程序中使用MyBatis的Mapper接口来执行CRUD操作。在这个例子中，我们定义了一个UserService类，它通过依赖注入的方式获取UserMapper实例，并提供了创建、删除、更新和查询用户信息的方法。这些方法对应于UserMapper接口中定义的操作，并且可以在应用程序的业务逻辑层中使用。

【JavaEE】深入浅出：Spring Boot配置文件全解析

2024-09-03

在Spring Boot中，配置文件主要有两种格式：application.properties和application.yml。

application.properties配置示例：




server.port=8080
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=myuser
spring.datasource.password=mypass

application.yml配置示例：




server:
  port: 8080
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: myuser
    password: mypass

在Spring Boot中，配置文件的位置和名称是固定的，必须在src/main/resources目录下，并且文件名必须是application.properties或application.yml。

Spring Boot会自动加载这些配置文件，并将它们的内容与应用程序的配置属性绑定。

在代码中，你可以使用@Value注解来注入配置值，例如：




@Controller
public class MyController {
 
    @Value("${server.port}")
    private int serverPort;
 
    // ...
}

或者使用@ConfigurationProperties注解来绑定配置文件中的一组属性到Java类：




@ConfigurationProperties(prefix="spring.datasource")
public class DataSourceProperties {
 
    private String url;
    private String username;
    private String password;
 
    // Getters and setters...
}

然后在Spring Boot的配置类中使用这个类：




@Configuration
public class AppConfig {
 
    @Bean
    public DataSource dataSource(DataSourceProperties properties) {
        // 使用DataSourceProperties中的属性创建DataSource实例
    }
}

以上是Spring Boot配置文件的基本使用方法，实际应用中可以根据需要进行更复杂的配置。

tomcat软件部署

2024-09-03

Tomcat软件部署通常指的是将Web应用程序包装为WAR文件，然后将其放置在Tomcat服务器的webapps目录下。这样Tomcat在启动时会自动部署该应用。

以下是部署Tomcat Web应用的基本步骤：

确保你的应用已经打包为WAR文件。如果你有源代码，你可以使用Maven或Gradle等构建工具来打包。
将WAR文件复制到Tomcat的webapps目录。
启动或重启Tomcat服务器。
访问应用，通常URL格式为：http://<hostname>:<port>/<YourAppName>

以下是一个简单的示例，演示如何使用Maven来打包WAR文件：




<project>
    <!-- ... other configurations ... -->
 
    <packaging>war</packaging>
 
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-war-plugin</artifactId>
                <version>3.3.1</version>
                <configuration>
                    <warName>myapp</warName>
                </configuration>
            </plugin>
        </plugins>
    </build>
 
    <!-- ... other configurations ... -->
</project>

然后在命令行运行：




mvn clean package

这将在target目录生成myapp.war文件。之后，将此WAR文件复制到Tomcat的webapps目录，并启动Tomcat。

如果你不使用Maven，可以手动将你的Web应用文件夹打包为WAR，或者使用其他工具如jar命令。

请注意，如果你使用的是Tomcat的非官方分支或定制版本，步骤可能会有所不同。

2024-09-03

SpringApplication 的 run 方法是 Spring Boot 应用启动的核心方法，它负责启动 Spring 应用上下文，并处理各种启动阶段的细节。

以下是 run 方法的核心流程：

设置当前 Spring Application 实例的属性，例如应用上下文类名、web环境标志等。
通过 SpringFactoriesLoader 查找并加载 classpath 下 META-INF/spring.factories 文件中的自动配置类。
配置启动环境，例如设置 JVM 系统属性、环境变量等。
创建事件监听器，并发布应用启动的相关事件。
启动监听器，监听相关事件。
创建 ApplicationContext。
刷新 ApplicationContext，这一步包括 Bean 定义、Bean 的初始化等。
再一次刷新上下文，处理任何 Bean 工厂后处理器。
启动完成后，发布应用启动完成的事件。

以下是一个简化的 run 方法代码示例：




public static ConfigurableApplicationContext run(Object source, String... args) {
    // 实例化SpringApplication
    SpringApplication app = new SpringApplication(source);
 
    // 设置默认属性
    app.setDefaultProperties(defaultProperties);
 
    // 创建并配置环境
    ConfigurableEnvironment environment = new StandardEnvironment();
    app.prepareEnvironment(environment, args);
 
    // 创建上下文
    ConfigurableApplicationContext context = new AnnotationConfigApplicationContext(app.getSources().toArray(new Class[0]));
 
    // 刷新上下文
    app.refresh(context);
 
    // 发布启动完成事件
    app.publishEvent(new ApplicationStartedEvent(new SpringApplication(), args));
 
    return context;
}

这个示例省略了许多细节，但足以展示核心流程。在实际的 Spring Boot 应用中，run 方法会更加复杂，包含了许多健壮性检查、条件注解处理和环境适配等功能。