spring高级篇（一）

1、ApplicationContext与BeanFactory

        BeanFactory是ApplicationContext的父级接口：（citl+alt+u查看类关系图）

        在springboot的启动类中，我们通过SpringApplication.run方法拿到的是继承了ApplicationContext的ConfigurableApplicationContext接口：

 ConfigurableApplicationContext applicationContext = SpringApplication.run(SpringPlusApplication.class, args);

        通过.getClass() 方法获取 Spring 应用上下文的类类型，得知在运行时，在本类中ApplicationContext 实现类的具体类型是AnnotationConfigServletWebServerApplicationContext

System.out.println(applicationContext.getClass());

        IOC，DI，管理SpringBean的生命周期，都是由beanFactory的实现类完成：

  //例：通过反射得到存放bean的数组Field singletonObjects = DefaultSingletonBeanRegistry.class.getDeclaredField("singletonObjects");singletonObjects.setAccessible(true);//得到BeanFactoryConfigurableListableBeanFactory beanFactory = applicationContext.getBeanFactory();//解析beanFactory中有多少单例的beanMap<String,Object> map = (Map<String, Object>) singletonObjects.get(beanFactory);map.forEach((k,v)->{System.out.println(k+":"+v);});

        注册两个自定义的bean：

@Component
public class Component1 {private static final Logger log = LoggerFactory.getLogger(Component1.class);@Autowiredprivate ApplicationEventPublisher publisher;public void register(){log.debug("用户注册");publisher.publishEvent(new UserRegisterEvent(this));}}

@Component
public class Component2 {private static final Logger log = LoggerFactory.getLogger(Component2.class);@EventListenerpublic void sendMessage(UserRegisterEvent event){log.debug(event.toString());log.info("发送短信");}
}

 //例：通过反射得到存放bean的数组Field singletonObjects = DefaultSingletonBeanRegistry.class.getDeclaredField("singletonObjects");singletonObjects.setAccessible(true);//得到BeanFactoryConfigurableListableBeanFactory beanFactory = applicationContext.getBeanFactory();//解析beanFactory中有多少单例的beanMap<String,Object> map = (Map<String, Object>) singletonObjects.get(beanFactory);map.entrySet().stream().filter(k->k.getKey().startsWith("component")).forEach(e->{System.out.println(e.getKey()+":"+e.getValue());});

        在上面的案例中，还可以观察到一种现象，即自定义的两个类，Component1和Component2的类名首字母都是大写，而在解析beanFactory时，.startsWith("component") 方法的component却是小写，其原因在于：

Spring中默认情况下，Bean的名称是小写的，Bean的名称是在定义Bean时指定的，如果你没有显式地为Bean指定名称，Spring会根据一定的命名规则自动生成Bean的名称。在自动生成名称时，通常会将类名的首字母小写作为Bean的名称。

         同时ApplicationContext也对BeanFactory通过聚合的方式进行了功能的扩展

  • MessageSource：国际化翻译
  • ResourcePatternResolver：根据通配符获取资源
  • EnvironmentCapable：获取配置信息
  • ApplicationEventPublisher：发送事件
1.1、MessageSource

        在resource目录下准备四个文件：

 messages_en.properties：

hi=Hello

 messages_ja.properties：

hi=こんにちは

 messages_zh.properties：

hi=你好
System.out.println(applicationContext.getMessage("hi", null, Locale.CHINESE));
System.out.println(applicationContext.getMessage("hi", null, Locale.ENGLISH));
System.out.println(applicationContext.getMessage("hi", null, Locale.JAPANESE));

1.2、ResourcePatternResolver
Resource resource = applicationContext.getResource("classpath*:META-INF/spring.factories");
System.out.println(resource);

1.3、 EnvironmentCapable
System.out.println(applicationContext.getEnvironment().getProperty("java_home"));   System.out.println(applicationContext.getEnvironment().getProperty("server.port"));

1.4、 ApplicationEventPublisher

        发布事件通知，类似于消息中间件的功能，可以实现解耦：

        首先创建一个中间类：

public class UserRegisterEvent extends ApplicationEvent {public UserRegisterEvent(Object source) {super(source);}
}

        消息生产者，调用publisher.publishEvent（）：

@Component
public class Component1 {private static final Logger log = LoggerFactory.getLogger(Component1.class);@Autowiredprivate ApplicationEventPublisher publisher;public void register(){log.debug("用户注册");publisher.publishEvent(new UserRegisterEvent(this));}}

        消息消费者，将UserRegisterEvent作为参数传入，同时方法上需要加上@EventListener：

@Component
public class Component2 {private static final Logger log = LoggerFactory.getLogger(Component2.class);@EventListenerpublic void sendMessage(UserRegisterEvent event) {log.debug(event.toString());log.info("发送短信");}
}

        主类：

Component1 component1 = applicationContext.getBean("component1", Component1.class);
component1.register();

        ApplicationEventPublisher的局限性：

不支持分布式事件发布。在典型的 Spring 应用程序中，ApplicationEventPublisher是用于在单个应用程序上下文中发布事件的，而不是用于跨应用程序或分布式系统的事件传播。所以在分布式系统中，推荐使用更加成熟的消息队列、事件总线或者分布式事件处理系统。

1.5、小结：

        ApplicationContext和BeanFactory的区别和联系：

        区别：

  • ApplicationContext：ApplicationContext是 BeanFactory的子接口之一。它提供了更多的企业级功能，如国际化、事件传播、资源加载等。ApplicationContext在启动时就会加载所有的单例 bean，并在初始化过程中完成依赖注入和各种后处理器的应用。ApplicationContext通常在实际开发中更为常用，因为它提供了更多的特性和功能。
  • BeanFactory：BeanFactory是 Spring 框架的核心接口之一，它提供了 bean 的配置、创建、管理和查找功能。BeanFactory的实现类负责加载 bean 的定义信息，并且在需要时才实例化 bean。与 ApplicationContext相比，BeanFactory更轻量级，因为它只在需要时才初始化 bean，节省了资源。但是它不提供像 ApplicationContext那样的扩展功能。

        联系：

  • 接口关系：ApplicationContext是 BeanFactory的子接口，因此 ApplicationContext包含了 BeanFactory的所有功能，并且在此基础上提供了更多的功能。
  • 功能：BeanFactory是 Spring 框架中负责管理 bean 的核心接口，而 ApplicationContext在 BeanFactory的基础上提供了更多的企业级功能和扩展。因此，ApplicationContext 在实际开发中更常用，但如果对资源有较高要求，可以考虑使用轻量级的 BeanFactory。

2、容器实现

        列举一些BeanFactory常见的实现：

  • XmlBeanFactory： XmlBeanFactory是 Spring 最基本的容器实现之一，它从 XML 文件中加载 bean 的定义信息，并在需要时实例化和管理 bean。这是 Spring 早期版本中最常用的容器实现之一，但现在已经不推荐使用，因为它在初始化时会加载所有的 bean，可能会造成性能问题。

  • ClassPathXmlApplicationContext： ClassPathXmlApplicationContext是基于 XML 配置文件的应用程序上下文实现。它从类路径中加载 XML 文件，并使用其中的 bean 定义来初始化应用程序上下文。这是使用 Spring 框架时最常见的容器实现之一。

  • FileSystemXmlApplicationContext： FileSystemXmlApplicationContext也是基于 XML 配置文件的应用程序上下文实现，但它从文件系统中加载 XML 文件。与 ClassPathXmlApplicationContext不同，它需要指定 XML 文件的绝对路径或相对路径。

  • AnnotationConfigApplicationContext： AnnotationConfigApplicationContext是基于注解的应用程序上下文实现。它会扫描指定的包路径，查找带有特定注解的类（如@Configuration、@Component等），并根据这些类中的配置来初始化 bean。

  • GenericApplicationContext： GenericApplicationContext是一个泛型的应用程序上下文实现，它可以通过编程方式动态地注册和管理 bean。与基于 XML 或注解的上下文实现不同，GenericApplicationContext允许在运行时动态地添加、修改和删除 bean。（是不带后处理器，较为干净的实现，后续演示后处理器使用该实现完成）

  • DefaultListableBeanFactory：是 BeanFactory 最重要的实现，像控制反转和依赖注入功能，都是它来实现

2.1、DefaultListableBeanFactory

        为了演示功能，首先创建几个静态内部类：

  •  Config类的作用是注册自定义bean，类上加入@Configuration  注解。
  •  bean3和bean4同时实现了Inter接口。
/*** 注册bean*/@Configurationstatic class config {@Beanpublic Bean1 createBean1() {return new Bean1();}@Beanpublic Bean2 createBean2() {return new Bean2();}@Beanpublic Bean3 createBean3() {return new Bean3();}@Beanpublic Bean4 createBean4() {return new Bean4();}}interface Inter{}static class Bean1 {private static final Logger log = LoggerFactory.getLogger(Bean1.class);@AutowiredBean2 bean2;//那么如果同时加了 @Autowired 和 @Resource 呢？答案是以 @Autowired为准。因为在后处理器中它的位置靠前
//        @Autowired//如果同一个接口有多个实现类，需要注入，必须要使用@Qualifier 或者 和bean的名字同名@Resource(name = "createBean4")//如果使用resource并且标注了name,按照name中的bean装配private Inter createBean3;public Bean1() {log.info("Bean1 created");}public Bean2 getBean2() {return bean2;}public Inter getInter() {return createBean3;}}static class Bean2 {private static final Logger log = LoggerFactory.getLogger(Bean2.class);public Bean2() {log.info("Bean2 created");}}static class Bean3 implements Inter{private static final Logger log = LoggerFactory.getLogger(Bean3.class);public Bean3(){log.info("Bean3 created");}}static class Bean4 implements Inter{private static final Logger log = LoggerFactory.getLogger(Bean4.class);public Bean4(){log.info("Bean4 created");}}

        主类：

//DefaultListableBeanFactory是beanFactory最重要的实现DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
//定义bean 包括范围，初始化，销毁 这里定义的是config bean
AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition(config.class).setScope("singleton").getBeanDefinition();
//注册config bean
beanFactory.registerBeanDefinition("config", beanDefinition);

        我们还需要给beanFactory添加一些常用的后处理器：（如果不添加后处理器，beanFactory不会主动解析@Configuration ，@Bean 等注解）

 AnnotationConfigUtils.registerAnnotationConfigProcessors(beanFactory);

        可以遍历查看后处理器：

      for (String name : beanFactory.getBeanDefinitionNames()) {//org.springframework.context.annotation.internalConfigurationAnnotationProcessor 解析@Bean//org.springframework.context.annotation.internalAutowiredAnnotationProcessor 解析@AutoWired @Value//org.springframework.context.annotation.internalCommonAnnotationProcessor 解析@Resource//org.springframework.context.event.internalEventListenerProcessor//org.springframework.context.event.internalEventListenerFactorySystem.out.println(name);}

         此时只是bean工厂中有了这些后处理器中的bean，但是要生效还需要：

         其中beanFactory.getBeansOfType(）：根据类型获取多个bean

        processor.postProcessBeanFactory（）：执行bean工厂后处理器

Collection<BeanFactoryPostProcessor> values = beanFactory.getBeansOfType(BeanFactoryPostProcessor.class).values();
for (BeanFactoryPostProcessor processor : values) {processor.postProcessBeanFactory(beanFactory);
}//再次查看beanFactory中的bean
for (String name : beanFactory.getBeanDefinitionNames()) {System.out.println(name);
}

        此时beanFactory已经有了解析@Configuration ，@Bean 等注解的能力：

        因为此时bean1中有一个使用@AutoWired 注入的bean2，此时尝试一下获取bean2：

  System.out.println(beanFactory.getBean(Bean1.class).getBean2());

         可以发现bean2没有被初始化：

         需要添加bean的相关后处理器，解析@AutoWired @Value @Resource 等注解信息：

  • internalConfigurationAnnotationProcessor：解析@Bean
  • internalAutowiredAnnotationProcessor ：解析@AutoWired @Value
  • internalCommonAnnotationProcessor： 解析@Resource

Collection<BeanPostProcessor> postProcessors = beanFactory.getBeansOfType(BeanPostProcessor.class).values();
for (BeanPostProcessor postProcessor : postProcessors) {System.out.println("<<<<<"+postProcessor);beanFactory.addBeanPostProcessor(postProcessor);
}for (String name : beanFactory.getBeanDefinitionNames()) {System.out.println(name);
}
System.out.println(beanFactory.getBean(Bean1.class).getBean2());

        至此所有的bean都加载完毕。但是有一个问题：bean3和bean4都实现了Inter接口，我在bean1中对其注入时，如果类型是bean3和bean4的父类，那么使用@AutoWired注解将注入哪一个bean?

        如果使用@AutoWired注解，需要配合@Qualifier 注解确定具体注入哪一个实现类。


        如果使用@Resource(name = "createBean4")注解，按照name属性的bean进行装配：

        属性名虽然叫createBean3，但是实际注入的是@Resource 的name所在的bean：

        那如果同时标上了@AutoWired  和@Resource 呢？答案是以 @Autowired为准。因为在后处理器中它的位置靠前：

        CommonAnnotationBeanPostProcessor的order排序：（解析@Resource）

         AutowiredAnnotationProcessor 的order排序：（解析@AutoWired @Value）

        order排序的数字越小，优先级越高。所以同时标注@AutoWired  和@Resource 时，以@AutoWired  为准。

2.2、常见 ApplicationContext 实现

        首先自定义两个bean：

static class Bean1{}static class Bean2{private Bean1 bean1;public void setBean1(Bean1 bean1) {this.bean1 = bean1;}public Bean1 getBean1() {return bean1;}}

        使用xml的方式进行bean管理： 

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"><!--        定义bean--><bean id="bean1" class="com.itbaima.a01.ApplicaionContextDemo.Bean1"/><bean id="bean2" class="com.itbaima.a01.ApplicaionContextDemo.Bean2"><property name="bean1" ref="bean1"/></bean>
</beans>
 2.2.1、基于classPath 读取xml文件
    public static void testClassPathXmlApplicationContext(){ClassPathXmlApplicationContext applicationContext =new ClassPathXmlApplicationContext("test1.xml");for (String name : applicationContext.getBeanDefinitionNames()) {System.out.println(name);}System.out.println(applicationContext.getBean(Bean2.class).getBean1());}

2.2.2、基于磁盘路径读取xml文件
    public static void testFileSystemXmlApplicationContext(){FileSystemXmlApplicationContext applicationContext = new FileSystemXmlApplicationContext("D:\\Idea_workspace\\2024\\spring-plus\\src\\main\\resources");for (String name : applicationContext.getBeanDefinitionNames()) {System.out.println(name);}System.out.println(applicationContext.getBean(Bean2.class).getBean1());}
2.2.3、基于java配置类实现

        会默认加上后处理器：

  @Configurationstatic class Config{@Beanpublic Bean1 bean1() {return new Bean1();}@Beanpublic Bean2 bean2(Bean1 bean1) {Bean2 bean2 = new Bean2();bean2.setBean1(bean1);return bean2;}}
    public static void testAnnotationConfigApplicationContext(){AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(Config.class);for (String name : applicationContext.getBeanDefinitionNames()) {System.out.println(name);}System.out.println(applicationContext.getBean(Bean2.class).getBean1());}

2.2.4、基于java配置类实现 web相关
 public static void testAnnotationConfigServletWebServerApplicationContext(){AnnotationConfigServletWebServerApplicationContext applicationContext = new AnnotationConfigServletWebServerApplicationContext(WebConfig.class);}
 @Configurationstatic class WebConfig{/*** 将内嵌tomcat注册成bean* @return*/@Beanpublic ServletWebServerFactory servletWebServerFactory() {return new TomcatServletWebServerFactory();}@Beanpublic DispatcherServlet dispatcherServlet(){return new DispatcherServlet();}@Beanpublic DispatcherServletRegistrationBean registrationBean(DispatcherServlet dispatcherServlet){return new DispatcherServletRegistrationBean(dispatcherServlet, "/");}@Bean("/hello")public Controller controller(){return ((httpServletRequest, httpServletResponse) -> {httpServletResponse.getWriter().write("hello");return null;});}}
2.3、小结

  • beanFactory 可以通过 registerBeanDefinition 注册一个 bean definition 对象

    • 我们平时使用的配置类、xml、组件扫描等方式都是生成 bean definition 对象注册到 beanFactory 当中

    • bean definition 描述了这个 bean 的创建蓝图：scope 是什么、用构造还是工厂创建、初始化销毁方法是什么，等等

  • beanFactory 需要手动调用 beanFactory 后处理器对它做增强

    • 例如通过解析 @Bean、@ComponentScan 等注解，来补充一些 bean definition

  • beanFactory 需要手动添加 bean 后处理器，以便对后续 bean 的创建过程提供增强

    • 例如 @Autowired，@Resource 等注解的解析都是 bean 后处理器完成的

    • bean 后处理的添加顺序会对解析结果有影响，见视频中同时加 @Autowired，@Resource 的例子

  • beanFactory 需要手动调用方法来初始化单例

  • beanFactory 需要额外设置才能解析 ${} 与 #{}

3、Bean的生命周期

        Spring 中的 bean 生命周期通常包括以下几个阶段：

  1. 实例化（Instantiation）：容器根据配置信息（XML、注解等）创建 bean 的实例。这通常涉及到实例化目标 bean 类，并根据配置注入依赖。

  2. 属性设置（Population）：容器通过依赖注入（Dependency Injection）将配置的属性值或引用设置到 bean 实例中。这包括基本属性、引用类型、集合类型等。

  3. 初始化（Initialization）：

    • Initialization callbacks：在 bean 实例化完成并且所有属性设置完毕后，容器会调用 bean 的InitializingBean接口的afterPropertiesSet()方法，或者调用在配置中声明的初始化方法。
    • BeanPostProcessors：在调用初始化方法之前和之后，容器会调用所有注册的 BeanPostProcessor实现类的postProcessBeforeInitialization() 和postProcessAfterInitialization（）方法，允许对 bean 进行自定义的初始化处理。

  4. 使用（In Use）：在初始化完成后，bean 可以被容器或其他 bean 使用。

  5. 销毁（Destruction）：

    • DisposableBean：如果 bean 实现了 DisposableBean接口，容器在销毁 bean 之前会调用其destroy() 方法。
    • 自定义销毁方法：在配置中可以声明自定义的销毁方法，在容器关闭时调用。

  6. 销毁回调（Destruction callbacks）：与初始化类似，容器在销毁 bean 之前会调用所有注册的 BeanPostProcessor实现类的 postProcessBeforeDestruction() 方法，允许对 bean 进行自定义的销毁处理。

@Component
public class MyBeanPostProcessor implements InstantiationAwareBeanPostProcessor, DestructionAwareBeanPostProcessor {private static final Logger log = LoggerFactory.getLogger(MyBeanPostProcessor.class);@Overridepublic void postProcessBeforeDestruction(Object bean, String beanName) throws BeansException {if (beanName.equals("lifeCycleBean")) {log.debug("<<<<<< 销毁之前执行, 如 @PreDestroy");}}@Overridepublic Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {if (beanName.equals("lifeCycleBean")) {log.debug("<<<<<< 实例化之前执行, 这里返回的对象会替换掉原本的 bean");}return null;}@Overridepublic boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {if (beanName.equals("lifeCycleBean")) {log.debug("<<<<<< 实例化之后执行, 这里如果返回 false 会跳过依赖注入阶段");
//            return false;}return true;}@Overridepublic PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {if (beanName.equals("lifeCycleBean")) {log.debug("<<<<<< 依赖注入阶段执行, 如 @Autowired、@Value、@Resource");}return pvs;}@Overridepublic Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {if (beanName.equals("lifeCycleBean")) {log.debug("<<<<<< 初始化之前执行, 这里返回的对象会替换掉原本的 bean, 如 @PostConstruct、@ConfigurationProperties");}return bean;}@Overridepublic Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {if (beanName.equals("lifeCycleBean")) {log.debug("<<<<<< 初始化之后执行, 这里返回的对象会替换掉原本的 bean, 如代理增强");}return bean;}
}

4、常见的Bean后处理器

        首先创建几个bean:

public class Bean2 {
}

public class Bean3 {
}

public class Bean1 {private static final Logger log = LoggerFactory.getLogger(Bean1.class);Bean3 bean3;Bean2 bean2;@Autowiredpublic void setBean1(Bean3 bean3) {log.debug("setBean3");this.bean3 = bean3;}@Resourcepublic void setBean2(Bean2 bean2) {log.debug("setBean2");this.bean2 = bean2;}@Autowiredpublic void autowiredMethod(@Value("${JAVA_HOME}")String name){log.debug("注入："+name);}@PostConstructpublic void initMethod(){log.debug("初始化");}@PreDestroypublic void destroyMethod(){log.debug("销毁");}
}
@ConfigurationProperties(prefix = "java")
public class Bean4 {String home;String version;public Bean4() {}public Bean4(String home, String version) {this.home = home;this.version = version;}/*** 获取* @return home*/public String getHome() {return home;}/*** 设置* @param home*/public void setHome(String home) {this.home = home;}/*** 获取* @return version*/public String getVersion() {return version;}/*** 设置* @param version*/public void setVersion(String version) {this.version = version;}public String toString() {return "Bean4{home = " + home + ", version = " + version + "}";}
}

        在主类中，我们使用ApplicationContext的GenericApplicationContext实现（在容器实现中提到过，GenericApplicationContext是不带后处理器，较为干净的实现）

  GenericApplicationContext context = new GenericApplicationContext();
//注册bean
context.registerBean("bean1", Bean1.class);
context.registerBean("bean2", Bean2.class);
context.registerBean("bean3", Bean3.class);
context.registerBean("bean4", Bean4.class);//初始化容器
context.refresh();//销毁容器
context.close();

        此时并没有打印出关于bean中定义的任何信息。

4.1、解析@AutoWired @Value

        如果需要解析bean1中的@AutoWired @Value ，则主类中需要增加：

//这行代码用于设置默认的 Bean 工厂的自动装配候选项解析器（AutowireCandidateResolver）。
context.getDefaultListableBeanFactory().setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
//AutowiredAnnotationBeanPostProcessor 是 Spring 框架中用于处理 @Autowired 注解的后置处理器，它会在 bean 实例化后，对标记了 @Autowired 注解的字段进行自动注入。
context.registerBean(AutowiredAnnotationBeanPostProcessor.class);

4.2、解析@Resource @PostConstruct @PreDestroy
context.registerBean(CommonAnnotationBeanPostProcessor.class);

4.3、解析@ConfigurationProperties
//将 ConfigurationPropertiesBindingPostProcessor 注册到 Spring 容器中的默认 Bean 工厂中。
//ConfigurationPropertiesBindingPostProcessor 是 Spring Boot 中用于处理 @ConfigurationProperties 注解的后置处理器。
ConfigurationPropertiesBindingPostProcessor.register(context.getDefaultListableBeanFactory());System.out.println(context.getBean("bean4"));
4.4、@Autowired bean 后处理器运行分析
 DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();beanFactory.registerSingleton("bean2", new Bean2());beanFactory.registerSingleton("bean3", new Bean3());//解析@value不出异常beanFactory.setAutowireCandidateResolver(newContextAnnotationAutowireCandidateResolver());//解析${}需要加上beanFactory.addEmbeddedValueResolver(new StandardEnvironment()::resolvePlaceholders);

        通过反射，演示一下AutowiredAnnotationBeanPostProcessor后处理器运行的过程：

AutowiredAnnotationBeanPostProcessor processor = new AutowiredAnnotationBeanPostProcessor();//设置后处理器要处理的beanFactory，因为bean2,bean3都在beanFactory中
processor.setBeanFactory(beanFactory);

       AutowiredAnnotationBeanPostProcessor执行依赖注入，实际是调用了：

  processor.postProcessProperties(null, bean1, "bean1");

        在该方法内部，再次调用了

        因为findAutowiringMetadata（） 是私有方法，所以通过反射的方式进行调用处理：

//通过反射获取findAutowiringMetadata方法
Method findAutowiringMetadata = AutowiredAnnotationBeanPostProcessor.class.getDeclaredMethod("findAutowiringMetadata", String.class, Class.class, PropertyValues.class);
findAutowiringMetadata.setAccessible(true);//执行findAutowiringMetadata方法 //参数一：方法所在的对象实例 参数二：方法的参数
//1.收集类中所有加了@AutoWired @Value注解的方法/成员变量
InjectionMetadata metadata = (InjectionMetadata) findAutowiringMetadata.invoke(processor,"bean1",Bean1.class,null);

        这样就拿到了findAutowiringMetadata（） 方法的返回，利用方法的返回调用inject()方法：

//2.进行依赖注入
metadata.inject(bean1,"bean1",null);
System.out.println(bean1);

        由此可知：postProcessProperties方法内部做了两件事：

        1.收集类中所有加了@AutoWired @Value注解的方法/成员变量

        2.进行依赖注入

        而inject() 方法内部如何根据类型找到值？

 //1.得到成员变量/方法的信息Field bean3 = Bean1.class.getDeclaredField("bean3");//2.封装成DependencyDescriptorDependencyDescriptor dependencyDescriptor = new DependencyDescriptor(bean3, false);//3.调用beanFactory的doResolveDependencyObject o = beanFactory.doResolveDependency(dependencyDescriptor, null, null, null);System.out.println(o);
//方法注入时，以某个方法的参数为单位去容器中找
Method method = Bean1.class.getDeclaredMethod("setBean1", Bean3.class);
DependencyDescriptor descriptor = new DependencyDescriptor(new MethodParameter(method, 0), false);
Object o1 = beanFactory.doResolveDependency(descriptor, null, null, null);
System.out.println(o1);//方法的参数值注入，以某个方法的参数为单位去容器中找
Method method1 = Bean1.class.getDeclaredMethod("autowiredMethod", String.class);
DependencyDescriptor dependencyDescriptor1 = new DependencyDescriptor(new MethodParameter(method1, 0), false);
Object o2 = beanFactory.doResolveDependency(dependencyDescriptor1, null, null, null);
System.out.println(o2);

        inject内部如何根据类型找到值？

        1.得到成员变量/方法的信息

        2.封装成DependencyDescriptor

        3.调用beanFactory的doResolveDependency

5、BeanFactory 后处理器

        如果需要解析@Bean @Mapper 等注解，则需要使用到BeanFactory的后处理器：

//需要添加对@Bean @ComponentScan @Import 的处理器
context.registerBean(ConfigurationClassPostProcessor.class);//需要添加对@MapperScan的后处理器
context.registerBean(MapperScannerConfigurer.class, bd -> {bd.getPropertyValues().add("basePackage","com.itbaima.a04.mapper");
});

  • ConfigurationClassPostProcessor 可以解析：

    • @ComponentScan

    • @Bean

    • @Import

    • @ImportResource

  • MapperScannerConfigurer 可以解析：

    • @Mapper

        下面会模拟源码中@ComponentScan @Bean @Mapper   后处理器的实现，在进行演示之前，首先介绍一下一些会用到的API和类：

  • CachingMetadataReaderFactory：是 Spring 框架中用于加载和缓存类元数据的工厂类，它提供了一种高效的方式来获取类的元数据信息，并且通过缓存机制提高了性能。当需要获取某个类的元数据时，它会通过底层的 MetadataReader实现类来读取类的信息，并将其封装为MetadataReader对象。
  • AnnotationBeanNameGenerator：是 Spring 框架中用于生成 bean 名称的默认策略类之一。当你不显式地为 bean 指定名称时，Spring 会自动使用它来生成 bean 的名称。这样，你就可以通过在类上添加相应的注解来控制 bean 的名称，而不需要额外进行配置。
  • BeanDefinitionBuilder：是 Spring 框架中用于构建 BeanDefinition对象的工具类。在 Spring 中，BeanDefinition是用于描述和定义 bean 的元数据信息的类，包括了 bean 的类名、作用域、构造函数参数、属性值、初始化方法、销毁方法等等。

其中BeanDefinitionBuilder的一些常用方法：

  • static BeanDefinitionBuilder genericBeanDefinition(Class<?> beanClass): 创建一个通用的 bean 定义构建器，指定 bean 的类名。
  • BeanDefinitionBuilder setScope(String scope): 设置 bean 的作用域。
  • BeanDefinitionBuilder addPropertyValue(String name, Object value): 添加一个属性值到 bean 的属性列表中。
  • BeanDefinitionBuilder addConstructorArgValue(Object value): 添加一个构造函数参数值到 bean 的构造函数参数列表中。
  • BeanDefinitionBuilder setInitMethodName(String methodName): 设置 bean 的初始化方法名。
  • BeanDefinitionBuilder setDestroyMethodName(String methodName): 设置 bean 的销毁方法名。
  • BeanDefinitionBuilder setLazyInit(boolean lazyInit): 设置是否启用延迟初始化。
  • BeanDefinitionBuilder setAutowireMode(int autowireMode): 设置自动装配模式。
5.1、模拟@ComponentScan 的实现

        找到类中的@ComponentScan 注解

 ComponentScan componentScan = AnnotationUtils.findAnnotation(Config.class, ComponentScan.class);

         if (!ObjectUtils.isEmpty(componentScan)) {//得到注解的值for (String base : componentScan.basePackages()) {//拼装成路径信息String path = "classpath*:" + base.replace(".","/") + "/**/*.class";//用于读取类的元数据 在运行时加载类的元数据，如类名、注解信息等CachingMetadataReaderFactory factory = new CachingMetadataReaderFactory();//用于根据类的注解生成 Bean 的名称AnnotationBeanNameGenerator generator = new AnnotationBeanNameGenerator();//context的扩展//得到路径下的所有资源是ApplicationContext对于BeanFactory的扩展GenericApplicationContext context = new GenericApplicationContext();Resource[] resource = context.getResources(path);for (Resource r : resource) {//从元数据读取工厂中获取一个元数据读取器readerMetadataReader reader = factory.getMetadataReader(r);//                    System.out.println("类名"+reader.getClassMetadata().getClassName());//                    System.out.println("是否加了Component"+reader.getAnnotationMetadata().hasAnnotation(Component.class.getName()));//                    System.out.println("是否加了Component 相关"+reader.getAnnotationMetadata().hasMetaAnnotation(Component.class.getName()));//从元数据读取器reader中获取注解元数据AnnotationMetadata annotationMetadata = reader.getAnnotationMetadata();//如果类上加了Component及相关注解if (annotationMetadata.hasMetaAnnotation(Component.class.getName())|| annotationMetadata.hasAnnotation(Component.class.getName())) {AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition(reader.getClassMetadata().getClassName()).getBeanDefinition();DefaultListableBeanFactory defaultListableBeanFactory = (DefaultListableBeanFactory) beanFactory;//生成一个唯一的bean名称。String name = generator.generateBeanName(beanDefinition, defaultListableBeanFactory);//通过BeanDefinitionBuilder创建的bean定义（即beanDefinition）注册到Spring容器中。// registerBeanDefinition方法将生成的bean名称（name）与对应的bean定义关联起来，使得该bean可以被Spring容器管理和使用。defaultListableBeanFactory.registerBeanDefinition(name, beanDefinition);}}}}
5.2、模拟解析 @Bean
//读取@Bean注解CachingMetadataReaderFactory factory = new CachingMetadataReaderFactory();//1.读取指定类路径下的信息MetadataReader reader = factory.getMetadataReader(new ClassPathResource("com/itbaima/a04/Config.class"));//2.获取指定类中所有标注了@Bean方法的信息Set<MethodMetadata> methods = reader.getAnnotationMetadata().getAnnotatedMethods(Bean.class.getName());//遍历这些方法for (MethodMetadata method : methods) {//使用反射获取注解信息String initMothod = method.getAnnotationAttributes(Bean.class.getName()).get("initMethod").toString();//用于创建一个通用的 Bean 定义。BeanDefinitionBuilder definitionBuilder = BeanDefinitionBuilder.genericBeanDefinition();//设置工厂方法来创建 Bean。使用config中的方法作为工厂方法创建beandefinitionBuilder.setFactoryMethodOnBean(method.getMethodName(), "config");//处理标注了@Bean的有参方法definitionBuilder.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_CONSTRUCTOR);if (initMothod.length()>0){//用于设置 Bean 的初始化方法名。初始化方法是在 Bean 实例化后立即调用的方法。definitionBuilder.setInitMethodName(initMothod);}//用于获取最终的 Bean 定义对象。AbstractBeanDefinition beanDefinition = definitionBuilder.getBeanDefinition();DefaultListableBeanFactory defaultListableBeanFactory = (DefaultListableBeanFactory)beanFactory;//将之前创建的 Bean 定义注册到 Spring 的 Bean 工厂中。     参数一：bean的名称 参数二：用于获取最终的 Bean 定义对象。defaultListableBeanFactory.registerBeanDefinition(method.getMethodName(), beanDefinition);}
5.3、模拟解析@Mapper

        关于Mapper工厂，需要在参数中指定SqlSessionFactory，以便Spring 容器将指定的依赖注入到方法的参数中。

    @Beanpublic MapperFactoryBean<Mapper1> mapper1(SqlSessionFactory sqlSessionFactory) {MapperFactoryBean<Mapper1> factory = new MapperFactoryBean<>(Mapper1.class);factory.setSqlSessionFactory(sqlSessionFactory);return factory;}

         模拟实现：

        与@Bean类似，被Spring bean管理的类型都是工厂，但是在处理bean名称的时候，需要额外进行，保证bean的名称是每个Mapper接口的名称，而不是工厂的名称。

 try {//获取指定路径下的资源PathMatchingResourcePatternResolver patternResolver = new PathMatchingResourcePatternResolver();Resource[] resources = patternResolver.getResources("classpath:com/itbaima/a04/mapper/**/*.class");CachingMetadataReaderFactory factory = new CachingMetadataReaderFactory();AnnotationBeanNameGenerator generator = new AnnotationBeanNameGenerator();for (Resource resource : resources) {MetadataReader reader = factory.getMetadataReader(resource);ClassMetadata classMetadata = reader.getClassMetadata();//判断路径下的某个资源是类还是接口if (classMetadata.isInterface()) {//生成接口对应的MapperFactoryBean//被spring管理的bean的类型 是 MapperFactoryBeanAbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition(MapperFactoryBean.class).addConstructorArgValue(classMetadata.getClassName())//给构造设置参数值.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE)//按照类型装配，对应方法上的参数.getBeanDefinition();//创建bean名称 此处是根据bean定义去生成名称的，我们此时定义的是bean工厂//所以要在定义一个beanDefinition，名字是Mapper1 Mapper2（具体的接口，非工厂）AbstractBeanDefinition beanDefinitionInter = BeanDefinitionBuilder.genericBeanDefinition(classMetadata.getClassName()).getBeanDefinition();String name = generator.generateBeanName(beanDefinitionInter, registry);registry.registerBeanDefinition(name, beanDefinition);}}} catch (IOException e) {throw new RuntimeException(e);}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.rhkb.cn/news/311583.html

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

PyCharm 2024.1 发布：全面升级，助力高效编程！

PyCharm 2024.1 发布：全面升级，助力高效编程！

PyCharm 2024.1 发布&#xff1a;全面升级&#xff0c;助力高效编程&#xff01; 文章目录 PyCharm 2024.1 发布&#xff1a;全面升级&#xff0c;助力高效编程&#xff01;摘要引言 Hugging Face&#xff1a;模型和数据集的快速文档预览针对 JavaScript 和 TypeScript 的全行代…
阅读更多...
深度学习-多尺度训练的介绍与应用

深度学习-多尺度训练的介绍与应用

一、引言 在当今快速发展的人工智能领域&#xff0c;多尺度训练已经成为了一种至关重要的技术&#xff0c;特别是在处理具有复杂结构和不同尺度特征的数据时。这种技术在许多应用中发挥着关键作用&#xff0c;例如图像识别、自然语言处理和视频分析等。 多尺度训练的定义 多尺…
阅读更多...
软考 - 系统架构设计师 - 嵌入式真题

软考 - 系统架构设计师 - 嵌入式真题

问题 1&#xff1a; &#xff08;1&#xff09;.HTML 静态化&#xff1a;可以实现对系统经常访问的页面进行静态化以提高系统访问的效率&#xff0c;但系统页面通常需要数据库中的用户信息和用户选择来动态显示&#xff0c;因此不适合采用。 HTML 静态化&#xff1a; 将动态生成…
阅读更多...
Python爬虫：requests模块的基本使用

Python爬虫：requests模块的基本使用

学习目标&#xff1a; 了解 requests模块的介绍掌握 requests的基本使用掌握 response常见的属性掌握 requests.text和content的区别掌握 解决网页的解码问题掌握 requests模块发送带headers的请求掌握 requests模块发送带参数的get请求 1 为什么要重点学习requests模块&…
阅读更多...
第23次修改了可删除可持久保存的前端html备忘录:增加了百度引擎

第23次修改了可删除可持久保存的前端html备忘录:增加了百度引擎

第22次修改了可删除可持久保存的前端html备忘录视频背景分离&#xff0c;增加了本地连接&#xff0c;增加了纯CSS做的折叠隐藏修改说明 <!DOCTYPE html> <html lang"zh"> <head><meta charset"UTF-8"><meta name"viewport…
阅读更多...
WPF中DataGrid主从数据（父子数据）展示

WPF中DataGrid主从数据（父子数据）展示

在wpf中可以使用DataGrid控件，进行主从数据展示，也称父子数据展示。下面展示纯原生控件编码实现功能（样式自己可以根据需求进行修改）。 效果如下： 点击图标，展开和收缩可以自由的切换，也可以自己重新写一个样式，比如+，-或者类似图标的样式，都是可以的。 1.首先创建一…
阅读更多...
【光伏企业】光伏项目怎么做才能提高效率？

【光伏企业】光伏项目怎么做才能提高效率？

一、精细化项目管理 项目规划&#xff1a;在项目启动前&#xff0c;进行充分的调研和规划&#xff0c;明确项目的目标、规模、预算和时间表&#xff0c;确保各项资源得到合理分配。 团队建设&#xff1a;组建一支高效、专业的项目团队&#xff0c;确保团队成员具备光伏领域的…
阅读更多...
计算机视觉——图像特征提取D2D先描述后检测特征提取算法原理

计算机视觉——图像特征提取D2D先描述后检测特征提取算法原理

概述 局部特征提取是计算机视觉中的一个重要任务&#xff0c;它旨在从图像中提取出能够代表图像局部结构和外观信息的特征。这些特征通常用于图像匹配、物体识别、三维重建、跟踪和许多其他应用。传统方法&#xff0c;如尺度不变特征变换&#xff08;SIFT&#xff09;&#xf…
阅读更多...
浅谈Java JVM

浅谈Java JVM

Java虚拟机&#xff08;Java Virtual Machine&#xff0c;简称JVM&#xff09;是Java语言的核心组成部分&#xff0c;它是一个抽象的计算机&#xff0c;负责执行Java字节码指令。JVM是Java平台无关性的基石&#xff0c;它为Java代码提供了一个标准的运行环境&#xff0c;使Java…
阅读更多...
【C/C++笔试练习】read函数、虚拟存储、用户态、线程特点、缺页处理、调度算法、进程优先级、锁的使用、创建进程、不用加减乘除做加法、三角形

【C/C++笔试练习】read函数、虚拟存储、用户态、线程特点、缺页处理、调度算法、进程优先级、锁的使用、创建进程、不用加减乘除做加法、三角形

文章目录 C/C笔试练习选择部分&#xff08;1&#xff09;read函数&#xff08;2&#xff09;虚拟存储&#xff08;3&#xff09;用户态&#xff08;4&#xff09;线程特点&#xff08;5&#xff09;缺页处理&#xff08;6&#xff09;调度算法&#xff08;7&#xff09;进程优先…
阅读更多...
《由浅入深学习SAP财务》：第2章 总账模块 - 2.6 定期处理 - 2.6.6 年初操作：科目余额结转

《由浅入深学习SAP财务》：第2章 总账模块 - 2.6 定期处理 - 2.6.6 年初操作：科目余额结转

2.6.6 年初操作&#xff1a;科目余额结转 在使用事务代码 FAGLB03 查询科目余额时&#xff0c;可以看到按期间的发生额清单。其中&#xff0c;第一行称为“余额结转”&#xff0c;该行的累计余额代表上年度遗留下来的余额&#xff0c;也就是年初余额。对于资产负债表科目而言&a…
阅读更多...
【教学类-52-05】20240417动物数独（4宫格）黏贴卡片需要至少几张？难度1-9 打印版

【教学类-52-05】20240417动物数独（4宫格）黏贴卡片需要至少几张？难度1-9 打印版

作品展示&#xff1a; 背景需求&#xff1a; 实际打印的是以下代码生成的动物数独&#xff08;2*2&#xff09;学具 【教学类-52-03】20240412动物数独&#xff08;4宫格&#xff09;难度1-9 打印版-CSDN博客文章浏览阅读1.1k次&#xff0c;点赞30次&#xff0c;收藏17次。【教…
阅读更多...
排序：冒泡排序，直接插入排序，简单选择排序，希尔排序，快速排序，堆排序，二路归并排序

排序：冒泡排序，直接插入排序，简单选择排序，希尔排序，快速排序，堆排序，二路归并排序

目录 一.冒泡排序 代码如下 冒泡排序时间复杂度分析 二.直接插入排序 直接插入排序时间复杂度分析 直接插入排序优化&#xff1a;折半插入排序 三.简单选择排序 简单选择排序优化&#xff1a;双向选择排序 选择排序时间复杂度 双向选择排序时间复杂度 四.希尔排序 希…
阅读更多...
2.2 iHRM人力资源 - 主页权限认证、Vux共享用户资料

2.2 iHRM人力资源 - 主页权限认证、Vux共享用户资料

iHRM人力资源 - 主页权限认证、主页内容展示 2.IHRM人力资源 - 登录-CSDN博客 文章目录 iHRM人力资源 - 主页权限认证、主页内容展示一、主页权限认证1.1 主页权限认证分析1.2 主页权限认证 - permission.js1.2.1 进度条部分1.2.2 token 认证 二、Vuex共享用户资料2.1 需求分析…
阅读更多...
day02|最小花费爬梯子

day02|最小花费爬梯子

最小花费爬梯子 比如 有一个数组 【2 5 20】我们直接选择从1号梯子&#xff08;从零编号&#xff09;跳两格就出去了。 算法原理 我们可以得出楼顶其实是数组的最后一个元素的下一个位置。对于最值问题我们可以尝试使用dpdp我们首先应该定义状态方差的含义&#xff0c;一般以…
阅读更多...
Linux的重要命令（二）+了解Linux目录结构

Linux的重要命令（二）+了解Linux目录结构

目录 一.Linux的目录结构 二.查看文件内容命令 1.cat 命令 2.more 命令 3.less 命令 4.head 命令 5.tail 命令 6.拓展 head 和 tail 的其他用法 ​编辑 三.统计文件内容的命令-wc ​编辑 四.检索和过滤文件内容的命令-grep ​编辑 ​编辑 五.压缩命令 gzip 和 bz…
阅读更多...
android studio 网络请求okhttp3、okgo

android studio 网络请求okhttp3、okgo

一、在build.gradle文件里添加 implementation com.squareup.okhttp3:okhttp:4.9.0 implementation com.squareup.okhttp3:okhttp:3.12.0 implementation com.squareup.okio:okio:1.17.4 implementation com.lzy.net:okgo:3.0.4 implementation com.alibaba:fastjson:1.2.57 i…
阅读更多...
windows下已经创建好了虚拟环境，但是切换不了的解决方法

windows下已经创建好了虚拟环境，但是切换不了的解决方法

用得多Ubuntu&#xff0c;今天用Windows重新更新anaconda出问题&#xff0c;重新安装之后&#xff0c;打开pycharm发现打开终端之后&#xff0c;刚开始是ps的状态&#xff0c;后面试了网上改cmd的方法&#xff0c;终端变成c盘开头了 切换到虚拟环境如下&#xff1a;目前的shell…
阅读更多...
实现iOS App代码混淆

实现iOS App代码混淆

简介 在开发iOS应用程序时&#xff0c;保护代码安全是至关重要的。代码混淆是一种常用的技术&#xff0c;可以增加逆向工程的难度&#xff0c;防止他人对代码的篡改和盗用。本文将介绍如何实现iOS App代码混淆的步骤和操作方法。 整体流程 下面是实现iOS App代码混淆的整体流…
阅读更多...
大数据平台搭建2024（一）

大数据平台搭建2024（一）

一&#xff1a;基础配置 创建虚拟机并查出ip地址进行连接 ip a1.配置node01静态ip地址与主机名 vi /etc/sysconfig/network-scripts/ifcfg-ens33修改或添加如下内容&#xff1a; BOOTPROTO"static" ONBOOTyes #根据虚拟机网卡信息配置 IPADDR192.168.200.141 NET…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023