十. 异步也可以这么优雅

以前我们在使用异步功能时，通常情况下有三种方式：

继承Thread类

实现Runable接口

使用线程池

让我们一起回顾一下：

1.继承Thread类

public class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("===call MyThread===");
    }
    public static void main(String[] args) {
        new MyThread().start();
    }
}

2.实现Runable接口

public class MyWork implements Runnable {
    @Override
    public void run() {
        System.out.println("===call MyWork===");
    }
    public static void main(String[] args) {
        new Thread(new MyWork()).start();
    }
}

3.使用线程池

public class MyThreadPool {
    private static ExecutorService executorService = new ThreadPoolExecutor(1, 5, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<>(200));
    static class Work implements Runnable {
        @Override
        public void run() {
            System.out.println("===call work===");
        }
    }
    public static void main(String[] args) {
        try {
            executorService.submit(new MyThreadPool.Work());
        } finally {
            executorService.shutdown();
        }
    }
}

这三种实现异步的方法不能说不好，但是spring已经帮我们抽取了一些公共的地方，我们无需再继承Thread类或实现Runable接口，它都搞定了。

如何spring异步功能呢？

第一步，springboot项目启动类上加@EnableAsync注解。

@EnableAsync
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        new SpringApplicationBuilder(Application.class).web(WebApplicationType.SERVLET).run(args);
    }
}

第二步，在需要使用异步的方法上加上@Async注解：

@Service
public class PersonService {
    @Async
    public String get() {
        System.out.println("===add==");
        return "data";
    }
}

然后在使用的地方调用一下：personService.get();就拥有了异步功能，是不是很神奇。

默认情况下，spring会为我们的异步方法创建一个线程去执行，如果该方法被调用次数非常多的话，需要创建大量的线程，会导致资源浪费。

这时，我们可以定义一个线程池，异步方法将会被自动提交到线程池中执行。

@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 MessageExecutor() {
        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;
    }
}

spring异步的核心方法：

根据返回值不同，处理情况也不太一样，具体分为如下情况：

十一. 听说缓存好用，没想到这么好用

spring cache架构图：

它目前支持多种缓存：

我们在这里以caffeine为例，它是spring官方推荐的。

第一步，引入caffeine的相关jar包

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>
<dependency>
    <groupId>com.github.ben-manes.caffeine</groupId>
    <artifactId>caffeine</artifactId>
    <version>2.6.0</version>
</dependency>

第二步，配置CacheManager，开启EnableCaching

@Configuration
@EnableCaching
public class CacheConfig {
    @Bean
    public CacheManager cacheManager(){
        CaffeineCacheManager cacheManager = new CaffeineCacheManager();
        //Caffeine配置
        Caffeine<Object, Object> caffeine = Caffeine.newBuilder()
                //最后一次写入后经过固定时间过期
                .expireAfterWrite(10, TimeUnit.SECONDS)
                //缓存的最大条数
                .maximumSize(1000);
        cacheManager.setCaffeine(caffeine);
        return cacheManager;
    }
}

第三步，使用Cacheable注解获取数据

@Service
public class CategoryService {
   //category是缓存名称,#type是具体的key，可支持el表达式
   @Cacheable(value = "category", key = "#type")
   public CategoryModel getCategory(Integer type) {
       return getCategoryByType(type);
   }
   private CategoryModel getCategoryByType(Integer type) {
       System.out.println("根据不同的type:" + type + "获取不同的分类数据");
       CategoryModel categoryModel = new CategoryModel();
       categoryModel.setId(1L);
       categoryModel.setParentId(0L);
       categoryModel.setName("电器");
       categoryModel.setLevel(3);
       return categoryModel;
   }
}

调用categoryService.getCategory()方法时，先从caffine缓存中获取数据，如果能够获取到数据则直接返回该数据，不会进入方法体。如果不能获取到数据，则直接方法体中的代码获取到数据，然后放到caffine缓存中。

十二. @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

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, 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方法中：

这个方法逻辑不复杂：

1.先判断有没有使用Conditional注解，如果没有直接返回false

2.收集condition到集合中

3.按order排序该集合

4.遍历该集合，循环调用condition的matchs方法。

十三. 如何妙用@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等注解引入的类进行递归，一次性全部引入。

由于文章篇幅有限不过多介绍了，这里留点悬念，后面会出一篇文章专门介绍@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方法中可以看到这三种方式的处理逻辑：

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

Spring 代码优化技巧(大全2)（一）

十. 异步也可以这么优雅

十一. 听说缓存好用，没想到这么好用

十二. @Conditional的强大之处

十三. 如何妙用@Import？

热门文章

最新文章

相关课程

相关电子书

相关实验场景