SpringBoot使用技巧
我们都知道spring默认支持的Scopesingleton 单例,每次从spring容器中获取到的bean都是同一个对象。prototype 多例,每次从spring容器中获取到的bean都是不同的对象。spring web又对ScopeRequestScope 同一次请求从spring容器中获取到的bean都是同一个对象。SessionScope 同一个会话从spring容器中获取到的bean
spring使用技巧
获取spring容器对象
实现BeanFactoryAware接口
@Service
public class PersonService implements BeanFactoryAware {
private BeanFactory beanFactory;
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
this.beanFactory = beanFactory;
}
public void add() {
Person person = (Person) beanFactory.getBean("person");
}
}
实现BeanFactoryAware
接口,然后重写setBeanFactory
方法,就能从该方法中获取到spring容器对象。
实现ApplicationContextAware接口
@Service
public class PersonService2 implements ApplicationContextAware {
private ApplicationContext applicationContext;
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
this.applicationContext = applicationContext;
}
public void add() {
Person person = (Person) applicationContext.getBean("person");
}
}
实现ApplicationContextAware
接口,然后重写setApplicationContext
方法,也能从该方法中获取到spring容器对象。
实现ApplicationListener接口
@Service
public class PersonService3 implements ApplicationListener<ContextRefreshedEvent> {
private ApplicationContext applicationContext;
@Override
public void onApplicationEvent(ContextRefreshedEvent event) {
applicationContext = event.getApplicationContext();
}
public void add() {
Person person = (Person) applicationContext.getBean("person");
}
}
实现ApplicationListener
接口,需要注意的是该接口接收的泛型是ContextRefreshedEvent
类,然后重写onApplicationEvent
方法,也能从该方法中获取到spring容器对象。此外,不得不提一下Aware
接口,它其实是一个空接口,里面不包含任何方法。
它表示已感知的意思,通过这类接口可以获取指定对象,比如:
- 通过BeanFactoryAware获取BeanFactory
- 通过ApplicationContextAware获取ApplicationContext
- 通过BeanNameAware获取BeanName等
springboot使用策略模式中一个接口配置多个策略实现类
- 自定义注解
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface SchoolType {
SchoolTypeEnum value();
}
- 枚举类
public enum SchoolTypeEnum {
HAIDIAN, CHAOYANG
}
- 接口
public interface SchoolService {
String getSchool();
}
- 实现类
@SchoolType(value = SchoolTypeEnum.HAIDIAN)
@Service
public class SchoolImpl1 implements SchoolService {
@Override
public String getSchool() {
return "海淀区学校";
}
}
@SchoolType(value = SchoolTypeEnum.CHAOYANG)
@Service
public class SchoolImpl2 implements SchoolService {
@Override
public String getSchool() {
return "朝阳区学校";
}
}
- 策略类
@Component
public class GoSchoolHandler implements ApplicationContextAware, InitializingBean {
private final Map<SchoolTypeEnum, SchoolService> serviceMap = new ConcurrentHashMap<>();
private ApplicationContext applicationContext;
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
this.applicationContext = applicationContext;
}
@Override
public void afterPropertiesSet() throws Exception {
// 获取SchoolService接口的实现类
Map<String, SchoolService> beanMap = applicationContext.getBeansOfType(SchoolService.class);
for(SchoolService impl: beanMap.values()){
SchoolType annotation = AnnotationUtils.findAnnotation(impl.getClass(), SchoolType.class);
if (Objects.isNull(annotation)) {
continue;
}
serviceMap.put(annotation.value(), impl);
}
}
public String getSchool(SchoolTypeEnum Type){
return serviceMap.get(Type).getSchool();
}
}
如何初始化Bean
使用@PostConstruct注解
@Service
public class AService {
@PostConstruct
public void init() {
System.out.println("===初始化===");
}
}
在需要初始化的方法上增加@PostConstruct
注解,这样就有初始化的能力。
实现InitializingBean接口
@Service
public class BService implements InitializingBean {
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("===初始化===");
}
}
实现InitializingBean
接口,重写afterPropertiesSet
方法,该方法中可以完成初始化功能。
自定义自己的Scope
我们都知道spring
默认支持的Scope
只有两种:
- singleton 单例,每次从spring容器中获取到的bean都是同一个对象。
- prototype 多例,每次从spring容器中获取到的bean都是不同的对象。
spring web
又对Scope
进行了扩展,增加了:
- RequestScope 同一次请求从spring容器中获取到的bean都是同一个对象。
- SessionScope 同一个会话从spring容器中获取到的bean都是同一个对象。
即便如此,有些场景还是无法满足我们的要求。
比如,我们想在同一个线程中从spring容器获取到的bean都是同一个对象,该怎么办?
这就需要自定义Scope
了。
自定义类型转换
spring目前支持3中类型转换器:
- Converter<S,T>:将 S 类型对象转为 T 类型对象
- ConverterFactory<S, R>:将 S 类型对象转为 R 类型及子类对象
- GenericConverter:它支持多个source和目标类型的转化,同时还提供了source和目标类型的上下文,这个上下文能让你实现基于属性上的注解或信息来进行类型转换。
这3种类型转换器使用的场景不一样,我们以Converter
为例。假如:接口中接收参数的实体对象中,有个字段的类型是Date,但是实际传参的是字符串类型:2021-01-03 10:20:15,要如何处理呢?
第一步,定义一个实体User
:
@Data
public class User {
private Long id;
private String name;
private Date registerDate;
}
第二步,实现Converter
接口:
public class DateConverter implements Converter<String, Date> {
private SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
@Override
public Date convert(String source) {
if (source != null && !"".equals(source)) {
try {
simpleDateFormat.parse(source);
} catch (ParseException e) {
e.printStackTrace();
}
}
return null;
}
}
第三步,将新定义的类型转换器注入到spring容器中:
@Configuration
public class WebConfig extends WebMvcConfigurerAdapter {
@Override
public void addFormatters(FormatterRegistry registry) {
registry.addConverter(new DateConverter());
}
}
第四步,调用接口
@RequestMapping("/user")
@RestController
public class UserController {
@RequestMapping("/save")
public String save(@RequestBody User user) {
return "success";
}
}
请求接口时User
对象中registerDate
字段会被自动转换成Date
类型。
spring mvc拦截器
spring mvc拦截器根spring拦截器相比,它里面能够获取HttpServletRequest
和HttpServletResponse
等web对象实例。
spring mvc拦截器的顶层接口是:HandlerInterceptor
,包含三个方法:
- preHandle 目标方法执行前执行
- postHandle 目标方法执行后执行
- afterCompletion 请求完成时执行
为了方便我们一般情况会用HandlerInterceptor接口的实现类HandlerInterceptorAdapter
类。
假如有权限认证、日志、统计的场景,可以使用该拦截器。
第一步,继承HandlerInterceptorAdapter
类定义拦截器:
public class AuthInterceptor extends HandlerInterceptorAdapter {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
throws Exception {
String requestUrl = request.getRequestURI();
if (checkAuth(requestUrl)) {
return true;
}
return false;
}
private boolean checkAuth(String requestUrl) {
System.out.println("===权限校验===");
return true;
}
}
第二步,将该拦截器注册到spring容器:
@Configuration
public class WebAuthConfig extends WebMvcConfigurerAdapter {
@Bean
public AuthInterceptor getAuthInterceptor() {
return new AuthInterceptor();
}
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(new AuthInterceptor());
}
}
第三步,在请求接口时spring mvc通过该拦截器,能够自动拦截该接口,并且校验权限。
该拦截器其实相对来说,比较简单,可以在DispatcherServlet
类的doDispatch
方法中看到调用过程:
Enable开关
不知道你有没有用过Enable
开头的注解,比如:EnableAsync
、EnableCaching
、EnableAspectJAutoProxy
等,这类注解就像开关一样,只要在@Configuration
定义的配置类上加上这类注解,就能开启相关的功能。
是不是很酷?
让我们一起实现一个自己的开关:
第一步,定义一个LogFilter:
public class LogFilter implements Filter {
@Override
public void init(FilterConfig filterConfig) throws ServletException {
}
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
System.out.println("记录请求日志");
chain.doFilter(request, response);
System.out.println("记录响应日志");
}
@Override
public void destroy() {
}
}
第二步,注册LogFilter:
@ConditionalOnWebApplication
public class LogFilterWebConfig {
@Bean
public LogFilter timeFilter() {
return new LogFilter();
}
}
注意,这里用了@ConditionalOnWebApplication
注解,没有直接使用@Configuration
注解。
第三步,定义开关@EnableLog
注解:
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(LogFilterWebConfig.class)
public @interface EnableLog {
}
第四步,只需在springboot
启动类加上@EnableLog
注解即可开启LogFilter记录请求和响应日志的功能。
统一异常处理
全局异常处理:RestControllerAdvice
@RestControllerAdvice
public class GlobalExceptionHandler {
@ExceptionHandler(Exception.class)
public String handleException(Exception e) {
if (e instanceof ArithmeticException) {
return "数据异常";
}
if (e instanceof Exception) {
return "服务器内部异常";
}
retur nnull;
}
}
只需在handleException
方法中处理异常情况,业务接口中可以放心使用,不再需要捕获异常(有人统一处理了)。真是爽歪歪。
异步也可以这么优雅
以前我们在使用异步功能时,通常情况下有三种方式:
- 继承Thread类
- 实现Runable接口
- 使用线程池
让我们一起回顾一下:
- 继承Thread类
public class MyThread extends Thread {
@Override
public void run() {
System.out.println("===call MyThread===");
}
public static void main(String[] args) {
new MyThread().start();
}
}
- 实现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();
}
}
- 使用线程池
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会为我们的异步方法创建一个线程去执行,如果该方法被调用次数非常多的话,需要创建大量的线程,会导致资源浪费。
这时,我们可以定义一个线程池,异步方法将会被自动提交到线程池中执行。
spring cache
它目前支持多种缓存:默认的ConCurrentMapCache、Caffine、Guava等缓存框架、redis等持久化DB、自定义缓存
我们在这里以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吗?怎么现在判断某个类了?
这个注解有个升级版的应用场景:比如common工程中写了一个发消息的工具类mqTemplate,业务工程引用了common工程,只需再引入消息中间件,比如rocketmq的jar包,就能开启mqTemplate的功能。而如果有另一个业务工程,通用引用了common工程,如果不需要发消息的功能,不引入rocketmq的jar包即可。
这个注解的功能还是挺实用的吧?
@ConditionalOnBean
@ConfigurationProperties赋值
spring事务要如何避坑
大多数情况下,我们在开发过程中使用更多的可能是声明式事务
,即使用@Transactional
注解定义的事务,因为它用起来更简单,方便。
只需在需要执行的事务方法上,加上@Transactional
注解就能自动开启事务:
这种声明式事务之所以能生效,是因为它的底层使用了AOP,创建了代理对象,调用TransactionInterceptor
拦截器实现事务的功能。
spring事务有个特别的地方:它获取的数据库连接放在
ThreadLocal
中的,也就是说同一个线程中从始至终都能获取同一个数据库连接,可以保证同一个线程中多次数据库操作在同一个事务中执行。
正常情况下是没有问题的,但是如果使用不当,事务会失效,主要原因如下:
除了上述列举的问题之外,由于@Transactional
注解最小粒度是要被定义在方法上,如果有多层的事务方法调用,可能会造成大事务问题。
所以,建议在实际工作中少用@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
注解要好些。
跨域问题的解决方案
关于跨域问题,前后端的解决方案还是挺多的,这里我重点说说spring的解决方案,目前有三种:
使用@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
方法,在该方法中定义跨域访问的规则。这是一个全局的配置,可以应用于所有接口。
如何自定义starter
以前在没有使用starter
时,我们在项目中需要引入新功能,步骤一般是这样的:
- 在maven仓库找该功能所需jar包
- 在maven仓库找该jar所依赖的其他jar包
- 配置新功能所需参数
以上这种方式会带来三个问题:
- 如果依赖包较多,找起来很麻烦,容易找错,而且要花很多时间。
- 各依赖包之间可能会存在版本兼容性问题,项目引入这些jar包后,可能没法正常启动。
- 如果有些参数没有配好,启动服务也会报错,没有默认配置。
「为了解决这些问题,springboot的starter
机制应运而生」。
starter机制带来这些好处:
- 它能启动相应的默认配置。
- 它能够管理所需依赖,摆脱了需要到处找依赖 和 兼容性问题的困扰。
- 自动发现机制,将spring.factories文件中配置的类,自动注入到spring容器中。
- 遵循“约定大于配置”的理念。
在业务工程中只需引入starter包,就能使用它的功能,太爽了。
项目启动时的附加功能
有时候我们需要在项目启动时定制化一些附加功能,比如:加载一些系统参数、完成初始化、预热本地缓存等,该怎么办呢?
好消息是springboot
提供了:
- CommandLineRunner
- ApplicationRunner
这两个接口帮助我们实现以上需求。
它们的用法还是挺简单的,以ApplicationRunner
接口为例:
@Component
public class TestRunner implements ApplicationRunner {
@Autowired
private LoadDataService loadDataService;
public void run(ApplicationArguments args) throws Exception {
loadDataService.load();
}
}
spring中创建Bean的方式
xml文件配置bean
我们先从xml配置bean
开始,它是spring最早支持的方式。后来,随着springboot
越来越受欢迎,该方法目前已经用得很少了,但我建议我们还是有必要了解一下。
Component注解
为了解决bean太多时,xml文件过大,从而导致膨胀不好维护的问题。在spring2.5中开始支持:@Component
、@Repository
、@Service
、@Controller
等注解定义bean。
如果你有看过这些注解的源码的话,就会惊奇得发现:其实后三种注解也是@Component
。
@Component
系列注解的出现,给我们带来了极大的便利。我们不需要像以前那样在bean.xml文件中配置bean了,现在只用在类上加Component、Repository、Service、Controller,这四种注解中的任意一种,就能轻松完成bean的定义。
其实,这四种注解在功能上没有特别的区别,不过在业界有个不成文的约定:
- Controller 一般用在控制层
- Service 一般用在业务层
- Repository 一般用在数据层
- Component 一般用在公共组件上
太棒了,简直一下子解放了我们的双手。
不过,需要特别注意的是,通过这种@Component
扫描注解的方式定义bean的前提是:需要先配置扫描路径。
目前常用的配置扫描路径的方式如下:
- 在applicationContext.xml文件中使用``标签。例如:
<context:component-scan base-package="com.sue.cache" />
- 在springboot的启动类上加上
@ComponentScan
注解,例如:
@ComponentScan(basePackages = "com.sue.cache")
@SpringBootApplication
public class Application {
public static void main(String[] args) {
new SpringApplicationBuilder(Application.class).web(WebApplicationType.SERVLET).run(args);
}
}
- 直接在
SpringBootApplication
注解上加,它支持ComponentScan功能:
@SpringBootApplication(scanBasePackages = "com.sue.cache")
public class Application {
public static void main(String[] args) {
new SpringApplicationBuilder(Application.class).web(WebApplicationType.SERVLET).run(args);
}
}
当然,如果你需要扫描的类跟springboot的入口类,在同一级或者子级的包下面,无需指定scanBasePackages
参数,spring默认会从入口类的同一级或者子级的包去找。
@SpringBootApplication
public class Application {
public static void main(String[] args) {
new SpringApplicationBuilder(Application.class).web(WebApplicationType.SERVLET).run(args);
}
}
此外,除了上述四种@Component
注解之外,springboot还增加了@RestController
注解,它是一种特殊的@Controller
注解,所以也是@Component
注解。@RestController
还支持@ResponseBody
注解的功能,即将接口响应数据的格式自动转换成json。
@Component
系列注解已经让我们爱不释手了,它目前是我们日常工作中最多的定义bean的方式。
JavaConfig
@Component
系列注解虽说使用起来非常方便,但是bean的创建过程完全交给spring容器来完成,我们没办法自己控制。
spring从3.0以后,开始支持JavaConfig的方式定义bean。它可以看做spring的配置文件,但并非真正的配置文件,我们需要通过编码java代码的方式创建bean。例如:
@Configuration
public class MyConfiguration {
@Bean
public Person person() {
return new Person();
}
}
在JavaConfig类上加@Configuration
注解,相当于配置了标签。而在方法上加`@Bean`注解,相当于配置了
标签。
此外,springboot还引入了一些列的@Conditional
注解,用来控制bean的创建。
@Configuration
public class MyConfiguration {
@ConditionalOnClass(Country.class)
@Bean
public Person person() {
return new Person();
}
}
@ConditionalOnClass
注解的功能是当项目中存在Country类时,才实例化Person类。换句话说就是,如果项目中不存在Country类,就不实例化Person类。
这个功能非常有用,相当于一个开关控制着Person类,只有满足一定条件才能实例化。
spring中使用比较多的Conditional还有:
- ConditionalOnBean
- ConditionalOnProperty
- ConditionalOnMissingClass
- ConditionalOnMissingBean
- ConditionalOnWebApplication
Import注解
通过前面介绍的@Configuration和@Bean相结合的方式,我们可以通过代码定义bean。但这种方式有一定的局限性,它只能创建该类中定义的bean实例,不能创建其他类的bean实例,如果我们想创建其他类的bean实例该怎么办呢?
这时可以使用@Import
注解导入。
普通类
spring4.2之后@Import
注解可以实例化普通类的bean实例。例如:
先定义了Role类:
@Data
public class Role {
private Long id;
private String name;
}
接下来使用@Import注解导入Role类:
@Import(Role.class)
@Configuration
public class MyConfig {
}
然后在调用的地方通过@Autowired
注解注入所需的bean。
@RequestMapping("/")
@RestController
public class TestController {
@Autowired
private Role role;
@GetMapping("/test")
public String test() {
System.out.println(role);
return "test";
}
}
聪明的你可能会发现,我没有在任何地方定义过Role的bean,但spring却能自动创建该类的bean实例,这是为什么呢?
这也许正是@Import
注解的强大之处。
此时,有些朋友可能会问:@Import
注解能定义单个类的bean,但如果有多个类需要定义bean该怎么办呢?
恭喜你,这是个好问题,因为@Import
注解也支持。
@Import({Role.class, User.class})
@Configuration
public class MyConfig {
}
甚至,如果你想偷懒,不想写这种MyConfig
类,springboot也欢迎。
@Import({Role.class, User.class})
@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class,
DataSourceTransactionManagerAutoConfiguration.class})
public class Application {
public static void main(String[] args) {
new SpringApplicationBuilder(Application.class).web(WebApplicationType.SERVLET).run(args);
}
}
可以将@Import加到springboot的启动类上。
这样也能生效?
springboot的启动类一般都会加@SpringBootApplication注解,该注解上加了@SpringBootConfiguration注解。
而@SpringBootConfiguration注解,上面又加了@Configuration注解
所以,springboot启动类本身带有@Configuration注解的功能。
Configuration类
上面介绍了@Import注解导入普通类的方法,它同时也支持导入Configuration类。
先定义一个Configuration类:
@Configuration
public class MyConfig2 {
@Bean
public User user() {
return new User();
}
@Bean
public Role role() {
return new Role();
}
}
然后在另外一个Configuration类中引入前面的Configuration类:
@Import({MyConfig2.class})
@Configuration
public class MyConfig {
}
这种方式,如果MyConfig2类已经在spring指定的扫描目录或者子目录下,则MyConfig类会显得有点多余。因为MyConfig2类本身就是一个配置类,它里面就能定义bean。
但如果MyConfig2类不在指定的spring扫描目录或者子目录下,则通过MyConfig类的导入功能,也能把MyConfig2类识别成配置类。这就有点厉害了喔。
其实下面还有更高端的玩法。
swagger作为一个优秀的文档生成框架,在spring项目中越来越受欢迎。接下来,我们以swagger2为例,介绍一下它是如何导入相关类的。
众所周知,我们引入swagger相关jar包之后,只需要在springboot的启动类上加上@EnableSwagger2
注解,就能开启swagger的功能。
其中@EnableSwagger2注解中导入了Swagger2DocumentationConfiguration类。
该类是一个Configuration类,它又导入了另外两个类:
- SpringfoxWebMvcConfiguration
- SwaggerCommonConfiguration
SpringfoxWebMvcConfiguration类又会导入新的Configuration类,并且通过@ComponentScan注解扫描了一些其他的路径。
SwaggerCommonConfiguration同样也通过@ComponentScan注解扫描了一些额外的路径。
如此一来,我们通过一个简单的@EnableSwagger2
注解,就能轻松的导入swagger所需的一系列bean,并且拥有swagger的功能。
ImportSelector
上面提到的Configuration类,它的功能非常强大。但怎么说呢,它不太适合加复杂的判断条件,根据某些条件定义这些bean,根据另外的条件定义那些bean。
那么,这种需求该怎么实现呢?
这时就可以使用ImportSelector
接口了。
首先定义一个类实现ImportSelector
接口:
public class DataImportSelector implements ImportSelector {
@Override
public String[] selectImports(AnnotationMetadata importingClassMetadata) {
return new String[]{"com.sue.async.service.User", "com.sue.async.service.Role"};
}
}
重写selectImports
方法,在该方法中指定需要定义bean的类名,注意要包含完整路径,而非相对路径。
然后在MyConfig类上@Import导入这个类即可:
@Import({DataImportSelector.class})
@Configuration
public class MyConfig {
}
朋友们是不是又发现了一个新大陆?
不过,这个注解还有更牛逼的用途。
@EnableAutoConfiguration注解中导入了AutoConfigurationImportSelector类,并且里面包含系统参数名称:spring.boot.enableautoconfiguration
。
AutoConfigurationImportSelector类实现了ImportSelector
接口。
并且重写了selectImports
方法,该方法会根据某些注解去找所有需要创建bean的类名,然后返回这些类名。其中在查找这些类名之前,先调用isEnabled方法,判断是否需要继续查找。
该方法会根据ENABLED_OVERRIDE_PROPERTY的值来作为判断条件。
而这个值就是spring.boot.enableautoconfiguration
。
换句话说,这里能根据系统参数控制bean是否需要被实例化,优秀。
我个人认为实现ImportSelector接口的好处主要有以下两点:
- 把某个功能的相关类,可以放到一起,方面管理和维护。
- 重写selectImports方法时,能够根据条件判断某些类是否需要被实例化,或者某个条件实例化这些bean,其他的条件实例化那些bean等。我们能够非常灵活的定制化bean的实例化。
ImportBeanDefinitionRegistrar
我们通过上面的这种方式,确实能够非常灵活的自定义bean。
但它的自定义能力,还是有限的,它没法自定义bean的名称和作用域等属性。
有需求,就有解决方案。
接下来,我们一起看看ImportBeanDefinitionRegistrar
接口的神奇之处。
先定义CustomImportSelector类实现ImportBeanDefinitionRegistrar接口:
public class CustomImportSelector implements ImportBeanDefinitionRegistrar {
@Override
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
RootBeanDefinition roleBeanDefinition = new RootBeanDefinition(Role.class);
registry.registerBeanDefinition("role", roleBeanDefinition);
RootBeanDefinition userBeanDefinition = new RootBeanDefinition(User.class);
userBeanDefinition.setScope(ConfigurableBeanFactory.SCOPE_PROTOTYPE);
registry.registerBeanDefinition("user", userBeanDefinition);
}
}
重写registerBeanDefinitions
方法,在该方法中我们可以获取BeanDefinitionRegistry
对象,通过它去注册bean。不过在注册bean之前,我们先要创建BeanDefinition对象,它里面可以自定义bean的名称、作用域等很多参数。
然后在MyConfig类上导入上面的类:
@Import({CustomImportSelector.class})
@Configuration
public class MyConfig {
}
tionRegistrar
我们通过上面的这种方式,确实能够非常灵活的自定义bean。
但它的自定义能力,还是有限的,它没法自定义bean的名称和作用域等属性。
有需求,就有解决方案。
接下来,我们一起看看ImportBeanDefinitionRegistrar
接口的神奇之处。
先定义CustomImportSelector类实现ImportBeanDefinitionRegistrar接口:
public class CustomImportSelector implements ImportBeanDefinitionRegistrar {
@Override
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
RootBeanDefinition roleBeanDefinition = new RootBeanDefinition(Role.class);
registry.registerBeanDefinition("role", roleBeanDefinition);
RootBeanDefinition userBeanDefinition = new RootBeanDefinition(User.class);
userBeanDefinition.setScope(ConfigurableBeanFactory.SCOPE_PROTOTYPE);
registry.registerBeanDefinition("user", userBeanDefinition);
}
}
重写registerBeanDefinitions
方法,在该方法中我们可以获取BeanDefinitionRegistry
对象,通过它去注册bean。不过在注册bean之前,我们先要创建BeanDefinition对象,它里面可以自定义bean的名称、作用域等很多参数。
然后在MyConfig类上导入上面的类:
@Import({CustomImportSelector.class})
@Configuration
public class MyConfig {
}
我们所熟悉的fegin功能,就是使用ImportBeanDefinitionRegistrar接口实现的:
更多推荐
所有评论(0)