Spring Boot 工程开发常见问题解决方案,日常开发全覆盖

这篇具有很好参考价值的文章主要介绍了Spring Boot 工程开发常见问题解决方案,日常开发全覆盖。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

本文是 SpringBoot 开发的干货集中营,涵盖了日常开发中遇到的诸多问题,通篇着重讲解如何快速解决问题,部分重点问题会讲解原理,以及为什么要这样做。便于大家快速处理实践中经常遇到的小问题,既方便自己也方便他人,老鸟和新手皆适合,值得收藏 😄

1. 哪里可以搜索依赖包的 Maven 坐标和版本

  • https://mvnrepository.com/

    这个在2023年前使用得最多,但目前(2024)国内访问该网站时,经常卡死在人机校验这一步,导致无法使用

  • https://central.sonatype.com/

    刚开始我是临时用这个网站来替换前面那个,现在它越来越好用,就直接使用它了

2. 如何确定 SpringBoot 与 JDK 之间的版本关系

在 Spring官网 可以找到 SpringBoot 对应的 JDK 关系,但这种关系说明位于具体版本的参考手册(Reference Doc)中,按照以下图示顺序操作即可找到。

Spring Boot 工程开发常见问题解决方案,日常开发全覆盖

Spring Boot 工程开发常见问题解决方案,日常开发全覆盖

Spring Boot 工程开发常见问题解决方案,日常开发全覆盖

重大版本与JDK及Spring基础框架的对应关系表

Spring Boot 版本 JDK 版本 Spring Framework 版本
2.7.18 JDK8 + 5.3.31 +
3.2.3 JDK17 + 6.1.4 +

3. 如何统一处理Web请求的JSON日期格式问题

方式一:编程式声明

在 JacksonAutoConfiguration 装配前, 先装配一个 Jackson2ObjectMapperBuilderCustomizer,并在这个 Customizer 中设置日期格式。如下所示:

@Configuration
@ConditionalOnClass(ObjectMapper.class)
@AutoConfigureBefore(JacksonAutoConfiguration.class)     // 本装配提前于官方的自动装配
 ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄
public class JacksonConfig {
    @Bean
    public Jackson2ObjectMapperBuilderCustomizer myJacksonCustomizer() {
        return builder -> {
            builder.locale(Locale.CHINA);
            builder.timeZone(TimeZone.getTimeZone(ZoneId.systemDefault()));
            builder.simpleDateFormat("yyyy-MM-dd HH:mm:ss");
    }
}    

方式二:配置式声明 <推荐>

参考下面的示例代码即可,关键之处是要指定 spring.http.converters.preferred-json-mapper 的值为 jackson, 否则配置不生效

spring:
  jackson:
    date-format: yyyy-MM-dd HH:mm:ss
    locale: zh_CN
    time-zone: "GMT+8"
  http:
    converters:
      preferred-json-mapper: jackson
       ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄

4. 如何以静态方式访问Bean容器

写一个实现了 ApplicationContextAware 接口的类,通过该接口的 setApplicationContext()方法,获取 ApplicationContext, 然后用一个静态变量来持有它。之后便可以通过静态方法使用 ApplicationContext 了。Spring 框架在启动完成后,会遍历容器中所有实现了该接口的Bean,然后调用它们的setApplicationContext()方法,将ApplicationContext(也就是容器自身)作为参数传递过去。下面是示例代码:

import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

@Component
public class ApplicationContextHolder implements ApplicationContextAware {

    // 声明一个静态变量来持有 ApplicationContext 
    private static ApplicationContext appContext;

    @Override
	public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
		ApplicationContextHolder.appContext = applicationContext;
	}

    public static ApplicationContext getContext() {
        return ApplicationContextHolder.appContext;
    }

}

5. 如何将工程打包成一个独立的可执行jar包

按以下三步操作即可(仅针对maven工程):

  • 在 pom.xml 中添加 spring boot 的构建插件
  • 为上一步的插件配置执行目标
  • 在工程目录下,命令行执行 maven clean package -Dmaven.test.skip=true
<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
			<version>2.1.6.RELEASE</version>
            <executions>
                <execution>
                    <goals>
                        <goal>repackage</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

🔔 关于 spring-boot-maven-plugin 插件的版本问题

如果不指定版本,默认会去下载最新的,这极有可能与代码工程所用的 jdk 版本不兼容,导致打包失败。那么应该用哪个版本呢?一个简单的办法,是先进入到本机的 Maven 仓库目录,然后再分别打开以下两个目录

  • org/springframework/boot/spring-boot
  • org/springframework/boot/spring-boot-maven-plugin

再结合自己工程的spring-boot版本(可通过IDE查看),选择相同版本或稍低版本的plugin插件

6. 如何从jar包外部读取配置文件

在 Java 启动命令中添加 spring-boot 配置文件相关参数,指定配置文件的位置,如下所示:

java -jar xxxx.jar --spring.config.location={yaml配置文件绝对路径} 
                    ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄

指定外部配置文件还有其它一些方式,详情参见 SpringBoot项目常见配置

📌 特别说明:

--spring.config.location 这个配置项一定要写在 xxxx.jar 之后,因为这是一个 SpringApplication 的参数,不是 java 命令的参数或选项,该参数最终是传递到了 main 方法的 args 变量上,因此在 main 方法中构建 SpringApplication 实例时,务必要把 args 参数传递过去,比如下面这两种写法

/** 样例A */
public static void main(String[] args) {
    SpringApplication.run(OverSpeedDataInsightMain.class);
}

/** 样例B */
public static void main(String[] args) {
    SpringApplication.run(OverSpeedDataInsightMain.class, args);
                                                           ̄ ̄ ̄
}

样例A由于没有传递args参数,因此通过命令行添加的 --spring.config.location 参数不会被SpringBoot实例读取到,在运行期间也就不会去读取它指定的配置文件了。

7. 如何同时启用多个数据源

方式一:手动创建多个My Batis的SqlSessionFactory

因为国内使用 MyBatis 框架最多,因此特别针对此框架单独说明。总体思路是这样的:

  • 多个数据源,各有各的配置
  • 针对每个数据源,单独创建一个 SqlSessionFactory
  • 每个 SqlSession 各自扫描不同数包和目录下的 Mapper.java 和 mapper.xml
  • 指定某个数据源为主数据源<强制>

样例工程部分代码如下,完整源码请访问码云上的工程 mybatis-multi-ds-demo

application.yml (点击查看)
spring:
  datasource:
    primary:
      driver: org.sqlite.JDBC
      url: jdbc:sqlite::resource:biz1.sqlite3?date_string_format=yyyy-MM-dd HH:mm:ss
    minor:
      driver: org.sqlite.JDBC
      url: jdbc:sqlite::resource:biz2.sqlite3?date_string_format=yyyy-MM-dd HH:mm:ss
主数据源装配 (点击查看)
@MapperScan(
        basePackages = {"cnblogs.guzb.biz1"},
        sqlSessionFactoryRef = "PrimarySqlSessionFactory"
)
@Configuration
public class PrimarySqlSessionFactoryConfig {

    // 表示这个数据源是默认数据源,多数据源情况下,必须指定一个主数据源
    @Primary
    @Bean(name = "PrimaryDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.primary")
    public DataSource getPrimaryDateSource() {
        // 这个MyBatis内置的无池化的数据源,仅仅用于演示,实际工程请更换成具体的数据源对象
        return new UnpooledDataSource();
    }

    @Primary
    @Bean(name = "PrimarySqlSessionFactory")
    public SqlSessionFactory primarySqlSessionFactory(
            @Qualifier("PrimaryDataSource") DataSource datasource) throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(datasource);
        // 主数据源的XML SQL配置资源
        Resource[] xmlMapperResources = new PathMatchingResourcePatternResolver().getResources("classpath:mappers/primary/*.xml");
        bean.setMapperLocations(xmlMapperResources);
        return bean.getObject();
    }

    @Primary
    @Bean("PrimarySqlSessionTemplate")
    public SqlSessionTemplate primarySqlSessionTemplate(
            @Qualifier("PrimarySqlSessionFactory") SqlSessionFactory sessionFactory) {
        return new SqlSessionTemplate(sessionFactory);
    }
}
副数据源装配 (点击查看)
@Configuration
@MapperScan(
        basePackages = {"cnblogs.guzb.biz2"},
        sqlSessionFactoryRef = "MinorSqlSessionFactory"
)
public class MinorSqlSessionFactoryConfig {

    @Bean(name = "MinorDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.minor")
    public DataSource getPrimaryDateSource() {
        // 这个MyBatis内置的无池化的数据源,仅仅用于演示,实际工程请更换成具体的数据源对象
        return new UnpooledDataSource();
    }

    @Bean(name = "MinorSqlSessionFactory")
    public SqlSessionFactory primarySqlSessionFactory(
            @Qualifier("MinorDataSource") DataSource datasource) throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(datasource);
        // 主数据源的XML SQL配置资源
        Resource[] xmlMapperResources = new PathMatchingResourcePatternResolver().getResources("classpath:mappers/minor/*.xml");
        bean.setMapperLocations(xmlMapperResources);
        return bean.getObject();
    }

    @Bean("MinorSqlSessionTemplate")
    public SqlSessionTemplate primarySqlSessionTemplate(
            @Qualifier("MinorSqlSessionFactory") SqlSessionFactory sessionFactory) {
        return new SqlSessionTemplate(sessionFactory);
    }
}

方式二:使用路由式委托数据源 AbstractRoutingDataSource <推荐>

上面这种方式,粒度比较粗,在创建SqlSessionFactory时,将一组Mapper与DataSource绑定。如果想粒度更细一些,比如在一个Mapper内,A方法使用数据源A, B方法使用数据源B,则无法做到。

Spring 官方有个 AbstractRoutingDataSource 抽象类, 它提供了以代码方式设置当前要使用的数据源的能力。其实就是把自己作为 DataSource 的一个实现类,并将自己作为数据源的集散地(代理人),在内部维护了一个数据源的池,将 getConnection() 方法委托给这个池中对应的数据源。

DynamicDataSource.java
public class DynamicDataSource extends AbstractRoutingDataSource {

    /** 通过 ThreadLocal 来记录当前线程中的数据源名称 */
    private final ThreadLocal<String> localDataSourceName = new ThreadLocal<>();

    public DynamicDataSource(DataSource defaultTargetDataSource, Map<Object, Object> targetDataSources) {
        super.setDefaultTargetDataSource(defaultTargetDataSource);
        super.setTargetDataSources(targetDataSources);
    }

    @Override
    protected Object determineCurrentLookupKey() {
        return localDataSourceName.get();
    }

    public void setDataSourceName(String dataSourceName) {
        localDataSourceName.set(dataSourceName);
    }

    public void clearDataSourceName() {
        localDataSourceName.remove();
    }
}
DynamicDataSourceConfig
@Configuration
public class DynamicDataSourceConfig {

    // 表示这个数据源是默认数据源,多数据源情况下,必须指定一个主数据源
    @Primary
    @Bean(name = "dynamic-data-source")
    @DependsOn(DataSourceName.FIRST)
    public DynamicDataSource getPrimaryDateSource(
            @Qualifier(DataSourceName.FIRST) DataSource defaultDataSource,
            @Qualifier(DataSourceName.SECOND) @Autowired(required = false) DataSource secondDataSource
    ) {

        System.out.println("first=" + defaultDataSource + ", second = " + secondDataSource);
        Map<Object, Object> allTargetDataSources = new HashMap<>();
        allTargetDataSources.put(DataSourceName.FIRST, defaultDataSource);
        allTargetDataSources.put(DataSourceName.SECOND, secondDataSource);

        return new DynamicDataSource(defaultDataSource, allTargetDataSources);
    }

    @Bean(name= DataSourceName.FIRST)
    @ConfigurationProperties(prefix = "spring.datasource.first")
    public DataSource createFirstDataSource() {
        // 这个MyBatis内置的无池化的数据源,仅仅用于演示,实际工程请更换成具体的数据源对象
        return new UnpooledDataSource();
    }

    @Bean(name= DataSourceName.SECOND)
    @ConfigurationProperties(prefix = "spring.datasource.second")
    public DataSource createSecondDataSource() {
        // 这个MyBatis内置的无池化的数据源,仅仅用于演示,实际工程请更换成具体的数据源对象
        return new UnpooledDataSource();
    }

}
SwitchDataSourceTo
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface SwitchDataSourceTo {

    /** 数据源的名称 */
    String value() default DataSourceName.FIRST;

}
SwitchDataSourceAspect
@Aspect
@Component
public class SwitchDataSourceAspect {

    @Autowired
    DynamicDataSource dynamicDataSource;

    @Around("@annotation(switchDataSourceTo)")
    public Object around(ProceedingJoinPoint point, SwitchDataSourceTo switchDataSourceTo) throws Throwable {
        String dataSourceName = switchDataSourceTo.value();
        try {
            dynamicDataSource.setDataSourceName(dataSourceName);
            System.out.println("切换到数据源: " + dataSourceName);
            return point.proceed();
        } finally {
            System.out.println("执行结束,准备切换回到主数据源");
            dynamicDataSource.setDataSourceName(DataSourceName.FIRST);
        }
    }
}
Biz1Mapper
@Mapper
public interface Biz1Mapper {

    // 未指定数据源,即为「默认数据源」
    @Select("select * from user")
    List<UserEntity> listAll();

    @SwitchDataSourceTo(DataSourceName.FIRST)
    @Select("select * from user where id=#{id}")
    UserEntity getById(@Param("id") Long id);
}
Biz2Mapper
@Mapper
public interface Biz2Mapper {

    @Select("select * from authority")
    @SwitchDataSourceTo(DataSourceName.SECOND)
    List<AuthorityEntity> listAll();

    // 本方法没有添加 SwitchDataSourceTo 注解,因此会使用默认的数据源,即 first
    // 但 first 数据源中没有这个表。该方法会通过在程序中手动设置数据源名称的方式,来切换
    @Select("select count(*) as quantity from authority")
    Integer totalCount();

}

完整源码请访问码云上的工程 mybatis-multi-ds-demo

方式三:使用 MyBatisPlus 的 多数据源方案 <推荐>

MyBatisPlus 增加了对多数据源的支持,详细做法请参考 MyBatis多数据源官方手册,它的底层原理与方式二一致,但特性更多,功能出更完善。若有兴趣的话,建议将这个多数据源的功能单独做成一个 jar 包或 maven 依赖。以使其可以在非 MyBatis 环境中使用。

多数据源切换引起的事务问题

对于纯查询类非事务性方法,上面的多数据源切换工作良好,一旦一个Service方法开启了事务,且内部调用了多个有不同数据源的Dao层方法,则这些数据源切换均会失败。原因为切换数据源发生在openConnection()方法执行时刻,但一个事务内只有一个Connection。当开启事务后,再次切换数据源时,由于已经有connection了,此时切换会无效。

因此解决办法为:先切换数据源,再开启事务。开启事务后,不能再切换数据源了。

8. 如何同时启用多个Redis连接

最简单的办法是直接使用 Redis官方的客户端库,但这样脱离了本小节的主旨。业务代码中使用spring 的 redis 封装,主要是使用 RedisTemplate 类,RedisTemplate 封装了常用的业务操作,但它并不关注如何获得 redis 的连接。这个工作是交由 RedisConnectionFactory 负责的。因此,RedisTemplate 需要指定一个 RedisConnectionFactory。由此可知,在工程中,创建两个RedisConnectionFactory, 每个连接工厂连接到不同的 redis 服务器即可。以下简易示例代码中,两个连接工厂连接的是同一个服务器的不同数据库。

创建两个 RedisConnectionFactory 和两个 RedisTemplate
@Configuration
public class RedisConfiguration {

    /** 
     * 0号数据库的连接工厂
     * 本示例没有使用早期的 JedisConnectionFactory, 而是选择了并发性更好的 LettuceConnectionFactory, 下同
     */
    @Primary
    @Bean("redis-connection-factory-db0")   // 明确地指定 Bean 名称,该实例将作为依赖项,传递给相应的 RedisTemplate, 下同
           ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄
    public RedisConnectionFactory createLettuceConnectionFactory0() {
        // 这里使用的是单实例Redis服务器的连接配置类,
        // 哨兵与集群模式的服务器,使用对应的配置类设置属性即可。
        // 另外,这里没有演示通过yaml外部配置文件来设置相应的连接参数,因为这不是本小节的重点
        RedisStandaloneConfiguration clientProps = new RedisStandaloneConfiguration();
        clientProps.setHostName("localhost");
        clientProps.setPort(6379);
        clientProps.setDatabase(0);
        return new LettuceConnectionFactory(clientProps);
    }

    /** 1号数据库的连接工厂 */
    @Bean("redis-connection-factory-db1")
            ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄
    public RedisConnectionFactory createLettuceConnectionFactory1() {
        RedisStandaloneConfiguration clientProps = new RedisStandaloneConfiguration();
        clientProps.setHostName("localhost");
        clientProps.setPort(6379);
        clientProps.setDatabase(1);
        return new LettuceConnectionFactory(clientProps);
    }

    /** 
     * 操作0号数据库的 RedisTemplate, 
     * 创建时,直接将0号数据库的 RedisConnectionFactory 实例传递给它
     */
    @Primary
    @Bean("redis-template-db-0")
    public RedisTemplate<String, String> createRedisTemplate0(
            @Qualifier("redis-connection-factory-db0") RedisConnectionFactory factory0) {
                         ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄
        RedisTemplate<String, String> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(factory0);
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new StringRedisSerializer());
        return redisTemplate;
    }

    /** 
     * 操作1号数据库的 RedisTemplate, 
     * 创建时,直接将1号数据库的 RedisConnectionFactory 实例传递给它
     */
    @Bean("redis-template-db-1")
    public RedisTemplate<String, String> createRedisTemplate1(
            @Qualifier("redis-connection-factory-db1") RedisConnectionFactory factory1) {
                         ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄
        RedisTemplate<String, String> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(factory1);
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new StringRedisSerializer());
        return redisTemplate;
    }

}
多Redis连接的测试验证代码
@Component
@SpringBootApplication
public class MultiRedisAppMain {

    // 注入操作0号数据库的Redis模板
    @Resource(name = "redis-template-db-0")
    RedisTemplate redisTemplate0;

    // 注入操作1号数据库的Redis模板
    @Resource(name = "redis-template-db-1")
    RedisTemplate redisTemplate1;

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

    @EventListener(ApplicationReadyEvent.class)
    public void operateBook() {
        redisTemplate0.opsForValue().set("bookName", "三体");
        redisTemplate0.opsForValue().set("bookPrice", "102");
        
        redisTemplate1.opsForValue().set("bookName", "老人与海");
        redisTemplate1.opsForValue().set("bookPrice", "95");
    }
}

本小节完整的示例代码已上传到 multi-redis-demo

9. 如何同时消费多个 Kafka Topic

9.1 同时消费同一 Kakfa 服务器的多个topic

这个是最常见的情况,同时也是最容易实现的,具体操作是:为 @KafkaListener 指定多个 topic 即可,如下所示

点击查看代码
/** 多个topic在一个方法中消费的情况 */
@KafkaListener(topics = {"topic-1", "topic-2", "topic-3"}, groupId = "group-1")
                ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄
public void consumeTopc1_2_3(String message) {
    System.out.println("收到消息 kafka :" + message);
}

/** 不同 topic 在不同方法中消费的情况 */
@KafkaListener(topics = "topic-A", groupId = "group-1")
public void consumeTopicA(String message) {
    System.out.println("收到消息 kafka :" + message);
}

/** 不同 topic 在不同方法中消费的情况 */
@KafkaListener(topics = "topic-B", groupId = "group-1")
public void consumeTopicB(String message) {
    System.out.println("收到消息 kafka :" + message);
}

9.2 同时消费不同Kafka服务器的多个topic

这种情况是本小节的重点,与 spring 对 redis 的封装不同,spring 对 kafka 官方的 client lib 封装比较重,引入了以下概念

  • ConsumerFactroy

    消费者工厂,该接口能创建一个消费者,它将创建与消息系统的网络连接

  • MessageListenerContainer

    消息监听器容器,这是 spring 在 Consumer 之上单独封装出来的概念,顾名思义,该组件的作用是根据监听参数,创建一个消息监听器。看上去它似乎与 Consumer 组件要干的事一样,但在 spring 的封装结构里,consumer 实际上只负责连接到消息系统,然后抓取消息,抓取后如何消费,是其它组件的事,MessageLisntener 便是这样的组件,而 MessageListenerContainer 是创建 MessageListener 的容器类组件。

  • KafkaListenerContainerFactory

    消息监听器容器的工厂类,即这个组件是用来创建 MessageListenerContainer 的,而 MessageListenerContainer 又是用来创建 MessageLisntener 的。

看了上面3个重要的组件的介绍,你一定会产生个疑问:创建一个监听器,需要这么复杂吗?感觉一堆的工厂类,这些工厂类还是三层套娃式的。答案是:如果仅仅针对 Kafka,不需要这么复杂。spring 的这种封装是要建立一套『事件编程模型』来消费消息。并且还是跨消息中间件的,也就是说,无论是消费 kafka 还是 rabbitmq , 它们的上层接口都是这种结构。为了应对不同消息系统间的差异,才引出了这么多的工厂类。

但不得不说,作为一个具体的使用者而言,这就相当于到菜单市买一斤五花肉,非得强行塞给你二两边角料,实得五花肉只有8两不说,那二两完全是多余的,既浪费又增加负担。spring 官方的这种封装,让它们的程序员爽了,但使用者的负担却是增加了。我们愿意花大把时间来学习 Spring Framework 和 Spring Boot 的编程思想和源代码,因为这两个是非常基础的通用框架。但是对具体产品的过渡封装,使用者大多是不喜欢的,因为我们可没那么多时间来学习它的复杂设计。毕竟这些只是工具的封装,不是一个可部署的产品。业务代码要基于它们来实现功能,谁也不想错误堆栈里全是一堆第三访库的类,而不是我们自己写的代码。尽管spring 的工具质量很好。但复杂的包装增加了使用难度,概念没有理解到位、某个理解不透彻的参数配置不对、某个完全没听说过的默认配置项在自己特定的环境下出错,这些因素导致的异常,都会让开发者花费巨大的时间成本来解决。因此,对于有复杂需求的同仁们,建议大家还是直接使用 kafka 官方提供的原生 client lib, 自己进行封装,这样可以做到完全可控。

回到主题,要实现同时连接多个不同的kafka服务器,提供相应服务器的 ConsumerFactory 即可。只是 ConsumerFactory 实例还需要传递给 KafkaListenerContainerFactory,最后在 @KafkaLisntener 注解中指定要使用的 KafkaListenerContainerFactory 名称即可。

连接多个 Kafka 服务器的组件配置类
@Configuration
public class KafkaConfiguration {
    @Primary
    @Bean("consumerFactory")
            ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄
    public ConsumerFactory createConsumerFactory() {
        Map<String, Object> consumerProperties = new HashMap<>();
        consumerProperties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
        consumerProperties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        consumerProperties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        return new DefaultKafkaConsumerFactory<>(consumerProperties);
    }

    // 第二个消费工厂,为便于实操, 这里依然连接的是同一个 Kafka 服务器
    @Bean("consumerFactory2")
            ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄
    public ConsumerFactory createConsumerFactory2() {
        Map<String, Object> consumerProperties = new HashMap<>();
        consumerProperties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
        consumerProperties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        consumerProperties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        return new DefaultKafkaConsumerFactory<>(consumerProperties);
    }

    @Primary
    // 自己创建的监听容器工厂实例中,一定要有一个实例的名字叫: kafkaListenerContainerFactory,
    // 因为 KafkaAnnotationDrivenConfiguration 中也默认配置了一个 KafkaListenerContainerFactory,
    // 这个默认的 KafkaListenerContainerFactory 名称就叫 kafkaListenerContainerFactory,
    // 其装配条件就是当容器中没有名称为 kafkaListenerContainerFactory 的Bean时,那个装配就生效,
    // 如果不阻止这个默认的KafkaListenerContainerFactory装备,会导致容器中有两个 KafkaListenerContainerFactory,这会引入一些初始化问题
    @Bean("kafkaListenerContainerFactory")
    public KafkaListenerContainerFactory<KafkaMessageListenerContainer> createContainerFactory1(
            ConcurrentKafkaListenerContainerFactoryConfigurer configurer,
            @Qualifier("consumerFactory") ConsumerFactory consumerFactory) {
                         ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄
        ConcurrentKafkaListenerContainerFactory listenerContainerFactory = new ConcurrentKafkaListenerContainerFactory();
        configurer.configure(listenerContainerFactory, consumerFactory);
        return listenerContainerFactory;
    }

    // 第二个监听器容器工厂
    @Bean("kafkaListenerContainerFactory2")
    public KafkaListenerContainerFactory<KafkaMessageListenerContainer> createContainerFactory2(
            ConcurrentKafkaListenerContainerFactoryConfigurer configurer,
            @Qualifier("consumerFactory2") ConsumerFactory consumerFactory2) {
                         ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄
        ConcurrentKafkaListenerContainerFactory listenerContainerFactory = new ConcurrentKafkaListenerContainerFactory();
        configurer.configure(listenerContainerFactory, consumerFactory2);
        return listenerContainerFactory;
    }
}
连接多 Kafka 服务器的测试主程序
@Component
@EnableKafka
@SpringBootApplication
public class MultiKafkaAppMain {
    public static void main(String[] args) {
        SpringApplication.run(MultiKafkaAppMain.class, args);
    }

    @KafkaListener(topics = "topic1", groupId = "g1", containerFactory = "kafkaListenerContainerFactory")
                                                                           ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄
    public void consumeKafka1(String message) {
        System.out.println("[KAFKA-1]: 收到消息:" + message);
    }

    @KafkaListener(topics = "topic-2", groupId = "g1", containerFactory = "kafkaListenerContainerFactory2")
                                                                           ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄
    public void consumeKafka2(String message) {
        System.out.println("[KAFKA-2]: 收到消息:" + message);
    }

    @EventListener(ApplicationReadyEvent.class)
    public void init() {
        System.out.println("[MAIN]: 启动成功,等待Kakfa消息");
    }
}

本小节完整的示例代码已上传到 multi-kafka-demo

10. 如何查看程序启动后所有的 Properties

方式一:遍历Environment对象

Spring Boot 中有个 Environment 接口,它记录了当前激活的 profile 和所有的「属性源」,下面是一段在 runtime 期间打印所有 properties 的示例代码

PrintAllPropetiesDemo.java(点击查看)
@Component
public class PrintAllPropetiesDemo {
    @Resource
    Environment env;

    @EventListener(ApplicationReadyEvent.class)
    public void printAllProperties throws Exception {
        // 打印当前激活的 profile
        System.out.println("Active profiles: " + Arrays.toString(env.getActiveProfiles()));
        
        // 从「环境」对象中,获取「属性源」
        final MutablePropertySources sources = ((AbstractEnvironment) env).getPropertySources();

        // 打印所有的属性,包括:去重、脱敏
        StreamSupport.stream(sources.spliterator(), false)
                .filter(ps -> ps instanceof EnumerablePropertySource)
                .map(ps -> ((EnumerablePropertySource) ps).getPropertyNames())
                .flatMap(Arrays::stream)
                // 去除重复的属性名
                .distinct()
                // 过滤敏感属性内容
                .filter(prop -> !(prop.contains("credentials") || prop.contains("password")))
                .forEach(prop -> System.out.println(prop + ": " + env.getProperty(prop)));
    }
}

方式二:查看 Spring Acuator 的 /env 监控页面 <推荐>

先引入 acuator 的依赖

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

然后在配置 acuator 的 web 访问 uri

@Bean
public SecurityWebFilterChain securityWebFilterChain(
  ServerHttpSecurity http) {
    return http.authorizeExchange()
      .pathMatchers("/actuator/**").permitAll()
      .anyExchange().authenticated()
      .and().build();
}

假定端口为8080, 则访问 http://localhost:8080/acuator/env 便能看到工程运行起来后所有的 properties 了

11. 如何申明和使用异步方法

在 SpringBoot 中使用异步方法非常简单,只要做以下同步

  • 启用异步特性
  • 在要异步执行的方法中,添加 @Async 注解

下面是一段示例代码

// 启用异步特性
@EnableAsync
public class BookService {
    @Async   // 声明要异步执行的方法
    public void disableAllExpiredBooks(){
        ....
    }
}

📣 特别说明

以上代码确实可以让 disableAllExpiredBook() 方法异步执行,但它的执行方式是: 每次调用此方法时,都新创建一个线程,然后在新线程中执行这个方法。如果方法调用得不是很频繁,这个做法是OK的。但如果方法调用得很频繁,就会导致系统频繁地开线程,而创建线程的开销是比较大的。Spring 已经考虑到了这个场景,只需要为异步执行的方法指定一个执行器就可以了,而这个执行器通常都是一个具备线程池功能的执行器。示例代码如下:

@EnableAsync
public class BookService {
    @Async("bookExcutor")  // 在注解中指定执行器
             ̄ ̄ ̄ ̄ ̄ ̄ ̄
    public void disableAllExpiredBooks(){
        ....
    }
}

@Configuration
public class ExecutorConfiguration {
    // 装配书籍任务的通用执行器
    @Bean("bookExcutor")
            ̄ ̄ ̄ ̄ ̄ ̄ ̄
    public Executor speedingArbitrationExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(6);
        executor.setMaxPoolSize(24);
        executor.setQueueCapacity(20000;
        executor.setKeepAliveSeconds(30);
        executor.setThreadNamePrefix("书籍后台任务线程-");
        executor.setWaitForTasksToCompleteOnShutdown(true);
        // 任务队列排满后,直接在主线程(提交任务的线程)执行任务,异步执行变同步
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        return executor;
    }
}

12. 如何快速添加 boot 的 maven 依赖项

Spring Boot 是一个以Boot为中心的生态圈,当我们指定了boot的版本后,如果要使用中生态圈中的组件,就不用再指定该组件的版本了。有两种方式可达到此目的。

  • 方式一:项目工程直接继承 Boot Starter Parent POM
<parent>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-parent</artifactId>
	<version>3.1.5</version>
</parent>
  • 方式二:在pom.xml的依赖管理节点下,添加 spring-boot-dependencies
<dependencies>
  <!-- ② 这里添加starter依赖,但不用指定版本 -->
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
  </dependency>
</dependencies

......

<dependencyManagement>
  <dependencies>
    <!-- ① 在这里添加spring-boot的依赖pom -->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-dependencies</artifactId>
      <version>2.7.16</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement>

同理,如果要引入 Spring Cloud 生态圈中的相关组件,也建议通过「方式二」,把 spring-cloud-dependencies 加入到依赖管理节点下

13. 如何以静态方式获取 HttpServletRequest 和 HttpServletResponse

通过 spring-web 组件提供的 RequestContextHolder 中的静态方法来获取 HttpServletRequest 和 HttpServletResponse,如下所示:

import org.springframework.web.util.WebUtils;

import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

public class WebTool extends WebUtils {

    public static HttpServletRequest getHttpRequest() {
        RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
         ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄
        ServletRequestAttributes servletRequestAttributes = (ServletRequestAttributes) requestAttributes;
        return servletRequestAttributes.getRequest();
    }

    public static HttpServletResponse getHttpResponse() {
        RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
         ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄
        ServletRequestAttributes servletRequestAttributes = (ServletRequestAttributes) requestAttributes;
        return servletRequestAttributes.getResponse();
    }
}

14. 如何解决 ConfigurationProperties 不生效的问题

如果你在自己的 Properties 类上添加了 @ConfigurationProperties 注解,启动程序后没有效果,可参考下面这两种方法来解决:

  • 方式一
    1. 在启动类添加 @EnableConfigurationProperties 注解

    2. 在 @ConfigurationProperties 标注的类上添加 @Component 注解 (@Service注解也可以)

    启动类

    @SpringBootApplication
    @EnableAutoConfiguration
    @EnableConfigurationProperties 
     ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄
    public class MyBootApp {
         public static void main(String[] args) {
             SpringApplication.run(MyBootApp.clss, args);
         }
    }
    

    自定义的 Properties 类

    @Component
     ̄ ̄ ̄ ̄ ̄ ̄ ̄
    @ConfigurationProperties(prefix="gzub.hdfs")
     ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄
    public class HdfsProperties {
        private String nameNode;
        private String user;
        private String password;
    }
    
  • 方式二
    1. 在启动类添加 @ConfigurationPropertiesScan 注解,并指定要扫描的 package
    2. 在自定义的 Properties 类上添加 @ConfigurationProperties(不需要添加 @Component 注解)

    启动类

    @SpringBootApplication
    @ConfigurationPropertiesScan({"vip.guzb"})
     ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄
    public class MyBootApp {
         public static void main(String[] args) {
             SpringApplication.run(MyBootApp.clss, args);
         }
    }
    

    自定义的 Properties 类

    @ConfigurationProperties(prefix="gzub.hdfs")
     ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄
    public class HdfsProperties {
        private String nameNode;
        private String user;
        private String password;
    }
    

15. 如何统一处理异常

  1. 编写一个普通的Bean,不继承和实现任何类与接口

  2. 在该Bean的类级别上添加 @RestControllerAdvice 注解,向框架声明这是一个可跨 Controller 处理异常、初始绑定和视图模型特性的类

  3. 在类中编写处理异常的方法,并在方法上添加 @ExceptionHandler 注解,向框架声明这是一个异常处理方法

    编写异常处理方法的要求如下:

    • 方法是 public 的
    • 方法必须用 @ExceptionHandler 注解修饰
    • 方法的返回值就是最终返给前端的内容,通常是JSON文本
    • 方法参数中,需指定要处理的异常类型
  4. 如果需要对特定异常做特殊的处理,则重复第3步

下面是一较完整的示例代码(点击查看)
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import org.springframework.http.ResponseEntity
import org.springframework.http.HttpStatus;

@RestControllerAdvice
public class MyGlobalExceptionHandlerResolver {
    
    /** 处理最外层的异常 */
    @ExceptionHandler(Exception.class)
    public ResponseEntity<ErrorResponse> handleException(Exception e) {
        List details = new ArrayList();
        details.add(e.getMesssage());
        ErrorResponse error = new ErrorResponse(e.getMessage, details);
        return new ResponseEntity<>(error, HttpStatus.BAD_REQUEST);
    }

    /** 处理业务异常,这里使用了另外一种方式来设置 http 响应码 */
    @ExceptionHandler(BusinessException.class)
    @ResponseStatus(HttpStatus.HTTP_BAD_REQUEST)
    public ErrorResponse handleException(BusinessException e) {
        List details = new ArrayList();
        details.add(e.getBackendMesssage());
        return new ErrorResponse(e.getFrontendMessage(), details);
    }
}

/** 返回给前端的错误内容对象 */
public class ErrorResponse {
    private String message;
    private List<String> details;
    ......
}

/** 业务异常 */
public class BusinessException extends RuntimeException{
    private String frontendMessage;
    private String backendMessage;
    ......
}

16. 应该对哪些异常做特殊处理

对于Web开发而言,我们应该在全局异常处理类中,对以下异常做特殊处理

  • Exception
  • BusinessExecption
  • HttpRequestMethodNotSupportedException
  • HttpClientErrorException
  • FeignException
  • ConstraintViolationException
  • ValidationException

17. 异常处理组件应该具备的特性

  1. 业务异常处理

    • 异常信息中,要明确区分出前端展示内容与后端错误内容

    • 后端错误内容可再进一步分为「错误的一般描述信息」和「详细的错误列表」

    • 前后端错误信息中,应过滤敏感内容,如身份证、密码等,且过滤机制提供开关功能,以方便开发调试

    • 异常信息中,应该包含业务流水号,便于调试和排查线上问题时,将各个节点的错误内容串联起来

    • 多数情况下,业务异常都不应该打印堆栈,只需要在日志中输出第一个触发业务异常的代码位置即可

      • 因为业务异常是我们在编码阶段就手动捕获了的,也就是说,这些异常是可预期的,并且是我们自己手动编码抛出的。因此,只需要输出该异常的抛出点代码位置,异常堆栈是没有意义的,它只会增加日志的存储体积
      • 另外,多数业务异常都是在检查业务的执行条件时触发的,比如:商品不存在、库存不足、越权访问、输入数据不合规等。且这类错误会频繁发生,若输出其堆栈的话,日志中会大量充斥着这样的异常堆栈。它既增加了日志的存储体积,也干扰了正常日志内容的查看
    • 异常信息中,要详细记录错误内容,尽可能把异常现场的信息都输出。
      这是开发人员最容易给自己和他人挖坑的地方,比如:一个业务异常的日志输出内容是这样:“积分等级不够”。这个异常信息是严重不足的,它缺少以下这些重要信息,以致极难在线上排查问题:

      • 谁的积分等级不足
      • 这个用户当前的积分是多少
      • 他要拥有多少积分,和什么样的等级
      • 他在访问什么资源

      注意:您可能会有疑问,把用户账号输出到日志就可以了,没必要输出它当前的积分,因为积分可以去数据库查。但这样做是不行的,因为:

      • 生产环境的数据库研发人员是不能直接访问的,让运维人员查,效率不高还增加运维工作量
      • 数据查询出来的值,也不是发生异常当时的值,时光荏然,你大妈已经不你大妈了 😁
      • 即使是个相对静态(变动不频繁)的参数,运行期代码所使用的值,也极有可能与数据库中不一致。比如程序启动时,没有从数据库中加载,而是使用了默认值,又或者是某个处理逻辑将它的值临时改变了
  2. 非业务异常

    • 尽可能地捕获所有异常
    • 一定要在日志中输出非业务异常的堆栈<重要>
    • 尽量不要二次包装非业务异常,如果一定要包装,「务必」在将包装后的异常 throw 前,先输出原始异常的堆栈信息

18. 为什么出错了却没有异常日志

在 WebMVC 程序中,通常都有一全局异常处理器(如15小节所述),因此,有异常一定是会被捕获,并输出日志的。不过,这个全局异常处理器,仅对Web请求有效,如果是以下以下情况,则需要在代码中手动捕获和输出异常日志:

  • 在非WEB请求的线程中运行的代码
    比如定时任务中的代码所产生的异常。如果没有捕获和输出异常日志,那么发生了异常也不知道,只能从结果数据上判断,可能发生了错误,但却无法快速定位。

  • 从Web请求线程中脱离出来的异步线程中的代码
    这种情况更常见,同时也要非常小心。比如异步发送短信,异步发邮件等,一定要做好异常处理

19. 如何处理异常日志只有一行简短的文本

比如下面这个经典的场景

java.lang.NullPointerException

异常信息只有这么一行,没有代码位置,没有causedException, 更没有堆栈。这是因为JVM有个快速抛出(FastThrow)的异常优化:如果相同的异常在短时间内集中大量throw,则将这些异常都合并为同一个异常对象,且没有堆栈。

解决办法为:java 启动命令中,添加-OmitStackTraceInFastThrow这个JVM选项,如:

java -XX:-OmitStackTraceInFastThrow -jar xxxx.jar

📌 说明1

JVM只对以下异常做FastThrow优化

  • NullPointerException
  • ArithmeticException
  • ArrayStoreException
  • ClassCastException
  • ArrayIndexOutOfBoundsException

📌 说明2

出现此问题,基本上意味着代码有重大缺陷,跟死循环差不多,不然不会出现大量相同的常集中抛出。另外,开启该选项后,若这种场景出现,是会刷爆日志存储的。当然,相比之下找到问题更重要,该选项是否要在生产环境开启,就自行决定吧。

20. 如何解决同一实例内部方法调用时,部分事务失效的问题

事务失效示例代码(点击查看)
@Service
public class BookService {
    @Resource
    BookDao bookDao;

    public void changePrice(Long bookId, Double newPrice) {
        doChangePrice(bookId, newPrice);
        logOperation();
        sendMail();
    }

    @Transactional(rollbackFor = Exception.class)
    public void resetPrice(Long bookId, Double newPrice) {
        doChangePrice(bookId, newPrice);
        logOperation();
        sendMail();
    }

    @Transactional(rollbackFor = Exception.class)
    public void doChangePrice(Long bookId, Double newPrice) {
        bookDao.setPrice(bookId, newPrice);
    }

    @Transactional(rollbackFor = Exception.class)
    public void logOperation(Long bookId, Double newPrice) {
        .... // 省略记录操作日志的代码
    }

    public void sendMail(Long bookId, Double newPrice) {
        .... // 省略发送邮件的代码
    }
}

上述代码,调用 changePrice() 方法时,如果 sendMail() 方法在执行时发生了异常,则前面的 doChangePrice() 和 logOperation() 所执行的数据库操作均不会回滚。但同样的情形如果发生在 resetPrice() 方法上,doChangePrice() 和 logOperation() 均会回滚。

这个例子还可以进行更细化的演进,不过核心原因都是一个:Spring 对注解事务的实现手段,是通过 CGLib 工具库创建一个继承这个业务类的新类,捕获原业务类方法执行期间的异常,然后执行回滚的。但是对原业务类中,方法内部对其它方法的调用,这个被调用的方法,其上的事务注解则不再生效。如果直接在外部调用这些方法,则事务注解是生效的。

以上面的示例代码为准, changePrice() 方法内部分别调用了 doChangePrice()、logOperation()、sendMail() 三个方法,但由于 changePrice() 方法本身并没有添加事务注解,因此,它内部调用的 doChangePrice()、logOperation() 这两个方法的事务注解是不生效的。因此,实际上执行过程都没有开启事务。当然,如果是从外部直接单独调用 doChangePrice() 和 logOperation(),则二者的事务均生效。

解决办法:在外部单独调用这些有事务注解的方法。如果需要将这些方法组合在一个方法体内,整体完成一个业务逻辑,也在其它类中创建方法,在该方法中调用这些有事务注解的方法完成逻辑组织。

21. 如何阻止某个第三方组件的自动装配

  1. 方法一:配置 @SpringBootApplication 注解的 exclude 属性

    如下代码所示:

    // 启动时,将Spring官方的数据源自动装配排除
    @SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})       
     ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄
    public class MyAppMain{
      public static void main(String[] args) {
        SpringApplication.run(MyAppMain.class, args);
      }
    }
    
  2. 方法二:在配置文件中指定 <推荐>

    方法一需要修改代码,对于普通的业务系统而言,是能不改代码就坚决不改。因此推荐下面这种配置的方式来指定:

    spring:
      autoconfigure:
        # 指定要排除的自动装配类,多个类使用英文逗号分隔
        exclude: org.springframework.cloud.gateway.config.GatewayAutoConfiguration
    
  3. 方法三:临时注释掉该组件的 @EnableXXX 注解
    比如常见的 @EnableConfigurationProperies 、@EnalbeAsync 、@EnableJms 等,在代码中临时注释掉这些注解即可。但仅适用于提供了这种 Enable 注解方式装配的组件。

22. 如何进行Body、Query、Path Variable类型的参数校验

  • Http Body 实体类型的参数校验

    这里特指 JSON 格式的 Body 体,这是最常见的情况。步骤如下:

    1. 编写一个类用来接收JSON格式的Body参数。这个类的要求如下

    • 字段需有相应的 Getter 和 Setter 方法
    • 在要做校验的字段上添加相应的约束注解,如 @NotBlank

    2. 对应的 Controller 方法参数中,使用 @RequestBody 修饰类型为第1步中写的类

    3. 对应的 Controller 方法参数中,使用 @Valid 或 @Validated 修饰类型为第1步中写的类

    示例代码(点击查看)
    /** 接收 http body JSON 参数的对象 */
    public class AddRoleRequest {
        @NotBlank(message = "角色编码不能为空")
        private String code;
    
        @NotBlank(message = "角色名称不能为空")
        private String name;
    
        @NotEmpty(message = "角色适用的区域等级不能为空")
        private List<RegionLevel> regionLevels;
    
        // Getter & Setter
    }
    
    @RestController
    @RequestMapping(path="/role")
    public class RoleController {
        // 这里的 @Valid 也可以换成 @Validated
        @PostMapping(path="/add")
        public void addRole(@Valid @RequestBody AddRoleRequest addRequest) {
            // 业务代码 ...
        }
    }
    
  • Query 与 Path Variable 类型的参数校验

    如下所示,下划线部分就是 Query 参数, 而{}中的内容就是 Path Vairable

    http://demo.guzb.vip/books/{china}/list-roles?code=system-admin&regionLevel=COUNTY
                                                   ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄
    

    默认情况下,Query 与 Path Variable 参数验证是没有效果的。可通过以下步骤开启该类型的参数校验:

    • 提供一个 MethodValidationPostProcessor 来处理 @Validated 注解。
    • 在 Controller 类上添加 @Validated 注解
      ⚠️ 注意:将 @Validate 注解添加在 Controller 的方法上或方法的参数上,均不会使 MethodValidationPostProcessor 生效,也就不能执行Query与PathVariable参数的校验
    示例代码(点击查看)
    @Configuration
    public class ValidationConfig {
        /** 
         * 重点是要添加一个MethodValidationPostProcessor实到到Bean容器中,
         * URL路径参数(Path Vairable)和查询参数(Query Parameter)的校验才会生效
         */
        @Bean
        public MethodValidationPostProcessor methodValidationPostProcessor() {
           return new MethodValidationPostProcessor();
        }
    }
    
    @Validated    // 这个注解必须加在 Controller 类级别上,MethodValidationPostProcessor 才会生效
     ̄ ̄ ̄ ̄ ̄ ̄
    @RestController
    @RequestMapping(path="/books")
    public class RoleController {
        @PostMapping(path="/{region}")
        public void addRole(
                @PathVairable("region") region, 
                @RequestParam("author") @Size(min=2, message="作者名称长度不能小于2")author) {
            // 业务代码 ...
        }
    }
    

    Query 与 Path Variable 参数验证是不需要在Controller方法的参数签名上加 @Validated 修饰的

    Spring Validation 框架在参数检验未通过时,会抛出 ConstraintViolationException 异常,因此应该在全局异常处理类中(请参考第15小节),添加对它的处理。

    ConstraintViolationException 异常处理示例代码(点击查看)
    @ExceptionHandler(ConstraintViolationException.class)
    public final ResponseEntity<ErrorResponse> handleConstraintViolation(ConstraintViolationException ex) {
      List<String> details = ex.getConstraintViolations()
                    .stream()
                    .map(ConstraintViolation::getMessage)
                    .collect(Collectors.toList());
    
      ErrorResponse error = new ErrorResponse(BAD_REQUEST, details);
      return new ResponseEntity<>(error, HttpStatus.BAD_REQUEST);
    }
    

📣 特别说明

  • 需要将 JSR-303 的api及相应实现添加到 classpath。当我们引入SpringMvc时,它们也自动引入了
  • @Valid 是 JSR-303 的标准注解
  • @Validated 是 Spring 的验证框架注解,它完全兼容 @Valid
  • MethodValidationPostProcessor 是 Spring 的验证框架中的一个容器Bean后置处理器

23. 如何级联校验多层级的参数对象

如果一个对象,它的拥有的字段,都是String 和 Java 的原始(Primitive)类型或其对应的包装类型,那么这些字段上具体的JSR-303校验注解是会生效的。但如果字段类型是数组、集合、或自定义的其它类,则我们在自定类的义字段上添加的JSR-303校验注解,默认情况下是不生效的。

有两种方式使上述多层级复杂结构对象上的校验注解生效:在复杂类型字段上添加 @Valid 注解,或在复杂类型的 class 定义上添加 @Valid注解,如下所示:

public class BookVo {
    @NotBlank(message = "图书名称不能为空")
    private String name;

    @Valid                    // 在author字段上添加该注解后,其内部的JSR-303约束注解就能生效了
    private AuthorVo author;

    // 出版商字段没有添加 @Valid 注解,而是在 PublisherVo 类的定义上添加了该注解
    privaet PublisherVo publisher;
}

public class AuthorVo {
    @NotBlank(message = "作者名称不能为空")
    private String name;

    @NotNull(message = "年龄不为空")
    @Range(min=6, max=120, message = "年龄必须在 6~120 以内");
    private Integer age;
}

/** 注解直接作用在类上,这样所有类型为该类的字段,校验都会生效 */
@Valid 
public class Publisher {
  @NotBlank(message = "出版商名称不能为空")
  private name;

  @NotBlank(message = "出让商地址不能为空")
  private String address;
}

24. 如何在程序启动完毕后自动执行某个任务

  • 方式一:实现 InitializingBean接口

    InitializingBean 是 Spring 基础框架提供的一个工 Bean 生命周期接口,它只有一个名为 afterPropertiesSet() 的方法。如果一个受容器管理的类实现了 InitializingBean,那么 Spring 容器在初始化完这个类后,会调用它的 afterPropertiesSet() 方法。比如下面这段示例代码:

    import org.springframework.stereotype.Component;
    import org.springframework.beans.factory.InitializingBean;
    
    @Component
    public class AuthenticationFailureLimitor implements InitializingBean {
        private LimitSettings limitSettings;
        
        // 这是一个模拟的业务方法:限制认证失败的次数
        public void tryBlock(int failureCount) {
            if (limitSettings.isEnable && failureCount > limitSettings.getMaxFailureCount) {
                doBlock();
            }
        }
    
        /** 
         * 本方法将在初化完成后(即所有需要自动注入的字段都被赋值后)调用
         * 这里在方法中模拟对限制设置对象的初始加载
         */
        @Override
        public void afterPropertiesSet() throws Exception {
            this.limitSettings = loadLmitSettings();
        }
        
    }
    
  • 方式二:使用 @PostContruct 注解修饰要在启动完成后立即执行的方法

    @PostContruct 是Java JSR-250 基础规范中的标准注解,

    import javax.annotation.PostConstruct;
    import org.springframework.stereotype.Component;
    
    @Component
    public class AuthenticationFailureLimitor {
    
        // 其它业务代码
        ......
    
        @PostConstruct
        public void init() {
            System.out.println("init()方法将在启动完成后执行");
        }
    
        // 方法的作用域即使是 private 也可以
        @PostConstruct
        private void setup() {
            System.out.println("setup()方法将在启动完成后执行");
        }
    }
    

    上述示例代码中的 init() 和 setup() 方法都会在启动完成后执行

  • 方式三:监听容器事件 <推荐>

    Spring 基础框架提供了事件机制,在容器启动的各个阶段中,均会向容器内的组件广播相应的事件,以便业务代码或第三方组件添加自己的扩展逻辑。有两种方法来监听事件。

    1. 实现 ApplicationListener 接口

    这是在 Spring4.2 版本以前的标准做法,接口定义了 onApplicationEvent () 方法,接口声明支持范型,可以指定要监听事件类型,这里需要监听的事件为 ApplicationReadyEvent。示例代码如下:

    import org.springframework.stereotype.Component;
    import org.springframework.context.ApplicationListener;
    
    @Component
    public class OneceTask implements ApplicationListener<ApplicationReadyEvent> { // 指定要监听的事件
                                                          ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄
        @Override
        public void onApplicationEvent(ApplicationReadyEvent event) {
            System.out.println("onApplicationEvent()方法将在容器启动完成后执行");
        }
    }
    

    2. 用 @EventLisnter 注解修饰目标方法 <推荐>

    随着注解方式装配容器成为主流,Spring4.2 版本以后引入了 @EventListener 来快速实现事件监听。示例代码如下:

    import org.springframework.stereotype.Component;
    import org.springframework.context.event.EventListener;
    
    @Component
    public class OnceTask {
        // 监听的事件还可以换成 ApplicationReadyEvent, 作用域也可以是 private 的
        @EventListener(ApplicationStartedEvent.class)
        private void doSomething(ApplicationStartedEvent event){
            System.out.println("我是容器启动后的初始化任务");
        }
    }
    
  • 方式四:实现 CommandLineRunner 接口 <推荐>

    SpringBoot 第一个版本就有这个接口,当应用容器完成所有Bean的装配后(对应的事件为 ApplicationStarted,此时应用还不能接收外部请求),将调用该接口内的方法。示例代码如下:

    import org.springframework.stereotype.Component;
    import org.springframework.boot.CommandLineRunner;  
    @Component
    public class OnceTask implements CommandLineRunner {
        // 监听的事件还可以换成 ApplicationReadyEvent
        @Override
        public void run(String... args) throws Exception {
            System.out.println("我将在应用容器完成所有Bean的装配后执行");
        }
    }
    

📣 特别说明

严格说来,事件监听方式和 CommandLineRunner 方式才是最符合要求的,它才是真正意义上的「容器启动完成后」执行的方法。另外两种方式实际上是在「Bean 初始化完成后」执行的。

假定有一个类,集中使用了上面的所有方式,那么这些方法谁先执行谁后执行呢 ?看看下面这个例子:

示例代码(点击查看)
@Comonent
public class OnceTask implements InitializingBean, ApplicationListener, CommandLineRunner {
    @PostConstruct
    private void setup() {
        System.out.println("OnceTask.@PostConstruct");
    }

    @EventListener
    private void onStartedByAnnotation(ApplicationStartedEvent event){
        System.out.println("OnceTask.@EventListener(ApplicationStartedEvent)");
    }

    @EventListener
    private void onReadyByAnnotation(ApplicationReadyEvent event){
        System.out.println("OnceTask.@EventListener(ApplicationReadyEvent)");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("OnceTask .afterPropertiesSet()");
    }

    @Override
    public void onApplicationEvent(ApplicationStartedEvent event) {
        System.out.println("OnceTask.onStartedByInterface(ApplicationStartedEvent)");
    }

    @Override
    public void run(String... args) throws Exception {
        System.out.println("OnceTask.commandLineRunner");
    }
}

以上代码的执行结果为:

OnceTask.@PostConstruct
OnceTask.afterPropertiesSet()
OnceTask.onStartedByInterface(ApplicationStartedEvent)
OnceTask.@EventListener(ApplicationStartedEvent)
OnceTask.commandLineRunner
OnceTask.@EventListener(ApplicationReadyEvent)

另外,使用XML装配方式时,在XML的<Bean>标签中,还可以通过 init-method 属性指定某个类的初始化方法,其作用与 @PostContrust 注解和 InitializingBean 的 afterProperties() 方法一致。但由于目前(2023年)国内所有新项目都使用注解来装配容器,这里就不再详细介绍它了。

25. 如何解决Bean装配过程中的循环依赖

循环依赖示意图:

┌───┐                    ┌───┐                    ┌───┐
│ A │ --- Depends On --> │ B │ --- Depends On --> │ C │
└───┘                    └───┘                    └─┬─┘
  ↑                                                 │
  └─────────────────── Depends On ──────────────────┘

Spring 本身是不支持循环依赖的,在程序启动期间,Bean 容器会检查是否存在循环依赖,如果存在,则直接启动失败,同时也会在日志中输出循环依赖的 Bean 信息。

最好的办法是在设计上避免循环依赖,如果实在避免不了,可以通过「手动装配部分」依赖的方式来解决。即让 Spring 完成无循环依赖的部分,在程序启动完毕后,再手动完成涉及循环依赖部分。下面是一个示例(示例的代码注释阐述了实现原理):

存在循环依赖问题的原始代码(点击查看)
//这个设计中,SerivceA 和 ServiceB 相互依赖对方,导致容器启动失败
@Service
public class ServiceA {
    @Autowired
    private ServiceB serviceB;
}

@Service
public class ServiceB {
    @Autowired
    private ServiceA serviceA;
}
通过手动装配部分依赖,解决循环依赖问题(点击查看)
@Service
public class ServiceA {
    // serviceB 字段的值不交由 Spring 容器处理,由我们手动赋值
    private ServiceB serviceB;

    /**
     * 这里通过「应用程序启动完成」事件,通过Bean容器中取出 ServiceB 实例
     * 然后再手动赋值给 serviceB 字段,解决循环依赖问题
     *
     * 说明一:ApplicationStartedEvent 事件表明所有 Bean 已装配完成,但此时尚未发生任何对外服务的调用,
     *        而整个系统可以对外提供服务的事件是 ApplicationReadyEvent, 因此这里使用 Started 事件更合适
     *
     * 说明二:手动装配的关键是「拿到ApplicationContext」和「在合适的时机进行手动装配」,这个合适的时机就是 ApplicationStartedEvent
     *       「拿到ApplilcationContext对象」还有其它一些办法,参见「第13小节」
     *       「合适的时机」同样也有一些其它的选择,参见「第24小节」
     */
    @EventListener(ApplicationStartedEvent.class)
    void setCycleDependencyFields(ApplicationStartedEvent appStartedEvent) {
        ServiceB serviceB = appStartedEvent.getApplicationContext().getBean(ServiceB.class);
        this.serviceB = serviceB;
    }
}

// ServiceB 正常装配
@Service
public class ServiceB {
    @Autowired
    private ServiceA serviceA;
}

26. 如何在所有Web请求的前后执行自己的代码

采用以下两种方式中的一种即可

  1. Sevlet 过滤器

  2. SpringMvc的HandlerInterceptor接口

27. 如何统一给配置项属性值加密

一般说来,研发人员是接触不到生产环境中的配置文件的,正规的项目,也不会将生产环境的信息内置到源代码Jar包中。因此,多数 C 端的项目是不需要对配置文件进行加密的。有此要求的大多是 toB 或 toG 类项目。

统一给配置文件中的指定属性值加密,可以使用 Jasypt 来完成。Jasypt 原本只是一个加密解密的基础工具,但经过进一步封装增强后的 jasypt-spring-boot-starter,便能够统一地对 SpringBoot 项目中的加密配置属性进行解密。全程是自动的,默认情况下,只需要进行以下两步设置:

  1. 设置 jasypt 的加密密钥

    Jasypt 默认的加密类的是 SimpleAsymmetricStringEncryptor, 它的密钥取自属性 jasypt.encryptor.password

  2. 生成密文并标识其需要由 Jasypt 做解密处理

    将要加密的明文,提前用第1步的密钥生成密文,然后将其包裹在ENC()的括号中,这样 Jasypt 就会在属性加载完毕后,对被 ENC() 包裹的属性值进行解密,并用解密后的明文替换原来的值。

下面是实操步骤:

引入依赖

<dependency>
    <groupId>com.github.ulisesbocchio</groupId>
    <artifactId>jasypt-spring-boot-starter</artifactId>
    <!-- SpringBoot3 以上的版本,使用3.x的版本,反之使用2.x的版本 -->
    <version>2.1.2</version>
</dependency>

配置文件中针敏感属性加密

# 无需加密的配置项,以明文配置
demo-app:
  username: westing-loafer
  password: continuous-wandering

# 加密后的配置项,PropertySource 加载后,[Jasypt][jasypt] 会查找 被 ENC() 包裹的配置属性项,然后将其解码
database:
  username: ENC(QTQhWWDOt4c2u3gHzd50F38nkQriShqE)               # ①
  password: ENC(NMiiJQbnMQFhZBbmiEa+LEe7Ps+u+DmWNd1JATXXPWs=)   # ②

# Jasypt 的加密密钥,解密配置项时,也使用该密钥。这里将其注释,因为正式的项目,不会将密钥写在配置文件中
# 详见 com.ulisesbocchio.jasyptspringboot.encryptor.DefaultLazyEncryptor#createPBEDefault() 方法
# jasypt.encryptor.password: cnblogs

在主方法中验证

点击查看代码
@SpringBootApplication
public class JaspytDemoAppMain implements CommandLineRunner {

    @Autowired
    Environment env;

    public static void main(String[] args) {
        args = checkOrSetDefaultJasyptPassword(args);           // ③
        SpringApplication.run(JaspytDemoAppMain.class, args);
    }

    /**
     * 检查 Jasypt 的密钥设置情况,若未通过命令行传递,则设置默认值
     * @param cmdLineArgs 命令行的参数
     * @return 经过检查后的参数数组
     */
    private static String[] checkOrSetDefaultJasyptPassword(String[] cmdLineArgs) {
        String defaultJasyptPasswordProperty = "--jasypt.encryptor.password=cnblogs";
        if (cmdLineArgs.length == 0) {
            return new String[]{defaultJasyptPasswordProperty};
        }

        if (isCmdLineArgsContainsJasyptPassword(cmdLineArgs)) {
            return cmdLineArgs;
        }
        
        String[] enhancedArgs = new String[cmdLineArgs.length + 1];
        for (int i = 0; i < cmdLineArgs.length; i++) {
            enhancedArgs[i] = cmdLineArgs[i];
        }
        enhancedArgs[enhancedArgs.length - 1] = defaultJasyptPasswordProperty;
        return enhancedArgs;
    }

    private static boolean isCmdLineArgsContainsJasyptPassword(String[] args) {
        for (String arg : args) {
            if (arg.startsWith("----jasypt.encryptor.password=")) {
                return true;
            }
        }
        return false;
    }

    @Override
    public void run(String... args) throws Exception {
        // 这两个配置,本身就是明文的
        System.out.println("demo-app.username = " + env.getProperty("demo-app.username"));
        System.out.println("demo-app.password = " + env.getProperty("demo-app.password"));

        // 以下两个属性配置项,文件为密文,但PropertySource加载后经过jasypt的处理,变成了明文
        System.out.println("database.username = " + env.getProperty("database.username"));
        System.out.println("database.password = " + env.getProperty("database.password"));
    }
}

代码说明一:

上述代码的 ① ② 处,您一定会有疑问: 这个密文是如何生成的呢,Jasypt 如何能在项目启动阶段对其正确的解密呢?没错,实际上这里的密文就是提前用 Jasypt 加密生成出来的。必须要保证生成密文所用的 password 与 SpringBoot 项目中给 Jasypt 指定的 password 内容是一致的,才能解密成功。下面是一段简单的加密代码示例:

public static String encrypt(String plainText, String secretKey) {
    BasicTextEncryptor textEncryptor = new BasicTextEncryptor();
    textEncryptor.setPassword(secretKey);
    return textEncryptor.encrypt(plainText);
}

代码说明二:

代码 ③ 处,在正式执行 SpringApplication.run(....) 方法之前, 对命令行参数 args 进行了检查,并使用了检查后的 args 作为命令行参数传递给 SpringApplication.run() 方法。对 args 参数的检查逻辑为:判断 args 中是否包含 --jasypt.encryptor.password= 的配置,如果没有,则默认追加上该条目,并给出一个默认的password。

这一步实际上就是希望将 Jasypt 的密钥通过命令行参数传递过来,而不是配置在配置文件中,避免可以通过配置中心的管理页面,直接查看到该密钥。如何保管好密钥,这是一个纯管理问题了,技术上只要能支撑起设计好的管理方式即可。

本小节的完整代码已上传到 jasypt-spring-boot-demo

28. 如何处理同名Bean对象多次注册导致的启动失败问题

这里单指不能修改程序包的情况,如果能修改源码,该问题自然好处理了,在代码中避免注册同名的Bean即可。以下情况,往往是无法修改源码的

  • 从其它团队交接过来的项目,且只有jar包,没有源码
    至于为什么交接的项目没有源码,国内的公司管理情况你懂的 😁 ,尤其是那种交接了好几手的项目,部分工程源码丢失也不是没有可能的

  • 项目中嵌套引用的基础工具
    这些工具以AutoConfiguration的方式做成Jar包,在其它工程中引入时,再次被包装成上层工具,这种层层包装方式,极有可能导致同名组件注册

  • 引入的第三方包中有同名组件注册问题

解决办法是,直接允许同名组件多次注册,配置如下:

spring.main.allow-bean-definition-overriding = true

关于 spring.main 的更多配置参见 SpringBoot项目组件常见配置

29. 如何优雅地停止 SpringBoot 服务

29.1 优雅停止不涉及 Web 服务的 SpringBoot 项目

通常来说,如果 SpringBoot 项目不涉及 Web 服务,但它还长时间在运行,那程序中一定有任务执行器在执行周期性任务。因此,优雅停机的方式就是要调用所有任务执行器的 shutdown 方法,该方法会让任务执行器进入停止状态,此时它具有以下特性:

  • 执行器不再接收新任务
  • 执行器等待已提交任务的执行完成
  • 超过最大等待时长任务依然没有执行完,则强制结束

示例代码如下:

先装配一个任务执行器

@Bean("taskExecutor")
public ThreadPoolTaskExecutor taskExecutor() {
	ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
	taskExecutor.setCorePoolSize(2);
	taskExecutor.setMaxPoolSize(2);
    // 开启「停机时等待已提交任务的执行完成」特性
	taskExecutor.setWaitForTasksToCompleteOnShutdown(true);
    // 设置最大等待时长
	taskExecutor.setAwaitTerminationSeconds(120);
    // 初始化任务执行器,此后执行器就进入工作状态了
	taskExecutor.initialize();
	return taskExecutor;
}

然后利用 Spring 生命周期中的 Bean 销毁回调,触发执行器 shutdown 方法的调用

@Component
public class ExecutorShutdownHook implements DisposableBean {
    @Resource
    ThreadPoolTaskExecutor taskExecutor;

    // 进程结束前,会调用本方法
    @Override
    public void destroy() throws Exception {
        System.out.println("[ShutdownHook]: 开始停止任务执行器");
        taskExecutor.shutdown();
        System.out.println("[ShutdownHook]: 任务执行器已平滑停止");
    }
}

29.2 优雅停止包含 Web 服务的 SpringBoot 项目

对于涉及 Web 服务的 SpringBoot 项目,与 nginx 一样,先让 Servlet 容器停止接收新请求,待已接收的请求处理完毕后,执行业务服务本身的清理工作。最后停止Servlet容器,结果整个服务进程。

在早期,上述工作需要开发人员,结合所用的 Servelt 容器(如 Tomcat)所提供的接口能力,手动编码来完成。从 spring-boot 2.3 开始,官方引入了 server.shutdown 这个配置项,只需要将其设置为 graceful 即可。即当配置了 server.shutdown=graceful 时,程序就能优雅停止 Web 服务了。与任务执行器的优雅停止一样,等待已接收请求的处理完成,也有个最大时长,这个时长也可以在 properties 中配置。如下所示:

server:
  # 开启Web服务的优雅停止特性
  shutdown: graceful

spring:
  lifecycle:
    # 设置收到TERM信号后,等待完成的最大时长
    timeout-per-shutdown-phase: 2m

下面是一个同时包含了「任务执行器」和「Web服务」的SpringBoot样例项目,平滑停机的最后日志输出:

[任务-1]: 我开始睡觉了哈...
[任务-2]: 我开始睡觉了哈...
2024-03-27 11:36:21.617  INFO 26540 --- [nio-8080-exec-1] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring DispatcherServlet 'dispatcherServlet'
2024-03-27 11:36:21.617  INFO 26540 --- [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet        : Initializing Servlet 'dispatcherServlet'
2024-03-27 11:36:21.618  INFO 26540 --- [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet        : Completed initialization in 0 ms
[SampleController#justRequest]: 将于10秒后返回
2024-03-27 11:36:25.909  INFO 26540 --- [ionShutdownHook] o.s.b.w.e.tomcat.GracefulShutdown        : Commencing graceful shutdown. Waiting for active requests to complete
[SampleController#justRequest]: 10秒时间到了,返回给客户端
2024-03-27 11:36:31.768  INFO 26540 --- [tomcat-shutdown] o.s.b.w.e.tomcat.GracefulShutdown        : Graceful shutdown complete
[ShutdownHook]: 开始停止任务执行器
[任务-1]: 我已经睡醒了喔 ^_^
[任务-2]: 我已经睡醒了喔 ^_^
[任务-3]: 我开始睡觉了哈...
[任务-3]: 我已经睡醒了喔 ^_^
[ShutdownHook]: 任务执行器已平滑停止

在第 6 行时,我们通过浏览器访问了 http://localhost:8080/test,这个请求会进入到 SampleController 的 test 方法,方法故意 sleep 了10秒,因此浏览器端处于等等响应的过程。页面没有输出。

在第 7 行处,向进程发出了终止信号,该行日志表明: 整个程序在等等活跃请求(active requests 即已接收到的请求)的执行完成。而此时第 6 行的Web请求依然还在处理中,直到 SampleController 的 test 方法 sleep 结束,才返回给了浏览器端,同时 Servelt 容器完全停止(见第 9 行)。

后面的 [任务-]、[任务-2]、[任务-3] 是任务执行器的平滑停机过程,这个是需要我们手动编码来控制的。

整个优雅停机样例的源码已上传到 gracefully-shutdown-spring-boot

30. 如何处理 YAML 或 Properties 的解析异常 MalformedInputException

时常遇到在IDE中启动程序OK,但打包后使用命令启动则抛出类似这面这样的错误:

org.yaml.snakeyaml.error.YAMLException: java.nio.charset.MalformedInputException: Input length = 1

解决文案分两步:

  1. 修正文件编码

  2. 设置java命令的编码参数

    如:java -Dfile.encoding=utf8 -jar xxxx.jar

31. 如何在运行期动态调整日志级别和增减Logger

可以在logback的配置文件中,指定日志配置的刷新周期,程序在运行期会按这个周期重要加载日志输出配置,如下所示:

<?xml version="1.0" encoding="UTF-8"?>
<configuration scan="true" scanPeriod="300 seconds">
                            ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄

32. IntelliJ Idea 中代码飘红的常见解决步骤

按照以下顺序进行,如果前一步执行完后问题已解决,就不用尝试后面的办法了。一般而言最后一步是终极大招,若这一招也不灵,那只能乞求上帝了。

  • 重新导入
  • 重建idea 文件索引缓存
  • 删除工程目录下的 .idea/ 目录

33. 一份 Linux 环境下部署 SpringBoot 程序的参考 Shell 脚本

本脚本提供以下特性文章来源地址https://www.toymoban.com/news/detail-843811.html

  • 关闭终端后,Java进程不会退出
  • 提供了部署、启动、停止、重启三种最见的操作
  • 每次部署时,均备份当前的程序包(可通过参数关闭备份)
Shell部署脚本
#!/bin/bash

THIS_DIR=$(cd $(dirname $0);pwd)

# 要部署的服务名称,请根据实际情况修改
SERVICE_NAME=gateway-service
# 要部署的服务名Jar包名称,请根据实际情况修改
JAR=gateway-service.jar
CONFIG_FILE=${THIS_DIR}/application.yml
 
usage() {
    # 提示内容请根据实际情况修改
    echo "网关服务"
    echo "用法: startup.sh [deploy|start|stop|status]"
    echo "   deploy: 部署新的jar包, 动作有"
    echo "     · 备份当前正运行的jar包"
    echo "     · 替换正运行的jar包"
    echo "     · 停止当前服务进程"
    echo "     · 使用jar包启动服务程序"
    echo "     · 启动成功,则只保留最近10个部署包"
    echo ""
    echo "   start: 直接启动程序包,如果已存在服务进程,会启动失败"
    echo ""
    echo "   stop: 停止服务进程"
    echo ""
    echo "   status: 检查服务进程是否处于运行状态"
    echo ""
    exit 0
}
 
 
check_process_existance(){
    pid=`ps -ef | grep $JAR | grep -v grep | awk '{print $2}'`
    if [ -z "$pid" ]; then
        return 1
    else
        return 0
    fi
}
 
run(){
    OPTS="-server -Dfile.encoding=utf8 -Dsun.jnu.encoding=utf8 -Xms128m -Xmx256m -Xmn256m"
    OPTS="${OPTS} -XX:HeapDumpPath=$THIS_DIR/vmstack/heap.dump -XX:+PrintGCDetails"
    OPTS="${OPTS} -XX:-HeapDumpOnOutOfMemoryError -XX:ErrorFile=$THIS_DIR/vmstack/hs_err.log "
    CMD="java ${OPTS} -jar $THIS_DIR/$JAR "
    RUN_PARAMS=" --spring.config.location=${CONFIG_FILE}"
    echo -e "Start ${SERVICE_NAME} with command:\n\t${CMD} ${RUN_PARAMS}"
    nohup $CMD $RUN_PARAMS > /dev/null 2>&1 &
    echo "$CMD $RUN_PARAMS"

    # 下面这个命令是将java程序在前台运行,以便在启动失败时,查看详细原因
    # 如果使用该命令,在终端前台也找不到有用的错误信息的话,需要个性 ${THIS_DIR}/logback.xml的日志输出器
    # 生产环境下,log方式的日志不输出到控制台, 只有 System.out 和 System.error 的打印才输出到终端
    #$CMD $RUN_PARAMS
}

deploy() {
    echo "deploy命令功能尚未完成"
    exit 1
}
 
start(){
    check_process_existance

    if [ $? -eq "0" ];then    
        echo "服务 ${SERVICE_NAME} 正处于运行中,进程号为:${pid} ";
    else
        run
    fi
}
 
stop(){
    check_process_existance
    if [ $? -eq "0" ];then
        echo "Stopping ${SERVICE_NAME} with pid: ${pid}"
        kill $pid
    while [ -e /proc/${pid} ]; do sleep 1; done
        echo "Shutdown ${SERVICE_NAME} with pid: ${pid}"
    else
        echo "${SERVICE_NAME} is not running"
    fi
}
 
status(){
    check_process_existance

    if [ $? -eq "0" ];then
        echo "${SERVICE_NAME} is running, pid is ${pid}"
    else
        echo "${SERVICE_NAME} is not running."
    fi
}
 
case "$1" in
  "deploy")
    deploy
    ;;
  "start")
    start
    ;;
  "stop")
    stop
    ;;
  "status")
    status
    ;;
  *)
    usage
    ;;
esac

到了这里,关于Spring Boot 工程开发常见问题解决方案,日常开发全覆盖的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Blender Three.js 智慧3D机房开发 模型创建与导入中的常见问题与解决方案

    目录 机房效果展示 可能出现的问题及解决方法 Three. js服务器运行环境搭建及文件配置 使用Node.js搭建本地服务器 文件配置  Blender材质处理 Blender导出GLTF模型出现材质丢失 Three.js玻璃材质制作  Blender导出glTF格式模型 Three. js模型显示场景的设置 总结   机房正面图: 机房背面

    2024年02月05日
    浏览(26)
  • 正则常见问题及解决方案

    使用正则处理问题的基本思路。有一些方法比较固定,比如将问题分解成多个小问题,每个小问题见招拆招:某个位置上可能有多个字符的话,就⽤字符组。某个位置上有多个字符串的话,就⽤多选结构。出现的次数不确定的话,就⽤量词。对出现的位置有要求的话,就⽤锚

    2024年02月10日
    浏览(25)
  • RabbitMQ常见问题及其解决方案

    目录 RabbitMQ如何保证顺序消费 RabbitMQ消息丢失及其解决方案 RabbitMQ如何保证顺序消费 RabbitMQ重复消费及其解决方案 RabbitMQ如何保证不重复消费 RabbitMQ消息积压及其解决方案 RabbitMQ如何实现分布式事务以及保障消息最终一致性 在 RabbitMQ 中实现顺序消费可以考虑以下方法: 单一

    2024年02月09日
    浏览(17)
  • RabbitMQ常见问题及解决方案

    目录 一、消息丢失 1、生产者重连 2、生产者确认 3、数据持久化 4、惰性队列 5、消费失败处理 二、消息重复 1、通过业务保证幂等性(优先) 2、通过消息状态去重保证幂等性 三、消息堆积 1、优化消费者处理逻辑 2、增加队列及消费者数量 3、使用惰性队列 四、保证消息顺

    2024年02月03日
    浏览(18)
  • RocketMQ常见问题及解决方案

    RocketMQ FAQ 可能原因 1)消费端处理消息发生异常没有捕获或是因为其他原因,没有返回消费状态 解决方案: 消费端捕获异常, 如果需要重试,返回ConsumeConcurrentlyStatus. RECONSUME_LATER , 如果不需要重试,返回ConsumeConcurrentlyStatus. RECONSUME_SUCCESS 可以在消费端增加重试次数判断,

    2023年04月08日
    浏览(23)
  • RabbitMQ详解与常见问题解决方案

    RabbitMQ 是一个开源的消息中间件,使用 Erlang 语言开发。这种语言天生非常适合分布式场景,RabbitMQ 也就非常适用于在分布式应用程序之间传递消息。RabbitMQ 有非常多显著的特点: 消息传递模式 :RabbitMQ 支持多种消息传递模式,包括发布/订阅、点对点和工作队列等,使其更

    2024年03月15日
    浏览(39)
  • 冷启问题目前常见解决方案

    随机冷启 个性化冷启 冷启动保量 冷启动保量,保证每个item曝光的次数一样,实时统计已曝光的次数和要曝光的次数 冷启动结束过滤,如果需曝光的量越大,且越接近冷启结束时间,得分越高,被曝光的概率越大 爬坡保量 实时统计曝光、点击、ctr;ctr越高,曝光越少,得分

    2024年02月11日
    浏览(15)
  • vlc option以及常见问题解决方案

    2024年02月08日
    浏览(80)
  • SpringBoot —— 整合RabbitMQ常见问题及解决方案

    企业中最常用的消息中间件既不是RocketMQ,也不是Kafka,而是RabbitMQ。 RocketMQ很强大,但主要是阿里推广自己的云产品而开源出来的一款消息队列,其实中小企业用RocketMQ的没有想象中那么多。 至于Kafka,主要还是用在大数据和日志采集方面,除了一些公司有特定的需求会使用

    2023年04月12日
    浏览(54)
  • 常见后端数据存储问题解决方案

    1、mysql数据准确性        常见电商系统中,如订单服务、现金券服务、活动类服务等,这类服务中经常会出现一些并发更新数据的情况,如何保证数据准确性。虽然有些操作可通过\\\"状态\\\"字段做了类似乐观锁的处理。但理论上还是会出现ABA的问题,而且规则不够统一,不同

    2023年04月18日
    浏览(16)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包