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

开发 前端
本文继续总结我认为spring中还不错的知识点,希望对您有所帮助。

[[377975]]

 前言

上一篇文章《spring中这些能升华代码的技巧,可能会让你爱不释手》发表之后,受到了不少读者的好评,很多读者都在期待续集。今天非常高兴的通知大家,你们要的续集来了。本文继续总结我认为spring中还不错的知识点,希望对您有所帮助。

一. @Conditional的强大之处

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

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

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

@ConditionalOnClass

问题1可以用@ConditionalOnClass注解解决,代码如下:

  1. public  class A { 
  2.  
  3. public  class B { 
  4.  
  5. @ConditionalOnClass(B.class) 
  6. @Configuration 
  7. public class TestConfiguration { 
  8.  
  9.     @Bean 
  10.     public A a() { 
  11.       return    new A(); 
  12.     } 

如果项目中存在B类,则会实例化A类。如果不存在B类,则不会实例化A类。

有人可能会问:不是判断有没有某个jar吗?怎么现在判断某个类了?

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

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

这个注解的功能还是挺实用的吧?

@ConditionalOnBean

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

  1. @Configuration 
  2. public  class TestConfiguration { 
  3.  
  4.     @Bean 
  5.     public B b() { 
  6.         return  new B(); 
  7.     } 
  8.  
  9.     @ConditionalOnBean(name="b"
  10.     @Bean 
  11.     public A a() { 
  12.       return    new A(); 
  13.     } 

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

@ConditionalOnProperty

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

  1. @ConditionalOnProperty(prefix = "demo",name="enable", havingValue = "true",matchIfMissing=true ) 
  2. @Configuration 
  3. public  class TestConfiguration { 
  4.  
  5.     @Bean 
  6.     public A a() { 
  7.       return    new A(); 
  8.     } 

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

  1. demo.enable=false 

各参数含义:

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

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

其他的Conditional注解

当然,spring用得比较多的Conditional注解还有:ConditionalOnMissingClass、ConditionalOnMissingBean、ConditionalOnWebApplication等。

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


自定义Conditional

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

第一步,自定义注解:

  1. @Conditional(MyCondition.class) 
  2. @Retention(RetentionPolicy.RUNTIME) 
  3. @Target({ElementType.TYPE, ElementType.METHOD}) 
  4. @Documented 
  5. public  @interface MyConditionOnProperty { 
  6.     String name() default ""
  7.  
  8.     String havingValue() default ""

第二步,实现Condition接口:

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

第三步,使用@MyConditionOnProperty注解。

Conditional的奥秘就藏在ConfigurationClassParser类的processConfigurationClass方法中:


这个方法逻辑不复杂:


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

二. 如何妙用@Import?

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

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

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


普通类

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

  1. public  class A { 
  2.  
  3. @Import(A.class) 
  4. @Configuration 
  5. public class TestConfiguration { 

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

  1. @Autowired 
  2. ivate A a; 

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

@Configuration注解的配置类

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

  • @Import
  • @ImportResource
  • @PropertySource等。
  1. public  class A { 
  2.  
  3. public  class B { 
  4.  
  5. @Import(B.class) 
  6. @Configuration 
  7. public class AConfiguration { 
  8.  
  9.     @Bean 
  10.     public A a() { 
  11.         return  new A(); 
  12.     } 
  13.  
  14. @Import(AConfiguration.class) 
  15. @Configuration 
  16. public class TestConfiguration { 

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

由于文章篇幅有限不过多介绍了,这里留点悬念,后面会出一篇文章专门介绍@Configuration注解,因为它实在太太太重要了。

实现ImportSelector接口的类

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

  1. public  class AImportSelector implements ImportSelector { 
  2.  
  3. private  static  final String CLASS_NAME = "com.sue.cache.service.test13.A"
  4.      
  5.  public String[] selectImports(AnnotationMetadata importingClassMetadata) { 
  6.         return  new String[]{CLASS_NAME}; 
  7.     } 
  8.  
  9. @Import(AImportSelector.class) 
  10. @Configuration 
  11. public class TestConfiguration { 

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

实现ImportBeanDefinitionRegistrar接口的类

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

  1. public  class AImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar { 
  2.     @Override 
  3.     public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) { 
  4.         RootBeanDefinition rootBeanDefinition = new RootBeanDefinition(A.class); 
  5.         registry.registerBeanDefinition("a", rootBeanDefinition); 
  6.     } 
  7.  
  8. @Import(AImportBeanDefinitionRegistrar.class) 
  9. @Configuration 
  10. public class TestConfiguration { 

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

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

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

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

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

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


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

三. @ConfigurationProperties赋值

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

  1. thread.pool.corePoolSize=5 
  2. thread.pool.maxPoolSize=10 
  3. thread.pool.queueCapacity=200 
  4. thread.pool.keepAliveSeconds=30 

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

  1. public  class ThreadPoolConfig { 
  2.  
  3.     @Value("${thread.pool.corePoolSize:5}"
  4.     private  int corePoolSize; 
  5.  
  6.     @Value("${thread.pool.maxPoolSize:10}"
  7.     private  int maxPoolSize; 
  8.  
  9.     @Value("${thread.pool.queueCapacity:200}"
  10.     private  int queueCapacity; 
  11.  
  12.     @Value("${thread.pool.keepAliveSeconds:30}"
  13.     private  int keepAliveSeconds; 
  14.  
  15.     @Value("${thread.pool.threadNamePrefix:ASYNC_}"
  16.     private String threadNamePrefix; 
  17.  
  18.     @Bean 
  19.     public Executor threadPoolExecutor() { 
  20.         ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor(); 
  21.         executor.setCorePoolSize(corePoolSize); 
  22.         executor.setMaxPoolSize(maxPoolSize); 
  23.         executor.setQueueCapacity(queueCapacity); 
  24.         executor.setKeepAliveSeconds(keepAliveSeconds); 
  25.         executor.setThreadNamePrefix(threadNamePrefix); 
  26.         executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy()); 
  27.         executor.initialize(); 
  28.         return executor; 
  29.     } 

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

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

如果参数少还好,多的话,需要给每一个参数都加上@Value注解,是不是有点麻烦?

此外,还有一个问题,@Value注解定义的参数看起来有点分散,不容易辨别哪些参数是一组的。

这时,@ConfigurationProperties就派上用场了,它是springboot中新加的注解。

第一步,先定义ThreadPoolProperties类

  1. @Data 
  2. @Component 
  3. @ConfigurationProperties("thread.pool"
  4. public  class ThreadPoolProperties { 
  5.  
  6.     private  int corePoolSize; 
  7.     private  int maxPoolSize; 
  8.     private  int queueCapacity; 
  9.     private  int keepAliveSeconds; 
  10.     private String threadNamePrefix; 

第二步,使用ThreadPoolProperties类

  1. @Configuration 
  2. public  class ThreadPoolConfig { 
  3.  
  4.     @Autowired 
  5.     private ThreadPoolProperties threadPoolProperties; 
  6.  
  7.     @Bean 
  8.     public Executor threadPoolExecutor() { 
  9.         ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor(); 
  10.         executor.setCorePoolSize(threadPoolProperties.getCorePoolSize()); 
  11.         executor.setMaxPoolSize(threadPoolProperties.getMaxPoolSize()); 
  12.         executor.setQueueCapacity(threadPoolProperties.getQueueCapacity()); 
  13.         executor.setKeepAliveSeconds(threadPoolProperties.getKeepAliveSeconds()); 
  14.         executor.setThreadNamePrefix(threadPoolProperties.getThreadNamePrefix()); 
  15.         executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy()); 
  16.         executor.initialize(); 
  17.         return executor; 
  18.     } 

使用@ConfigurationProperties注解,可以将thread.pool开头的参数直接赋值到ThreadPoolProperties类的同名参数中,这样省去了像@Value注解那样一个个手动去对应的过程。

这种方式显然要方便很多,我们只需编写xxxProperties类,spring会自动装配参数。此外,不同系列的参数可以定义不同的xxxProperties类,也便于管理,推荐优先使用这种方式。

它的底层是通过:ConfigurationPropertiesBindingPostProcessor类实现的,该类实现了BeanPostProcessor接口,在postProcessBeforeInitialization方法中解析@ConfigurationProperties注解,并且绑定数据到相应的对象上。

绑定是通过Binder类的bindObject方法完成的:


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

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

「此外,友情提醒一下:」

使用@ConfigurationProperties注解有些场景有问题,比如:在apollo中修改了某个参数,正常情况可以动态更新到@ConfigurationProperties注解定义的xxxProperties类的对象中,但是如果出现比较复杂的对象,比如:

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

可能动态更新不了。

这时候该怎么办呢?

答案是使用ApolloConfigChangeListener监听器自己处理:

  1. @ConditionalOnClass(com.ctrip.framework.apollo.spring.annotation.EnableApolloConfig.class) 
  2. public class ApolloConfigurationAutoRefresh implements ApplicationContextAware { 
  3.    private ApplicationContext applicationContext; 
  4.     
  5.    @Override 
  6.    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException { 
  7.         this.applicationContext = applicationContext; 
  8.    } 
  9.     
  10.     @ApolloConfigChangeListener 
  11.     private void onChange(ConfigChangeEvent changeEvent{ 
  12.         refreshConfig(changeEvent.changedKeys()); 
  13.     } 
  14.     private void refreshConfig(Set<String> changedKeys){ 
  15.        System.out.println("将变更的参数更新到相应的对象中"); 
  16.     } 

四. spring事务要如何避坑?

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

声明式事务

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

只需在需要执行的事务方法上,加上@Transactional注解就能自动开启事务:

  1. @Service 
  2. public  class UserService { 
  3.  
  4.     @Autowired 
  5.     private UserMapper userMapper; 
  6.      
  7.     @Transactional 
  8.     public void add(UserModel userModel) { 
  9.         userMapper.insertUser(userModel); 
  10.     } 

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

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

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


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


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

编程式事务

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

  1. @Service 
  2. public  class UserService { 
  3.    @Autowired 
  4.    private TransactionTemplate transactionTemplate; 
  5.     
  6.    ... 
  7.     
  8.    public void save(final User user) { 
  9.          transactionTemplate.execute((status) => { 
  10.             doSameThing... 
  11.             return Boolean.TRUE
  12.          }) 
  13.    } 

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

五. 跨域问题的解决方案

关于跨域问题,前后端的解决方案还是挺多的,这里我重点说说spring的解决方案,目前有三种:

一.使用@CrossOrigin注解

  1. @RequestMapping("/user"
  2. @RestController 
  3. public  class UserController { 
  4.  
  5.     @CrossOrigin(origins = "http://localhost:8016"
  6.     @RequestMapping("/getUser"
  7.     public String getUser(@RequestParam("name") String name) { 
  8.         System.out.println("name:" + name); 
  9.         return  "success"
  10.     } 

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

二.增加全局配置

  1. @Configuration 
  2. public  class WebConfig implements WebMvcConfigurer { 
  3.  
  4.     @Override 
  5.     public void addCorsMappings(CorsRegistry registry) { 
  6.         registry.addMapping("/**"
  7.                 .allowedOrigins("*"
  8.                 .allowedMethods("GET""POST"
  9.                 .allowCredentials(true
  10.                 .maxAge(3600) 
  11.                 .allowedHeaders("*"); 
  12.  
  13.     } 

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

三.自定义过滤器

  1. @WebFilter("corsFilter"
  2. @Configuration 
  3. public  class CorsFilter implements Filter { 
  4.  
  5.     @Override 
  6.     public void init(FilterConfig filterConfig) throws ServletException { 
  7.  
  8.     } 
  9.  
  10.     @Override 
  11.     public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException { 
  12.         HttpServletResponse httpServletResponse = (HttpServletResponse) response; 
  13.         httpServletResponse.setHeader("Access-Control-Allow-Origin""*"); 
  14.         httpServletResponse.setHeader("Access-Control-Allow-Methods""POST, GET"); 
  15.         httpServletResponse.setHeader("Access-Control-Max-Age""3600"); 
  16.         httpServletResponse.setHeader("Access-Control-Allow-Headers""x-requested-with"); 
  17.         chain.doFilter(request, response); 
  18.     } 
  19.  
  20.     @Override 
  21.     public void destroy() { 
  22.  
  23.     } 

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

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


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

六. 如何自定义starter

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

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

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

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

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

starter机制带来这些好处:

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

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

下面用一张图,总结starter的几个要素:


接下来我们一起实战,定义一个自己的starter。

第一步,创建id-generate-starter工程:

其中的pom.xml配置如下:

  1. <?xml version="1.0" encoding="UTF-8"?> 
  2.  
  3. <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"
  4.     <modelVersion>4.0.0</modelVersion> 
  5.  
  6.     <version>1.3.1</version> 
  7.     <groupId>com.sue</groupId> 
  8.     <artifactId>id-generate-spring-boot-starter</artifactId> 
  9.     <name>id-generate-spring-boot-starter</name
  10.     <dependencies> 
  11.         <dependency> 
  12.             <groupId>com.sue</groupId> 
  13.             <artifactId>id-generate-spring-boot-autoconfigure</artifactId> 
  14.             <version>1.3.1</version> 
  15.         </dependency> 
  16.     </dependencies> 
  17. </project> 

第二步,创建id-generate-spring-boot-autoconfigure工程:

该项目当中包含:

  • pom.xml
  • spring.factories
  • IdGenerateAutoConfiguration
  • IdGenerateService

IdProperties pom.xml配置如下:

  1. <?xml version="1.0" encoding="UTF-8"?> 
  2.  
  3. <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"
  4.  
  5.     <parent> 
  6.         <groupId>org.springframework.boot</groupId> 
  7.         <artifactId>spring-boot-starter-parent</artifactId> 
  8.         <version>2.0.4.RELEASE</version> 
  9.     </parent> 
  10.     <modelVersion>4.0.0</modelVersion> 
  11.     <version>1.3.1</version> 
  12.     <groupId>com.sue</groupId> 
  13.     <artifactId>id-generate-spring-boot-autoconfigure</artifactId> 
  14.     <name>id-generate-spring-boot-autoconfigure</name
  15.  
  16.     <dependencies> 
  17.         <dependency> 
  18.             <groupId>org.springframework.boot</groupId> 
  19.             <artifactId>spring-boot-starter</artifactId> 
  20.         </dependency> 
  21.  
  22.         <dependency> 
  23.             <groupId>org.springframework.boot</groupId> 
  24.             <artifactId>spring-boot-autoconfigure</artifactId> 
  25.         </dependency> 
  26.  
  27.         <dependency> 
  28.             <groupId>org.springframework.boot</groupId> 
  29.             <artifactId>spring-boot-configuration-processor</artifactId> 
  30.             <optional>true</optional> 
  31.         </dependency> 
  32.     </dependencies> 
  33.  
  34.     <build> 
  35.         <plugins> 
  36.             <plugin> 
  37.                 <groupId>org.apache.maven.plugins</groupId> 
  38.                 <artifactId>maven-compiler-plugin</artifactId> 
  39.                 <configuration> 
  40.                     <source>1.8</source> 
  41.                     <target>1.8</target> 
  42.                 </configuration> 
  43.             </plugin> 
  44.         </plugins> 
  45.     </build> 
  46. </project> 

spring.factories配置如下:

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

IdGenerateAutoConfiguration类:

  1. @ConditionalOnClass(IdProperties.class) 
  2. @EnableConfigurationProperties(IdProperties.class) 
  3. @Configuration 
  4. public class IdGenerateAutoConfiguration { 
  5.  
  6.     @Autowired 
  7.     private IdProperties properties; 
  8.  
  9.     @Bean 
  10.     public IdGenerateService idGenerateService() { 
  11.         return  new IdGenerateService(properties.getWorkId()); 
  12.     } 

IdGenerateService类:

  1. public  class IdGenerateService { 
  2.  
  3.     private Long workId; 
  4.  
  5.     public IdGenerateService(Long workId) { 
  6.         this.workId = workId; 
  7.     } 
  8.  
  9.     public Long generate() { 
  10.         return  new Random().nextInt(100) + this.workId; 
  11.     } 

IdProperties类:

  1. @ConfigurationProperties(prefix = IdProperties.PREFIX) 
  2. public  class IdProperties { 
  3.  
  4.  
  5.     public  static  final String PREFIX = "sue"
  6.  
  7.     private Long workId; 
  8.  
  9.     public Long getWorkId() { 
  10.         return workId; 
  11.     } 
  12.  
  13.     public void setWorkId(Long workId) { 
  14.         this.workId = workId; 
  15.     } 

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

  1. <dependency> 
  2.       <groupId>com.sue</groupId> 
  3.       <artifactId>id-generate-spring-boot-starter</artifactId> 
  4.       <version>1.3.1</version> 
  5. </dependency> 

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

  1. @Autowired 
  2.  private IdGenerateService idGenerateService; 

完美。

七.项目启动时的附加功能

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

好消息是springboot提供了:

  • CommandLineRunner
  • ApplicationRunner

这两个接口帮助我们实现以上需求。

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

  1. @Component 
  2. public  class TestRunner implements ApplicationRunner { 
  3.  
  4.     @Autowired 
  5.     private LoadDataService loadDataService; 
  6.  
  7.     public void run(ApplicationArguments args) throws Exception { 
  8.         loadDataService.load(); 
  9.     } 
  10.      

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

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

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

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


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


最后还有一个问题:这两个接口有什么区别?

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

唠唠家常

写着写着又有这么多字了,按照惯例,为了避免篇幅过长,今天就先写到这里。预告一下,后面会有AOP、BeanPostProcessor、Configuration注解等核心知识点的专题,每个主题的内容都挺多的,可以期待一下喔。

 

责任编辑:姜华 来源: 苏三说技术
相关推荐

2021-01-18 09:55:46

Spring代码Java

2021-01-11 08:21:34

spring升华代码的技巧开发

2010-12-08 09:59:10

CSS

2011-09-16 09:06:20

Smalltalk

2011-03-31 14:22:28

Chrome插件

2021-04-13 10:07:08

Python软件包编程语言

2021-04-25 10:15:38

Python编程语言软件包

2009-08-29 08:41:07

Windows 7新功能

2020-11-03 15:10:55

Spring Batc框架Java

2011-05-12 09:12:16

Ubuntu 11.0

2017-05-24 18:00:13

AndroidAndroid DatView

2021-01-20 06:29:42

JS工具操作符

2021-12-09 13:30:17

微软

2021-02-02 21:42:30

VS Code编辑器开发

2013-05-06 22:52:10

智能手机交互方式用户体验

2021-07-13 10:59:49

Python可视化

2016-05-05 10:54:53

Android开发应用

2023-07-04 08:19:25

IDEA插件

2011-04-19 09:08:09

web工具项目管理

2023-07-18 08:46:34

开发必备软件工具
点赞
收藏

51CTO技术栈公众号