Spring中那些让你爱不释手的代码技巧（下）

1、@Conditional的强大

不知道你们有没有遇到过这些问题：

某个功能需要根据项目中有没有某个jar判断是否开启该功能。
某个bean的实例化需要先判断另一个bean有没有实例化，再判断是否实例化自己。
某个功能是否开启，在配置文件中有个参数可以对它进行控制

看SpringBoot的自动配置源码，你会经常看到@Conditional这个注解

你会发现除了Hikari DataSource configuration 外，其它都是红色的因为缺失依赖类没生效，我们导入的依赖包spring-boot-starter-jdbc里面有hikari的依赖包，所以Hikari DataSource configuration生效，成为默认的数据源，

@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，必定引入了某个类。这个注解有个升级版的应用场景：比如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") // 实例A只有在实例B存在时，才能实例化
    @Bean
    public A a() {
      return    new A();
    }
}

@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 表示是否允许缺省配置，也就是说demo.enable默认是true

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

下面用一张图整体认识一下@Conditional家族。

SpringBoot自动配置原理飞天班第8节：SpringBoot原理探究

自定义Conditional

说实话，个人认为springboot自带的Conditional系列已经可以满足我们绝大多数的需求了。但如果你有比较特殊的场景，也可以自定义自定义Conditional。

第一步，自定义注解：

@Conditional(MyCondition.class)
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD})
@Documented
public  @interface MyConditionOnProperty {
    String name() default "";

    String havingValue() default "";
}

第二步，实现Condition接口：

public  class MyCondition implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        System.out.println("实现自定义逻辑");
        return  false;
    }
}

第三步，使用@MyConditionOnProperty注解。

Conditional的奥秘就藏在ConfigurationClassParser类的processConfigurationClass方法中，该方法会被同类的parse方法调用，parse方法被ConfigurationClassPostProcessor类的processConfigBeanDefinitions方法调用，该方法从bean定义注册器中获取所有配置类，代码片段如下

configCandidates就是所有候选配置节点，循环验证是否生效，代码片段如下：

现在我们继续看ConfigurationClassParser类的processConfigurationClass方法

条件判断就在shouldSkip方法

public boolean shouldSkip(@Nullable AnnotatedTypeMetadata metadata, @Nullable ConfigurationPhase phase) {
 // 没有使用Conditional注解，直接返回false
  if (metadata == null || !metadata.isAnnotated(Conditional.class.getName())) {
    return false;
  }

  // 配置类
  if (phase == null) {
    if (metadata instanceof AnnotationMetadata &&
        ConfigurationClassUtils.isConfigurationCandidate((AnnotationMetadata) metadata)) {
      return shouldSkip(metadata, ConfigurationPhase.PARSE_CONFIGURATION);
    }
    return shouldSkip(metadata, ConfigurationPhase.REGISTER_BEAN);
  }
// 收集条件conditions
  List<Condition> conditions = new ArrayList<>();
  for (String[] conditionClasses : getConditionClasses(metadata)) {
    for (String conditionClass : conditionClasses) {
      Condition condition = getCondition(conditionClass, this.context.getClassLoader());
      conditions.add(condition);
    }
  }
// 排序
  AnnotationAwareOrderComparator.sort(conditions);
// 遍历该集合，循环调用condition的matchs方法。
  for (Condition condition : conditions) {
    ConfigurationPhase requiredPhase = null;
    if (condition instanceof ConfigurationCondition) {
      requiredPhase = ((ConfigurationCondition) condition).getConfigurationPhase();
    }
    if ((requiredPhase == null || requiredPhase == phase) && !condition.matches(this.context, metadata)) {
      return true; // 不满足匹配条件，改配置类就会不生效
    }
  }
  return false;
}

2、如何妙用@Import

有时我们需要在某个配置类中引入另外一些类，被引入的类也加到spring容器中。这时可以使用@Import注解完成这个功能。如果你看过它的源码会发现，引入的类支持三种不同类型。但是我认为最好将普通类和@Configuration注解的配置类分开讲解，所以列了四种不同类型：

普通类

这种引入方式是最简单的，被引入的类会被实例化bean对象。

public  class A {
}

@Import(A.class)
@Configuration
public class TestConfiguration {
}

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

@Autowired
private A a;

是不是挺让人意外的？不用加@Bean注解也能实例化bean。

@Configuration注解的配置类

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

@Import
@ImportResource
@PropertySource等

public  class A {
}

public  class B {
}

@Import(B.class)
@Configuration
public class AConfiguration {
    @Bean
    public A a() {
        return  new A();
    }
}

@Import(AConfiguration.class)
@Configuration
public class TestConfiguration {
}

通过@Import注解引入@Configuration注解的配置类，会把该配置类相关@Import、@ImportResource、@PropertySource（属性资源文件）等注解引入的类进行递归，一次性全部引入，spring的源码里看到。由于文章篇幅有限不过多介绍了，这里留点悬念，后面会出一篇文章专门介绍@Configuration注解，因为它实在太太太重要了。

实现ImportSelector接口的类

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

public  class AImportSelector implements ImportSelector {
  private  static  final String CLASS_NAME = "com.sue.cache.service.test13.A";

  public String[] selectImports(AnnotationMetadata importingClassMetadata) {
    return  new String[]{CLASS_NAME};
  }
}

@Import(AImportSelector.class)
@Configuration
public class TestConfiguration {
}

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

实现ImportBeanDefinitionRegistrar接口的类

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

public  class AImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
  @Override
  public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
    RootBeanDefinition rootBeanDefinition = new RootBeanDefinition(A.class);
    registry.registerBeanDefinition("a", rootBeanDefinition);
  }
}

@Import(AImportBeanDefinitionRegistrar.class)
@Configuration
public class TestConfiguration {
}

这种方式是最灵活的，能在registerBeanDefinitions方法中获取到BeanDefinitionRegistry容器注册对象，可以手动控制BeanDefinition的创建和注册。

当然@import注解非常人性化，还支持同时引入多种不同类型的类。

@Import({B.class,AImportBeanDefinitionRegistrar.class})
@Configuration
public class TestConfiguration {
}

总结：

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

在ConfigurationClassParser类的processImports方法中可以看到这三种方式的处理逻辑：

最后的else方法其实包含了：普通类和@Configuration注解的配置类两种不同的处理逻辑。

3、@ConfigurationProperties赋值

Springboot 自动配置参数场景，多数时候都会用到该注解飞天班第8节：SpringBoot原理探究，经常配合@Value和@PropertySource 一起使用

在application.properties定义

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

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

@Configuration
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。

方法二：通过@ConfigurationProperties注解

如果参数多的时候，@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("将变更的参数更新到相应的对象中");
    }
}

4、Spring事务如何避坑

声明式事务

大多数情况下，我们在开发过程中使用更多的可能是声明式事务，即使用@Transactional注解定义的事务，因为它用起来简单方便，但是只能控制单个数据库的事务

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

这种声明式事务之所以能生效，是因为它的底层使用了AOP，创建了代理对象，调用TransactionInterceptor事务拦截器实现事务的功能。

spring事务有个特别的地方：它获取的数据库连接放在ThreadLocal中的，也就是说同一个线程中从始至终都能获取同一个数据库连接，可以保证同一个线程中多次数据库操作在同一个事务中执行。

正常情况下是没有问题的，但是如果使用不当，事务会失效，主要原因如下:

默认情况下， Spring会对所有的运行时异常进行事务回滚

除了上述列举的问题之外，由于@Transactional注解最小粒度是要被定义在方法上，如果有多层的事务方法调用，可能会造成大事务问题

所以，建议在实际工作中少用@Transactional注解开启事务，使用TransactionTemplate替代

编程式事务

一般情况下编程式事务我们可以通过TransactionTemplate类开启事务功能。有个好消息，就是springboot已经默认实例化好这个对象了，我们能直接在项目中使用。

@Service
public  class UserService {
   @Autowired
   private TransactionTemplate transactionTemplate;
   
   ...
   
   public void save(final User user) {
         transactionTemplate.execute((status) => {
            doSameThing...
            return Boolean.TRUE; // 返回true，则自动提交事务，false就回滚事务
         })
   }
}

使用TransactionTemplate的编程式事务能避免很多事务失效的问题，但是对大事务问题，不一定能够解决，只是说相对于使用@Transactional注解要好些。事务控制在execute方法里，看源码：

@Nullable
public <T> T execute(TransactionCallback<T> action) throws TransactionException {
  Assert.state(this.transactionManager != null, "No PlatformTransactionManager set");
  if (this.transactionManager instanceof CallbackPreferringPlatformTransactionManager) {
    return ((CallbackPreferringPlatformTransactionManager)this.transactionManager).execute(this, action);
  } else {
    TransactionStatus status = this.transactionManager.getTransaction(this);

    Object result;
    try {
      result = action.doInTransaction(status);
    } catch (Error | RuntimeException var5) {
      this.rollbackOnException(status, var5);
      throw var5;
    } catch (Throwable var6) {
      this.rollbackOnException(status, var6);
      throw new UndeclaredThrowableException(var6, "TransactionCallback threw undeclared checked exception");
    }

    this.transactionManager.commit(status);
    return result;
  }
}

从源码可以看出，spring会开启一个事务，并在这个事务里执行所有的业务操作，当然只限本地事务。

不使用TransactionTemplate可以直接获取事务进行业务操作，自己手动commit或rollback

@Resource
@Qualifier("transactionManager1")
private PlatformTransactionManager txManager1;
@Qualifier("transactionManager2")
@Resource
private PlatformTransactionManager txManager2;

public void test(){
  DefaultTransactionDefinition def1 = new DefaultTransactionDefinition(); 
  // explicitly setting the transaction name is something that can be done only programmatically 
  def1.setName("SomeTxName"); 
  def1.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
  TransactionStatus status1 = txManager1.getTransaction(def1);

  DefaultTransactionDefinition def2 = new DefaultTransactionDefinition(); 
  // explicitly setting the transaction name is something that can be done only programmatically 
  def2.setName("SomeTxName"); 
  def2.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
  TransactionStatus status2 = txManager2.getTransaction(def2);

  //统一进行事务控制
  try {
      // put your business logic here
      executeDataSource1(txManager1,otherParams);
      executeDataSource2(txManager2,otherParams);
  }
  catch (MyException ex) {
      txManager1.rollback(status1);
      txManager2.rollback(status2);
      throw ex;
  }
  txManager1.commit(status1);
  txManager2.commit(status2);
}

区别

声明式事务只能做到public方法级别的粒度控制，代码简洁。

注意自调用问题, @Transactional 注解仅在外部类的调用才生效, 原因是使用 Spring AOP 机制造成的. 所以: 主调函数如果是本Service类, 应该也要打上 @Transactional, 否则事务控制被忽略；

缺省的情况下, 只有 RuntimeException 类异常才会触发回滚. 如果在事务中抛出其他异常,并期望回滚事务, 必须设定 rollbackFor 参数. 例子: @Transactional(propagation=Propagation.REQUIRED,rollbackFor= MyException.class)，只要MyException 继承 RuntimeException就行
编程式事务粒度更细，可以做到代码块级别的事务控制，原理是通过AOP+proxy代理模式的方式实现的。

PlatformTransactionManager接口

Spring 控制事务的方式基础是 PlatformTransactionManager 接口, 它为各种数据访问技术提供了统一的事务支持接口, 不同的数据技术都有自己的实现:

Spring JDBC 技术: DataSourceTransactionManager
JPA 技术: JpaTransactionManager
Hibernate 技术: HibernateTransactionManager
JDO 技术: JdoTransactionManager
分布式事务: JtaTransactionManager

Spring Boot 项目中

1.引入了 spring-boot-starter-jdbc 之后, 会自动注入一个 DataSourceTransactionManager 类型 bean 对象, 这个对象有两个名称, 分别为 transactionManager 和 platformTransactionManager

2.引入了 spring-boot-starter-data-jpa 依赖后, 会自动注入一个 JpaTransactionManager 类型 bean 对象, 这个对象有两个名称, 分别为 transactionManager 和 platformTransactionManager

多数据源指定事务控制器

如果我们项目有多个数据源, 或者既引入了 spring-boot-starter-jdbc, 又引入了 spring-boot-starter-data-jpa 依赖, 自动注入事务控制器就会混乱, 所以需要创建一个 TransactionManager configuration 类, 手动为不同数据源建立对应的 PlatformTransactionManager bean. 如果使用 @Transactional 注解控制事务, 需要指定对应的事务控制器, 比如

@Transactional(value="txManager1") 

事务管理配置类

@EnableTransactionManagement
class TransactionManagerConfig{
@Bean  
public PlatformTransactionManager txManager1(DataSource dataSource1) {     
  return new DataSourceTransactionManager(dataSource1);    
}
 @Bean       
 public PlatformTransactionManager txManager2(DataSource dataSource2) {    
   return new DataSourceTransactionManager(dataSource2);    
 }
}
// dataSourec1、dataSourec2是多数据源配置注入的bean,考虑这样的场景：mysql主从库，一个服务应用连接两个数据库，做读写分离，写必须是主库

    @Bean
    @Primary // 不指定的时候取这个事务控制器
    public PlatformTransactionManager rccManager(@Qualifier("rccShardingDataSource") DataSource dataSource){
        return new DataSourceTransactionManager(dataSource);
    }

    @Bean
    public PlatformTransactionManager smcManager(@Qualifier("smcShardingDataSource") DataSource dataSource){
        return new DataSourceTransactionManager(dataSource);
    }

    @Bean
    public PlatformTransactionManager mccManager(@Qualifier("mccShardingDataSource") DataSource dataSource){
        return new DataSourceTransactionManager(dataSource);
    }

事务监听机制

原文：https://fangshixiang.blog.csdn.net/article/details/91897175

在spring事务的管控下，需要在执行完数据库操作后，发送消息（比如短信、邮件、微信通知等）来执行其它的操作，而这些并不是主干业务，所以一般会放在异步线程里。spring 提供了两种解决方案

事务同步管理器TransactionSynchronizationManager
@TransactionalEventListener注解（Spring 4.2+）

demo代码

@Slf4j
@Service
public class HelloServiceImpl implements HelloService {
  @Autowired
  private JdbcTemplate jdbcTemplate;
  @Autowired
  private ApplicationEventPublisher applicationEventPublisher;

  @Transactional
  @Override
  public Object hello(Integer id) {
    // 向数据库插入一条记录
    String sql = "insert into user (id,name,age) values (" + id + ",'fsx',21)";
    jdbcTemplate.update(sql);

    // 发布自定义事件
    applicationEventPublisher.publishEvent(new MyAfterTransactionEvent("我是和事务相关的事件，请事务提交后执行我~~~", id));
    return "service hello";
  }

  @Slf4j
  @Component
  private static class MyTransactionListener {
    @Autowired
    private JdbcTemplate jdbcTemplate;

    // 订阅自定义事件，事务提交后触发
    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
    private void onHelloEvent(HelloServiceImpl.MyAfterTransactionEvent event) {
      Object source = event.getSource();
      Integer id = event.getId();

      String query = "select count(1) from user where id = " + id;
      Integer count = jdbcTemplate.queryForObject(query, Integer.class);
      log.info(source + ":" + count.toString()); // 我是和事务相关的事件，请事务提交后执行我~~~:1
    }
  }

  // 定一个事件，继承自ApplicationEvent 
  private static class MyAfterTransactionEvent extends ApplicationEvent {
    private Integer id;

    public MyAfterTransactionEvent(Object source, Integer id) {
      super(source);
      this.id = id;
    }

    public Integer getId() {
      return id;
    }
  }
}

默认情况下，spring的事件监听机制不是异步的，而是同步的，只是做了代码上的解耦，注解@TransactionEventListener也是同步的，通过回调的方式，在提交或者回滚后触发回调事件（被该注解标识的方法）。

点进TransactionalEventListener的源码

@Target({ElementType.METHOD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@EventListener
public @interface TransactionalEventListener {
	/**
	 * Phase to bind the handling of an event to.
	 * <p>The default phase is {@link TransactionPhase#AFTER_COMMIT}.
	 * <p>If no transaction is in progress, the event is not processed at
	 * all unless {@link #fallbackExecution} has been enabled explicitly.
	 取值有：BEFORE_COMMIT、AFTER_COMMIT、AFTER_ROLLBACK、AFTER_COMPLETION
	 */
	TransactionPhase phase() default TransactionPhase.AFTER_COMMIT;

	/**
	 * Whether the event should be processed if no transaction is running.
	 若没有事务的时候，对应的event是否已经执行  
	 */
	boolean fallbackExecution() default false;

	/**
	 * Alias for {@link #classes}.
	 */
	@AliasFor(annotation = EventListener.class, attribute = "classes")
	Class<?>[] value() default {};

	/**
	 * The event classes that this listener handles.
	 * <p>If this attribute is specified with a single value, the annotated
	 * method may optionally accept a single parameter. However, if this
	 * attribute is specified with multiple values, the annotated method
	 * must <em>not</em> declare any parameters.
	 */
	@AliasFor(annotation = EventListener.class, attribute = "classes")
	Class<?>[] classes() default {};

	/**
	 * Spring Expression Language (SpEL) attribute used for making the event
	 * handling conditional.
	 * <p>The default is {@code ""}, meaning the event is always handled.
	 * @see EventListener#condition
	 支持spel表达式，触发事件的条件，详情看注解的EventListener#condition
	 */
	String condition() default "";
}

注解@TransactionalEventListener标识的方法，底层是通过TransactionalEventListenerFactory工厂方法生成一个ApplicationListenerMethodTransactionalAdapter适配器，把监听事件ApplicationEvent注册到事件发射器的容器里面

点进ApplicationListenerMethodTransactionalAdapter的源码，它继承ApplicationListenerMethodAdapter应用事件监听方法适配器，

class ApplicationListenerMethodTransactionalAdapter extends ApplicationListenerMethodAdapter {
  private final TransactionalEventListener annotation; // 被封装的对象

  public ApplicationListenerMethodTransactionalAdapter(String beanName, Class<?> targetClass, Method method) {
    super(beanName, targetClass, method);
    TransactionalEventListener ann = AnnotatedElementUtils.findMergedAnnotation(method, TransactionalEventListener.class); // 找到添加了注解@TransactionalEventListener的方法
    if (ann == null) {
      throw new IllegalStateException("No TransactionalEventListener annotation found on method: " + method);
    }
    this.annotation = ann;
  }
  
  	@Override
	public void onApplicationEvent(ApplicationEvent event) {
    // 事务同步管理器，注册事务同步器，同步器里就是自定义的同步事件
		if (TransactionSynchronizationManager.isSynchronizationActive() &&
				TransactionSynchronizationManager.isActualTransactionActive()) {
			TransactionSynchronization transactionSynchronization = createTransactionSynchronization(event); 
			TransactionSynchronizationManager.registerSynchronization(transactionSynchronization);
		}else if (this.annotation.fallbackExecution()) { // 如果没有事务，也执行事件
			if (this.annotation.phase() == TransactionPhase.AFTER_ROLLBACK && logger.isWarnEnabled()) {
				logger.warn("Processing " + event + " as a fallback execution on AFTER_ROLLBACK phase");
			}
			processEvent(event);
		}else {
			// No transactional event execution at all
			if (logger.isDebugEnabled()) {
				logger.debug("No transaction is active - skipping " + event);
			}
		}
	}
}    

createTransactionSynchronization方法返回的是内部类TransactionSynchronizationEventAdapter 事务同步事件适配器

注解@TransactionalEventListener底层原理还是TransactionSynchronization和TransactionSynchronizationManager。

内部类TransactionSynchronizationEventAdapter的源码

private static class TransactionSynchronizationEventAdapter extends TransactionSynchronizationAdapter {

  private final ApplicationListenerMethodAdapter listener;

  private final ApplicationEvent event;

  private final TransactionPhase phase;

  public TransactionSynchronizationEventAdapter(ApplicationListenerMethodAdapter listener,
                                                ApplicationEvent event, TransactionPhase phase) {

    this.listener = listener;
    this.event = event;
    this.phase = phase;
  }

  @Override
  public int getOrder() { // 50
    return this.listener.getOrder();
  }

  @Override // 提交前处理事件
  public void beforeCommit(boolean readOnly) {
    if (this.phase == TransactionPhase.BEFORE_COMMIT) {
      processEvent();
    }
  }

  @Override // 提交或回滚后处理事件
  public void afterCompletion(int status) {
    if (this.phase == TransactionPhase.AFTER_COMMIT && status == STATUS_COMMITTED) {
      processEvent();
    }
    else if (this.phase == TransactionPhase.AFTER_ROLLBACK && status == STATUS_ROLLED_BACK) {
      processEvent();
    }
    else if (this.phase == TransactionPhase.AFTER_COMPLETION) {
      processEvent();
    }
  }

  protected void processEvent() {
    this.listener.processEvent(this.event);
  }
}

5、跨域问题的3种解决方案

SpringBoot 解决跨越问题的3种方案

CrossOrigin注解

@RequestMapping("/user")
@RestController
public  class UserController {
    @CrossOrigin(origins = "http://localhost:8016")
    @RequestMapping("/getUser")
    public String getUser(@RequestParam("name") String name) {
        System.out.println("name:" + name);
        return  "success";
    }
}

该方案需要在跨域访问的接口上加@CrossOrigin注解，访问规则可以通过注解中的参数控制，控制粒度更细。如果需要跨域访问的接口数量较少，可以使用该方案。

全局配置类

@Configuration
public  class WebConfig implements WebMvcConfigurer {
    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/**")
                .allowedOrigins("*")
                .allowedMethods("GET", "POST")
                .allowCredentials(true)
                .maxAge(3600)
                .allowedHeaders("*");
    }
}

该方案需要实现WebMvcConfigurer接口，重写addCorsMappings方法，在该方法中定义跨域访问的规则。这是一个全局的配置，可以应用于所有接口。

自定义过滤器

@WebFilter("corsFilter")
@Configuration
public  class CorsFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        HttpServletResponse httpServletResponse = (HttpServletResponse) response;
        httpServletResponse.setHeader("Access-Control-Allow-Origin", "*");
        httpServletResponse.setHeader("Access-Control-Allow-Methods", "POST, GET");
        httpServletResponse.setHeader("Access-Control-Max-Age", "3600");
        httpServletResponse.setHeader("Access-Control-Allow-Headers", "x-requested-with");
        chain.doFilter(request, response);
    }

    @Override
    public void destroy() {

    }
}

该方案通过在请求的header中增加Access-Control-Allow-Origin等参数解决跨域问题

顺便说一下，使用@CrossOrigin注解和实现WebMvcConfigurer接口的方案，spring在底层最终都会调用到DefaultCorsProcessor类的handleInternal方法：

最终三种方案殊途同归，都会往header中添加跨域需要参数，只是实现形式不一样而已。

6、如何自定义starter

spring boot starter原理：飞天班第8节：SpringBoot原理探究

以前在没有使用starter时，我们在项目中需要引入新功能，步骤一般是这样的：

在maven仓库找该功能所需jar包
在maven仓库找该jar所依赖的其他jar包
配置新功能所需参数（xml）

以上这种方式会带来三个问题：

如果依赖包较多，找起来很麻烦，容易找错，而且要花很多时间。
各依赖包之间可能会存在版本兼容性问题，项目引入这些jar包后，可能没法正常启动。
如果有些参数没有配好，启动服务也会报错，没有默认配置。

「为了解决这些问题，springboot的starter机制应运而生」。

它能启动相应的默认配置。
它能够管理所需依赖，摆脱了需要到处找依赖和兼容性问题的困扰。
自动发现机制，将spring.factories文件中配置的类，自动注入到spring容器中。
遵循“约定大于配置”的理念。

在业务工程中只需引入xxx-starter包，就能使用它的功能，太爽了。

下面用一张图，总结starter的几个要素：

加了@SpringBootApplication注解的启动类，启动加载的时候会从spring.factories读取配置

实战，定义自己的starter

启动器包含两个模块：

autoconfigure module 配置模块
starter module 启动模块

starter module是一个空jar,只是用来提供依赖包

第一步，创建id-generate-starter的spring boot工程，pom.xml配置如下：

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

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <version>1.3.1</version>
    <groupId>com.sue</groupId>
    <artifactId>id-generate-spring-boot-starter</artifactId>
    <name>id-generate-spring-boot-starter</name>
    <dependencies>
        <dependency>
            <groupId>com.sue</groupId>
            <artifactId>id-generate-spring-boot-autoconfigure</artifactId>
            <version>1.3.1</version>
        </dependency>
    </dependencies>
</project>

第二步，创建id-generate-spring-boot-autoconfigure工程：

pom.xml配置如下

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

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.4.RELEASE</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <version>1.3.1</version>
    <groupId>com.sue</groupId>
    <artifactId>id-generate-spring-boot-autoconfigure</artifactId>
    <name>id-generate-spring-boot-autoconfigure</name>

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

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

该项目当中包含

spring.factories
IdGenerateAutoConfiguration
IdGenerateService
IdProperties

spring.factories配置如下：

org.springframework.boot.autoconfigure.EnableAutoConfiguration=com.sue.IdGenerateAutoConfiguration

IdGenerateAutoConfiguration类：

@ConditionalOnClass(IdProperties.class)
@EnableConfigurationProperties(IdProperties.class)
@Configuration
public class IdGenerateAutoConfiguration {
    @Autowired
    private IdProperties properties;

    @Bean
    public IdGenerateService idGenerateService() {
        return  new IdGenerateService(properties.getWorkId());
    }
}

IdGenerateService类：

public  class IdGenerateService {
    private Long workId;

    public IdGenerateService(Long workId) {
        this.workId = workId;
    }

    public Long generate() {
        return  new Random().nextInt(100) + this.workId;
    }
}

IdProperties类：

@ConfigurationProperties(prefix = IdProperties.PREFIX)
public  class IdProperties {
    public  static  final String PREFIX = "sue";
    private Long workId;

    public Long getWorkId() {
        return workId;
    }

    public void setWorkId(Long workId) {
        this.workId = workId;
    }
}

这样在业务项目中引入相关依赖:

<dependency>
      <groupId>com.sue</groupId>
      <artifactId>id-generate-spring-boot-starter</artifactId>
      <version>1.3.1</version>
</dependency>

就能使用注入使用IdGenerateService的功能了

@Autowired
private IdGenerateService idGenerateService;

完成。

7、项目启动时的附加功能

有时候我们需要在项目启动时定制化一些附加功能，比如：加载一些系统参数、完成初始化、预热本地缓存等，该怎么办呢？

方法一：@PostConstruct注解加到Service方法上，在项目启动加载servlet时运行完成初始化。

方法二：使用springboot提供的CommandLineRunner接口和ApplicationRunner接口

callRunner

它们的用法还是挺简单的，以ApplicationRunner接口为例：

@Component
public  class TestRunner implements ApplicationRunner {
    @Autowired
    private LoadDataService loadDataService;

    public void run(ApplicationArguments args) throws Exception {
        loadDataService.load();
    }   
}

实现ApplicationRunner接口，重写run方法，在该方法中实现自己定制化需求。

如果项目中有多个类实现了ApplicationRunner接口，他们的执行顺序要怎么指定呢？

答案是使用`@Order(n)`注解，n的值越小越先执行。当然也可以通过@Priority注解指定顺序。

springboot项目启动时主要流程是这样的：

SpringApplication的run方法源码:

在SpringApplication类的callRunners方法中，我们能看到这两个接口的具体调用：

所以项目启动时，会调用TestRunner类的run方法。

这两个接口有什么区别？

CommandLineRunner接口中run方法的参数为String数组
ApplicationRunner中run方法的参数为ApplicationArguments，该参数包含了String数组参数和一些可选参数。