Spring框架——2

最新推荐文章于 2022-10-20 23:45:50 发布
最新推荐文章于 2022-10-20 23:45:50 发布
阅读量137 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52188375/article/details/115564122
版权
本文详细介绍了Spring框架中的依赖注入（DI）原理，包括属性setter注入和构造注入的实现方式。此外，文章还阐述了Spring中Bean的配置、常用属性，以及三种实例化Bean的方法：构造器实例化、静态工厂和实例工厂。同时，文章讨论了Bean的作用域，如singleton和prototype，以及Bean的生命周期管理，包括初始化和销毁过程。
摘要由CSDN通过智能技术生成

1.Spring DI（依赖注入）的实现方式：属性注入和构造注入

           依赖注入（Dependency Injection，DI）和控制反转含义相同，它们是从两个角度描述的同一个概念。
           当某个 Java 实例需要另一个 Java 实例时，传统的方法是由调用者创建被调用者的实例（例如，使用 new 关键字
    获得被调用者实例），而使用 Spring 框架后，被调用者的实例不再由调用者创建，而是由 Spring 容器创建，这称为控
    制反转。
           Spring 容器在创建被调用者的实例时，会自动将调用者需要的对象实例注入给调用者，这样，调用者通过 Spring
    容器获得被调用者实例，这称为依赖注入。

被调用者
public  class  Person{

}
调用者
public class  Student{
//被调用者---依赖对象
    private  Person  person;
public  void  getPerson(){
     person=new Person();
}
}

           当某个 Java 实例【Student】需要另一个 Java 实例【Person】，Spring 容器在创建被调用者的实例【Person】时
    会自动将调用者需要的对象实例【Person】注入给调用者【Student】，这样调用者【Student】通过 Spring 容器获得被
    调用者【Person】实例，这称为依赖注入。
           依赖注入主要有两种实现方式，分别是属性 setter 注入和构造方法注入。具体介绍如下。
  1）属性 setter 注入--Set方法注入
           指 IoC 容器使用 setter 方法注入被依赖的实例。通过调用无参构造器或无参 static 工厂方法实例化 bean 后，调用该
    bean 的 setter 方法，即可实现基于 setter 的 DI。
1.创建项目，完善结构，导入依赖

<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>5.1.5.RELEASE</version>
</dependency>

2.创建被调用者类

package com.wangxing.springdemo2;

public class Person {
    public void testPerson(){
        System.out.println("Person类的实例方法testPerson（）");
    }
}

3.创建调用者类

package com.wangxing.springdemo2;

public class Student {
    //定义依赖对象
    private Person person;
    //依赖对象的set方法
    public void setPerson(Person person) {
        this.person = person;
    }
    public void getStudent(){
        System.out.println("Student类的实例方法getStudent（）");
        person.testPerson();
    }
}

4..配置Spring配置文件

<?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">

    <!--创建Person类对象-->
    <bean id="per" class="com.wangxing.springdemo2.Person"></bean>
    <!--创建Student类对象-->
    <bean id="student" class="com.wangxing.springdemo2.Student">
        <!--setter注入-->
        <property name="person" ref="per"></property>
    </bean>
</beans>

5.创建单元测试

package com.wangxing.springdemo2;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AppTest {
    @Test
    public void test1(){
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
        //字符串参数是配置文件中student对象的id属性的值
        Student student=applicationContext.getBean("student",Student.class);
        student.getStudent();
    }
}

  2）构造方法注入
           指 IoC 容器使用构造方法注入被依赖的实例。基于构造器的 DI 通过调用带参数的构造方法实现，每个参数代表一个依赖。
1创建项目，完善结构，导入依赖

<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>5.1.5.RELEASE</version>
</dependency>

2.创建被调用者类

package com.wangxing.springdemo3;

public class Person {
    public  void testPerson(){
        System.out.println( "Person类的实例方法testPerson（）" );
    }
}

3.创建调用者类

package com.wangxing.springdemo3;

public class Student {
    //定义依赖对象
    private Person  person;
    //依赖对象的set方法
    public Student(Person person){
        this.person=person;
    }
    public void getStudent(){
        System.out.println("Student类的实例方法getStudent（）");
        person.testPerson();
    }
}

4.创建spring配置文件

<?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">

    <!--创建Person类对象-->
    <bean id="per" class="com.wangxing.springdemo3.Person"></bean>
    <!--创建Student类对象-->
    <bean id="student" class="com.wangxing.springdemo3.Student">
        <!--构造方法注入-->
        <constructor-arg index="0" ref="per"></constructor-arg>
    </bean>
</beans>

5.创建测试方法

package com.wangxing.springdemo3;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AppTest {
    @Test
    public void shouldAnswerWithTrue(){
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
        Student student=applicationContext.getBean("student",Student.class);
        student.getStudent();
    }
}

2.Spring Bean的配置及常用属性

           作为 Spring 核心机制的依赖注入，改变了传统的编程习惯，对组件的实例化不再由应用程序完成，转而交由 Spring 容器完
    成，在需要时注入应用程序中，从而对组件之间依赖关系进行了解耦。这一切都离不开 Spring 配置文件中使用的 <bean> 元素。
           Spring 容器可以被看作一个大工厂，而 Spring 容器中的 Bean 就相当于该工厂的产品。如果希望这个大工厂能够生产和管理
     Bean，这时则需要告诉容器需要哪些 Bean，以及需要以何种方式将这些 Bean 装配到一起。
           Spring 配置文件支持两种不同的格式，分别是 XML 文件格式和 Properties 文件格式。
           通常情况下，Spring 会以 XML 文件格式作为 Spring 的配置文件，这种配置方式通过 XML 文件注册并管理 Bean 之间的
    依赖关系。
           XML 格式配置文件的根元素是 <beans>，该元素包含了多个 <bean> 子元素，每一个 <bean> 子元素定义了一个 Bean，并
    描述了该 Bean 如何被装配到 Spring 容器中。
定义 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">
    <!--创建Person类对象-->
    <bean  name="per" class="com.wangxing.springtest3.Person"></bean>
    <!--创建Student类对象-->
    <bean id="stu" class="com.wangxing.springtest3.Student">
        <!--构造方法注入-->
        <constructor-arg index="0" ref="per"></constructor-arg>
    </bean>
</beans>

           在上述代码中，分别使用 id 和 name 属性定义了两个 Bean，并使用 class 元素指定了 Bean 对应的实现类。
           <bean> 元素中包含很多属性，其常用属性如表 1 所示。

表 1 <bean>元素的常用属性

属性名称

描述

id

是一个 Bean 的唯一标识符，Spring 容器对 Bean 的配置和管理都通过该属性完成

name

Spring 容器同样可以通过此属性对容器中的 Bean 进行配置和管理，name 属性中可以为 Bean 指定多个名称，每个名称之间用逗号或分号隔开

class

该属性指定了 Bean 的具体实现类，它必须是一个完整的类名，使用类的全限定名【反射机制】

scope 

用于设定 Bean 实例的作用域，其属性值有 singleton（单例）、prototype（原型）、request、session 和 global Session。其默认值是 singleton

constructor-arg

<bean>元素的子元素，可以使用此元素传入构造参数进行实例化。该元素的 index 属性指定构造参数的序号（从 0 开始），type 属性指定构造参数的类型

property

<bean>元素的子元素，用于调用 Bean 实例中的 Set 方法完成属性赋值，从而完成依赖注入。该元素的 name 属性指定 Bean 实例中的相应属性名

ref

<property> 和 <constructor-arg> 等元素的子元索，该元素中的 bean 属性用于指定对 Bean 工厂中某个 Bean 实例的引用

value

<property> 和 <constractor-arg> 等元素的子元素，用于直接指定一个常量值

list

用于封装 List 或数组类型的依赖注入

set

用于封装 Set 类型属性的依赖注入

map

用于封装 Map 类型属性的依赖注入

entry

<map> 元素的子元素，用于设置一个键值对。其 key 属性指定字符串类型的键值，ref 或 value 子元素指定其值

3.Spring实例化Bean的三种方法

           在面向对象的程序中，要想调用某个类的成员方法，就需要先实例化该类的对象。在 Spring 中，实例化 Bean 有三
    种方式，分别是构造器实例化、静态工厂方式实例化和实例工厂方式实例化。本节将针对这三种方式分别进行讲解。
  构造器实例化
           构造器实例化是指 Spring 容器通过 Bean 对应的类中默认的构造函数实例化 Bean。下面通过案例演示如何使用构造
    器实例化 Bean。
1创建项目，完善结构，导入依赖

<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>5.1.5.RELEASE</version>
</dependency>

2.创建Person类

package com.wangxing.createbean;

public class Person {
    public  void testPerson() {
        System.out.println( "Person类的testPerson()实例方法" );
    }
}

3.创建Spring配置文件

<?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="person" class="com.wangxing.createbean.Person"></bean>
</beans>

4.测试方法

package com.wangxing.createbean;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class AppTest {
    @Test
    public void shouldAnswerWithTrue() {
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
        Person person=applicationContext.getBean("person",Person.class);
        person.testPerson();
    }
}

  静态工厂方式实例化
           在 Spring 中，也可以使用静态工厂的方式实例化 Bean。此种方式需要提供一个静态工厂方法创建 Bean 的实例。
1创建项目，完善结构，导入依赖

<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>5.1.5.RELEASE</version>
</dependency>

2.创建UserBean 类

package com.wangxing.createbean;

public class UserBean {
    public  void testUser() {
        System.out.println( "UserBean类的testUser()实例方法" );
    }
}

3.创建静态工厂类，并在该静态工厂类中创建一个返回UserBean类对象的名为getUserBean的静态方法，用于创建 Bean 的实例，如下所示。

package com.wangxing.createbean;
/**
 * 静态工厂类
 */
public class MyBeanStaticFactory {
    //4.创建一个返回UserBean类对象的名为getUserBean的静态方法
    public  static  UserBean getUserBean(){
        return  new UserBean();
    }
}

4.创建 Spring 配置文件

<?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="user" class="com.wangxing.createbean.MyBeanStaticFactory" factory-method="getUserBean"></bean>
</beans>

5.测试方法

package com.wangxing.createbean;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class AppTest {
    @Test
    public void shouldAnswerWithTrue() {
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
        UserBean userBean=applicationContext.getBean("user",UserBean.class);
        userBean.testUser();
    }
}

  实例工厂方式实例化
           在 Spring 中，还有一种实例化 Bean 的方式就是采用实例工厂。在这种方式中，工厂类不再使用静态方法创建 Bean 的实
    例，而是直接在成员方法中创建 Bean 的实例。
           同时，在配置文件中，需要实例化的 Bean 也不是通过 class 属性直接指向其实例化的类，而是通过 factory-bean 属性配置
    一个实例工厂，然后使用 factory-method 属性确定使用工厂中的哪个方法。下面通过案例演示实例工厂方式的使用。
1创建项目，完善结构，导入依赖

<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>5.1.5.RELEASE</version>
</dependency>

2.创建Student类

package com.wangxing.createbean;

public class Student {
    public void testStudent(){
        System.out.println("Student类的testStudent()实例方法");
    }
}

3.创建一个名为 MyBeanFactory 的实例工厂类，在该类中创建一个返回Student类对象的实例方法。

package com.wangxing.createbean;
/**
 * 实例工厂类
 */
public class MyBeanFactory {
    //返回Student类对象的实例方法
    public Student getStudent(){
        return new Student();
    }
}

4.创建 Spring 配置文件

<?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="myBeanFactory" class="com.wangxing.createbean.MyBeanFactory"></bean>
    <!--创建Student类对象-->
    <bean id="student" factory-bean="myBeanFactory" factory-method="getStudent"></bean>
</beans>

           上述代码中，首先配置了一个实例工厂 Bean【myBeanFactory】，然后配置了需要实例化的 Bean。在 id 为 student的 Bean
     中，使用 factory-bean 属性指定一个实例工厂，该属性值就是实例工厂的 id 属性值。使用 factory-method 属性确定使用工厂中的
     getStudent() 方法。
5. 创建测试类

package com.wangxing.createbean;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class AppTest {
    @Test
    public void shouldAnswerWithTrue() {
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
        Student student=applicationContext.getBean("student",Student.class);
        student.testStudent();
    }
}

4.Spring中Bean的作用域

           本节先简单介绍了 Spring 中 bean 的 5 种作用域，然后详细介绍 singleton 和 prototype 这两种最常用的作用域。
  作用域的种类
           Spring 容器在初始化一个 Bean 的实例时，同时会指定该实例的作用域。Spring3 为 Bean 定义了五种作用域，具体如下。
    1）singleton
           单例模式，使用 singleton 定义的 Bean 在 Spring 容器中只有一个实例，这也是 Bean 默认的作用域。
    2）prototype
           原型模式，每次通过 Spring 容器获取 prototype 定义的 Bean 时，容器都将创建一个新的 Bean 实例。
    3）request
           在一次 HTTP 请求中，容器会返回该 Bean 的同一个实例。而对不同的 HTTP 请求，会返回不同的实例，该作用域仅在当
           前 HTTP Request 内有效。
    4）session
           在一次 HTTP Session 中，容器会返回该 Bean 的同一个实例。而对不同的 HTTP 请求，会返回不同的实例，该作用域仅在
           当前 HTTP Session 内有效。
    5）global Session
           在一个全局的 HTTP Session 中，容器会返回该 Bean 的同一个实例。该作用域仅在使用 portlet context 时有效。
           在上述五种作用域中，singleton 和 prototype 是最常用的两种，接下来将对这两种作用域进行详细讲解。
  singleton 作用域
           singleton 是 Spring 容器默认的作用域，当一个 Bean 的作用域为 singleton 时，Spring 容器中只会存在一个共享的 Bean 实例，
    并且所有对 Bean 的请求，只要 id 与该 Bean 定义相匹配，就只会返回 Bean 的同一个实例。
           通常情况下，这种单例模式对于无会话状态的 Bean（如 DAO 层、Service 层）来说，是最理想的选择。
           在 Spring 配置文件中，可以使用 <bean> 元素的 scope 属性，将 Bean 的作用域定义成 singleton，其配置方式如下所示：
                      <bean id="person" class="com.mengma.scope.Person" scope="singleton"/>
1.创建项目，完善结构，导入依赖

<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>5.1.5.RELEASE</version>
</dependency>

2.创建UserBean类

package com.wangxing.scope;

public class UserBean {
    public  void testUser(){
        System.out.println( "UserBean类的testUser()实例方法" );
    }
}

3.创建Spring配置文件

<?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="user" class="com.wangxing.scope.UserBean" scope="singleton"></bean>
</beans>

4.测试

package com.wangxing.scope;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class AppTest {
    @Test
    public void shouldAnswerWithTrue() {
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationCntext.xml");
        UserBean userBean1=applicationContext.getBean("user",UserBean.class);
        UserBean userBean2=applicationContext.getBean("user",UserBean.class);
        System.out.println("userBean1的hashcode码："+userBean1.hashCode());
        System.out.println("userBean2的hashcode码："+userBean2.hashCode());
    }
}

           两次输出的结果相同，这说明 Spring 容器只创建了一个 UserBean类的实例。由于 Spring 容器默认作用域是 singleton，
    如果不设置 scope="singleton"，则其输出结果也将是一个实例。
  prototype 作用域
           使用 prototype 作用域的 Bean 会在每次请求该 Bean 时都会创建一个新的 Bean 实例。因此对需要保持会话状态的
    Bean（如 Struts2 的 Action 类）应该使用 prototype 作用域。
           在 Spring 配置文件中，要将 Bean 定义为 prototype 作用域，只需将 <bean> 元素的 scope 属性值定义成 prototype，
    其示例代码如下所示：
                      <bean id="person" class="com.mengma.scope.Person" scope="prototype"/>
1.创建项目，完善结构，导入依赖

<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>5.1.5.RELEASE</version>
</dependency>

2.创建PersonBean类

package com.wangxing.scope;

public class PersonBean {
    public  void testPerson(){
        System.out.println( "PersonBean类的testPerson()实例方法" );
    }
}

3.创建Spring配置文件

<?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="person" class="com.wangxing.scope.PersonBean" scope="prototype"></bean>
</beans>

4.测试

package com.wangxing.scope;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class AppTest {
    @Test
    public void shouldAnswerWithTrue() {
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
        PersonBean personBean1=applicationContext.getBean("person",PersonBean.class);
        PersonBean personBean2=applicationContext.getBean("person",PersonBean.class);
        System.out.println("personBean1的hashcode码："+personBean1.hashCode());
        System.out.println("personBean2的hashcode码："+personBean2.hashCode());
    }
}

           输出结果中可以看到，两次输出的结果并不相同，这说明在 prototype 作用域下，Spring 容器创建了两个不同的 Student实例。

5.Spring Bean的生命周期

           Spring 容器可以管理 singleton 作用域 Bean 的生命周期，在此作用域下，Spring 能够精确地知道该 Bean 何时被创建，何时
    初始化完成，以及何时被销毁。
           而对于 prototype 作用域的 Bean，Spring 只负责创建，当容器创建了 Bean 的实例后，Bean 的实例就交给客户端代码管理，
    Spring 容器将不再跟踪其生命周期。每次客户端请求 prototype 作用域的 Bean 时，Spring 容器都会创建一个新的实例，并且不
    会管那些被配置成 prototype 作用域的 Bean 的生命周期。
           了解 Spring 生命周期的意义就在于，可以利用 Bean 在其存活期间的指定时刻完成一些相关操作。这种时刻可能有很多，但
    一般情况下，会在 Bean 被初始化后和被销毁前执行一些相关操作。
           在 Spring 中，Bean 的生命周期是一个很复杂的执行过程，我们可以利用 Spring 提供的方法定制 Bean 的创建过程。
           当一个 Bean 被加载到 Spring 容器时，它就具有了生命，而 Spring 容器在保证一个 Bean 能够使用之前，会进行很多工作。
           Spring 容器中 Bean 的生命周期流程如图 1 所示。

                                                                                                                                               图 1  Bean 的生命周期

    Bean 生命周期的整个执行过程描述如下。
           1）根据配置情况调用 Bean 构造方法或工厂方法实例化 Bean。
           2）利用依赖注入完成 Bean 中所有属性值的配置注入。
           3）如果 Bean 实现了 BeanNameAware 接口，则 Spring 调用 Bean 的 setBeanName() 方法传入当前 Bean 的 id 值。
           4）如果 Bean 实现了 BeanFactoryAware 接口，则 Spring 调用 setBeanFactory() 方法传入当前工厂实例的引用。
           5）如果 Bean 实现了 ApplicationContextAware 接口，则 Spring 调用 setApplicationContext() 方法传入当前
                 ApplicationContext 实例的引用。
           6）如果 BeanPostProcessor 和 Bean 关联，则 Spring 将调用该接口的预初始化方法 postProcessBeforeInitialzation()
                 对 Bean 进行加工操作，此处非常重要，Spring 的 AOP 就是利用它实现的。
           7）如果 Bean 实现了 InitializingBean 接口，则 Spring 将调用 afterPropertiesSet() 方法。
           8）如果在配置文件中通过 init-method 属性指定了初始化方法，则调用该初始化方法。
           9）如果 BeanPostProcessor 和 Bean 关联，则 Spring 将调用该接口的初始化方法 postProcessAfterInitialization()。此时，
                 Bean 已经可以被应用系统使用了。
         10）如果在 <bean> 中指定了该 Bean 的作用范围为 scope="singleton"，则将该 Bean 放入 Spring IoC 的缓存池中，将触发
                Spring 对该 Bean 的生命周期管理；如果在 <bean> 中指定了该 Bean 的作用                     范围为 scope="prototype"，则
                将该 Bean 交给调用者，调用者管理该 Bean 的生命周期，Spring 不再管理该 Bean。
         11）如果 Bean 实现了 DisposableBean 接口，则 Spring 会调用 destory() 方法将 Spring 中的 Bean 销毁；如果在配置文件中通
                 过 destory-method 属性指定了 Bean 的销毁方法，则 Spring 将调用该方法对 Bean 进行销毁。
           Spring 为 Bean 提供了细致全面的生命周期过程，通过实现特定的接口或 <bean> 的属性设置，都可以对 Bean 的生命周期过程产
    生影响。虽然可以随意配置 <bean> 的属性，但是建议不要过多地使用 Bean 实现接口，因为这样会导致代码和 Spring 的聚合过于紧密。
1.创建项目，完善结构，导入依赖

<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>5.1.5.RELEASE</version>
</dependency>

2.创建PersonBean 类

package com.wangxing.demo5;

public class PersonBean {
    public PersonBean(){
        System.out.println("创建PersonBean对象");
    }
    public void initPerson(){
        System.out.println("initPerson（）是我们定制的初始化方法");
    }
    public void testPerson(){
        System.out.println("testPerson（）是PersonBean的实例方法");
    }
    public void  destoryPerson(){
        System.out.println("destoryPerson（）是我们定制的销毁方法");
    }
}

3.创建Spring配置文件

<?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="person" class="com.wangxing.demo5.PersonBean" scope="singleton" init-method="initPerson" destroy-method="destoryPerson"></bean>
</beans>

4.测试

package com.wangxing.demo5;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class AppTest {
    @Test
    public void shouldAnswerWithTrue() {
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
        PersonBean personBean=applicationContext.getBean("person",PersonBean.class);
        personBean.testPerson();
        //((AbstractApplicationContext)applicationContext).close();
        ((AbstractApplicationContext)applicationContext).registerShutdownHook();
    }
}

           当spring配置文件中的scope属性是singleton时，Spring 能够精确地知道该 Bean 何时被创建，何时初始化完成，以及何时被销毁。
           被定制的销毁方法【destoryPerson()】可以被执行

           当spring配置文件中的scope属性是prototype时，Spring 只负责创建，当容器创建了 Bean 的实例后，Bean 的实例就交给客户端代码管理，Spring 容器将不再跟踪其生命周期。
           被定制的销毁方法【destoryPerson()】不会执行

折翼天使【*-*】
关注
Spring框架——IOC
weixin_60246887的博客
08-19 1771
spring框架IOC部分的内容，可配合尚硅谷spring5视频实用。基于视频内容根据自己理解整理出的，按照视频顺序的笔记可以看另一位博主的文章，链接如下：https://blog.csdn.net/m0_63324772/article/details/124129130
【Spring】 ——初识Spring
最新发布
冷兮雪的博客
05-29 1832
容器是⽤来容纳某种物品的（基本）装置。——来⾃：百度百科我们想想，之前我们接触的容器有哪些？List/Map -> 数据存储容器Tomcat -> Web 容器既然 Spring 是⼀个 IoC容器，重点应该是在“容器”⼆字上，那么它就具备两个最基础的功能：将对象存⼊到容器；从容器中取出对象所以Spring 是⼀个 IoC 容器，说的是对象的创建和销毁的权利都交给 Spring 来管理了，它本身⼜具备了存储对象和获取对象的能⼒。
2021-04-09——Spring框架-——2
weixin_53371536的博客
04-09 216
Spring框架 Spring DI（依赖注入）的实现方式：属性注入和构造注入 依赖注入（Dependency Injection，DI）和控制反转含义相同，它们是从两个角度描述的同一个概念。 当某个Java实例需要另一个 Java 实例时，传统的方法是由调用者创建被调用者的实例（例如，使用 new 关键字获得被调用者实例），而使用Spring框架后，被调用者的实例不再由调用者创建，而是由 Spring 容器创建，这称为控制反转。 Spring 容器在创建被调...
Spring学习笔记(2)一DI依赖注入和Spring Bean配置、注解原理、动态注入
黄规速博客:学如逆水行舟，不进则退
12-23 8829
IOC(Inversion of Control)：传统的方法，当某个java对象A需要调用对象B时，是由调用者（对象A）通过new关键字来创建对象B的，而在Spring中，则是由spring完成创建的，所以“控制反转”了。Spring通过一种称作控制反转（IoC）的技术促进了低耦合。当应用了IoC，一个对象依赖的其它对象会通过被动的方式传递进来，而不是这个对象自己创建或者查找依赖对象。你可以认为IoC与JNDI（JNDI是 Java 命名与目录接口Java Naming and Directory Int
Spring Bean的配置及常用属性
unber的博客
08-09 485
作为 Spring 核心机制的依赖注入，改变了传统的编程习惯，对组件的实例化不再由应用程序完成，转而交由 Spring 容器完成，在需要时注入应用程序中，从而对组件之间依赖关系进行了解耦。
spring 配置文件种bean标签的相关配置属性
健康平安的活着的专栏
01-02 1391
一.spring bean标签的相关属性 1.1 bean标签属性的作用介绍 <bean>标签 id属性：在容器中bean实例的唯一标识，不允许重复 class属性：要实例的bean的全限定名 scope属性：bean的作用范围，常用的是singleton(单例)和prototype <property>标签： 属性注入 name 属性：属性名称 value 属性：注入的普通属性值 ref属性: 注入的对象引用值 &...
springboot bean依赖属性配置
m0_62520968的博客
09-20 479
使用@EnableConfigurationProperties注解设定使用属性类时加载bean。业务类定义业务功能bean，在引导类通常使用@Import导入，解耦强制加载bean。将业务功能bean运行需要的资源抽取长独立的属性类，设置读取配置文件的信息。配置文件application.yml使用固定格式为属性注入数据。
Spring————面试题库
03-04
Spring框架的目的是帮助Java开发者解决在开发应用程序时遇到的基础性问题，让开发者能够专注于业务逻辑的开发，而不必担心底层基础设施的复杂性。Spring框架的设计遵循了经典的设计模式，它是一个模块化的架构，允许...
Spring框架 —— 使用STS开发Spring程序
NotaChtholly的博客
09-15 792
使用STS开发Spring程序使用STS开发Spring程序 使用STS开发Spring程序 由于Spring的配置文件较多，基于Eclipse配置也比较复杂。为了提高开发的效率，建议使用STS开发工具开发，或者在Eclipse安装一个STS插件。 在开发者配置bean的class时候能够根据 alt+/ 自动提示 通过STS插件，配置文件可以直接通过工具管理，不需要做过多的配置。 在Eclip...
Spring记录之Bean属性配置、依赖关系及生命周期
HoiDev
05-12 1327
Spring配置Bean的属性和依赖关系Spring的IOC容器负责管理所有的应用系统组件，并协助组件之间建立关联。Spring支持Properties文件格式，和XML文件配置，XML是常用的。设置普通属性值(设值注入)当bean实例创建以后，Spring会遍历配置文件的<bean>元素中所有的<property>子元素，每发现一个<property>，就根据name属性调用相应的setter方法
Spring自动注入（自动注入、属性文件(*.properties)）
weixin_43708793的博客
04-26 1073
**1、自动注入的前提：**Spring对象中的属性名(该属性指是对象属性)与ref="“值相同的情况可以使用自动注入。 2、自动注入的五种使用方式介绍： 自动注入是在或者标签中使用属性autowire=”“属性， autowire=""属性有五个值：default、no、byName、byType、constructor 2.1、default值:如果在标签中使用，表示默认使用全局配置标签中的a...
3. Spring配置文件 - Bean的实例化
Bi-Hu的博客
06-18 211
Spring配置文件 【对 第一个 HelloWorld 程序】 进行解刨知识点 1.Bean标签基本配置 用于配置对象交由Spring 来创建。 默认情况下它调用的是类中的无参构造函数，如果没有无参构造函数则不能创建成功。【这种方法叫做 无参方法实例化 Bean对象是根据它的无参构造来获取的】 基本属性： id：Bean实例在Spring容器中的唯一标识 【emm 唯一标识 真是个常识.】 ...
spring中bean的实例化
张姐姐聊编程
04-06 481
如果把Spring看作一个大型工厂，那么Spring容器中的Bean就是该工厂的产品。要想使用Spring工厂生产和管理Bean，就需要在配置文件中指明需要哪些Bean，以及需要使用何种方式将这些Bean装配到一起。
Spring之（四）Bean的配置及实例化
qq_50994235的博客
07-16 670
四、Bean的配置及实例化 4.1 Bean的配置 Spring可以被看做是一个大型工厂，这个工厂的作用就是生产和管理Spring容器中的Bean。如果需要在项目中使用这个工厂，就需要我们对Spring的配置文件进行配置。 Spring容器支持XML和Properties两种格式的配置文件，在实际开发中最常使用的就是XML格式的配置方式，这种配置方式通过XML文件来注册并管理Bean之间的依赖关系。 在Spring中，XML配置文件的根元素是beans，beans中包含了多个bean子元素，每一个bean子
Spring容器的依赖注入方式（二）
鲤鱼打挺的博客
03-21 139
如果通过配置beans.xml的方式对属性进行注入，需要编写大量的xml代码，造成了配置文件的臃肿，为了解决这个问题，spring提供了在JAVA代码中通过注解的方式来对属性进行装配。   方法三：通过注解方式对属性进行注入    第一步：要使用注解方式进行装备，首先需要修改beans.xml文件，让spring打开注解功能： &lt;?xml version="1.0" encoding...
@Bean注解详解
热门推荐
怪咖@的博客
10-20 3万+
@Bean属于spring当中的注解，@Bean用于将对象存入spring的ioc容器中，同`@controller、@Service、@Component、@Configuration`等几个注解是一样的，都是负责`将对象存入容器当中`。只不过方式不同，他们是用在类上面的，然后将当前类`通过无参构造函数创建对象`然后放入容器，而`@Bean`是用在方法上，将当前方法的`返回值对象`放到容器当中！可以理解为前者是由spring自动创建对象，而@Bean创建对象是交给我们自己来控制。
spring入门
m0_67376124的博客
08-22 474
Spring的基本概念Spring的基本概念。
Spring学习:手写简单实现Spring的IOC功能(简单实现依赖注入以及单例多例注解)
bilibilidicks的博客
06-28 401
选择quickstart进行创建即可，除了测试类无需引入其他jar包坐标只需引入junit即可 ，方便后续测试容器构造器部分代码，为了实现方便，未对扫描包的字节码文件做递归扫描，只扫描一层，后续可改为递归扫描包内字节码文件。Spring的IOC容器有一个重要方法：getBean方法，此方法利用的beanDefinition对象在IOC初始化过程中进行构建，方便getBean调用，减少其代码量。扫包过程中获取到的单例池对象在创建完毕后再逐一放入singletonObjMap中。 BeanDefinit
Spring框架深度解析——官方指南
2. **控制反转(Inversion of Control, IoC)**：与DI密切相关，IoC意味着应用程序不再控制对象的创建和管理，而是将这些责任交给Spring框架。这降低了组件间的耦合度。 3. **模块(Core Container)**：包括...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值