spring中那些让你爱不释手的代码技巧(续集上)

简介: spring中那些让你爱不释手的代码技巧(续集)

前言


今天非常高兴的通知大家,你们要的续集来了。本文继续总结我认为spring中还不错的知识点,希望对您有所帮助。


正文


一. @Conditional的强大之处


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

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

如果你有遇到过上述这些问题,那么恭喜你,本节内容非常适合你。


@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注解还有:ConditionalOnMissingClassConditionalOnMissingBeanConditionalOnWebApplication等。

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

9.png


自定义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方法中:

7.png


这个方法逻辑不复杂:

8.png

  1. 先判断有没有使用Conditional注解,如果没有直接返回false
  2. 收集condition到集合中
  3. order排序该集合
  4. 遍历该集合,循环调用conditionmatchs方法。


二. 如何妙用@Import?


有时我们需要在某个配置类中引入另外一些类,被引入的类也加到spring容器中。这时可以使用@Import注解完成这个功能。

如果你看过它的源码会发现,引入的类支持三种不同类型。

但是我认为最好将普通类和@Configuration注解的配置类分开讲解,所以列了四种不同类型:

6.png


普通类


这种引入方式是最简单的,被引入的类会被实例化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等注解引入的类进行递归,一次性全部引入。

由于文章篇幅有限不过多介绍了,这里留点悬念,后面会出一篇文章专门介绍@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 {
}

这四种引入类的方式各有千秋,总结如下:

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

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

5.png

最后的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方法完成的:

4.png

以上这段代码会递归绑定数据,主要考虑了三种情况:

  • 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);
    }
}

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

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

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

3.png

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

2.png

所以,建议在实际工作中少用@Transactional注解开启事务。


编程式事务


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

@Service
public class UserService {
   @Autowired
   private TransactionTemplate transactionTemplate;
   ...
   public void save(final User user) {
         transactionTemplate.execute((status) => {
            doSameThing...
            return Boolean.TRUE;
         })
   }
}

使用TransactionTemplate的编程式事务能避免很多事务失效的问题,但是对大事务问题,不一定能够解决,只是说相对于使用@Transactional注解要好些。

相关文章
|
1月前
ext portal+dwr+spring实现个性主页面拖拉效果的核心代码
ext portal+dwr+spring实现个性主页面拖拉效果的核心代码
44 6
|
16天前
|
缓存 监控 Java
|
1月前
|
Java BI API
spring boot 整合 itextpdf 导出 PDF,写入大文本,写入HTML代码,分析当下导出PDF的几个工具
这篇文章介绍了如何在Spring Boot项目中整合iTextPDF库来导出PDF文件,包括写入大文本和HTML代码,并分析了几种常用的Java PDF导出工具。
418 0
spring boot 整合 itextpdf 导出 PDF,写入大文本,写入HTML代码,分析当下导出PDF的几个工具
|
1月前
|
存储 Java 程序员
SpringIOC和DI的代码实现,Spring如何存取对象?@Controller、@Service、@Repository、@Component、@Configuration、@Bean DI详解
本文详细讲解了Spring框架中IOC容器如何存储和取出Bean对象,包括五大类注解(@Controller、@Service、@Repository、@Component、@Configuration)和方法注解@Bean的用法,以及DI(依赖注入)的三种注入方式:属性注入、构造方法注入和Setter注入,并分析了它们的优缺点。
28 0
SpringIOC和DI的代码实现,Spring如何存取对象?@Controller、@Service、@Repository、@Component、@Configuration、@Bean DI详解
|
3月前
|
存储 缓存 Java
面试问Spring循环依赖?今天通过代码调试让你记住
该文章讨论了Spring框架中循环依赖的概念,并通过代码示例帮助读者理解这一概念。
面试问Spring循环依赖?今天通过代码调试让你记住
|
3月前
|
SQL 数据库
Spring5入门到实战------13、使用JdbcTemplate操作数据库(批量增删改)。具体代码+讲解 【下篇】
这篇文章是Spring5框架的实战教程,深入讲解了如何使用JdbcTemplate进行数据库的批量操作,包括批量添加、批量修改和批量删除的具体代码实现和测试过程,并通过完整的项目案例展示了如何在实际开发中应用这些技术。
Spring5入门到实战------13、使用JdbcTemplate操作数据库(批量增删改)。具体代码+讲解 【下篇】
|
3月前
|
XML Java 数据格式
Spring5入门到实战------11、使用XML方式实现AOP切面编程。具体代码+讲解
这篇文章是Spring5框架的AOP切面编程教程,通过XML配置方式,详细讲解了如何创建被增强类和增强类,如何在Spring配置文件中定义切入点和切面,以及如何将增强逻辑应用到具体方法上。文章通过具体的代码示例和测试结果,展示了使用XML配置实现AOP的过程,并强调了虽然注解开发更为便捷,但掌握XML配置也是非常重要的。
Spring5入门到实战------11、使用XML方式实现AOP切面编程。具体代码+讲解
|
3月前
|
Java 数据安全/隐私保护 Spring
揭秘Spring Boot自定义注解的魔法:三个实用场景让你的代码更加优雅高效
揭秘Spring Boot自定义注解的魔法:三个实用场景让你的代码更加优雅高效
|
3月前
|
XML 数据库 数据格式
Spring5入门到实战------14、完全注解开发形式 ----JdbcTemplate操作数据库(增删改查、批量增删改)。具体代码+讲解 【终结篇】
这篇文章是Spring5框架的实战教程的终结篇,介绍了如何使用注解而非XML配置文件来实现JdbcTemplate的数据库操作,包括增删改查和批量操作,通过创建配置类来注入数据库连接池和JdbcTemplate对象,并展示了完全注解开发形式的项目结构和代码实现。
Spring5入门到实战------14、完全注解开发形式 ----JdbcTemplate操作数据库(增删改查、批量增删改)。具体代码+讲解 【终结篇】
|
3月前
|
SQL XML Java
Spring5入门到实战------12、使用JdbcTemplate操作数据库(增删改查)。具体代码+讲解 【上篇】
这篇文章是Spring5框架的实战教程,详细讲解了如何使用JdbcTemplate进行数据库的增删改查操作,包括在项目中引入依赖、配置数据库连接池、创建实体类、定义DAO接口及其实现,并提供了具体的代码示例和测试结果,最后还提供了完整的XML配置文件和测试代码。
Spring5入门到实战------12、使用JdbcTemplate操作数据库(增删改查)。具体代码+讲解 【上篇】