跳至主要內容

SpringBoot

ZJX2023年4月15日大约 12 分钟

创建简单视图

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.ViewControllerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

// 适用于前后不分离项目，创建简单的视图控制器
@Configuration
public class WebConfig implements WebMvcConfigurer {

  @Override
  public void addViewControllers(ViewControllerRegistry registry) {
    // 将 url / 映射到 /home
    registry.addViewController("/").setViewName("home");
    registry.addViewController("/login");
  }

}

Spring 注入方式

建议始终在 bean 中使用基于构造函数的依赖项注入，始终对强制性依赖项使用断言； 构造器和 setter 注入，在类被调用时可以保证它们都完全准备好了，也可以保证这些变量的值不会是 null

// 基于 Lombok 提供的注解注入
@RequiredArgsConstructor
public class UserServiceImpl implents UserService{
    private final UserDao userDao;
}

// 基于构造函数注入
public class UserServiceImpl implents UserService{
    private final UserDao userDao;

    @Autowired
    public UserServiceImpl(UserDao userDao){
        Assert.notNull(userDao, "userDao must not be null");
        this.userDao = userDao;
    }
}

// 基于 Setter 注入
public class UserServiceImpl implents UserService{
     private final UserDao userDao;

     // Spring 4.3 及以后的版本中，@Autowired 可不写
     @Autowired
     public setUserDao(UserDao userDao){
         Assert.notNull(userDao, "userDao must not be null");
         this.userDao = userDao;
     }
 }

// 基于字段入
 public class UserServiceImpl implents UserService{
     @Autowired
     private UserDao userDao;
 }

属性配置

使用@ConfigurationProperties 注解示例

# 配置示例
alipay:
  appId: 666
  aliAppPublicKey: 555
@Data
@Component
@ConfigurationProperties(prefix = "alipay")
public class AlipayConfig {
    private String appId;
    private String aliAppPublicKey;
}

提示

在 IDE 中可能看到 yml 文件存在“unknown property”警告，这是因为 IDE 会尝试寻找它所需要的元数据，以便了解这些属性的含义； 在 pom.xml 中添加如下依赖即可消除警告

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
    <optional>true</optional>
</dependency>

应用启动时执行

Spring Boot 提供了两个非常有用的接口，用于在应用启动的时候执行一定的逻辑，即 CommandLineRunner 和 ApplicationRunner

因为 CommandLineRunner 和 ApplicationRunner 都是函数式接口，都需要实现一个 run() 方法，所以在配置类中可以很容易地将其声明为 bean，只需在一个返回 lambda 表达式的方法上使用@Bean 注解

CommandLineRunner 和 ApplicationRunner 的区别在于各自 run() 方法的参数； CommandLineRunner 的 run() 方法接受一个 String 类型的可变长度参数； ApplicationRunner 的 run() 方法接受一个 ApplicationArguments 参数；

CommandLineRunner
@Bean
public CommandLineRunner dataLoader(MyService service) {
  return args -> {
    // 这里的 args 代表命令行参数；如 java -jar xxx.jar --version 1.0 运行
    // args 就为'version 1.0'的字符串；
    // CommandLineRunner 的 run 方法参数可变，若有多个命令行参数，则  （arg1,arg2,...） -> {}
    service.doSomething();
  };
}

加载外部 jar 包

在项目 resources 目录下创建一个文件夹，例如名称为 lib ，将需要加载的 jar 包放入新建的 lib 目录中，并修改 pom.xml，配置如下：

<!-- 外部引入的 jar 包，g、a、v 可随意定义 -->
<dependency>
    <groupId>com.zjx</groupId>
    <artifactId>zjx-test-a</artifactId>
    <version>1.0</version>
    <systemPath>${project.basedir}/src/main/resources/lib/a.jar</systemPath>
</dependency>
<dependency>
    <groupId>com.zjx</groupId>
    <artifactId>zjx-test-b</artifactId>
    <version>1.0</version>
    <systemPath>${project.basedir}/src/main/resources/lib/b.jar</systemPath>
</dependency>

日志配置

SLF4J 是日志的接口标准，Logback 和 Log4j2 都是 SLF4J 的具体实现，Spring Boot 2.x 选择 Logback 作为默认的日志框架，Spring Boot 3.x 的默认日志实现改为了 Log4j 2。

为了完全控制日志的配置，可以在类路径的根目录下（在“src/main/resources”中）创建一个 logback.xml 文件

借助 Spring Boot 的配置属性功能，不用创建 logback.xml 文件也能完成配置

# 配置示例
logging:
  file:
    path: /var/logs/
    file: TacoCloud.log
  level:
    root: WARN
    org.springframework.security: DEBUG

比较完整的 logback.xml 示例

<?xml version="1.0" encoding="UTF-8"?>
<configuration debug="">

    <!--默认配置-->
    <!--<include resource="org/springframework/boot/logging/logback/defaults.xml"/>-->
    <!--配置控制台 (Console)-->
    <!--<include resource="org/springframework/boot/logging/logback/console-appender.xml"/>-->

    <springProperty scope = "context" name = "applicationName" source = "spring.application.name" />
    <springProperty scope = "context" name = "env" source = "spring.profiles.active" />
    <springProperty scope = "context" name = "console_log_level" source = "console.log.level" />

    <!--输出到控制台-->
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <!--此日志 appender 是为开发使用，只配置最底级别，控制台输出的日志级别是大于或等于此级别的日志信息-->
        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
            <level>${console_log_level}</level>
        </filter>
        <encoder>
            <Pattern>[%date{yyyy-MM-dd HH:mm:ss}] [ %-5level] [%X{traceId}] [%X{requestId}] %logger{96} [%line] - %msg%n</Pattern>
            <!-- 设置字符集 -->
            <charset>UTF-8</charset>
        </encoder>
    </appender>

    <appender name = "debug_log" class = "ch.qos.logback.core.rolling.RollingFileAppender">
        <file>logs/debug/application.log</file>
        <rollingPolicy class = "ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <fileNamePattern>logs/debug/application-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <maxFileSize>5MB</maxFileSize>
            <maxHistory>7</maxHistory>
            <totalSizeCap>20GB</totalSizeCap>
        </rollingPolicy>
        <encoder>
            <pattern>[%date{yyyy-MM-dd HH:mm:ss}] [ %-5level] [%X{traceId}] [%X{requestId}] %logger{96} [%line] - %msg%n</pattern>
            <charset>UTF-8</charset>
        </encoder>
        <!-- 此日志文档记录 debug 以上级别的 -->
        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
            <level>debug</level>
        </filter>
    </appender>

    <appender name = "info_log" class = "ch.qos.logback.core.rolling.RollingFileAppender">
        <file>logs/info/application.log</file>
        <rollingPolicy class = "ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <fileNamePattern>logs/info/application-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <maxFileSize>5MB</maxFileSize>
            <maxHistory>7</maxHistory>
            <totalSizeCap>20GB</totalSizeCap>
        </rollingPolicy>
        <encoder>
            <pattern>[%date{yyyy-MM-dd HH:mm:ss}] [ %-5level] [%X{traceId}] [%X{requestId}] %logger{96} [%line] - %msg%n</pattern>
            <charset>UTF-8</charset>
        </encoder>
        <!-- 此日志文档记录 info 以上级别的 -->
        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
            <level>info</level>
            <!--<onMatch>ACCEPT</onMatch>-->
            <!--<onMismatch>DENY</onMismatch>-->
        </filter>
    </appender>

    <appender name = "error_log" class = "ch.qos.logback.core.rolling.RollingFileAppender">
        <file>logs/error/application.log</file>
        <rollingPolicy class = "ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <fileNamePattern>logs/error/application-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <maxFileSize>5MB</maxFileSize>
            <maxHistory>7</maxHistory>
            <totalSizeCap>20GB</totalSizeCap>
        </rollingPolicy>
        <encoder>
            <pattern>[%date{yyyy-MM-dd HH:mm:ss}] [ %-5level] [%X{traceId}] [%X{requestId}] %logger{96} [%line] - %msg%n</pattern>
            <charset>UTF-8</charset>
        </encoder>
        <!-- 此日志文档记录 info 以上级别的 -->
        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
            <level>error</level>
            <!--<onMatch>ACCEPT</onMatch>-->
            <!--<onMismatch>DENY</onMismatch>-->
        </filter>
    </appender>

    <!-- 为 logstash 输出的 JSON 格式的 Appender -->
    <appender name="logstash" class="net.logstash.logback.appender.LogstashTcpSocketAppender">
        <destination>47.108.88.119:4560</destination>
        <!-- 日志输出编码 -->
        <encoder charset="UTF-8" class="net.logstash.logback.encoder.LoggingEventCompositeJsonEncoder">
            <providers>
                <timestamp>
                    <timeZone>UTC</timeZone>
                </timestamp>
                <pattern>
                    <pattern>
                        {
                        "severity": "%level",
                        "service": "${applicationName:-}",
                        "trace": "%X{traceId:-}",
                        "pid": "${PID:-}",
                        "thread": "%thread",
                        "class": "%logger{40}",
                        "message": "%message",
                        "env": "${env}",
                        "stack_trace": "%exception"
                        }
                    </pattern>
                </pattern>
            </providers>
        </encoder>
    </appender>

    <logger name="com.zjx.com.mapper" level="DEBUG">
        <appender-ref ref="CONSOLE" />
        <appender-ref ref="info_log" />
    </logger>

    <root level = "INFO">
        <appender-ref ref="logstash"/>
        <appender-ref ref="CONSOLE"/>
        <!--<appender-ref ref = "debug_log" />-->
        <appender-ref ref = "info_log" />
        <appender-ref ref = "error_log" />
    </root>

</configuration>

Spring Boot 中加载 xml 配置

@Configuration
@ImportResource("classpath:/xxx.xml")
public class MyConfig { ... }

缓存

以下都为注解式缓存示例，他们可以同时存在，也可以只使用其中一个，根据项目需求添加即可。

Caffeine

Caffeine 是一个高性能、功能强大的本地缓存库。

pom.xml
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>
<dependency>
    <groupId>com.github.ben-manes.caffeine</groupId>
    <artifactId>caffeine</artifactId>
</dependency>

Redis

pom.xml
<!-- 这里说明一下，如果项目中已经有 Redisson 作为 Redis 客户端，则此处依赖都可以删掉 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
    <groupId>io.lettuce</groupId>
    <artifactId>lettuce-core</artifactId>
</dependency>

Redission

关于 Redission 的依赖和配置项，请参考此篇文档，保证 Spring 容器中有 RedissonClient 这个 Bean 即可。以下是使用 Redisson 实现注解式缓存的示例。

CacheConfig
@Slf4j
@Configuration
@EnableCaching
public class MultiCacheConfig {

    @Value("${cache.caffeine.default-spec:maximumSize=1000,expireAfterWrite=600s}")
    private String caffeineDefaultSpec;

    // 缓存名称常量（统一在全局引用）
    public static final String USER_CACHE = "userCache";
    public static final String PRODUCT_CACHE = "productCache";
    public static final String SESSION_CACHE = "sessionCache";

    /**
     * Redisson 缓存管理器 - 高级分布式缓存
     * 适用于需要 TTL + 最大空闲时间控制的场景
     */
    @Bean("redissonCacheManager")
    public CacheManager redissonCacheManager(RedissonClient redissonClient) {
        log.info("初始化 Redisson Cache Manager...");

        Map<String, CacheConfig> config = new HashMap<>();
        config.put(USER_CACHE, new CacheConfig(
                TimeUnit.MINUTES.toMillis(30),  // 30分钟TTL（对应的毫秒数）
                TimeUnit.MINUTES.toMillis(15)   // 15分钟最大空闲时间
        ));
        config.put(PRODUCT_CACHE, new CacheConfig(
                TimeUnit.HOURS.toMillis(2),        // 2小时TTL
                TimeUnit.MINUTES.toMillis(30)      // 30分钟最大空闲时间
        ));
        config.put(SESSION_CACHE, new CacheConfig(
                TimeUnit.HOURS.toMillis(24),    // 24小时TTL
                TimeUnit.HOURS.toMillis(1)      // 1小时最大空闲时间
        ));

        // RedissonSpringCacheManager 使用 RMapCache 实现（支持 TTL + Idle）
        return new RedissonSpringCacheManager(redissonClient, config);
    }
}

单元测试

单元测试案例参考

简单使用
import org.junit.jupiter.api.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import java.util.concurrent.TimeUnit;

/**
 * 单元测试案例
 */
@Slf4j
@ComponentScan(basePackages = "com.zjx")
@SpringBootTest // 此注解只能在 springboot 主包下使用
public class DemoUnitTest {

    private final IMyTestService service;

    @Autowired
    public DemoUnitTest(IMyTestService service) {
        this.service = service;
    }

    @Test
    public void testTest() {
        Assertions.assertNotNull(service);
        log.info(service.toString());
    }
}

启用 WebSocket

  • pom.xml

    <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-websocket</artifactId>
</dependency>

  • 实现方式

    方式一（推荐）
    @Component
@ServerEndpoint("/first-endpoint")
public class FirstWebSocketEndpoint {

    @OnOpen
    public void onOpen(Session session) {
        // 连接建立时执行
    }

    @OnMessage
    public void onMessage(String message, Session session) {
        // 收到消息时执行
    }

    @OnClose
    public void onClose(Session session) {
        // 连接关闭时执行
    }

    @OnError
    public void onError(Session session, Throwable error) {
        // 发生错误时执行
    }
}

解决跨越问题

  • 使用 @CrossOrigin 注解（不推荐）

    在控制器方法或类上添加 @CrossOrigin 注解，适用于小型项目或单个接口的跨域配置

    @RestController
@GetMapping("/api")
@CrossOrigin(origins = "https://example.com", maxAge = 3600)
public class MyController {
    @GetMapping("/resource")
    public ResponseEntity<?> getResource() {
        ...
    }
}

  • 全局配置（推荐）

    通过 WebMvcConfigurer 实现统一配置，适合管理所有端点的 CORS 规则。适用于未接入其他安全框架（如Spring Security）。

    @Configuration
public class CorsConfig implements WebMvcConfigurer {
    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/**")  // 所有接口
                .allowedOrigins("https://trusted-domain.com", "https://another-domain.com") // 严格指定可信域名，建议生产环境使用
                // .allowedOriginPatterns("https://*.trusted-domain.com", "https://another-domain.com") // 通配符指定可信域名，生产环境需注意是否存在安全风险
                .allowedMethods("GET", "POST", "PUT", "DELETE", "OPTIONS") // 允许的 HTTP 方法
                .allowedHeaders("*") // 允许所有请求头
                .allowCredentials(true) // 允许携带 Cookie
                .maxAge(3600); // 1 小时内不需要预检请求
    }
}

  • Spring Security 集成配置

      @Configuration
  @EnableWebSecurity
  public class SecurityConfig {

      @Bean
      public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
          http
              .cors(cors -> cors.configurationSource(corsConfigurationSource()))
              // ... 其他安全配置
          return http.build();
      }

      // CORS 配置源
      CorsConfigurationSource corsConfigurationSource() {
          CorsConfiguration config = new CorsConfiguration();
          config.setAllowedOrigins(Arrays.asList("https://trusted-domain.com"));
          config.setAllowedMethods(Arrays.asList("GET", "POST", "PUT", "OPTIONS"));
          config.setAllowedHeaders(Arrays.asList("Authorization", "Content-Type"));
          config.setAllowCredentials(true);
          config.setMaxAge(3600L);

          UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
          source.registerCorsConfiguration("/**", config);
          return source;
      }
  }
最近更新：