Spring 扩展点

**本人博客网站 **IT小神 www.itxiaoshen.com

官网地址****：https://spring.io/projects/spring-framework

The Spring Framework provides a comprehensive programming and configuration model for modern Java-based enterprise applications - on any kind of deployment platform.

Spring框架为现代基于java的企业应用程序提供了全面的编程和配置模型——适用于任何类型的部署平台。

Spring之所以能打败其他所有同类型Java开发框架屹立不倒的重要原因之一就是提供很多扩展点，让其他组件和框架很容易就整合到Spring框架里,所以也就诞生很多基于Spring的二次开发项目，接下来我们一起聊聊Spring提供哪些扩展点，这篇文章只是简单说明扩展点但不深入，有兴趣的伙伴可以后续一起学习交流，本篇最后我们再进行一个Mybatis和Spring整合工程简易开发示例

Spring加载上下文方式

Spring加载容器上下文主要提供以下三大类方式，第一种基于配置类为常用的使用方式，AnnotationConfigApplicationContext传入参数是一个Class数组也即是支持多个配置类

  1. public class ApplicationDemo {
  2.     public static void main(String[] args) {
  3.         //基于配置类加载Spring上下文
  4.         AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MyConfig.class);
  5.         Student student = applicationContext.getBean(Student.class);
  6.         System.out.println(student);
  8.         //基于项目路径xml加载Spring上下文
  9.         ClassPathXmlApplicationContext applicationContextXml = new ClassPathXmlApplicationContext("spring.xml");
  10.         student = applicationContextXml.getBean(Student.class);
  11.         System.out.println(student);
  13.         //基于文件系统绝对路径xml加载Spring上下文
  14.         FileSystemXmlApplicationContext applicationContextFileXml = new FileSystemXmlApplicationContext("E://spring.xml");
  15.         student = applicationContextXml.getBean(Student.class);
  16.         System.out.println(student);
  17.     }
  18. }
  20. @Configuration
  21. @ComponentScan({"com.itxs.pojo","com.itxs.extend"})
  22. public class MyConfig {
  23. }
  1. public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
  2.     this();
  3.     register(componentClasses);
  4.     refresh();
  5. }

扩展点

ApplicationContextInitializer

这个是Spring Boot提供的扩展点,在整个 spring 容器在刷新之前初始化 ConfigurableApplicationContext 的回调接口，简单来说，就是在容器刷新之前调用此类的 initialize 方法。这个点允许被用户自己扩展。用户可以在整个 spring 容器还没被初始化之前做一些事情。可以想到的场景可能为，在最开始激活一些配置，或者利用这时候 class 还没被类加载器加载的时机，进行动态字节码注入等操作

  1. public class MyApplicationContextInitializer implements ApplicationContextInitializer {
  2.     @Override
  3.     public void initialize(ConfigurableApplicationContext configurableApplicationContext) {
  4.         System.out.println("-----------------------MyApplicationContextInitializer initialize");
  5.     }
  6. }
  1. @SpringBootApplication
  2. public class MyApplication {
  3.     public static void main(String[] args) {
  4.         //SpringApplication Main函数添加初始化器方式
  5.         SpringApplication springApplication = new SpringApplication(MyApplication.class);
  6.         springApplication.addInitializers(new MyApplicationContextInitializer());
  7.         springApplication.run(args);
  8.     }
  9. }

第二种配置文件中配置

  1. context:
  2.   initializer:
  3.     classes: com.itxs.extend.MyApplicationContextInitializer

第三种SpringBoot的SPI扩展---META-INF/spring.factories中配置

  1. org.springframework.context.ApplicationContextInitializer=com.itxs.extend.MyApplicationContextInitializer

BeanDefinitionRegistryPostProcessor-bean定义注册后置处理器

BeanDefinitionRegistryPostProcessor是BeanFactoryPostProcessor的子接口，BeanFactoryPostProcessor的作用是在bean的定义信息已经加载但还没有进行初始化的时候执行postProcessBeanFactory(）的方法，BeanDefinitionRegistryPostProcessor是在BeanFactoryPostProcessor的前面执行，在bean定义之后提供的扩展点，比如可以在这里动态注册自己的 beanDefinition，加载 classpath 之外的 bean信息。

  1. @Component
  2. public class MyBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {
  3.     @Override
  4.     public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanDefinitionRegistry) throws BeansException {
  5.         System.out.println("BeanDefinitionRegistryPostProcessor-postProcessBeanDefinitionRegistry");
  6.         System.out.println("BeanDefinitionCount:"+beanDefinitionRegistry.getBeanDefinitionCount());
  7.         String[] beanDefinitionNames = beanDefinitionRegistry.getBeanDefinitionNames();
  8.         for (String beanDefinitionName : beanDefinitionNames) {
  9.             System.out.println("beanDefinitionName:"+beanDefinitionName);
  10.         }
  11.     }
  13.     @Override
  14.     public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
  15.         System.out.println("BeanDefinitionRegistryPostProcessor-postProcessBeanFactory");
  16.     }
  17. }

BeanFactoryPostProcessor-Bean工厂后置处理器

BeanFactoryPostProcessor 接口是 Spring 初始化 BeanFactory 的扩展接口，在 Spring 在读取 beanDefinition 信息之后实例化 bean 之前读取 bean 的定义并可以修改它。在这个时机，用户可以通过实现这个扩展接口来自行处理一些东西，比如修改已经注册的 beanDefinition 的元信息。下面将student bean类型修改为teacher bean类型

  1. @Component
  2. public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
  3.     @Override
  4.     public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
  5.         System.out.println("BeanFactoryPostProcessor-postProcessBeanFactory");
  6.         BeanDefinition student = configurableListableBeanFactory.getBeanDefinition("student");
  7.         student.setBeanClassName(Teacher.class.getName());
  8.     }
  9. }

BeanPostProcessor-Bean后置处理器

该接口也可称为后置处理器，而我们Spring提供很多种bean后置处理器（比如在Spring源码中九大后置处理器九次调用后置处理器地方的说法），其作用是在Bean对象实例化和依赖注入完毕后，在显示调用初始化方法的前后添加我们自己的业务逻辑；注意是Bean实例化完毕后及依赖注入完成后触发的；在这个扩展点我们可以修改bean的属性，可以给bean生成一个动态代理实例等等。Spring AOP的底层处理主要也是通过实现BeanPostProcessor来执行代理包装逻辑。方法中输入是一个个的bean,返回值则是bean修改的对象，默认为null则是不修改；bean后置处理器可以有多个，可以通过实现Ordered接口或者标记@Order注解来决定其处理顺序。

· postProcessBeforeInitialization：初始化 bean 之前，相当于把 bean 注入 spring 上下文之前

· postProcessAfterInitialization：初始化 bean 之后，相当于把 bean 注入 spring 上下文之后

  1. @Component
  2. public class MyBeanPostProcessor implements BeanPostProcessor {
  3.     @Override
  4.     public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
  5.         System.out.println("postProcessBeforeInitialization beanName:"+beanName);
  6.         return null;
  7.     }
  9.     @Override
  10.     public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
  11.         System.out.println("postProcessAfterInitialization beanName:"+beanName);
  12.         if (bean.getClass().isAssignableFrom(Student.class)){
  13.             return Teacher.class;
  14.         }
  15.         return null;
  16.     }
  17. }

InstantiationAwareBeanPostProcessor

该接口也是 BeanPostProcessor的子接口，而BeanPostProcessor接口只在 bean 的初始化阶段进行扩展（Bean实例化完毕后及依赖注入完成后触发的），而 InstantiationAwareBeanPostProcessor 接口在此基础上增加了 3 个方法，把可扩展的范围增加了实例化阶段和属性注入阶段,该类主要的扩展点有以下 5 个方法，主要在 bean 生命周期的两大阶段：实例化阶段和初始化阶段**，而初始化阶段两个方法也即是上一节BeanPostProcessor提供的两个方法**

· postProcessBeforeInstantiation：实例化 bean 之前，相当于 new 这个 bean 之前

· postProcessAfterInstantiation：实例化 bean 之后，相当于 new 这个 bean 之后

· postProcessPropertyValues：bean 已经实例化完成，在属性注入时阶段触发，@Autowired,@Resource 等注解原理基于此方法实现

使用场景：这个扩展点非常有用 ，无论是写中间件和业务中，都能利用这个特性；比如对实现了某一类接口的 bean 在各个生命期间进行收集，或者对某个类型的 bean 进行统一的设值等等。

  1. @Component
  2. public class MyInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {
  3.     @Override
  4.     public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
  5.         System.out.println("postProcessBeforeInstantiation beanName" + beanName);
  6.         return null;
  7.     }
  9.     @Override
  10.     public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
  11.         System.out.println("postProcessAfterInstantiation beanName" + beanName);
  12.         return false;
  13.     }
  15.     @Override
  16.     public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
  17.         System.out.println("postProcessProperties beanName" + beanName);
  18.         return null;
  19.     }
  20. }

**### **

该接口也是 InstantiationAwareBeanPostProcessor 的子接口

· predictBeanType：该触发点发生在 postProcessBeforeInstantiation 之前，这个方法用于预测 Bean 的类型，返回第一个预测成功的 Class 类型，如果不能预测返回 null；当你调用 BeanFactory.getType(name) 时当通过 bean 的名字无法得到 bean 类型信息时就调用该回调方法来决定类型信息。

· determineCandidateConstructors：该触发点发生在 postProcessBeforeInstantiation 之后，用于确定该 bean 的构造函数之用，返回的是该 bean 的所有构造函数列表。用户可以扩展这个点，来自定义选择相应的构造器来实例化这个 bean。

· getEarlyBeanReference：该触发点发生在 postProcessAfterInstantiation 之后，当有循环依赖的场景，当 bean 实例化好之后，为了防止有循环依赖，Spring主要解决是的属性的循环依赖，会提前暴露回调方法，用于 bean 实例化的后置处理，这个方法就是在提前暴露的回调方法中触发。

  1. @Component
  2. public class MySmartInstantiationAwareBeanPostProcessor implements SmartInstantiationAwareBeanPostProcessor{
  3.     @Override
  4.     public Class<?> predictBeanType(Class<?> beanClass, String beanName) throws BeansException {
  5.         System.out.println("predictBeanType beanName:"+beanName);
  6.         return null;
  7.     }
  9.     @Override
  10.     public Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, String beanName) throws BeansException {
  11.         if (!beanClass.isAssignableFrom(Student.class)){
  12.             System.out.println("determineCandidateConstructors beanName:"+beanName);
  13.         }
  14.         return null;
  15.     }
  17.     @Override
  18.     public Object getEarlyBeanReference(Object bean, String beanName) throws BeansException {
  19.         System.out.println("getEarlyBeanReference beanName:"+beanName);
  20.         return null;
  21.     }
  22. }

ApplicationContextAwareProcessor

这个是一个实现了BeanPostProcessor的实现类，该类本身并没有扩展点，但是该类内部却有 多个扩展点可供实现 ，这些类触发的时机在 bean 实例化之后，初始化之前,可以看到，该类用于执行各种驱动接口，在 bean 实例化之后，属性填充之后，通过执行以上红框标出的扩展接口，来获取对应容器的变量。所以这里应该来说是有 6 个扩展点，这里就放一起来说了

· EnvironmentAware：用于获取 EnviromentAware 的一个扩展类，这个变量非常有用， 可以获得系统内的所有参数。当然个人认为这个 Aware 没必要去扩展，因为 spring 内部都可以通过注入的方式来直接获得。

· EmbeddedValueResolverAware：用于获取 StringValueResolver 的一个扩展类， StringValueResolver 用于获取基于 String 类型的 properties 的变量，一般我们都用 @Value 的方式去获取，如果实现了这个 Aware 接口，把 StringValueResolver 缓存起来，通过这个类去获取 String 类型的变量，效果是一样的。

· ResourceLoaderAware：用于获取 ResourceLoader 的一个扩展类，ResourceLoader 可以用于获取 classpath 内所有的资源对象，可以扩展此类来拿到 ResourceLoader 对象。

· ApplicationEventPublisherAware：用于获取 ApplicationEventPublisher 的一个扩展类，ApplicationEventPublisher 可以用来发布事件，结合 ApplicationListener 来共同使用，下文在介绍 ApplicationListener 时会详细提到。这个对象也可以通过 spring 注入的方式来获得。

· MessageSourceAware：用于获取 MessageSource 的一个扩展类，MessageSource 主要用来做国际化。

· ApplicationContextAware：用来获取 ApplicationContext 的一个扩展类，ApplicationContext 应该是很多人非常熟悉的一个类了，就是 spring 上下文管理器，可以手动的获取任何在 spring 上下文注册的 bean，我们经常扩展这个接口来缓存 spring 上下文，包装成静态方法。同时 ApplicationContext 也实现了 BeanFactory，MessageSource，ApplicationEventPublisher 等接口，也可以用来做相关接口的事情。

  1. private void invokeAwareInterfaces(Object bean) {
  2.    if (bean instanceof EnvironmentAware) {
  3.       ((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
  4.    }
  5.    if (bean instanceof EmbeddedValueResolverAware) {
  6.       ((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
  7.    }
  8.    if (bean instanceof ResourceLoaderAware) {
  9.       ((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
  10.    }
  11.    if (bean instanceof ApplicationEventPublisherAware) {
  12.       ((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
  13.    }
  14.    if (bean instanceof MessageSourceAware) {
  15.       ((MessageSourceAware) bean).setMessageSource(this.applicationContext);
  16.    }
  17.    if (bean instanceof ApplicationStartupAware) {
  18.       ((ApplicationStartupAware) bean).setApplicationStartup(this.applicationContext.getApplicationStartup());
  19.    }
  20.    if (bean instanceof ApplicationContextAware) {
  21.       ((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
  22.    }
  23. }

SmartInitializingSingleton

这个接口中只有一个方法 afterSingletonsInstantiated，其作用是 在 spring 容器管理的所有单例对象（非懒加载对象）初始化完成之后调用的回调接口。其触发时机为 postProcessAfterInitialization 之后。使用场景：用户可以扩展此接口在对所有单例对象初始化完毕后，做一些后置的业务处理。

  1. @Component
  2. public class MySmartInitializingSingleton implements SmartInitializingSingleton {
  3.     @Override
  4.     public void afterSingletonsInstantiated() {
  5.         System.out.println("afterSingletonsInstantiated");
  6.     }
  7. }

FactoryBean

Spring为此提供了一个org.springframework.bean.factory.FactoryBean的工厂类接口，用户可以通过实现该接口定制实例化Bean的逻辑。FactoryBean接口对于Spring框架来说占用重要的地位，Spring自身就提供了70多个FactoryBean的实现；FactoryBean是一个接口，当在IOC容器中的Bean实现了FactoryBean后，通过getBean(String BeanName)获取到的Bean对象并不是FactoryBean的实现类对象，而是这个实现类中的getObject()方法返回的对象。要想获取FactoryBean的实现类，就要getBean(&BeanName)，在BeanName之前加上&；

  1. @Component
  2. public class MyFactoryBean implements FactoryBean<Teacher> {
  4.     @Override
  5.     public Teacher getObject() throws Exception {
  6.         return new Teacher();
  7.     }
  9.     @Override
  10.     public Class<?> getObjectType() {
  11.         return Teacher.class;
  12.     }
  13. }
  1. public class ApplicationExtend {
  2.     public static void main(String[] args) {
  3.         AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MyConfig.class);
  4.         //Student student = applicationContext.getBean("student", Student.class); //这里是原来获取Student的类型，扩展点修改后需要注释掉不然会类型转换错误
  5.         Object student = applicationContext.getBean("student");
  6.         System.out.println("object:"+student);
  7.         System.out.println("factoryBeanReturn:"+applicationContext.getBean("myFactoryBean"));
  8.         System.out.println("factoryBeanSelf:"+applicationContext.getBean("&myFactoryBean"));
  9.     }
  10. }

CommandLineRunner

这个是Spring Boot提供扩展接口，这个接口也只有一个方法：run(String... args)，触发时机为整个项目启动完毕后，自动执行。如果有多个 CommandLineRunner，可以利用 @Order注解 来进行排序,值越小越优先执行。使用场景：用户扩展此接口，进行启动项目之后一些业务的预处理。

  1. @Component
  2. @Order(1)
  3. public class MyCommandLineRunner implements CommandLineRunner {
  4.     @Override
  5.     public void run(String... args) throws Exception {
  6.         System.out.println("MyCommandLineRunner run args:" +args);
  7.     }
  8. }
  1. @Component
  2. @Order(0)
  3. public class MyTwoCommandLineRunner implements CommandLineRunner {
  4.     @Override
  5.     public void run(String... args) throws Exception {
  6.         System.out.println("MyTwoCommandLineRunner run args:" +args);
  7.     }
  8. }

ApplicationListener

ApplicationListener 可以监听某个事件的 event，触发时机可以穿插在业务方法执行过程中，用户可以自定义某个业务事件;但是 spring 内部也有一些内置事件，这种事件，可以穿插在启动调用中。我们也可以利用这个特性，来自己做一些内置事件的监听器来达到和前面一些触发点大致相同的事情。接下来罗列下 spring 主要的内置事件：

· ContextRefreshedEvent

· ApplicationContext 被初始化或刷新时，该事件被发布。这也可以在 ConfigurableApplicationContext 接口中使用 refresh() 方法来发生。此处的初始化是指：所有的 Bean 被成功装载，后处理 Bean 被检测并激活，所有 Singleton Bean 被预实例化，ApplicationContext 容器已就绪可用。

· ContextStartedEvent

· 当使用 ConfigurableApplicationContext （ApplicationContext 子接口）接口中的 start() 方法启动 ApplicationContext 时，该事件被发布。你可以调查你的数据库，或者你可以在接受到这个事件后重启任何停止的应用程序。

· ContextStoppedEvent

· 当使用 ConfigurableApplicationContext 接口中的 stop() 停止 ApplicationContext 时，发布这个事件。你可以在接受到这个事件后做必要的清理的工作

· ContextClosedEvent

· 当使用 ConfigurableApplicationContext 接口中的 close() 方法关闭 ApplicationContext 时，该事件被发布。一个已关闭的上下文到达生命周期末端；它不能被刷新或重启

· RequestHandledEvent

· 这是一个 web-specific 事件，告诉所有 bean HTTP 请求已经被服务。只能应用于使用 DispatcherServlet 的 Web 应用。在使用 Spring 作为前端的 MVC 控制器时，当 Spring 处理用户请求结束后，系统会自动触发该事件

  1. @Configuration
  2. public class MyApplicationListener implements ApplicationListener {
  3.     @Override
  4.     public void onApplicationEvent(ApplicationEvent applicationEvent) {
  5.         System.out.println("MyApplicationListener onApplicationEvent");
  6.     }
  7. }

BeanNameAware

BeanNameAware也是 Aware 接口扩展的子接口，触发点在 bean 的初始化之前，也就是 postProcessBeforeInitialization 之前

如果bean实现了BeanNameAware接口，spring将bean的id传给setBeanName()方法；这个类的触发点方法只有一个：setBeanName使用场景为：用户可以扩展这个点，在初始化 bean 之前拿到 spring 容器中注册的的 beanName，来自行修改这个 ；

  1. @Component
  2. public class MyBeanNameAware implements BeanNameAware {
  3.     @Override
  4.     public void setBeanName(String s) {
  5.         System.out.println("setBeanName:"+s);
  6.     }
  7. }

BeanFactoryAware

BeanFactoryAware也是 Aware 接口扩展的子接口，只有一个触发点，发生在 bean 的实例化之后，注入属性之前，也就是 Setter 之前。这个类的扩展点方法为 setBeanFactory，可以拿到 BeanFactory 这个属性。使用场景为，你可以在 bean 实例化之后，但还未初始化之前，拿到 BeanFactory，在这个时候，可以对每个 bean 作特殊化的定制。也或者可以把 BeanFactory 拿到进行缓存，日后使用，如果bean实现了BeanFactoryAware接口，spring将调用setBeanFactory方法，将BeanFactory实例传进来；

  1. @Component
  2. public class MyBeanFactoryAware implements BeanFactoryAware {
  3.     @Override
  4.     public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
  5.         System.out.println("MyBeanFactoryAware setBeanFactory:"+beanFactory.getBean("myBeanFactoryAware").getClass().getSimpleName());
  6.     }
  7. }

Bean初始化及销毁回调方法

  • InitializingBean是用来初始化 bean 的。InitializingBean 接口为 bean 提供了初始化方法的方式，它只包括 afterPropertiesSet 方法，凡是继承该接口的类，在初始化 bean 的时候都会执行该方法。这个扩展点的触发时机在 postProcessAfterInitialization 之前。
  • DisposableBean这个扩展点也只有一个方法：destroy()，其触发时机为当此对象销毁时，会自动执行这个方法。比如说运行 applicationContext.registerShutdownHook 时，就会触发这个方法。
  • @PostConstruct这个并不算一个扩展点，其实就是一个标注。其作用是在 bean 的初始化阶段，如果对一个方法标注了 @PostConstruct，会先调用这个方法。这里重点是要关注下这个标准的触发点，这个触发点是在 postProcessBeforeInitialization 之后，InitializingBean.afterPropertiesSet 之前。使用场景：用户可以对某一方法进行标注，来进行初始化某一个属性
  • @PreDestroy修饰的方法会在服务器关闭Spring容器的时候运行，并且只会调用一次

使用场景：用户实现此接口，来进行系统启动的时候一些业务指标的初始化工作。

  1. @Repository
  2. public class Student implements InitializingBean, DisposableBean {
  4.     @PostConstruct
  5.     public void init() throws Exception {
  6.         System.out.println("Student init");
  7.     }
  9.     @PreDestroy
  10.     public void close() throws Exception {
  11.         System.out.println("Student close");
  12.     }
  14.     @Override
  15.     public void destroy() throws Exception {
  16.         System.out.println("Student destroy");
  17.     }
  19.     @Override
  20.     public void afterPropertiesSet() throws Exception {
  21.         System.out.println("Student afterPropertiesSet");
  22.     }
  23. }

整合示例

mybatis-spring gitee源码地址

https://gitee.com/yongzhebuju/mybatis-spring

我们从这些 Spring&Spring Boot 的扩展点当中，大致可以窥视到整个 bean 的生命周期。在业务开发或者写中间件业务的时候，可以合理利用 Spring 提供给我们的扩展点，在 Spring 启动的各个阶段内做一些事情，以达到自定义初始化的目的。接下来我们一起学习一个常见Mybatis和Spring整合开发简易示例,上面内容我们初步对于Spring扩展点有了一些理解，由于本人阅读过部分Mybatic与Spring整合源码，思路也是来源于此，由于目前是简易示例，不在工程加入Mybatis依赖，着重在整合部分

思考问题

  • Spring的Bean是如何生成的？
  • Spring提供哪些扩展点来整合第三方框架？
  • Spring是如何来整理Mybatis的？Mybatis代理对象都是接口，不能直接通过New方式将Mapper Bean注册Spring容器里

主体思路

  • 首先可以明确一点，我们需要利用到Jdk动态代理及反射机制
  • 借助FactoryBean特性，FactoryBean可以返回动态代理的对象及类型
  • 通过ImportBeanDefinitionRegistrar通过Import注解将FactoryBean通过BeanDefinition注册到BeanDefinitionRegistry通过后续Bean的生命周期最终放到Spring的容器里

Mybatic快速入门

从官网的就可以直接找到Java编程快速入门** ,这里只是大概说明一下**

  1. String resource = "org/mybatis/example/mybatis-config.xml";
  2. InputStream inputStream = Resources.getResourceAsStream(resource);
  3. SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
  5. try (SqlSession session = sqlSessionFactory.openSession()) {
  6.   BlogMapper mapper = session.getMapper(BlogMapper.class);
  7.   Blog blog = mapper.selectBlog(101);
  8. }

整合示例实现

pom文件

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <modelVersion>4.0.0</modelVersion>
  7.     <groupId>com.itxs</groupId>
  8.     <artifactId>mybatis-spring</artifactId>
  9.     <version>1.0-SNAPSHOT</version>
  11.     <properties>
  12.         <maven.compiler.source>8</maven.compiler.source>
  13.         <maven.compiler.target>8</maven.compiler.target>
  14.     </properties>
  16.     <dependencies>
  17.         <dependency>
  18.             <groupId>org.springframework</groupId>
  19.             <artifactId>spring-context</artifactId>
  20.             <version>5.3.9</version>
  21.         </dependency>
  22.     </dependencies>
  23. </project>

注解接口,通过@Import同时将ItxsImportBeanDefinitionRegistrar导入到Spring容器里

  1. @Retention(RetentionPolicy.RUNTIME)
  2. @Import({ItxsImportBeanDefinitionRegistrar.class})
  3. public @interface ItxsScan {
  4.     String value() default "";
  5. }

配置类,@ItxsScan为我们自定义的注解，主要标记扫描mapper路径

  1. @Configuration
  2. @ComponentScan({"com.itxs"})
  3. @ItxsScan("com.itxs.dao")
  4. public class AppConfig {
  5. }

mapper接口，@ItxsSelect为我们自定义的注解，主要标记mapper接口方法sql语句

  1. package com.itxs.dao;
  3. import com.itxs.annotation.ItxsSelect;
  4. import com.itxs.pojo.User;
  6. public interface UserMapper {
  8.     @ItxsSelect("select * from user where user_id = #{userId}")
  9.     User selectByUserId(Integer userId);
  10. }

service实现类

  1. @Component
  2. public class UserService {
  4.     @Autowired
  5.     UserMapper userMapper;
  7.     @Autowired
  8.     OrderMapper orderMapper;
  10.     public void getUser(){
  11.         userMapper.selectByUserId(1);
  12.         orderMapper.selectByOrderId(1);
  13.     }
  14. }

FactoryBean实现,这里通过构造函数传入接口的Class类型，将类型通过Jdk动态代理生成并返回对象，当调用目标对象后会执行代理对象invoke方法，从invoke方法通过反射与注解获取到sql语句，后续流程就可以利用Mybatis提供操作数据库流程，这里就不继续深入了

  1. package com.itxs.utils;
  3. import com.itxs.annotation.ItxsSelect;
  4. import org.springframework.beans.factory.FactoryBean;
  5. import java.lang.reflect.InvocationHandler;
  6. import java.lang.reflect.Method;
  7. import java.lang.reflect.Proxy;
  9. public class ItxsFactoryBean implements FactoryBean {
  11.     private Class mapper;
  13.     public ItxsFactoryBean(Class mapper) {
  14.         this.mapper = mapper;
  15.     }
  17.     @Override
  18.     public Object getObject() throws Exception {
  19.         //使用动态代理机制
  20.         Object o = Proxy.newProxyInstance(ItxsFactoryBean.class.getClassLoader(), new Class[]{mapper}, new InvocationHandler() {
  21.             @Override
  22.             public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  23.                 if (Object.class.equals(method.getDeclaringClass())){
  24.                     return method.invoke(this,args);
  25.                 }
  26.                 ItxsSelect annotation = method.getAnnotation(ItxsSelect.class);
  27.                 System.out.println("调用方法名称是"+method.getName()+",sql语句为"+annotation.value());
  28.                 //后面可执行Mybatic操作数据库的相关操作
  29.                 return null;
  30.             }
  31.         });
  32.         return o;
  33.     }
  35.     @Override
  36.     public Class<?> getObjectType() {
  37.         return mapper;
  38.     }
  39. }

ImportBeanDefinitionRegistrar的实现，通过获取@import上的注解找到mapper的扫描路径，通过classLoader加载磁盘下Class文件生成BeanDefinition并设置构造函数mapper类型参数，最终将BeanDefinition注册到BeanDefinitionRegistry

  1. package com.itxs.utils;
  3. import com.itxs.annotation.ItxsScan;
  4. import com.itxs.dao.OrderMapper;
  5. import com.itxs.dao.UserMapper;
  6. import org.springframework.beans.factory.support.AbstractBeanDefinition;
  7. import org.springframework.beans.factory.support.BeanDefinitionBuilder;
  8. import org.springframework.beans.factory.support.BeanDefinitionRegistry;
  9. import org.springframework.beans.factory.support.BeanNameGenerator;
  10. import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
  11. import org.springframework.core.type.AnnotationMetadata;
  13. import java.io.File;
  14. import java.net.URL;
  15. import java.util.ArrayList;
  16. import java.util.List;
  17. import java.util.Map;
  19. public class ItxsImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
  21.     @Override
  22.     public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry, BeanNameGenerator importBeanNameGenerator) {
  23.         //获取注解ItxsScan对象，并取出value值作为扫描的路径
  24.         Map<String, Object> annotationAttributes = importingClassMetadata.getAnnotationAttributes(ItxsScan.class.getName());
  25.         String mapperPath = annotationAttributes.get("value").toString();
  26.         List<Class> mappers = scan(mapperPath);
  27.         for (Class mapper : mappers) {
  28.             BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition();
  29.             AbstractBeanDefinition beanDefinition = builder.getBeanDefinition();
  30.             beanDefinition.setBeanClass(ItxsFactoryBean.class);
  31.             beanDefinition.getConstructorArgumentValues().addGenericArgumentValue(mapper);
  32.             registry.registerBeanDefinition(StringUtils.toLowerCaseFirstOne(mapper.getSimpleName()),beanDefinition);
  33.         }
  34.     }
  36.     private List<Class> scan(String path) {
  37.         List<Class> classList = new ArrayList<Class>();
  38.         path = path.replace(".", "/");
  39.         ClassLoader classLoader = ItxsImportBeanDefinitionRegistrar.class.getClassLoader();
  40.         URL url = classLoader.getResource(path);
  41.         File file = new File(url.getFile());
  42.         if (file.isDirectory()) {
  43.             File[] files = file.listFiles();
  44.             for (int i = 0; i < files.length; i++) {
  45.                 String absolutePath = files[i].getAbsolutePath();
  46.                 absolutePath = absolutePath.substring(absolutePath.indexOf("com"), absolutePath.indexOf(".class"));
  47.                 absolutePath = absolutePath.replace("\\", ".");
  48.                 try {
  49.                     Class<?> aClass = classLoader.loadClass(absolutePath);
  50.                     classList.add(aClass);
  51.                 } catch (ClassNotFoundException e) {
  52.                     e.printStackTrace();
  53.                 }
  54.             }
  55.         }
  56.         return classList;
  57.     }
  58. }

Main程序

  1. package com.itxs;
  3. import com.itxs.config.AppConfig;
  4. import com.itxs.service.UserService;
  5. import org.springframework.context.annotation.AnnotationConfigApplicationContext;
  7. public class MybatisApplication {
  8.     public static void main(String[] args) {
  9.         AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);
  10.         UserService userService = applicationContext.getBean("userService", UserService.class);
  11.         userService.getUser();
  12.     }
  13. }

运行结果

Spring扩展点-v5.3.9的更多相关文章

  1. spring扩展点之三：Spring 的监听事件 ApplicationListener 和 ApplicationEvent 用法，在spring启动后做些事情

    <spring扩展点之三:Spring 的监听事件 ApplicationListener 和 ApplicationEvent 用法,在spring启动后做些事情> <服务网关zu ...

  2. spring扩展点之二：spring中关于bean初始化、销毁等使用汇总,ApplicationContextAware将ApplicationContext注入

    <spring扩展点之二:spring中关于bean初始化.销毁等使用汇总,ApplicationContextAware将ApplicationContext注入> <spring ...

  3. spring扩展点整理

    本文转载自spring扩展点整理 背景 Spring的强大和灵活性不用再强调了.而灵活性就是通过一系列的扩展点来实现的,这些扩展点给应用程序提供了参与Spring容器创建的过程,好多定制化的东西都需要 ...

  4. spring扩展点之一：BeanFactoryPostProcessor和BeanPostProcessor

    一.BeanFactoryPostProcessor和BeanPostProcessor的区别 BeanFactoryPostProcessor和BeanPostProcessor都是spring初始 ...

  5. spring扩展点之五：ApplicationContextInitializer实现与使用

    ApplicationContextInitializer是Spring框架原有的东西,这个类的主要作用就是在ConfigurableApplicationContext类型(或者子类型)的Appli ...

  6. Spring扩展：替换IOC容器中的Bean组件 -- @Replace注解

    1.背景:     工作中是否有这样的场景?一个软件系统会同时有多个不同版本部署,比如我现在做的IM系统,同时又作为公司的技术输出给其他银行,不同的银行有自己的业务实现(比如登陆验证.用户信息查询等) ...

  7. Spring扩展之一：ApplicationContextInitializer

    1.介绍 用于Spring容器ConfigurableApplicationContext在刷新之前初始化Spring的回调接口. 通常在需要对应用程序上下文进行一些编程初始化的Web应用程序中使用. ...

  8. spring扩展的常用接口

    一:ApplicationContextAware接口 实现ApplicationContextAware接口,重写setApplicationContext方法,可以将spring容器上下文对象注入 ...

  9. Spring扩展：Spring的IoC容器（注入对象的方式和编码方式）

    二.Spring的IoC容器 IoC:Inversion of Control(控制反转) DI:Dependency Injection(依赖注入) 三.依赖注入的方式 (1)构造注入 (2)set ...

随机推荐

  1. 关于 我的博客和Git-hub

    欢迎大家到我的GitHub 热烈讨论 https://github.com/ljj-19951010 由于另一个博客忘了怎么登陆了,换用此博客(仅供个人学习使用,请勿传播) 如果想看 特别详细的教程请 ...

  2. Request failed with status code 500以及自引用循环Self referencing loop detected for property ‘xx‘ with type

    错误Error: Request failed with status code 500 ,调试前端没问题,后端也没问题,还报错"连接超时" 在Network中找到错误Self r ...

  3. [BZOI2014]大融合——————线段树进阶

    竟然改了不到一小时就改出来了, 可喜可贺 Description Solution 一开始想的是边两侧简单路径之和的乘积,之后发现这是个树形结构,简单路径数就是节点数. 之后的难点就变成了如何求线段树 ...

  4. 攻防世界 web2.robots

    输入ip/robots.txt,显示出了flag目录,直接访问.

  5. Spring源码解读（一）：Spring的背景起源及框架整体介绍

    一.前言 Spring起源于2002年Rod Johnson写的一本书<Expert One-on-One J2EE>,书里介绍了Java企业应用程序开发情况,并指出Java EE和EJB ...

  6. 把字符串转换成整数 牛客网 剑指Offer

    把字符串转换成整数 牛客网 剑指Offer 题目描述 将一个字符串转换成一个整数(实现Integer.valueOf(string)的功能,但是string不符合数字要求时返回0),要求不能使用字符串 ...

  7. Python import Queue ImportError: No module named 'Queue'

    python3 中引入Queue 会报出这个问题 python3 中这样引入 import queue python2 中这样引入 import Queue 为了兼容 可以这样 import sys ...

  8. ICPC Mid-Central USA Region 2019 题解

    队友牛逼!带我超神!蒟蒻的我还是一点一点的整理题吧... Dragon Ball I 这个题算是比较裸的题目吧....学过图论的大概都知道应该怎么做.题目要求找到七个龙珠的最小距离.很明显就是7个龙珠 ...

  9. 第01课 OpenGL窗口（1）

    教程的这一节在2000年一月彻底重写了一遍.将会教您如何设置一个 OpenGL窗口.它可以只是一个窗口或是全屏幕的.可以任意 大小.任意色彩深度.此处的代码很稳定且很强大,您可以在您所有的OpenGL ...

  10. Kubernetes Deployment 源码分析（一）

    概述Deployment 基础创建 DeploymentReplicaSet滚动更新失败回滚历史版本回滚其他特性小结 概述 Deployment 是最常用的 Kubernetes 原生 Workloa ...