【Spring高级】第2讲：容器实现类

目录

  • BeanFactory实现
    • BeanDefinition
    • 后置处理器
    • 单例bean创建
    • 后置处理器顺序
    • 总结
  • ApplicationContext实现
    • ClassPathXmlApplicationContext
    • FileSystemXmlApplicationContext
    • AnnotationConfigApplicationContext
    • AnnotationConfigServletWebServerApplicationContext

BeanFactory实现

BeanDefinition

BeanDefinition顾名思义就是Bean的一些定义信息。我们平时使用的配置类、xml、组件扫描等方式都是生成 BeanDefinition 对象注册到 beanFactory 当中。

前面我们讲过DefaultListableBeanFactory，他是BeanFactory最重要的实现，其类图如下

在这里插入图片描述

下面以DefaultListableBeanFactory为例演示。

有如下示例：

public class TestBeanFactory {public static void main(String[] args) {DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();}@Configurationstatic class Config {@Beanpublic Bean1 bean1() {return new Bean1();}}static class Bean1 {public Bean1() {System.out.println("Bean1 构造方法");}}static class Bean2 {public Bean2() {System.out.println("Bean2 构造方法");}}}

我们直接通过new创建一个beanFactory，但是其实他的功能非常简单，其内部也没有任何的Bean。

但是我们可以通过添加一些BeanDefinition，然后beanFactory利用BeanDefinition来创建Bean。

首先来看下如何添加BeanDefinition：

public static void main(String[] args) {DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();// 创建Config的BeanDefinitionAbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition(Config.class).setScope("singleton").getBeanDefinition();// 把beanDefinition注册到beanFactorybeanFactory.registerBeanDefinition("config", beanDefinition);// 查看beanFactory中beanDefinition的名字for (String beanDefinitionName : beanFactory.getBeanDefinitionNames()) {System.out.println(beanDefinitionName);}
}

运行结果：

config

发现结果中只有config，说明我们的BeanDefinition已经注册到beanFactory中了。但是此时还是没有任何的Bean，因为还没有去使用BeanDefinition创建Bean。要创建Bean，不是beanFactory能够完成的，需要借助于后处理器，他能识别@Configuration注解和@Bean注解，从而创建对应的Bean。

后置处理器

添加后置处理器的代码如下：

// 给beanFactory添加一些内置的后处理器
AnnotationConfigUtils.registerAnnotationConfigProcessors(beanFactory);

添加后再打印出BeanDefinition的名字，结果如下：

config
org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.annotation.internalCommonAnnotationProcessor
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory

可以看到，除了config，还添加了5个内置的处理器的BeanDefinition，其中internalConfigurationAnnotationProcessor就是来处理@Configuration注解的。

但是上面的步骤只是把BeanDefinition加到了beanFactory中，还并没有开始被使用。下面看下怎么运行后置处理器：

public static void main(String[] args) {DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();// 创建Config的BeanDefinitionAbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition(Config.class).setScope("singleton").getBeanDefinition();// 把beanDefinition注册到beanFactorybeanFactory.registerBeanDefinition("config", beanDefinition);// 给beanFactory添加一些内置的后处理器AnnotationConfigUtils.registerAnnotationConfigProcessors(beanFactory);// 拿到beanFactory的后置处理器，这里有很多，其中一个就是internalConfigurationAnnotationProcessorMap<String, BeanFactoryPostProcessor> processorMap = beanFactory.getBeansOfType(BeanFactoryPostProcessor.class);// 执行后置处理器，当internalConfigurationAnnotationProcessor运行，就会把Bean1和Bean2的beanDefinition注册到beanFactoryprocessorMap.values().stream().forEach(processor -> {processor.postProcessBeanFactory(beanFactory);});// 查看beanFactory中beanDefinition的名字for (String beanDefinitionName : beanFactory.getBeanDefinitionNames()) {System.out.println(beanDefinitionName);}}

运行结果如下：

config
org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.annotation.internalCommonAnnotationProcessor
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory
bean1
bean2

可以看到bean1和bean2成功被注册到了beanFactory。

所以，beanFactory本身功能比较简单，但是可以通过一些后置处理器，补充了一些Bean的定义，即BeanDefinition。

上面是把BeanDefinition成功注册到了beanFactory，那实际我们的Bean是否已经成功创建了呢？使用如下代码：

// 获取Bean
Bean1 bean1 = beanFactory.getBean(Bean1.class);
System.out.println(bean1.getBean2());

结果如下：

Bean1 构造方法
null

可以看到，Bean1被成功创建了，且是使用getBean时，调用了其构造方法。但是他的bean2属性却是null，缺少了依赖注入的功能。这是因为还缺少了其他的后置处理器，就是Bean的后置处理器，他能够解析Autowired注解。注意他与BeanFactory的后置处理器不同，beanFactory的后置处理器主要补充BeanDefinition，而Bean的后置处理器主要对Bean的生命周期内进行一些处理。

注意上面打印的BeanDefinition，有一个internalAutowiredAnnotationProcessor，他就是来处理Autowired注解的。

public static void main(String[] args) {DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();// 创建Config的BeanDefinitionAbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition(Config.class).setScope("singleton").getBeanDefinition();// 把beanDefinition注册到beanFactorybeanFactory.registerBeanDefinition("config", beanDefinition);// 给beanFactory添加一些内置的后处理器，注意只是把后处理器添加到了beanFactory而已，后处理器还不会起作用AnnotationConfigUtils.registerAnnotationConfigProcessors(beanFactory);// 拿到beanFactory的后置处理器，这里有很多，其中一个就是internalConfigurationAnnotationProcessorMap<String, BeanFactoryPostProcessor> processorMap = beanFactory.getBeansOfType(BeanFactoryPostProcessor.class);// 执行后置处理器，当internalConfigurationAnnotationProcessor运行，就会把Bean1和Bean2的beanDefinition注册到beanFactoryprocessorMap.values().stream().forEach(processor -> {processor.postProcessBeanFactory(beanFactory);});// Bean 的后处理器，针对Bean的生命周期的各个阶段提供扩展，例如@Autowired。// 注意这一步，是把后处理器与beanFactory绑定，这样创建Bean时，后处理器才能起作用beanFactory.getBeansOfType(BeanPostProcessor.class).values().stream().forEach(beanFactory::addBeanPostProcessor);// 查看beanFactory中beanDefinition的名字for (String beanDefinitionName : beanFactory.getBeanDefinitionNames()) {System.out.println(beanDefinitionName);}System.out.println("---------- 分割线 ----------");// 获取BeanBean1 bean1 = beanFactory.getBean(Bean1.class);System.out.println(bean1.getBean2());}

运行如下：

config
org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.annotation.internalCommonAnnotationProcessor
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory
bean1
bean2
---------- 分割线 ----------
16:47:57.859 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'bean1'
16:47:57.860 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'config'
Bean1 构造方法
16:47:57.907 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'bean2'
Bean2 构造方法
com.cys.demo02.TestBeanFactory$Bean2@3e11f9e9

可以看到，成功把bean2注入到了bean1。

单例bean创建

另外从上面的例子还可以看到，上面的分割线之后，bean1和bean2才开始创建，且他们都是单例的。也就说，只有当真正需要bean的时候，他才会去创建。我们可以使用方法preInstantiateSingletons，主动去创建那些单例bean。代码如下：

public static void main(String[] args) {DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();// 省略代码...// 主动创建单例beanbeanFactory.preInstantiateSingletons();System.out.println("---------- 分割线 ----------");// 获取BeanBean1 bean1 = beanFactory.getBean(Bean1.class);System.out.println(bean1.getBean2());}

结果如下：

config
org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.annotation.internalCommonAnnotationProcessor
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory
bean1
bean2
16:56:37.614 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'config'
16:56:37.624 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'bean1'
Bean1 构造方法
16:56:37.663 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'bean2'
Bean2 构造方法
---------- 分割线 ----------
com.cys.demo02.TestBeanFactory$Bean2@49049a04

可以看到，bean的创建在分割线之前了，也就是这些单例bean被提前创建好了。

后置处理器顺序

处理是有顺序的，不同的顺序对解析结果影响也不同。

看如下一个例子：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.context.annotation.AnnotationConfigUtils;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;import java.net.InterfaceAddress;
import java.util.Map;public class TestBeanFactoryPostProcessor {public static void main(String[] args) {DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();// 创建Config的BeanDefinitionAbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition(Config.class).setScope("singleton").getBeanDefinition();// 把beanDefinition注册到beanFactorybeanFactory.registerBeanDefinition("config", beanDefinition);// 给beanFactory添加一些内置的后处理器AnnotationConfigUtils.registerAnnotationConfigProcessors(beanFactory);// 拿到beanFactory的后置处理器，这里有很多，其中一个就是internalConfigurationAnnotationProcessorMap<String, BeanFactoryPostProcessor> processorMap = beanFactory.getBeansOfType(BeanFactoryPostProcessor.class);// 执行后置处理器，当internalConfigurationAnnotationProcessor运行，就会把Bean1和Bean2的beanDefinition注册到beanFactoryprocessorMap.values().stream().forEach(processor -> {processor.postProcessBeanFactory(beanFactory);});// Bean 的后处理器，针对Bean的生命周期的各个阶段提供扩展，例如@AutowiredbeanFactory.getBeansOfType(BeanPostProcessor.class).values().stream().forEach(beanFactory::addBeanPostProcessor);// 查看beanFactory中beanDefinition的名字
//        for (String beanDefinitionName : beanFactory.getBeanDefinitionNames()) {
//            System.out.println(beanDefinitionName);
//        }// 主动创建单例beanbeanFactory.preInstantiateSingletons();System.out.println("---------- 分割线 ----------");// 获取BeanBean1 bean1 = beanFactory.getBean(Bean1.class);System.out.println(bean1.getInter());}@Configurationstatic class Config {@Beanpublic Bean1 bean1() {return new Bean1();}@Beanpublic Bean2 bean2() {return new Bean2();}@Beanpublic Bean3 bean3() {return new Bean3();}@Beanpublic Bean4 bean4() {return new Bean4();}}interface Inter {};static class Bean3 implements Inter{};static class Bean4 implements Inter{};static class Bean1 {public Bean1() {System.out.println("Bean1 构造方法");}@Autowiredprivate Bean2 bean2;public Bean2 getBean2() {return bean2;}@Autowiredprivate Inter inter;public Inter getInter() {return inter;}}static class Bean2 {public Bean2() {System.out.println("Bean2 构造方法");}}
}

与前面不同的是，又重新定义了Bean3和Bean4，他们都实现了接口Inter，然后在Bean1中，使用了@Autowired注入一个Inter类型的Bean，由前面Spring的基础知识，我们知道，Autowired是根据诶行匹配的，由于Bean3和Bean4都实现了Inter，容器不知道到底是注入Bean3还是Bean4，会报错。

以前的解决办法可以使用@Qualifier("bean3")指定注入bean3。除此以外，我们还可以直接修改Bean1中成员变量的名字，如下：

static class Bean1 {public Bean1() {System.out.println("Bean1 构造方法");}@Autowiredprivate Bean2 bean2;public Bean2 getBean2() {return bean2;}@Autowiredprivate Inter bean3;public Inter getInter() {return bean3;}}

运行后发现这样也是可以的，这是因为容器当发现多个同一类型的bean时，容器会去比较成员变量的名字与bean的名字进行匹配，注入能够匹配名字的bean。

还有一种，如果使用@Resource，他也是按照类型匹配的，但是他有个name属性，可以指定注入的bean的名字：

static class Bean1 {public Bean1() {System.out.println("Bean1 构造方法");}@Autowiredprivate Bean2 bean2;public Bean2 getBean2() {return bean2;}@Resource(name = "bean4")private Inter bean3;public Inter getInter() {return bean3;}}

可以发现，最后注入的还是bean4。

那么问题来了，如果同时使用@Autowired和@Resource会怎么样呢？

static class Bean1 {public Bean1() {System.out.println("Bean1 构造方法");}@Autowiredprivate Bean2 bean2;public Bean2 getBean2() {return bean2;}@Autowired@Resource(name = "bean4")private Inter bean3;public Inter getInter() {return bean3;}}

运行结果如下：

Bean1 构造方法
17:37:36.885 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'bean2'
Bean2 构造方法
17:37:36.891 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'bean3'
17:37:36.891 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'bean4'
---------- 分割线 ----------
com.cys.demo02.TestBeanFactoryPostProcessor$Bean3@506ae4d4

可以发现，最后结果是bean3，这是为什么呢？

这就和后置处理器的顺序有关了。由于AutowiredAnnotationBeanPostProcessor是先添加到beanFactory，所以他先解析，后面的就不会再解析了。

代码验证，打印出顺序：

public static void main(String[] args) {DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();// 创建Config的BeanDefinitionAbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition(Config.class).setScope("singleton").getBeanDefinition();// 把beanDefinition注册到beanFactorybeanFactory.registerBeanDefinition("config", beanDefinition);// 给beanFactory添加一些内置的后处理器AnnotationConfigUtils.registerAnnotationConfigProcessors(beanFactory);// 拿到beanFactory的后置处理器，这里有很多，其中一个就是internalConfigurationAnnotationProcessorMap<String, BeanFactoryPostProcessor> processorMap = beanFactory.getBeansOfType(BeanFactoryPostProcessor.class);// 执行后置处理器，当internalConfigurationAnnotationProcessor运行，就会把Bean1和Bean2的beanDefinition注册到beanFactoryprocessorMap.values().stream().forEach(processor -> {processor.postProcessBeanFactory(beanFactory);});// Bean 的后处理器，针对Bean的生命周期的各个阶段提供扩展，例如@AutowiredbeanFactory.getBeansOfType(BeanPostProcessor.class).values().stream().forEach(processor -> {System.out.println("processor:" + processor);beanFactory.addBeanPostProcessor(processor);});// 主动创建单例beanbeanFactory.preInstantiateSingletons();System.out.println("---------- 分割线 ----------");// 获取BeanBean1 bean1 = beanFactory.getBean(Bean1.class);System.out.println(bean1.getInter());}

打印结果如下：

processor:org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor@49c7b90e
processor:org.springframework.context.annotation.CommonAnnotationBeanPostProcessor@10d307f1

可以看到AutowiredAnnotationBeanPostProcessor先添加，然后是CommonAnnotationBeanPostProcessor，CommonAnnotationBeanPostProcessor就是用来解析@Resource的。

我们也可以通过beanFactory的getDependencyComparator方法改变后置处理器的顺序：

beanFactory.getBeansOfType(BeanPostProcessor.class).values().stream().sorted(beanFactory.getDependencyComparator()).forEach(processor -> {System.out.println("processor:" + processor);beanFactory.addBeanPostProcessor(processor);
});

getDependencyComparator方法是由前面的AnnotationConfigUtils工具类提供给beanFactory的：

public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(BeanDefinitionRegistry registry, @Nullable Object source) {DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);if (beanFactory != null) {if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);}if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());}}// 省略代码...
}

核心代码就是

beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);

也就是AnnotationAwareOrderComparator

public class AnnotationAwareOrderComparator extends OrderComparator {/*** Shared default instance of {@code AnnotationAwareOrderComparator}.*/public static final AnnotationAwareOrderComparator INSTANCE = new AnnotationAwareOrderComparator();/*** This implementation checks for {@link Order @Order} or* {@link javax.annotation.Priority @Priority} on various kinds of* elements, in addition to the {@link org.springframework.core.Ordered}* check in the superclass.*/@Override@Nullableprotected Integer findOrder(Object obj) {Integer order = super.findOrder(obj);if (order != null) {return order;}return findOrderFromAnnotation(obj);}@Nullableprivate Integer findOrderFromAnnotation(Object obj) {AnnotatedElement element = (obj instanceof AnnotatedElement ? (AnnotatedElement) obj : obj.getClass());MergedAnnotations annotations = MergedAnnotations.from(element, SearchStrategy.TYPE_HIERARCHY);Integer order = OrderUtils.getOrderFromAnnotations(element, annotations);if (order == null && obj instanceof DecoratingProxy) {return findOrderFromAnnotation(((DecoratingProxy) obj).getDecoratedClass());}return order;}// 省略代码...
}

可以看到，它是一个单例对象，里面有findOrder来获取处理器的顺序。

看下AutowiredAnnotationBeanPostProcessor和CommonAnnotationBeanPostProcessor都有个order的属性和getOrder的方法。CommonAnnotationBeanPostProcessor的是在父类InitDestroyAnnotationBeanPostProcessorzh中。

总结

  1. beanFactory 可以通过 registerBeanDefinition 注册一个 BeanDefinition 对象
    • 我们平时使用的配置类、xml、组件扫描等方式都是生成 BeanDefinition 对象注册到 beanFactory 当中
    • BeanDefinition 描述了这个 bean 的创建蓝图：scope 是什么、用构造还是工厂创建、初始化销毁方法是什么，等等
  2. beanFactory 需要手动调用 beanFactory 后处理器对它做增强
    • 例如通过解析 @Bean、@ComponentScan 等注解，来补充一些 BeanDefinition
  3. beanFactory 需要手动添加 bean 后处理器，以便对后续 bean 的创建过程提供增强
    • 例如 @Autowired，@Resource 等注解的解析都是 bean 后处理器完成的
    • bean 后处理的添加顺序会对解析结果有影响
  4. beanFactory 需要手动调用方法来初始化单例

因为beanFactory上面的一些局限性，一般我们使用ApplicationContext比较多，因为beanFactory需要手动做的事，他都帮我们自动做好了。

ApplicationContext实现

ApplicationContext有4个比较典型的实现类ClassPathXmlApplicationContext、FileSystemXmlApplicationContext、AnnotationConfigApplicationContext、‘AnnotationConfigServletWebServerApplicationContext’。

ClassPathXmlApplicationContext

ClassPathXmlApplicationContext用于从类路径（classpath）中加载 XML 配置文件，进而创建和初始化 Spring 应用上下文（ApplicationContext）。当使用 ClassPathXmlApplicationContext 时，Spring 会自动从类路径中查找指定的 XML 配置文件，并根据该文件的配置创建和管理 Spring Beans。

类图如下

在这里插入图片描述

示例：

首先我们创建一个测试类：

public class TestApplicationContext {public static void main(String[] args) {}static class Bean1 {}static class Bean2 {private Bean1 bean1;public Bean1 getBean1() {return bean1;}public void setBean1(Bean1 bean1) {this.bean1 =  bean1;}}}

里面定义了Bean1类和Bean2类，并且Bean2的属性有Bean1对象。

创建一个XML文件b01.xml

<?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 id="bean1" class="com.cys.demo02.TestApplicationContext.Bean1"/><bean id="bean2" class="com.cys.demo02.TestApplicationContext.Bean2"><property name="bean1" ref="bean1"/></bean></beans>

测试方法：

public static void main(String[] args) {testClassPathXmlApplicationContext();
}private static void testClassPathXmlApplicationContext() {ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("b01.xml");for (String beanDefinitionName : context.getBeanDefinitionNames()) {System.out.println("beanDefinitionName:" + beanDefinitionName);}// 获取bean2Bean2 bean2 = context.getBean(Bean2.class);System.out.println(bean2.getBean1());}

结果如下：

beanDefinitionName:bean1
beanDefinitionName:bean2
com.cys.demo02.TestApplicationContext$Bean1@3e27aa33

需要注意的是，ClassPathXmlApplicationContext 在加载配置文件时会立即创建和初始化所有的单例 Bean。这意味着，如果你在配置文件中定义了一个单例 Bean，并且它有一个在初始化时执行的构造函数或 init-method，那么当 ClassPathXmlApplicationContext 加载配置文件时，这个 Bean 的构造函数或 init-method 会被调用。

FileSystemXmlApplicationContext

FileSystemXmlApplicationContext与ClassPathXmlApplicationContext类似，只不过他是读取系统中文件来，且文件位置不是相对于类路径了，而是绝对路径或者项目跟目录。这个用的很少。

示例：

public static void main(String[] args) {testFileSystemXmlApplicationContext();
}private static void testFileSystemXmlApplicationContext() {// 注意些绝对路径，且要是双斜杠FileSystemXmlApplicationContext context = new FileSystemXmlApplicationContext("src//main//resources//b01.xml");for (String beanDefinitionName : context.getBeanDefinitionNames()) {System.out.println("beanDefinitionName:" + beanDefinitionName);}// 获取bean2Bean2 bean2 = context.getBean(Bean2.class);System.out.println(bean2.getBean1());
}

其结果一样。

AnnotationConfigApplicationContext

AnnotationConfigApplicationContext用于加载基于 Java 配置类的应用程序上下文。与 ClassPathXmlApplicationContext 不同，AnnotationConfigApplicationContext 依赖于 Java 类（使用 @Configuration 注解）而不是 XML 文件来定义和配置 Spring Beans。

使用 AnnotationConfigApplicationContext 的主要好处是它可以利用 Java 的编译时类型检查，从而提供更强大的配置验证。此外，Java 配置通常更加简洁和灵活，因为它可以直接利用 Java 的编程能力，如条件配置、环境特定的配置等。

示例：

首先创建一个配置类：

@Configuration
static 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 main(String[] args) {
//        testClassPathXmlApplicationContext();testAnnotationConfigApplicationContext();}private static void testAnnotationConfigApplicationContext() {AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Config.class);for (String beanDefinitionName : context.getBeanDefinitionNames()) {System.out.println("beanDefinitionName:" + beanDefinitionName);}// 获取bean2Bean2 bean2 = context.getBean(Bean2.class);System.out.println(bean2.getBean1());}

结果如下：

beanDefinitionName:org.springframework.context.annotation.internalConfigurationAnnotationProcessor
beanDefinitionName:org.springframework.context.annotation.internalAutowiredAnnotationProcessor
beanDefinitionName:org.springframework.context.annotation.internalCommonAnnotationProcessor
beanDefinitionName:org.springframework.context.event.internalEventListenerProcessor
beanDefinitionName:org.springframework.context.event.internalEventListenerFactory
beanDefinitionName:testApplicationContext.Config
beanDefinitionName:bean1
beanDefinitionName:bean2
com.cys.demo02.TestApplicationContext$Bean1@6cb107fd

看到，成功创建了bean1和bean2，并把bean1注入了bean2。

另外上面五个后置处理器，也帮我们注册到了容器中。

AnnotationConfigServletWebServerApplicationContext

它是 AnnotationConfigApplicationContext 的一个子类，专门用于创建基于 Java 配置的 Servlet Web 应用程序上下文。这个类结合了 Spring Boot 的自动配置功能和 Spring MVC 的 Web 功能，使得开发者能够快速地创建和部署基于 Java 配置的 Web 应用程序。

AnnotationConfigServletWebServerApplicationContext 通常用于启动 Spring Boot 的 Web 应用程序。它会自动配置 Tomcat、Jetty 或 Undertow 等嵌入式 Web 服务器，并根据你在配置类中定义的 @Bean 和其他注解来创建和管理应用程序上下文。

示例：

使用时也需要指定配置类：

@Configuration
static class WebConfig {/*** tomcat服务器bean** @return*/@Beanpublic ServletWebServerFactory servletWebServerFactory() {return new TomcatServletWebServerFactory();}/*** dispatcherServlet的bean** @return*/@Beanpublic DispatcherServlet dispatcherServlet() {return new DispatcherServlet();}/*** 绑定tomcat服务器和dispatcherServlet** @param dispatcherServlet* @return*/@Beanpublic DispatcherServletRegistrationBean registrationBean(DispatcherServlet dispatcherServlet) {return new DispatcherServletRegistrationBean(dispatcherServlet, "/");}/*** 控制器bean** @return*/@Bean("/hello")public Controller controller1() {return new Controller() {@Overridepublic ModelAndView handleRequest(javax.servlet.http.HttpServletRequest request, javax.servlet.http.HttpServletResponse response) throws Exception {response.getWriter().println("hello");return null;}};}
}

测试：

public static void main(String[] args) {
//        testClassPathXmlApplicationContext();
//        testAnnotationConfigApplicationContext();testAnnotationConfigServletWebServerApplicationContext();}private static void testAnnotationConfigServletWebServerApplicationContext() {AnnotationConfigServletWebServerApplicationContext context = new AnnotationConfigServletWebServerApplicationContext(WebConfig.class);}

启动后，访问http://127.0.0.1:8080/hello，正常就可以访问了。

如果启动出现这个错exception is java.lang.NoClassDefFoundError: org/apache/catalina/WebResourceRoot。这是因为缺少jar包，添加如下：

<dependency>
<groupId>org.apache.tomcat.embed</groupId>
<artifactId>tomcat-embed-core</artifactId>
</dependency>

通过以上案例就可以大致了解一个web服务内部的核心组件，以及和tomcat的交互。

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

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

相关文章

【论文阅读】单词级文本攻击TAAD2.2

【论文阅读】单词级文本攻击TAAD2.2

TAAD2.2论文概览 0.前言1-101.Bridge the Gap Between CV and NLP! A Gradient-based Textual Adversarial Attack Frameworka. 背景b. 方法c. 结果d. 论文及代码 2.TextHacker: Learning based Hybrid Local Search Algorithm for Text Hard-label Adversarial Attacka. 背景b…
阅读更多...
JavaScript极速入门(1)

JavaScript极速入门(1)

初识JavaScript JavaScript是什么 JavaScript(简称JS),是一个脚本语言,解释型或者即时编译型语言.虽然它是作为开发Web页面的脚本语言而著名,但是也应用到了很多非浏览器的环境中. 看似这门语言叫JavaScript,其实在最初发明之初,这门语言的名字其实是在蹭Java的热度,实际上和…
阅读更多...
常用设计模式详解

常用设计模式详解

设计模式 1.UML图 统一建模语言是用来设计软件的可视化建模语言。定义了用例图、类图、对象图、状态图、活动图、时序图、协作图、构件图、部署图等 9 种图。 1.1类图 1.1.1类的表示方式 在UML类图中&#xff0c;类使用包含类名、属性(field) 和方法(method) 且带有分割线…
阅读更多...
二维码门楼牌管理系统应用场景：赋能市场研究与城市决策的新动力

二维码门楼牌管理系统应用场景：赋能市场研究与城市决策的新动力

文章目录 前言一、市场研究的新视角&#xff1a;门牌数据揭示市场趋势二、城市规划的得力助手&#xff1a;门牌数据指导资源分配三、决策制定的科学依据&#xff1a;门牌数据提升决策准确性四、未来展望&#xff1a;二维码门楼牌管理系统的更多可能性 前言 随着信息技术的飞速…
阅读更多...
电脑工作电压是多少你要看看光驱电源上面标的输入电压范围

电脑工作电压是多少你要看看光驱电源上面标的输入电压范围

要确定电脑的工作电压&#xff0c;必须查看电源上标注的输入电压范围。 国内法规规定民用220V电压范围为10%-15%&#xff0c;也就是说通信220V电压正常范围为187--242V&#xff0c;供电设备一般为180V。 --250V电压范围&#xff0c;即正常情况下电脑电源电压不低于187V即可工作…
阅读更多...
基于单片机的电梯控制系统设计

基于单片机的电梯控制系统设计

目 录 摘 要 I Abstract II 引 言 1 1 总体方案设计 3 1.1 设计原理 3 1.2 系统设计方案 3 2 硬件电路的设计 7 2.1 主控制模块 7 2.2 单片机的最小系统 8 2.3 电源电路 9 2.4 电梯呼叫按键电路 9 2.5 楼层显示和楼层指示电路 9 2.6 电梯上下指示电路 10 2.7 防夹模块电路 10 …
阅读更多...
无编制教师和有编制教师区别在哪

无编制教师和有编制教师区别在哪

走进教育的世界&#xff0c;我们常常听到“编制教师”与“非编制教师”的说法&#xff0c;这两者之间的区别&#xff0c;犹如一道隐形的鸿沟&#xff0c;隔开了两种不同的教育生涯。今天&#xff0c;就让我们一起来探讨一下&#xff0c;这两者之间的差异究竟体现在哪里。 教育系…
阅读更多...
超时检测、抓包分析、数据库

超时检测、抓包分析、数据库

#include <myhead.h>//定义添加员工信息函数 int Add_worker(sqlite3 *ppDb) {//准备sql语句printf("请输入要添加的员工信息:\n");//从终端获取员工信息char rbuf[128]"";fgets(rbuf,sizeof(rbuf),stdin);rbuf[strlen(rbuf)-1]0;char sql[128]"…
阅读更多...
一次一对一服务引起的沉思和笑话（微信号Stefan）

一次一对一服务引起的沉思和笑话（微信号Stefan）

前情提要 客户需求&#xff1a; 分析页面代码和接口请求协议和参数需求&#xff0c;将人工下载视频怎么获得最终的视频链接&#xff0c;这一逻辑清晰的展示并讲解清除。我询问了是否需要成品爬虫&#xff0c;他说代码他自己能搞定。 我给的价格选择&#xff1a; 第一种、首…
阅读更多...
NFTScan ：什么是 ERC-404？深入解读 NFT 协议的未来

NFTScan ：什么是 ERC-404？深入解读 NFT 协议的未来

上月初&#xff0c;ERC-404 成为最首要热门的话题&#xff0c;ERC-404 是由 Pandora 团队在 2 月初为创作者和开发者等开源的实验性代币标准&#xff0c;其混合 ERC-20 / ERC-721 实现&#xff0c;具有原生流动性和碎片化等特点。伴随着早期的发展&#xff0c;越来越多参与者开…
阅读更多...
基于STM32的驿站取货小车系统设计

基于STM32的驿站取货小车系统设计

目 录 摘 要 I Abstract II 引 言 3 1 控制系统设计 6 1.1系统方案 6 1.2 系统工作原理 6 1.2.1 系统的工作原理 6 1.2.2 系统的结构 7 2 硬件电路设计 9 2.1主控模块的选择 9 2.1.1 单片机及其选型介绍 8 2.1.2 复位电路的介绍 9 2.2 电机驱动模块 10 2.3 ov7670模块电路 10 …
阅读更多...
代码随想录刷题笔记-Day29

代码随想录刷题笔记-Day29

1. N皇后 51. N 皇后https://leetcode.cn/problems/n-queens/ 按照国际象棋的规则&#xff0c;皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。 n 皇后问题 研究的是如何将 n 个皇后放置在 nn 的棋盘上&#xff0c;并且使皇后彼此之间不能相互攻击。 给你一个整数…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023