Spring-IOC

于 2024-09-12 10:13:45 发布
阅读量711 收藏 9
点赞数 8
分类专栏： SSM # Spring Java 文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gaosw0521/article/details/142162779
版权
Java 同时被 3 个专栏收录
33 篇文章 0 订阅
订阅专栏
Spring
5 篇文章 0 订阅
订阅专栏
SSM
4 篇文章 0 订阅
订阅专栏

文章目录

1 前言

1.1 内容概要

  1. 掌握IOC和DI的概念
  2. 熟悉注册组件的几种方式和相关注解
  3. 熟悉取出组件的几种方式和相关注解
  4. 理解Spring组件的生命周期的含义
  5. 熟悉BeanPostProcessor的执行时机

1.2 前置知识准备

  • 注解的相关知识@Target、@Retention、属性
  • 理解容器的思想

2 介绍Spring

2.1 SpringFramework的起源

Spring Framework通常人们称之为Spring。

Spring是一个开源框架，Spring是于2003 年兴起的一个轻量级的Java 开发框架，由Rod Johnson 在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来。

它是为了解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许使用者选择使用哪一个组件，同时为 J2EE 应用程序开发提供集成的框架。

Spring是一个分层的Java SE/EE full-stack(一站式) 轻量级开源框架。

2.2 ★IOC控制反转

Inverse of Control

控制反转这个词要拆开来看

控制：实例的生成权

反转：由应用程序反转给Spring容器

容器：生成并管理实例的抽象空间

获取依赖对象被反转了，它是被动获取；

正转就是自己去new一个对象，自己获取对象

2.3 ★DI依赖注入

Dependency Injection

Q1谁依赖谁？Q2为什么需要依赖？Q3谁注入谁？Q4注入了什么？

思考上面的问题，一定要在控制反转的基础上去思考。

思考的是应用程序和Spring容器之间的关系 👉 经过了控制反转，Spring容器（IoC容器）掌握了更多的实例，变得更加富有，而应用程序变得贫穷

Answer1 应用程序依赖于IoC容器；

Answer2 应用程序需要IoC容器来提供对象需要的外部资源；

Answer3 IoC容器注入应用程序某个对象，应用程序依赖的对象；

Answer4 注入某个对象所需要的外部资源（包括对象、资源、常量数据）；

2.3 Spring的优点

  • 方便解耦，简化开发（高内聚低耦合）
  • AOP编程的支持
  • 声明式事务的支持
  • 方便程序的测试
  • 方便集成各种优秀框架
  • 降低JavaEE API的使用难度

2.4 核心技术

依赖注入、事件、资源、i18n国际化、校验、数据绑定、类型转换、Spring Expression Language、AOP

3 入门案例

3.1 入门案例1

3.1.1 引入依赖

引入依赖 beans、context、aop、expression、core、jcl 5+1

<dependencies>
    <!--引入依赖 beans、context、aop、expression、core、jcl 5+1-->
    <!--spring-context-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.2.5.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
</dependencies>

3.1.2 提供接口和实现类

public class UserDaoImpl implements UserDao{
    @Override
    public void sayHello() {
        System.out.println("hello xiaowu");
    }
}

原先使用实例的时候，是通过构造方法生成的；后续要变更为来源Spring容器

3.1.3 Spring配置文件

配置文件为Xml格式的文件，需要引入对应的Schema约束

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

    <!-- bean definitions here -->

</beans>

在配置文件中注册组件

<!--spring配置文件的名称通常叫application(-xxx).xml-->
<!-- bean definitions here -->
<!--控制反转-->
<!--id属性 👉 组件在容器中的唯一标识-->
<!--name属性 👉 名称 👉 通常省略不写-->
<!--class 全类名 👉 实现类的全类名-->
<!--组件 注册 👉 将实例交给spring管理的过程我们称之为注册-->
<bean id="userDao" class="com.cskaoyan.dao.UserDaoImpl"/>

3.1.4 从容器中取出组件，执行方法

注意：取出组件的3种方式！

@Test
public void mytest(){
    //容器的具体的存在ApplicationContext
    //加载的是classpath下的spring配置文件
    ApplicationContext applicationContext =
        new ClassPathXmlApplicationContext("application.xml");
    //Spring容器想象为婚姻介绍所 → 介绍对象
    //applicationContext.getBean(String) → 按照组件的名称（id）
    UserDao userDao1 = (UserDao) applicationContext.getBean("userDao");
    //applicationContext.getBean(Class) → 按照组件的类型(class)
    //可以写接口的类型，也可以写实现类的类型 → 容器当中该组件的类型只有一个的时候，可以使用这种方式
    UserDao userDao2 = applicationContext.getBean(UserDao.class);
    //applicationContext.getBean(String,Class) → 按照组件的名称和类型共同作用（id和class）
    UserDao userDao3 = applicationContext.getBean("userDao", UserDao.class);
    userDao1.sayHello();
    userDao2.sayHello();
    userDao3.sayHello();
}

3.2 入门案例2

维护组件之间的依赖关系，在容器中注册dao层和service层组件，并且service层的组件依赖于dao层组件（谁需要谁就是谁依赖谁）

3.2.1 service类和dao类

通过在service类中增加dao类成员变量维护依赖关系

public class UserServiceImpl implements UserService{
    //主动 → 控制
    //UserDao userDao = new UserDaoImpl();
    UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public void serviceSayHello() {
        System.out.println("service层的sayHello");
        userDao.sayHello();
    }
}

public class UserDaoImpl implements UserDao{
    @Override
    public void sayHello() {
        System.out.println("hello xiaowu");
    }
}

3.2.2 维护组件之间依赖关系

通过property标签的ref属性维护组件之间的依赖关系

<!-- bean definitions here -->
<bean id="userDao" class="com.cskaoyan.dao.UserDaoImpl"/>
<bean id="userService" class="com.cskaoyan.service.UserServiceImpl">
    <!--name属性对应的是set方法-->
    <!--ref属性对应的是容器中的组件id-->
    <property name="userDao" ref="userDao"/>
</bean>

3.2.3 单元测试

直接从容器中取出service组件，执行对应的方法

@Test
public void mytest1(){
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application.xml");
    UserService userService = applicationContext.getBean(UserService.class);
    userService.serviceSayHello();

    UserDao userDao = applicationContext.getBean(UserDao.class);
}

注意:一定是从容器中取出对应的组件

4 ★ 注解

在使用Spring注解的时候，我们按照功能来进行划分

4.1 配置类

配置类，承担做通用配置的功能，同时在配置类中可以组件注册

  • 我们在类定义上增加一些功能性的注解，增加一些通用性的配置
  • 我们在类中的方法里注册组件

比如我们定义一个配置类，需要在类上增加一个@Configuration注解

// 这里增加功能性的注解
@Configuration
public class SpringConfiguration {
    // 类中的方法做组件的注册
}

4.2 组件注册功能（IOC）

4.2.1 类直接注册

组件注册功能首先要打开扫描开关

// 这里增加功能性的注解
@Configuration
@ComponentScan("com.cskaoyan.demo1")
public class SpringConfiguration {
    // 类中的方法做组件的注册
}

组件注册功能的注解@Component

除了@Component注解，还有什么类似的注解

@Target(ElementType.TYPE)// 该注解写在类上
@Retention(RetentionPolicy.RUNTIME)
public @interface Component {

   /**
    * The value may indicate a suggestion for a logical component name,
    * to be turned into a Spring bean in case of an autodetected component.
    * @return the suggested component name, if any (or empty String otherwise)
    */
   String value() default "";

}
  • @Service → 通常是Service层的组件使用的注解，Service层组件也能使用@Component
  • @Repository → 通常是Dao层的组件使用@Repository注解，dao层组件也能使用@Component
  • @Configuration → 配置类组件
  • @Controller（SpringMVC阶段）
  • 等

@Service、@Repository、@Controller、@Configuration，这些注解的ElementType都是TYPE，也就是这些注解都是要写在类定义上。

组件id默认为类名的首字母小写，另外也可以使用注解的value属性来指定组件id

//@Component
//@Repository("userDao")  //组件id为userDao
@Repository               //组件id为userDaoImpl
public class UserDaoImpl implements UserDao{
}
//@Component
@Service
public class UserServiceImpl implements UserService{
}

4.2.2 配置类注册（JavaConfig）

在配置类中完成对应的组件注册以及相关配置，配置类的核心就是提供对应的信息

JavaConfig的目标是干掉配置文件，JavaConfig也是SpringBoot推荐使用的配置方式，SpringBoot中不再使用Spring的xml配置文件

在配置类中，使用注册功能的注解@Bean 以及方法来完成组件注册

@Target({ElementType.METHOD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Bean {}

该注解增加在方法上，并且可以和其他注解共存

这个方法的返回值注册为容器中的组件

/**
 * 要通过这个方法注册一个DruidDataSource组件
 * @return 应该返回的是一个DruidDataSource的实例，这个返回值会注册为容器中的组件
 * 返回值的定义：可以写实现类，也可以写接口；提供组件的类型信息给到容器中；建议写接口
 * SE的代码风格来提供属性值就可以
 * 通过这种方式注册的组件id：1、默认值是方法名；2、@Bean注解的value属性可以指定组件id
 */
@Bean
public DataSource dataSource(){
    DruidDataSource dataSource = new DruidDataSource();
    dataSource.setDriverClassName("com.mysql.jdbc.Driver");
    dataSource.setUrl("jdbc:mysql://localhost:3306/cskaoyan_db?useUnicode=true&characterEncoding=utf-8");
    dataSource.setUsername("root");
    dataSource.setPassword("123456");
    return dataSource;
}

想要通过@Bean注册Component1这个组件

public class Component1 {
    
    DataSource dataSource;

    public DataSource getDataSource() {
        return dataSource;
    }

    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
    }
}

/**
 * Component1这个类中有一个成员变量 叫dataSource需要的是一个DataSource类型的组件
 * 设置的这个DataSource想要从容器中来获得
 * 形参：默认是按照类型从容器中取出组件的  ac.getBean(Class)
 * @return
 */
@Bean
public Component1 component1(DataSource dataSource) {
    Component1 component1 = new Component1();
    component1.setDataSource(dataSource);
    return component1;
}

额外增加一个DataSource组件的话，容器中DataSource类型的组件不止一个，通过形参从容器中取出组件需要指定组件id

@Bean
public DataSource dataSource2(){
    DruidDataSource dataSource = new DruidDataSource();
    dataSource.setDriverClassName("com.mysql.jdbc.Driver");
    dataSource.setUrl("jdbc:mysql://localhost:3306/cskaoyan_db2?useUnicode=true&characterEncoding=utf-8");
    dataSource.setUsername("root");
    dataSource.setPassword("123456");
    return dataSource;
}

/**
 * Component1这个类中有一个成员变量 叫dataSource需要的是一个DataSource类型的组件
 * 设置的这个DataSource想要从容器中来获得
 * 形参：默认是按照类型从容器中取出组件的  ac.getBean(Class)
 * 如果形参所需的组件在容器中不止一个，需要额外指定组件id的信息 → @Qualifier 的value属性指定组件id
 * 形参的名称也可以作为组件的id，但是我们更建议使用@Qualifier ，更直观一些
 * @return
 */
@Bean
public Component1 component1(@Qualifier("dataSource2") DataSource dataSource) {
    Component1 component1 = new Component1();
    component1.setDataSource(dataSource);
    return component1;
}

@Bean

返回值类型、方法名、形参、返回值、@Bean注解的value属性 各自的含义大家需要关注

4.3 组件注入功能（DI）

注意：要求是容器中的组件，才能够使用注入功能的注解

4.3.1 JavaConfig的@Bean

方法的形参，就是从容器中取出的组件

4.3.2 构造器注入

如果类中没有无参构造方法的话，如果这个类上有组件注册功能的注解，它会使用有参构造方法来完成实例化。

有参构造方法的形参会从容器中取出组件

@Component
public class Component2 {
    DataSource dataSource;

    public Component2(DataSource dataSource) {
        this.dataSource = dataSource;
    }
}

Component2中没有无参构造方法，就会使用有参构造方法来完成实例化

  • 默认是按照类型从容器中取出组件

  • 如果这个类型的组件在容器中不止一个，可以使用@Qualifier指定组件id(形参名称也可以但不建议)

    • NoUniqueBeanDefinitionException:

    • 使用@Qualifier指定组件id

    • @Component
public class Component2 {
  DataSource dataSource;

  public Component2(@Qualifier("dataSource1") DataSource dataSource) {
    this.dataSource = dataSource;
  }
}

  • 其中的常量值可以通过@Value注解来提供

    • public UserServiceImpl(UserDao userDao,@Value("zhangsan") String name) {
  this.userDao = userDao;
  this.name = name;
}

  • 如果有多个有参构造方法，需要指定构造方法

    • @Service
public class UserServiceImpl implements UserService{
  UserDao userDao;
  String name;

  public UserServiceImpl(UserDao userDao,@Value("zhangsan") String name) {
    this.userDao = userDao;
    this.name = name;
  }
  @Autowired
  public UserServiceImpl(UserDao userDao) {
    this.userDao = userDao;
  }
}

4.3.3 方法注入

可以是组件中的任意方法，但是通常这样的方法我们用的是set方法，在方法上增加@Autowired注解

@Component
public class Component3 {
    DataSource dataSource;

    // 默认这个方法并不会自动执行
    // 如果我们在上面增加了@Autowired 注解的话，在生命周期设置属性值的过程中会自动执行
    // 形参默认按照类型从容器中取出;如果要指定组件id，还是@Qualifier
    @Autowired
    public void setDataSource(@Qualifier("dataSource2") DataSource dataSource) {
        this.dataSource = dataSource;
    }
}

（set）方法这种形式是Spring框架建议使用的方式，但其实绝大部分程序员用的都不是这种方式

4.3.4 成员变量注入

注入功能的注解使用这三组：

  1. @Autowired
  2. @Autowired + @Qualifier
  3. @Resource

容器中注册了这些类型的组件，OrderDao类型的组件（orderDaoImpl）、UserDao类型的组件userDaoImpl1和userDaoImpl2

@Repository
public class OrderDaoImpl implements OrderDao{
}
@Repository
public class UserDaoImpl1 implements UserDao{
}
@Repository
public class UserDaoImpl2 implements UserDao{
}

从容器中取出的对应的组件，执行注入，要注意，要求是在容器中的组件里注入

/**
 * 要使用注入功能注解，一定要保证当前类是容器中的组件
 */
@Service
public class UserServiceImpl implements UserService{
    @Autowired //容器中该类型的组件只有一个
    OrderDao orderDao;
    @Autowired //使用@Qualifier注解指定组件id
    @Qualifier("userDaoImpl1")
    UserDao userDao1;
    @Resource(name = "userDaoImpl2") //默认是按照组件的类型去注入，使用name属性指定组件id
    UserDao userDao2;
}

4.3.5 注意事项

  • 开发业务代码过程中，最常用的方式只使用一个@Autowired ：绝大部分组件在容器中这个类型的组件只有一个
  • 要在容器中的组件中使用这些注解，使用注解的话，所处的类上要有组件注册功能的注解，且处于扫描包目录
  • 维护的是容器中的组件之间的依赖关系

4.4 Spring的单元测试

引入spring-test依赖

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
    <version>5.2.5.RELEASE</version>
    <scope>test</scope>
</dependency>

使用@Runwith和@ContextConfiguration注解，在单元测试类中可以使用注入功能的注解

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:application.xml")
public class MyTest2 {

    @Autowired
    UserService userService;
    @Autowired
    OrderDao orderDao;
    @Autowired
    @Qualifier("userDaoImpl1")
    UserDao userDao1;
    /**
     * 从容器中取出UserService组件
     * 查看userService组件中的成员变量是否取出容器中的组件
     */
    @Test
    public void mytest1(){

    }
}

5 Bean的准备

5.1 Bean的实例化

5.1.1 无参构造方法（默认方式）

这也是最常用的一种方式

/**
 * 无参构造方法
 */
@Data //提供了getter和setter方法，以及重写了toString方法
@NoArgsConstructor //增加无参构造方法，默认存在无参构造，该注解也可以不写
public class Bean1 {
    String parameter1;
    String parameter2;
}

对应的配置文件

<!--构造方法完成实例化-->
<!--无参构造方法 👉 默认使用的无参构造方法-->
<bean id="bean1" class="com.cskaoyan.bean.Bean1">
    <property name="parameter1" value="xiaowu"/>
    <property name="parameter2" value="male"/>
</bean>

其中的参数，可以通过property标签使用到set方法来提供

5.1.2 有参构造方法

/**
 * 有参构造方法
 */
@Data
@AllArgsConstructor //增加有参构造方法
public class Bean2 {
    String parameter1;
    String parameter2;
}

对应的配置文件

<!--有参构造方法-->
<bean id="bean2" class="com.cskaoyan.bean.Bean2">
    <!--name属性对应的是有参构造方法的参数名-->
    <constructor-arg name="parameter1" value="xiaofang"/>
    <constructor-arg name="parameter2" value="female"/>
</bean>

5.1.3 工厂

工厂提供实例，而实例交给Spring容器来进行管理

5.1.3.1 工厂（略）

通过配置类中的方法，方法上增加@Bean注解，该方法的返回值注册为容器中的组件

5.1.3.2 FactoryBean

实现FactoryBean接口，组件类型和FactoryBean接口中的getObject方法的类型相同

public interface FactoryBean<T> {
    String OBJECT_TYPE_ATTRIBUTE = "factoryBeanObjectType";

    @Nullable
    T getObject() throws Exception;

    @Nullable
    Class<?> getObjectType();

    default boolean isSingleton() {
        return true;
    }
}

比如要注册一个User类型的组件，可以通过User对应的FactoryBean来注册组件。

/**
 * 直接注册为容器中的组件
 * FactoryBean 👉 XXXFactoryBean
 *      👉 组件类型和FactoryBean接口中的getObject方法相关
 * BeanFactory和factoryBean：
 *      BeanFactory：生产的是容器中的所有的组件
 *      FactoryBean：生产的是特定的组件
 */
@Component
public class UserFactoryBean implements FactoryBean<User> {

    /**
     * 完成组件的实例化
     * @return 组件类型和返回值相关
     * @throws Exception
     */
    @Override
    public User getObject() throws Exception {
        User user = new User();
        return user;
    }

    @Override
    public Class<?> getObjectType() {
        return User.class;
    }
}

注意：BeanFactory和FactoryBean之间的区别

5.1.3.3 思考1

我们 在什么情况下使用的工厂的方式？

难道我们不是直接用构造方法更方便么，为啥还要使用工厂？

确实，使用构造方法是很方便，但是有些情况用不了构造方法。比如动态代理 ProxyFactoryBean

使用构造器要提供大量的参数，而提供大量的参数过程又比较繁琐，也就是通常在使用一些框架的时候，会给你提供一些对应的工厂

一些框架已经写好了一些代码，要在此基础上增加对Spring框架的支持，要将框架中的一些核心的对象交给Spring容器来管理，通常就会提供一个框架的拓展包，拓展包中提供对应的工厂，使用工厂可以直接将这个框架需要的核心对象注册为容器中的组件 SqlSessionFactoryBean

工厂：主要就是对已有的代码做些拓展

5.1.3.4 思考2

BeanFactory是ApplicationContext的父接口，也就是容器接口 → 所有的组件的生成和管理都是通过它的

BeanFactory和FactoryBean之间的联系和区别

联系：通过他们都可以向容器中注册组件

区别：BeanFactory是容器，所有的组件注册都是通过BeanFactory；而FactoryBean注册的特定的单个组件

5.2 作用域 Scope

Singleton：单例，每一次取出组件都是同一个组件

Prototype：原型，每一次取出组件都是全新的组件

默认值是singleton，我们通常省略不写

@Scope 使用value属性指定作用域

@Component
@Scope("singleton")
public class SingletonBean {
}
@Component
@Scope("prototype")
public class PrototypeBean {
}
@Component
public class DefaultBean {
}

注册3个组件，分别给到不同的scope，然后从容器中取出组件多次，查看是否是同一个组件（查看内存地址）

@Test
public void mytest1(){
    ApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfiguration.class);
    SingletonBean bean1 = applicationContext.getBean(SingletonBean.class);
    SingletonBean bean2 = applicationContext.getBean(SingletonBean.class);
    SingletonBean bean3 = applicationContext.getBean(SingletonBean.class);
}
@Test
public void mytest2(){
    ApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfiguration.class);
    PrototypeBean bean1 = applicationContext.getBean(PrototypeBean.class);
    PrototypeBean bean2 = applicationContext.getBean(PrototypeBean.class);
    PrototypeBean bean3 = applicationContext.getBean(PrototypeBean.class);
}
@Test
public void mytest3(){
    ApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfiguration.class);
    DefaultBean bean1 = applicationContext.getBean(DefaultBean.class);
    DefaultBean bean2 = applicationContext.getBean(DefaultBean.class);
    DefaultBean bean3 = applicationContext.getBean(DefaultBean.class);
}

5.3 生命周期

5.3.1 概念

生命周期指组件在容器中要完成实例化，组件从实例化开始直至可用状态会执行到哪些过程。

Servlet的生命周期：init、service、destroy

  • 准备阶段
  • 服务阶段
  • 销毁阶段

对于Bean（容器中的组件），在容器中也会经历这样的一些阶段

  • 容器初始化的时候，组件做准备性工作
  • 组件可以从容器中取出，提供服务，比如从容器中取出userService实例，调用其sayHello方法
  • 容器关闭，组件做销毁工作

在特定的时间执行一系列的方法

5.3.2 初始化阶段的方法

  1. Bean的实例化

  2. 设置参数方法

  3. BeanNameAware、BeanFactoryAware、ApplicationContextAware

  4. BeanPostProcessor的postProcessBeforeInitialization

  5. InitializingBean的afterPropertiesSet方法

  6. 自定义的init方法

  7. BeanPostProcessor的postProcessAfterInitialization

在这里插入图片描述

5.3.3 容器关闭阶段的方法

单例的组件才会执行到对应的方法

DisposableBean的destroy方法

自定义的destroy方法

5.3.4 作用域对生命周期的影响

scope=singleton（默认值） → 在容器初始化的时候就开始组件的初始化（立即加载），并且会执行销毁阶段

scope=prototype → 在获取组件的时候才执行生命周期(懒加载)，每获取一次执行一次生命周期的初始化方法，不会执行销毁方法

5.3.5 代码

示例生命周期的组件

/**
 * 组件可以使用之前要经过这样的一些生命周期
 *  组件可以使用之前：
 *      singleton：容器初始化的时候
 *      prototype：从容器中取出组件的时候，getBean
 */
@Component
public class LifeCycleBean implements BeanNameAware, BeanFactoryAware, ApplicationContextAware,
InitializingBean, DisposableBean {
  //实例化
  public LifeCycleBean(){
    System.out.println("1、bean的实例化");
  }
  //参数设置
  String parameter;
	@Autowired
  public void setParameter(String parameter) {
    System.out.println("2、设置参数");
    this.parameter = parameter;
  }
  //Aware：为组件中的成员变量提供参数 → BeanName、BeanFactory、ApplicationContext
  String beanName;
  BeanFactory beanFactory;
  ApplicationContext applicationContext;
  @Override
  public void setBeanName(String beanName) {
    System.out.println("3、BeanNameAware");
    this.beanName = beanName;
  }
  @Override
  public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
    System.out.println("3、BeanFactoryAware");
    this.beanFactory = beanFactory;
  }
  @Override
  public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
    System.out.println("3、ApplicationContextAware");
    this.applicationContext = applicationContext;
  }

  @Override
  public void afterPropertiesSet() throws Exception {
    System.out.println("5、InitializingBean的afterPropertiesSet方法");
  }
  @PostConstruct
  public void init(){
    System.out.println("6、自定义的init方法");
  }

  @Override
  public void destroy() throws Exception {
    System.out.println("8、DisposableBean的destroy");
  }
  @PreDestroy
  public void customDestroy(){
    System.out.println("9、自定义的destroy");
  }


}

BeanPostProcessor

//该组件的before和after方法的作用范围：除了该组件本身之外，其他的所有组件
@Component
public class CustomBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("4、BeanPostProcessor的before方法");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("7、BeanPostProcessor的after方法");
        return bean;
    }
}

组件注册到容器中才会生效

5.3.6 注意

注意：生命周期的方法，不是都会执行到的，有些执行是需要条件的。另外要注意BeanPostProcessor的作用范围

6 附件 思维导图

请添加图片描述

·云扬·
关注
  • 8
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
maven-spring-ioc
08-07
**Spring IoC 框架详解** Spring框架是Java开发中的一个核心组件，它提供了许多功能，其中最重要的一项就是Inversion of Control（IoC），也称为Dependency Injection（DI）。IoC容器是Spring的核心，它负责管理...
coco-spring-ioc
04-16
在“coco-spring-ioc-master”中，我们可以找到对应的Bean工厂实现，了解其如何加载配置信息，以及如何根据配置创建Bean。 3. **依赖注入**：是IOC的核心，通过配置文件或注解指定Bean之间的依赖关系。在“coco-...
Spring-IoC（XML配置文件形式）
maohe的博客
10-30 1282
IoC思想：为了解耦，。如果我们直接通过new的方式获得对象，需要清楚所有的底层对象初始化过程进行依赖处理，才能进行逻辑处理，而通过IoC引入的对象（外部提供），我们通过依赖注入(DI)的方式进行依赖处理就行。IoC容器从当IoC思想中的"外部"，用来负责对象的创建、初始化等一系列工作，在IoC容器中的对象统称为bean。：在IoC容器中建立bean与bean之间的依赖关系的整个过程，称为依赖注入。
Spring-IoC源码分析
一名蒟蒻的博客
05-25 2332
IoC源码分析 1、IoC定义 将原本在程序中⼿动创建对象的控制权，交由Spring框架来管理。 IoC 容器是 Spring⽤来实现 IoC 的载体， IoC 容器实际上就是个Map（key，value），Map 中存放的是各种对象 将对象之间的相互依赖关系交给 IoC 容器来管理，并由 IoC 容器完成对象的注⼊。 IoC 容器就像是⼀个⼯⼚⼀样，当我们需要创建⼀个对象的时候，只需要配置好配置⽂件/注解即 可，完全不⽤考虑对象是如何被创建出来的。 IoC 的实现原理就是工厂模式加反射机制 优点： 代
Spring-IoC 篇
小周不想写代码的博客
03-16 2436
在 Spring IoC 容器中，每个被管理的对象都由一个 Bean 定义来描述。Bean 定义包括对象的类型、依赖关系、生命周期等信息。
Spring-IOC的XML配置
打酱油的葫芦娃
06-05 5111
引言 在Springboot编程实践中，我们偏向使用注解的方式进行Bean的注册和依赖注入等，但XML格式的容器信息管理方式仍是Spring提供的最为强大、支持最为全面的方式，本文对Spring-IOC的XML配置进行详细的讲解。 <beans>和<bean> BeanFactory和ApplicationContext的XML配置均采用统一的格式，在Spring2.0之前...
spring--IOC详解
Cqy180的博客
06-16 2096
1.IOC容器 2.基于xml管理bean 3.基于注解管理bean
CGB2110-DAY02-Spring-IOC
qq_16804847的博客
12-22 8683
1. Spring框架学习 1.1 Spring介绍 Spring框架是一个开放源代码的J2EE应用程序框架，由Rod Johnson发起，是针对bean的生命周期进行管理的轻量级容器（lightweight container）。 Spring解决了开发者在J2EE开发中遇到的许多常见的问题，提供了功能强大IOC、AOP及Web MVC等功能。Spring可以单独应用于构筑应用程序，也可以和Struts、Webwork、Tapestry等众多Web框架组合使用，并且可以与 Swing等桌面应用程序AP组合
面试汇总-Spring-IOC和AOP
热门推荐
weixin_37672801的博客
08-18 1万+
Resource对象与对应ApplicationContext类型如下。
Spring-IOC是什么
jj89929665的博客
05-25 2910
Spring-IOC是Spring框架的核心，是一个容器，它负责实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。，欢迎大家加入我的开源项目，或者(在我的主页联系我)加入你们的开源项目，点点Github-Stars。
Spring-IOC-DI
Cw_Herry的博客
04-15 1953
当我们需要创建一个非常复杂的对象时，例如MyBatis中的SqlSession对象。我们得到SqlSession对象前需要做一系列的事情的时候，就可以使用Spring的工厂模式来创建。定义想要获取的对象，例JavaBean创建JavaBeanFactoryBean用于获取JavaBean实例，需要实现FactoryBean重写 getObject getObjectType 以及 isSingleton方法，获取对象、获取对象类型、是否为单例创建。
Spring-IOC接口
m0_57410337的博客
03-07 2509
1.IOC思想是基于IOC容器完成的，IOC的底层就是对象工厂 2.Spring里边提供了IOC容器的实现的两种方式 (1) BeanFactroy：IOC容器是Spring内部的使用接口，不提供给开发人员使用 public class DemoTest { //传统写法 @Test public void run(){ Demo demo = new Demo(); demo.hello();
Spring-IOC丐版
02-26
Spring框架是Java开发中不可或缺的一部分，它以其强大的依赖注入（Dependency Injection，简称DI）和控制反转（Inversion of Control，简称IOC）特性而闻名。在这个名为"Spring-IOC丐版"的项目中，我们将深入探讨...
Spring-ioc-jar
07-18
这个jar文件"Spring-ioc-jar"包含了实现Spring IOC功能所需的关键类和接口，是学习和使用Spring IOC技术的基础。 Spring框架的IOC容器是其核心组件，主要由`ApplicationContext`和`BeanFactory`两个接口代表。`...
Spring-IoC-DI-main
02-11
标题“Spring-IoC-DI-main”提示我们讨论的核心是Spring框架中的两个核心特性：控制反转（Inversion of Control, IoC）和依赖注入（Dependency Injection, DI）。这两个概念是Java开发中的重要基石，尤其在构建大型...
spring揭秘19-spring事务01-事务抽象
PacosonSWJTU的博客
09-08 1281
1）spring对事务元素进行抽象， 客户端仅按照统一的编程模型管理事务，而不用关心数据访问技术以及具体要访问什么类型的事务资源；此外：spring事务管理与spring提供的数据访问技术（如JdbcTemplate）进行结合；2）spring事务框架设计的基本原则： 让事务管理逻辑与数据访问逻辑解耦；spring揭秘15-spring集成数据访问技术(orm框架)总结事务隔离级别；isolation；事务传播行为；事务超时时间；timeout；是否为只读事务；readOnly；
SpringBoot登录退出|苍穹外卖登录退出分析
分享技术，分享经验
09-07 1422
用户登录：用户提交登录请求➡️后端认证用户(拦截器会放行登录接口，先判断用户名密码，然后生成token)➡️生成令牌token，并将其返回给客户端。
Spring05——注解开发定义bean、Spring纯注解开发模式
后端小白个人学习记录
09-08 876
注解开发定义bean、Spring纯注解开发模式
Spring cache的使用
最新发布
cyt涛的博客
09-08 714
Spring Cache是Spring提供的一个缓存框架，基于AOP原理，实现了基于注解的缓存功能，只需要简单地加一个注解就能实现缓存功能，对业务代码的侵入性很小。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值