Spring应用上下文

已于 2023-03-27 09:35:28 修改
阅读量667 收藏
点赞数
文章标签： spring java 前端 Powered by 金山文档
于 2023-03-26 23:16:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43522117/article/details/129784141
版权

学习《极客时间、spring全家桶学习记录贴》

Spring application context介绍：

Spring applicationcontext包含了业务pojo对象，还有配置的信息，Spring applicationcontext管理了所有的组件的生命周期，比如Inventoryservice、Productservice等组件。spring依赖注入也是通过上下文的实现的，在受托管的组件中，声明A组件依赖B组件，然后spring容器就会把依赖注入进去。

Spring应用上下文常用的接口

  • BeanFactory

  • DefaultListableBeanFactory

  • ApplicationContext的实现类：

  • ClassPathxmlApplicationContext

  • FileSystemXmlApplicationContext

  • AnnotationConfigApplicationContext

一般我们使用ApplicationContext接口及其实现，BeanFactory是最近本的应用上下文，springapplication context扩展了BeanFactory。开发过程中不建议直接使用BeanFactory。

web上下文层次：

当需要在Servlet中寻找某个Bean时,如果找不到，sping会到Root中去寻找。

通过Aop增强类方法的方式理解应用上下文
/**
 * 在方法结束打印信息
 */
@Aspect
@Slf4j
public class FooAspect {
    @AfterReturning("bean(testBean*)")
    public void printAfter() {
        log.info("after hello()");
    }
}
/**
 * 打印信息，知道哪个上下文做了增强
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
@Slf4j
public class TestBean {
    private String context;

    public void hello() {
        log.info("hello " + context);
    }
}
/**
     * implements ApplicationRunner 重写run方法
     * @param args
     * @throws Exception
     */
    @Override
    public void run(ApplicationArguments args) throws Exception {
        //注解方式的上下文
        ApplicationContext fatherContext = new AnnotationConfigApplicationContext(FatherConfig.class);
        //声明fatherContext与childrenContext两个上下文是集成关系
        ClassPathXmlApplicationContext childrenContext = new ClassPathXmlApplicationContext(
                new String[] {"applicationContext.xml"}, fatherContext);
        TestBean bean = fatherContext.getBean("testBeanA", TestBean.class);
        bean.hello();

        log.info("=============");

        TestBean bean1 = childrenContext.getBean("testBeanA", TestBean.class);
        bean1.hello();

        TestBean bean2 = childrenContext.getBean("testBeanB", TestBean.class);
        bean2.hello();
    }
第一种情况：Father和children上下文中都对testBeanA做了AOP增强
@Configuration
@EnableAspectJAutoProxy
public class FatherConfig {
    /**
     * 声明AOPAspect
     * @return
     */
    @Bean
    public FatherAspect fatherAspect() {
        return new FatherAspect();
    }

    @Bean
    public TestBean testBeanA() {
        return new TestBean("Father");
    }

    @Bean
    public TestBean testBeanB() {
        return new TestBean("Father");
    }
}
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
    <aop:aspectj-autoproxy/>

    <bean id="testBeanA" class="com.springwork.high.context.TestBean">
        <constructor-arg name="context" value="children" />
    </bean>

<!--    <bean id="fatherAspect" class="com.springwork.high.context.FatherAspect" />-->
</beans>

结果：Father上下文中的了testBeanA、testBeanB都得到AOP增强，同时children可以得到Father上下文中testBeanA的增强方法

23:09:56.847 [main] INFO  com.springwork.high.HighApplication - Started HighApplication in 2.261 seconds (JVM running for 3.135)
23:09:56.919 [main] INFO  com.springwork.high.context.TestBean - hello Father
23:09:56.920 [main] INFO  com.springwork.high.context.FatherAspect - after hello()
23:09:56.920 [main] INFO  com.springwork.high.HighApplication - =============
23:09:56.920 [main] INFO  com.springwork.high.context.TestBean - hello children
23:09:56.920 [main] INFO  com.springwork.high.context.FatherAspect - after hello()
23:09:56.920 [main] INFO  com.springwork.high.context.TestBean - hello Father
23:09:56.920 [main] INFO  com.springwork.high.context.FatherAspect - after hello()
23:09:56.921 [main] INFO  com.springwork.high.HighApplication -
第二种情况：Father上下文中做了AOP增强，children上下文中没有AOP增强
/**
 * @author high
 * @version 1.0.0
 * @date 2023/3/26 21:45
 * @EnableAspectJAutoProxy 开启AspectJAutoProxy支持
 */
@Configuration
@EnableAspectJAutoProxy
public class FatherConfig {
    /**
     * 声明AOPAspect
     * @return
     */
    @Bean
    public FatherAspect fatherAspect() {
        return new FatherAspect();
    }

    @Bean
    public TestBean testBeanA() {
        return new TestBean("Father");
    }

    @Bean
    public TestBean testBeanB() {
        return new TestBean("Father");
    }
}
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
<!--    <aop:aspectj-autoproxy/>-->

    <bean id="testBeanA" class="com.springwork.high.context.TestBean">
        <constructor-arg name="context" value="children" />
    </bean>

<!--    <bean id="fatherAspect" class="com.springwork.high.context.FatherAspect" />-->
</beans>

结果：代表children的testBeanA没有被增强，发现children可以得到Father上下文中testBeanB增强

22:55:05.895 [main] INFO  com.springwork.high.context.TestBean - hello Father
22:55:05.896 [main] INFO  com.springwork.high.context.FatherAspect - after hello()
22:55:05.896 [main] INFO  com.springwork.high.HighApplication - =============
22:55:05.896 [main] INFO  com.springwork.high.context.TestBean - hello children
22:55:05.896 [main] INFO  com.springwork.high.context.TestBean - hello Father
22:55:05.896 [main] INFO  com.springwork.high.context.FatherAspect - after hello()
22:55:05.897 [main] INFO  com.springwork.high.HighApplication -
第三种情况：Father上下文中没有AOP增强，children上下文中AOP增强了
@Configuration
@EnableAspectJAutoProxy
public class FatherConfig {
    /**
     * 声明AOPAspect
     * @return
     */
//    @Bean
//    public FatherAspect fatherAspect() {
//        return new FatherAspect();
//    }

    @Bean
    public TestBean testBeanA() {
        return new TestBean("Father");
    }

    @Bean
    public TestBean testBeanB() {
        return new TestBean("Father");
    }
}
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
    <aop:aspectj-autoproxy/>

    <bean id="testBeanA" class="com.springwork.high.context.TestBean">
        <constructor-arg name="context" value="children" />
    </bean>

    <bean id="fatherAspect" class="com.springwork.high.context.FatherAspect" />
</beans>

结果：Father上下文中的没有testBeanA、testBeanB没有AOP增强，children上下文中testBeanA得到AOP增强了

23:02:16.950 [main] INFO  com.springwork.high.HighApplication - Started HighApplication in 2.175 seconds (JVM running for 3.014)
23:02:17.070 [main] INFO  com.springwork.high.context.TestBean - hello Father
23:02:17.070 [main] INFO  com.springwork.high.HighApplication - =============
23:02:17.075 [main] INFO  com.springwork.high.context.TestBean - hello children
23:02:17.076 [main] INFO  com.springwork.high.context.FatherAspect - after hello()
23:02:17.076 [main] INFO  com.springwork.high.context.TestBean - hello Father
23:02:17.077 [main] INFO  com.springwork.high.HighApplication -
总结：

Father上下文中方法得到AOP增强后，children上下文可以在Father上下文中获取到增强后的方法；

children上下文中方法得到AOP增强后，Father上下文不能够在children上下文获取到增强后的方法；

Spring应用上下文 ApplicationContext
javalingyu的博客
05-31 2494
Spring 应用上下文 ApplicationContext 前面一系列文章都是围绕 BeanFactory 进行分析的，BeanFactory 是 Spring 底层 IoC 容器的实现，完成了 IoC 容器的基本功能。在实际的应用场景中，BeanFactory 容器有点简单，它并不适用于生产环境，我们通常会选择 ApplicationContext。ApplicationContext 就是大名鼎鼎的 Spring 应用上下文，它不仅继承了 BeanFactory 体系，还提供更加高级的功能，更加适
SpringBoot运行源码分析：Spring应用上下文刷新
m0_63437643的博客
02-23 942
Spring应用上下文的刷新 Spring 应用上下文的刷新，是通过调用 SpringApplication 中的 refreshContext 方法来完成的。SpringApplication 中 refreshContext 方法相关代码如下。 private void refreshContext(ConfigurableApplicationContext context) { //调用 refresh 方法 refresh(context); if (this.registerShutdow
Spring Cloud引导应用程序上下文
qq_40354025的博客
10-16 790
Spring Boot对于如何使用Spring构建应用程序有一个看法：例如它具有常规配置文件的常规位置，以及用于常见管理和监视任务的端点。Spring Cloud建立在此之上，并添加了一些可能系统中所有组件将使用或偶尔需要的功能。
Spring 源码学习（一）—— spring 上下文概览
最新发布
weixin_63445802的博客
10-12 862
ResourceLoader 接口所定义的功能为对资源进行处理，其拥有一个字符串常量 CLASSPATH_URL_PREFIX 与两个方法；其中 CLASSPATH_URL_PREFIX 常量值为 classpath:，作用为替换配置文件中替代文件的类路径前缀，getResource 方法获取指定位置的 Resource 对象及 getClassLoader 方法则是获取所使用的类加载对象。@Nullable。
Spring 的应用上下文
weixin_43790623的博客
12-06 400
在spring中，有两种定义上下文做aop拦截的方式。一种是使用Java类做一个父配置。另外一个就是用applicationContext.xml做子配置。 我们在FooConfig.java 中定义两个 testBean，分别为 testBeanX(foo) 和 testBeanY(foo)。 applicationContext.xml 定义了一个 testBeanX(bar)。具体如代码所示...
【Spring | 应用上下文】
爱媳妇儿爱编程
07-19 4286
应用上下文和资源路径要点总结
Spring 应用上下文获取 Bean 的常用姿势实例总结
08-19
Spring 应用上下文获取 Bean 的常用姿势实例总结 Spring 应用上下文获取 Bean 是一个常见的操作，在 Spring 框架中获取 Bean 对象是非常重要的。本文将总结 Spring 应用上下文获取 Bean 的常用姿势实例，并对其...
第二十章 Spring 应用上下文生命周期（ApplicationContext Lifecycle）1
08-04
本章将深入探讨Spring应用上下文的生命周期，从启动准备阶段到关闭阶段，包括各个关键步骤和相关组件的作用。 1. **Spring 应用上下文启动准备阶段** 在这个阶段，AbstractApplicationContext的`prepareRefresh()`...
spring 应用上下文
xianyundanfeng的博客
10-09 317
spring自带了以下几种应用上下文 1、ClassPathXmlApplicationContext 从类路径下加载xml 2、FileSystemXmlApplicationContext 读取文件系统下的xml 3、XmlWebApplicationContext 读取web应用下的xml 比如： ApplicationContext context = new FileSyste...
spring上下文
热门推荐
lqzxpp的博客
02-12 2万+
应用上下文即是Spring容器抽象的一种实现；而我们常见的ApplicationContext本质上说就是一个维护Bean定义以及对象之间协作关系的高级接口。额，听起来是不是很抽象拗口？那你再读一遍呢。。。这里，我们必须明确，Spring的核心是容器，而容器并不唯一，框架本身就提供了很多个容器的实现，大概分为两种类型：一种是不常用的BeanFactory，这是最简单的容器，只能提供基本的DI功能；...
Spring-MVC理解之一：应用上下文webApplicationContext
weixin_30701521的博客
02-01 459
一、先说ServletContext 　　javaee标准规定了，servlet容器需要在应用项目启动时，给应用项目初始化一个ServletContext作为公共环境容器存放公共信息。ServletContext中的信息都是由容器提供的。 举例： 通过自定义contextListener获取web.xml中配置的参数 1.容器启动时，找到配置文件中的context-param作为键值对放到...
Spring5 应用上下文
weixin_33910759的博客
03-20 166
为什么80%的码农都做不了架构师？>>> ...
【Spring】深入理解 Spring 上下文（Context）层次结构
DC1020的博客
05-26 1376
在使用 Spring 框架进行应用程序开发时，Spring 上下文（Context）是一个非常重要的概念。Spring 上下文提供了一个环境，用于管理应用程序中的对象（通常称为 Bean）及其之间的依赖关系。在复杂的应用程序中，可能存在多个上下文对象，而这些上下文对象之间可以形成一种层次结构。本文将深入探讨 Spring 上下文的层次结构，并介绍如何在实际项目中应用这种结构。
spring应用上下文的理解
u012413709的博客
04-22 2880
spring应用上下文的理解 #容器 什么叫容器呢? 如果你想要一个手机,好这时候spring就给你一个手机.你想要使用的对象,spring就会给你,但是现在我们就会问那spring给的对象来自于哪里呢? spring要负责的工作很多,那么多对象的创建管理都是它在负责,那肯定会有一个地方是负责造对象的.造手机的叫工厂,而spring造对象的不叫所谓的工厂,如果叫工厂有点low,所以给出一个...
深入理解Spring上下文（Application Context）
diligent_man_z的博客
03-11 4547
Spring上下文是Spring框架的核心部分之一，它是一个容器，负责管理应用程序中的对象（也称为Bean）。上下文在应用程序中充当了一个中央枢纽的角色，它负责创建、配置和管理Bean的生命周期。Spring上下文可以理解为一个容器，它包含了应用程序中所有的Bean定义和它们之间的关系。上下文通过读取配置文件（如XML文件或注解）来了解Bean的定义和配置信息，并在需要的时候创建和提供这些Bean的实例。Spring上下文是Spring框架的核心组件之一，它负责管理应用程序中的Bean。
Spring学习（1）关于spring的上下文
lettuce_的博客
08-23 1309
本文的相关理解，是基于以下博主文章以及spring书籍总结而来 spring上下文 博客 文字型个人理解：https://www.cnblogs.com/chenbenbuyi/p/8166304.html 代码型技术解析：https://www.cnblogs.com/hello-shf/p/11006750.html 书籍：《Spring实战》第4版 P18-P19页 1.2.1...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值