SpringBoot开发技巧-SpringBoot开发技巧二-《Java笔记》

admin

0
文章

0
评论

2025-10-19 05:01:35 编程来源：ZONE.CI 全球网 0 阅读模式

一、@Conditional的强大之处
二. @Import
三、@ConfigurationProperties赋值
四、Spring事务避坑
- 声明式事务
- 编程式事务
五、跨域问题的解决方案
六、自定义starter
七、项目启动时的附加功能

Java Spring

一、`@Conditional`的强大之处

在项目开发中是否会遇到过这些问题：

某个功能需要根据项目中有没有某个jar判断是否开启该功能。
某个bean的实例化需要先判断另一个bean有没有实例化，再判断是否实例化自己。
某个功能是否开启，在配置文件中有个参数可以对它进行控制。
@ConditionalOnClass
问题1可以用@ConditionalOnClass注解解决，代码如下：
```
public class A {
}
public class B {
}
@ConditionalOnClass(B.class)
@Configuration
public class TestConfiguration {
 @Bean
 public A a() {
   return new A();
 }
}
```
如果项目中存在B类，则会实例化A类。如果不存在B类，则不会实例化A类。有人可能会问：不是判断有没有某个jar吗？怎么现在判断某个类了？

直接判断有没有该jar下的某个关键类更简单。

这个注解有个升级版的应用场景：比如common工程中写了一个发消息的工具类mqTemplate，业务工程引用了common工程，只需再引入消息中间件，比如rocketmq的jar包，就能开启mqTemplate的功能。而如果有另一个业务工程，通用引用了common工程，如果不需要发消息的功能，不引入rocketmq的jar包即可。

`@ConditionalOnBean`

问题2可以通过@ConditionalOnBean注解解决，代码如下：

@Configuration
public class TestConfiguration {
    @Bean
    public B b() {
        return new B();
    }
    @ConditionalOnBean(name="b")
    @Bean
    public A a() {
      return new A();
    }
}

实例A只有在实例B存在时，才能实例化。

`@ConditionalOnProperty`

问题3可以通过@ConditionalOnProperty注解解决，代码如下：

@ConditionalOnProperty(prefix = "demo",name="enable", havingValue = "true",matchIfMissing=true )
@Configuration
public class TestConfiguration {
    @Bean
    public A a() {
      return new A();
    }
}

在applicationContext.properties文件中配置参数：

demo.enable=false

各参数含义：

prefix 表示参数名的前缀，这里是demo
name 表示参数名
havingValue 表示指定的值，参数中配置的值需要跟指定的值比较是否相等，相等才满足条件
matchIfMissing 表示是否允许缺省配置。

这个功能可以作为开关，相比EnableXXX注解的开关更优雅，因为它可以通过参数配置是否开启，而EnableXXX注解的开关需要在代码中硬编码开启或关闭。

其他的Conditional注解

当然，Spring用得比较多的Conditional注解还有：ConditionalOnMissingClass、ConditionalOnMissingBean、ConditionalOnWebApplication等。下面用一张图整体认识一下@Conditional家族。

自定义Conditional

SpringBoot自带的Conditional系列已经可以满足绝大多数的需求了。但如果有比较特殊的场景，也可以自定义自定义Conditional。第一步，自定义注解：

@Conditional(MyCondition.class)

@Retention(RetentionPolicy.RUNTIME)

@Target({ElementType.TYPE,%20ElementType.METHOD})

@Documented

public%20@interface%20MyConditionOnProperty%20{

%20%20%20%20String%20name()%20default%20"";

%20%20%20%20String%20havingValue()%20default%20"";

}

第二步，实现Condition接口：

public%20class%20MyCondition%20implements%20Condition%20{

%20%20%20%20@Override

%20%20%20%20public%20boolean%20matches(ConditionContext%20context,%20AnnotatedTypeMetadata%20metadata)%20{

%20%20%20%20%20%20%20%20System.out.println("实现自定义逻辑");

%20%20%20%20%20%20%20%20return%20false;

%20%20%20%20}

}

第三步，使用@MyConditionOnProperty注解。Conditional的奥秘就藏在ConfigurationClassParser类的processConfigurationClass方法中：这个方法逻辑不复杂： SpringBoot开发技巧二 - 图3

先判断有没有使用@Conditional注解，如果没有直接返回false
收集condition到集合中
按order排序该集合
遍历该集合，循环调用condition的matchs方法。
二. @Import
有时需要在某个配置类中引入另外一些类，被引入的类也加到Spring容器中。这时可以使用@Import注解完成这个功能。如果看过它的源码会发现，引入的类支持三种不同类型。但是最好将普通类和@Configuration注解的配置类分开讲解，所以列了四种不同类型：普通类这种引入方式是最简单的，被引入的类会被实例化bean对象。public%20class%20A%20{

}

@Import(A.class)

@Configuration

public%20class%20TestConfiguration%20{

}

通过@Import注解引入A类，Spring就能自动实例化A对象，然后在需要使用的地方通过@Autowired注解注入即可：

@Autowired

private%20A%20a; 不用加@Bean注解也能实例化bean。

@Configuration注解的配置类这种引入方式是最复杂的，因为@Configuration注解还支持多种组合注解，比如：

@Import
@ImportResource
@PropertySource等。
public%20class%20A%20{

}

public%20class%20B%20{

}

@Import(B.class)

@Configuration

public%20class%20AConfiguration%20{

%20%20@Bean

%20%20public%20A%20a()%20{

%20%20%20%20%20%20return%20new%20A();

%20%20}

}

@Import(AConfiguration.class)

@Configuration

public%20class%20TestConfiguration%20{

}

通过@Import注解引入@Configuration注解的配置类，会把该配置类相关@Import、@ImportResource、@PropertySource等注解引入的类进行递归，一次性全部引入。

实现ImportSelector接口的类

这种引入方式需要实现ImportSelector接口：

public%20class%20AImportSelector%20implements%20ImportSelector%20{

private%20static%20final%20String%20CLASS_NAME%20=%20"com.sue.cache.service.test13.A";

public%20String[]%20selectImports(AnnotationMetadata%20importingClassMetadata)%20{

%20%20%20%20%20%20return%20new%20String[]{CLASS_NAME};

%20%20}

}

@Import(AImportSelector.class)

@Configuration

public%20class%20TestConfiguration%20{

}

这种方式的好处是selectImports方法返回的是数组，意味着可以同时引入多个类，还是非常方便的。

实现ImportBeanDefinitionRegistrar接口的类

这种引入方式需要实现ImportBeanDefinitionRegistrar接口：

public%20class%20AImportBeanDefinitionRegistrar%20implements%20ImportBeanDefinitionRegistrar%20{

%20%20@Override

%20%20public%20void%20registerBeanDefinitions(AnnotationMetadata%20importingClassMetadata,%20BeanDefinitionRegistry%20registry)%20{

%20%20%20%20%20%20RootBeanDefinition%20rootBeanDefinition%20=%20new%20RootBeanDefinition(A.class);

%20%20%20%20%20%20registry.registerBeanDefinition("a",%20rootBeanDefinition);

%20%20}

}

@Import(AImportBeanDefinitionRegistrar.class)

普通类，用于创建没有特殊要求的bean实例。
@Configuration注解的配置类，用于层层嵌套引入的场景。
实现ImportSelector接口的类，用于一次性引入多个类的场景，或者可以根据不同的配置决定引入不同类的场景。
实现ImportBeanDefinitionRegistrar接口的类，主要用于可以手动控制BeanDefinition的创建和注册的场景，它的方法中可以获取BeanDefinitionRegistry注册容器对象。

在ConfigurationClassParser类的processImports方法中可以看到这三种方式的处理逻辑：最后的else方法其实包含了：普通类和@Configuration注解的配置类两种不同的处理逻辑。

三、`@ConfigurationProperties`赋值

在项目中使用配置参数是非常常见的场景，比如在配置线程池的时候，需要在applicationContext.propeties文件中定义如下配置：

thread.pool.corePoolSize=5
thread.pool.maxPoolSize=10
thread.pool.queueCapacity=200
thread.pool.keepAliveSeconds=30

方法一：通过@Value注解读取这些配置。

public class ThreadPoolConfig {
    @Value("${thread.pool.corePoolSize:5}")
    private int corePoolSize;
    @Value("${thread.pool.maxPoolSize:10}")
    private int maxPoolSize;
    @Value("${thread.pool.queueCapacity:200}")
    private int queueCapacity;
    @Value("${thread.pool.keepAliveSeconds:30}")
    private int keepAliveSeconds;
    @Value("${thread.pool.threadNamePrefix:ASYNC_}")
    private String threadNamePrefix;
    @Bean
    public Executor threadPoolExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(corePoolSize);
        executor.setMaxPoolSize(maxPoolSize);
        executor.setQueueCapacity(queueCapacity);
        executor.setKeepAliveSeconds(keepAliveSeconds);
        executor.setThreadNamePrefix(threadNamePrefix);
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        executor.initialize();
        return executor;
    }
}

这种方式使用起来非常简单，但建议在使用时都加上:，因为:后面跟的是默认值，比如：@Value("${thread.pool.corePoolSize:5}")，定义的默认核心线程数是5。

假如有这样的场景：business工程下定义了这个ThreadPoolConfig类，api工程引用了business工程，同时job工程也引用了business工程，而ThreadPoolConfig类只想在api工程中使用。这时，如果不配置默认值，job工程启动的时候可能会报错。

如果参数少还好，多的话，需要给每一个参数都加上@Value注解，是不是有点麻烦？此外，还有一个问题，@Value注解定义的参数看起来有点分散，不容易辨别哪些参数是一组的。这时，@ConfigurationProperties就派上用场了，它是SpringBoot中新加的注解。第一步，先定义ThreadPoolProperties类

@Data
@Component
@ConfigurationProperties("thread.pool")
public class ThreadPoolProperties {
    private int corePoolSize;
    private int maxPoolSize;
    private int queueCapacity;
    private int keepAliveSeconds;
    private String threadNamePrefix;
}

第二步，使用ThreadPoolProperties类

@Configuration
public class ThreadPoolConfig {
    @Autowired
    private ThreadPoolProperties threadPoolProperties;
    @Bean
    public Executor threadPoolExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(threadPoolProperties.getCorePoolSize());
        executor.setMaxPoolSize(threadPoolProperties.getMaxPoolSize());
        executor.setQueueCapacity(threadPoolProperties.getQueueCapacity());
        executor.setKeepAliveSeconds(threadPoolProperties.getKeepAliveSeconds());
        executor.setThreadNamePrefix(threadPoolProperties.getThreadNamePrefix());
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        executor.initialize();
        return executor;
    }
}

使用@ConfigurationProperties注解，可以将thread.pool开头的参数直接赋值到ThreadPoolProperties类的同名参数中，这样省去了像@Value注解那样一个个手动去对应的过程。这种方式显然要方便很多，只需编写xxxProperties类，Spring会自动装配参数。此外，不同系列的参数可以定义不同的xxxProperties类，也便于管理，推荐优先使用这种方式。它的底层是通过：ConfigurationPropertiesBindingPostProcessor类实现的，该类实现了BeanPostProcessor接口，在postProcessBeforeInitialization方法中解析@ConfigurationProperties注解，并且绑定数据到相应的对象上。绑定是通过Binder类的bindObject方法完成的：以上这段代码会递归绑定数据，主要考虑了三种情况：

bindAggregate 绑定集合类
bindBean 绑定对象
bindProperty 绑定参数前面两种情况最终也会调用到bindProperty方法。

「此外，友情提醒一下：」使用@ConfigurationProperties注解有些场景有问题，比如：在apollo中修改了某个参数，正常情况可以动态更新到@ConfigurationProperties注解定义的xxxProperties类的对象中，但是如果出现比较复杂的对象，比如：

private Map<String, Map<String,String>>  urls;

可能动态更新不了。这时候该怎么办呢？答案是使用ApolloConfigChangeListener监听器自己处理：

@ConditionalOnClass(com.ctrip.framework.apollo.spring.annotation.EnableApolloConfig.class)
public class ApolloConfigurationAutoRefresh implements ApplicationContextAware {
   private ApplicationContext applicationContext;
   @Override
   public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
   }
    @ApolloConfigChangeListener
    private void onChange(ConfigChangeEvent changeEvent{
        refreshConfig(changeEvent.changedKeys());
    }
    private void refreshConfig(Set<String> changedKeys){
       System.out.println("将变更的参数更新到相应的对象中");
    }
}

四、Spring事务避坑

Spring中的事务功能主要分为：声明式事务和编程式事务。

声明式事务

大多数情况下，在开发过程中使用更多的可能是声明式事务，即使用@Transactional注解定义的事务，因为它用起来更简单，方便。只需在需要执行的事务方法上，加上@Transactional注解就能自动开启事务：

@Service
public class UserService {
    @Autowired
    private UserMapper userMapper;
    @Transactional
    public void add(UserModel userModel) {
        userMapper.insertUser(userModel);
    }
}