Java框架 Spring5--IOC

1. IOC的概念和原理

1.1 什么是 IOC

        （1）控制反转，把对象创建和对象之间的调用过程，交给 Spring 进行管理

        （2）使用 IOC 目的：为了耦合度降低

        （3）做入门案例就是 IOC 实现

1.2 IOC 底层原理（xml 解析、工厂模式、反射）

1.2.1 原始方式和工厂模式的对象创建和对象之间的调用过程

1.2.2 IOC的对象创建和对象之间的调用过程

2. IOC 接口

1、IOC 思想基于 IOC 容器完成，IOC 容器底层就是对象工厂

2、Spring 提供 IOC 容器实现两种方式：（两个接口）

（1） BeanFactory ：IOC 容器基本实现，是 Spring 内部的使用接口，不提供开发人员进行使用

*特点：加载配置文件时候不会创建对象，在获取对象（使用）才去创建对象

（2） ApplicationContext ：BeanFactory 接口的子接口，提供更多更强大的功能，一般由开发人员进行使用

* 特点：加载配置文件时候就会把在配置文件对象进行创建

3、ApplicationContext 接口有实现类

3. IOC 操作 Bean 管理（基于 xml 方式）

3.1 IOCBean 管理（概念）

1、什么是 Bean 管理

        Bean 管理指的是两个操作

                （1）Spring 创建对象

                （2）Spirng 注入属性

2、Bean 管理操作有两种方式

         （1）基于 xml 配置文件方式实现

        （2）基于注解方式实现

3.2 IOC操作 Bean管理（基于 xml 方式）

3.2.1 基于 xml 方式创建对象

（1）在 spring 配置文件中，使用 bean 标签，标签里面添加对应属性，就可以实现对象

         创建

（2）在 bean 标签有很多属性，介绍常用的属性

        * id 属性：唯一标识

        * class 属性：类全路径（包类路径）

（3）创建对象时候，默认也是执行无参数构造方法完成对象创建

3.2.2 基于 xml 方式注入属性

DI ：依赖注入，就是注入属性

DI是IOC中的一种具体实现

DI需要在创建对象的基础上实现的

3.2.3 注入方式1：使用 set 方法进行注入

1.创建类，定义属性和对应的 set 方法


public class Book {
    private String bname;
    private String bauthor;
 
    public void setBname(String bname) {
        this.bname = bname;
    }
 
    public void setBauthor(String bauthor) {
        this.bauthor = bauthor;
    }
 
    @Override
    public String toString() {
        return "Book{" +
                "bname='" + bname + '\'' +
                ", bauthor='" + bauthor + '\'' +
                '}';
    }
}

2. 在 spring 配置文件配置对象创建，配置属性注入


    
    <bean id="book" class="com.chenyixin.spring5.demo_2_ioc.pojo.Book">
        
        <property name="bname" value="Java从入门到放弃"/>
        <property name="bauthor" value="张三"/>
    bean>

3. 测试：


public class Test {
 
    @org.junit.Test
    public void test1() {
        // 1 加载 spring 配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("demo2_ioc.xml");
 
        // 2 获取配置创建的对象
        Book book = context.getBean("book", Book.class);
 
        System.out.println(book.toString());
    }
}

4. 结果：

3.2.4 注入方式2：使用有参数构造进行注入

1. 创建类，定义属性，创建属性对应有参数构造方法


public class Orders {
    private String oName;
    private String oAddress;
 
    public Orders(String oName, String oAddress) {
        this.oName = oName;
        this.oAddress = oAddress;
    }
 
    @Override
    public String toString() {
        return "Orders{" +
                "oName='" + oName + '\'' +
                ", oAddress='" + oAddress + '\'' +
                '}';
    }
}

2. 在 spring 配置文件中进行配置


    <bean id="orders" class="com.chenyixin.spring5.demo_2_ioc.pojo.Orders">
        
        <constructor-arg name="oName" value="A1111"/>
        <constructor-arg name="oAddress" value="China"/>
        
        
    bean>

3.测试


public void test2() {
        // 1 加载 spring 配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("demo2_ioc.xml");
 
        // 2 获取配置文件创建的对象
        Orders orders = context.getBean("orders", Orders.class);
 
        System.out.println(orders.toString());
    }

4. 结果：

3.2.5 p 名称空间注入

使用 p 名称空间注入，可以简化基于 xml 配置方式

1. 添加 p 名称空间在配置文件中

2. 代码示例：

创建类


public class User {
    private Integer id;
    private String name;
 
    public void setId(Integer id) {
        this.id = id;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

xml配置：


<beans xmlns="http://www.springframework.org/schema/beans"
	   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	   xmlns:p="http://www.springframework.org/schema/p"
	   xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">
 
	
 
	<bean id="user" class="com.chenyixin.spring5.demo_2_ioc.pojo.User" p:id="1" p:name="张三"/>
 
beans>

测试：


@org.junit.Test
    public void test3() {
        ApplicationContext context = new ClassPathXmlApplicationContext("demo2_ioc.xml");
 
        User user = context.getBean("user", User.class);
 
        System.out.println(user.toString());
    }

结果：

3.3 IOC 操作 Bean 管理（xml 注入其他类型属性）

3.3.1 字面量

（1）null 值

< property name= "address" >

< null />

property >

（2）属性值包含特殊符号

< property name= "address" >

< value >>]]> value >

property >

代码示例：

创建类：


public class Student1 {
    private Integer id;
    private String name;
    private String address;
 
    public Student1(Integer id, String name, String address) {
        this.id = id;
        this.name = name;
        this.address = address;
    }
 
    @Override
    public String toString() {
        return "Student1{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}

xml配置


    <bean id="student1" class="com.chenyixin.spring5.demo_2_ioc.pojo.Student1">
		<constructor-arg name="id">
			<null/>
		constructor-arg>
		<constructor-arg name="name" value="<张三>"/>
		<constructor-arg name="address">
			<value>>]]>value>
		constructor-arg>
	bean>

测试：


@org.junit.Test
    public void test4() {
        ApplicationContext context = new ClassPathXmlApplicationContext("demo2_ioc.xml");
 
        Student1 student1 = context.getBean("student1", Student1.class);
 
        System.out.println(student1.toString());
    }

结果：

3.3.2 注入属性-外部 bean

需求：

（1）创建两个类 service 类和 dao 类

（2）在 service 调用 dao 里面的方法

（3）在 spring 配置文件中进行配置

代码示例：

创建类：


public interface UserDao {
    public void update();
}
public class UserDaoImpl  implements UserDao {
    @Override
    public void update() {
        System.out.println(" 这是 实现了UserDao接口的UserDaoImpl类 的update方法！！！  ");
    }
}


public class UserService {
    private UserDao userDao;
 
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
 
    public void add() {
        System.out.println(" 这是UserService类的 add 方法");
        userDao.update();
    }
}

配置xml文件：


    
	<bean id="userDaoImpl" class="com.chenyixin.spring5.demo_2_ioc.dao.impl.UserDaoImpl"/>
	<bean id="userService" class="com.chenyixin.spring5.demo_2_ioc.service.UserService">
		
		
		<property name="userDao" ref="userDaoImpl"/>
	bean>

测试：


@org.junit.Test
    public void test5() {
        ApplicationContext context = new ClassPathXmlApplicationContext("demo2_ioc.xml");
 
        UserService userService = context.getBean("userService", UserService.class);
 
        userService.add();
    }

结果：

3.3.3 注入属性-内部 bean

需求：

（1）一对多关系：部门和员工

一个部门有多个员工，一个员工属于一个部门

部门是一，员工是多

（2）在实体类之间表示一对多关系，员工表示所属部门，使用对象类型属性进行表示

( 3 ）在 spring 配置文件中进行配置

代码示例：

1. 创建类


// 部门类
public class Dept {
    private String dname;
 
    public void setDname(String dname) {
        this.dname = dname;
    }
 
    @Override
    public String toString() {
        return "Dept{" +
                "dname='" + dname + '\'' +
                '}';
    }
}
 
// 员工类
public class Emp {
    private String name;
    private String gender;
    private Dept dept;
 
    public void setName(String name) {
        this.name = name;
    }
 
    public void setGender(String gender) {
        this.gender = gender;
    }
 
    public void setDept(Dept dept) {
        this.dept = dept;
    }
 
    @Override
    public String toString() {
        return "Emp{" +
                "name='" + name + '\'' +
                ", gender='" + gender + '\'' +
                ", dept=" + dept +
                '}';
    }
}

2. 在 spring 配置文件中进行配置

这里学习内部Bean，所以使用内部Bean，但推荐使用外部Bean，可读性高


    
	<bean id="emp" class="com.chenyixin.spring5.demo_2_ioc.pojo.Emp">
		
		<property name="name" value="张三"/>
		<property name="gender" value="女"/>
		
		<property name="dept">
			<bean id="dept" class="com.chenyixin.spring5.demo_2_ioc.pojo.Dept">
				<property name="dname" value="安保部"/>
			bean>
		property>
	bean>

3.测试：


 @org.junit.Test
    public void test6() {
        ApplicationContext context = new ClassPathXmlApplicationContext("demo2_ioc.xml");
 
        Emp emp = context.getBean("emp", Emp.class);
 
        System.out.println(emp.toString());
    }

4.结果：

3.3.4 注入属性-级联赋值

使用上个例子

代码示例：

写法一：


<bean id="emp" class="com.chenyixin.spring5.demo_2_ioc.pojo.Emp">
   
   <property name="name" value="张三"/>
   <property name="gender" value="女"/>
   
   <property name="dept" ref="dept"/>
bean>
 
<bean id="dept" class="com.chenyixin.spring5.demo_2_ioc.pojo.Dept">
   <property name="dname" value="财务部"/>
bean>

结果：

写法2：

1.先给dept属性加个get方法


public Dept getDept() {
        return dept;
    }

2.编写配置文件：


	<bean id="emp" class="com.chenyixin.spring5.demo_2_ioc.pojo.Emp">
		
		<property name="name" value="张三"/>
		<property name="gender" value="女"/>
		
		<property name="dept" ref="dept"/>
		<property name="dept.dname" value="技术部"/>
	bean>
 
	<bean id="dept" class="com.chenyixin.spring5.demo_2_ioc.pojo.Dept">
		<property name="dname" value="财务部"/>
	bean>

结果：

3.3.5 小结（个人理解）

1. property，constructor-arg使用双标签时，两标签之间所放入的标签（转义标签除外）

可当成该属性的value值

2. 级联赋值可当成需要赋值的外部Bean

3. 注入属性对象时，需使用ref属性，而不是使用value属性（使用内部级联除外）

4. 在注入属性对象时，推荐使用级联赋值方式或外部Bean方式

3.4 IOC 操作 Bean 管理（xml 注入数组、集合属性）

3.4.1 xml 注入数组、集合属性

需求：

1、注入数组类型属性

2、注入 List 集合类型属性

3、注入 Set 集合类型属性

4、注入 Map 集合类型属性

代码示例：

1. 创建类


public class Student {
    // 1 数组类型的属性
    private String[] arr;
    // 2 List类型的属性
    private List list;
    // 3 Set类型的属性
    private Set set;
    // 4 Map类型的属性 map;
    private Map map;
 
    public Student(String[] arr, List list, Set set, Map map) {
        this.arr = arr;
        this.list = list;
        this.set = set;
        this.map = map;
    }
 
    public void test(){
        System.out.println(Arrays.toString(arr));
        System.out.println(list);
        System.out.println(set);
        System.out.println(map);
    }
}

2. xml配置文件编写


<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="student" class="com.chenyixin.spring5.demo_3_ioc_collection.collection.Student">
		<constructor-arg name="arr">
			
			<array>
				<value>Javavalue>
				<value>pythonvalue>
			array>
		constructor-arg>
		<constructor-arg name="list">
			
			<list>
				<value>张三value>
				<value>小三value>
			list>
		constructor-arg>
		<constructor-arg name="set">
			
			<set>
				<value>黄焖鸡value>
				<value>蛋炒饭value>
			set>
		constructor-arg>
		<constructor-arg name="map">
			
			<map>
				<entry key="Java" value="90"/>
				<entry key="python" value="85"/>
			map>
		constructor-arg>
	bean>
beans>

3.测试


public class Test {
    @org.junit.Test
    public void testStudent() {
        ApplicationContext context = new ClassPathXmlApplicationContext("demo3_ioc_colliction.xml");
 
        Student student = context.getBean("student", Student.class);
        student.test();
    }
}

4.结果：

3.4.2 在集合里面设置对象类型值

代码示例：

1. 创建类


// 图书类
// 图书类
public class Book {
    private Integer id;
    private String name;
 
    public Integer getId() {
        return id;
    }
 
    public String getName() {
        return name;
    }
 
    public void setId(Integer id) {
        this.id = id;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    @Override
    public String toString() {
        return "Book{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}


 
// 书柜类
public class Books {
    private Book[] arr;
    private List list;
    private Set set;
    private Map map;
 
 
    public Book[] getArr() {
        return arr;
    }
 
    public void setArr(Book[] arr) {
        this.arr = arr;
    }
 
    public List getList() {
        return list;
    }
 
    public void setList(List list) {
        this.list = list;
    }
 
    public Set getSet() {
        return set;
    }
 
    public void setSet(Set set) {
        this.set = set;
    }
 
    public Map getMap() {
        return map;
    }
 
    public void setMap(Map map) {
        this.map = map;
    }
    public void test(){
        System.out.println(Arrays.toString(arr));
        System.out.println(list);
        System.out.println(set);
        System.out.println(map);
    }
}

2. 编写xml配置文件：


<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="book1" class="com.chenyixin.spring5.demo_3_ioc_collection.collection.Book">
		<property name="id" value="111"/>
		<property name="name" value="java从入门到放弃"/>
	bean>
	<bean id="book2" class="com.chenyixin.spring5.demo_3_ioc_collection.collection.Book">
		<property name="id" value="222"/>
		<property name="name" value="c从入门到入土"/>
	bean>
	<bean id="book3" class="com.chenyixin.spring5.demo_3_ioc_collection.collection.Book">
		<property name="id" value="333"/>
		<property name="name" value="c++从入门到入坟"/>
	bean>
 
	
	<bean id="books" class="com.chenyixin.spring5.demo_3_ioc_collection.collection.Books">
		<property name="arr">
			<array>
				<ref bean="book1"/>
				<ref bean="book3"/>
			array>
		property>
		<property name="list">
			<list>
				<ref bean="book1"/>
				<ref bean="book2"/>
				<ref bean="book3"/>
			list>
		property>
		<property name="set">
			<set>
				<ref bean="book2"/>
				<ref bean="book3"/>
			set>
		property>
		<property name="map">
			<map>
				<entry key-ref="book1" value="28.8"/>
				<entry key-ref="book2" value="88.8"/>
				<entry key-ref="book3" value="888.8"/>
			map>
		property>
	bean>
beans>

3. 测试：


@org.junit.Test
    public void testBooks() {
        ApplicationContext context = new ClassPathXmlApplicationContext("demo3_ioc_colliction2.xml");
        Books books = context.getBean("books", Books.class);
        books.test();
    }

4.结果：


[Book{id=111, name='java从入门到放弃'}, Book{id=333, name='c++从入门到入坟'}]
[Book{id=111, name='java从入门到放弃'}, Book{id=222, name='c从入门到入土'}, Book{id=333, name='c++从入门到入坟'}]
[Book{id=222, name='c从入门到入土'}, Book{id=333, name='c++从入门到入坟'}]
{Book{id=111, name='java从入门到放弃'}=28.8, Book{id=222, name='c从入门到入土'}=88.8, Book{id=333, name='c++从入门到入坟'}=888.8}

3.4.3 把集合注入部分提取出来

1. 在 spring 配置文件中引入名称空间 util

红色部分为添加部分

2.xml配置文件代码：


<beans xmlns="http://www.springframework.org/schema/beans"
	   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	   xmlns:util="http://www.springframework.org/schema/util"
	   xsi:schemaLocation=
			   "http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
				http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">
 
 
	
	<bean id="book1" class="com.chenyixin.spring5.demo_3_ioc_collection.collection.Book">
		<property name="id" value="111"/>
		<property name="name" value="java从入门到放弃"/>
	bean>
	<bean id="book2" class="com.chenyixin.spring5.demo_3_ioc_collection.collection.Book">
		<property name="id" value="222"/>
		<property name="name" value="c从入门到入土"/>
	bean>
	<bean id="book3" class="com.chenyixin.spring5.demo_3_ioc_collection.collection.Book">
		<property name="id" value="333"/>
		<property name="name" value="c++从入门到入坟"/>
	bean>
 
	
	<util:list id="list">
		<ref bean="book1"/>
		<ref bean="book3"/>
	util:list>
	<util:set id="set">
		<ref bean="book2"/>
		<ref bean="book3"/>
	util:set>
	<util:map id="map">
		<entry key-ref="book1" value="39.99"/>
		<entry key-ref="book2" value="99.99"/>
		<entry key-ref="book3" value="999.99"/>
	util:map>
 
	
	<bean id="books2" class="com.chenyixin.spring5.demo_3_ioc_collection.collection.Books">
		<property name="arr">
			<array>
				<ref bean="book1"/>
				<ref bean="book3"/>
			array>
		property>
		<property name="list" ref="list"/>
		<property name="set" ref="set"/>
		<property name="map" ref="map"/>
	bean>
beans>

3.测试：


@org.junit.Test
    public void testBooks2() {
        ApplicationContext context = new ClassPathXmlApplicationContext("demo3_ioc_colliction3.xml");
        Books books2 = context.getBean("books2", Books.class);
        books2.test();
    }

4.结果：


[Book{id=111, name='java从入门到放弃'}, Book{id=333, name='c++从入门到入坟'}]
[Book{id=111, name='java从入门到放弃'}, Book{id=333, name='c++从入门到入坟'}]
[Book{id=222, name='c从入门到入土'}, Book{id=333, name='c++从入门到入坟'}]
{Book{id=111, name='java从入门到放弃'}=39.99, Book{id=222, name='c从入门到入土'}=99.99, Book{id=333, name='c++从入门到入坟'}=999.99}

3.5 IOC 操作 Bean 管理（FactoryBean）

1、Spring 有两种类型 bean，一种普通 bean，另外一种工厂 bean（FactoryBean）

2、普通 bean：在配置文件中定义 bean 类型就是返回类型

3、工厂 bean：在配置文件定义 bean 类型可以和返回类型不一样

       工厂Bean可以返回普通类型的Bean，降低普通Bean与调用者的耦合度

        第一步创建类，实现接口 FactoryBean，让这个类作为工厂 bean

        第二步实现接口里面的方法，在实现的方法中定义返回的 bean 类型

代码示例：

1.创建类，实现接口 FactoryBean，让这个类作为工厂 bean，并实现getObject方法


// 创建工厂Bean
public class MyBean implements FactoryBean {
    @Override
    //定义返回 bean ：要与泛型一致
    public Book getObject() throws Exception {
        Book book = new Book();
        book.setId(111);
        book.setName("aaa");
        return book;
    }
 
    @Override
    public Class getObjectType() {
        return null;
    }
 
    @Override
    public boolean isSingleton() {
        return FactoryBean.super.isSingleton();
    }
}

2. 编写xml配置文件

<bean id="myBean" class="com.chenyixin.spring5.demo_3_ioc_collection.factorybean.MyBean"/>

3.测试：


@Test
    public void testMyBean() {
        ApplicationContext context = new ClassPathXmlApplicationContext("demo3_ioc_factorybean.xml");
        Book book = context.getBean("myBean", Book.class);
        System.out.println(book);
    }

4.结果：

3.6 IOC 操作 Bean 管理（bean 作用域）

在 Spring 里面，设置创建 bean 实例是单实例还是多实例

3.6.1 在 Spring 里面，设置创建 bean 实例在默认情况下，bean 是单实例对象

代码验证：

1.创建类：


public class Person {
    private String name;
 
    public void setName(String name) {
        this.name = name;
    }
}

2.xml代码：


    <bean id="person" class="com.chenyixin.spring5.demo_3_ioc_collection.factorybean.Person">
		<property name="name" value="张三"/>
	bean>

3.验证：


@Test
    public void testPerson() {
        ApplicationContext context = new ClassPathXmlApplicationContext("demo3_ioc_factorybean.xml");
        Person person1 = context.getBean("person", Person.class);
        Person person2 = context.getBean("person", Person.class);
        System.out.println(person1);
        System.out.println(person2);
    }

4. 结果：

Person对象实例的地址值相同，说明这是单例对象

3.6.2 设置单实例还是多实例

（1）在 spring 配置文件 bean 标签里面有属性（scope）用于设置单实例还是多实例

（2）scope 属性值

singleton（默认值），表示是单实例对象

prototype，表示是多实例对象

request, 表示一次请求域（了解）

session, 表示一个会话域（了解）

代码示例：

1.更改xml配置文件：


<bean id="person" class="com.chenyixin.spring5.demo_3_ioc_collection.factorybean.Person" scope="prototype">
		<property name="name" value="张三"/>
	bean>

2. 测试：


@Test
    public void testPerson() {
        ApplicationContext context = new ClassPathXmlApplicationContext("demo3_ioc_factorybean.xml");
        Person person1 = context.getBean("person", Person.class);
        Person person2 = context.getBean("person", Person.class);
        System.out.println(person1);
        System.out.println(person2);
    }

3.结果：

Person对象实例的地址值不相同，说明这是多例对象

3.7 IOC 操作 Bean 管理（bean 生命周期）

生命周期就是从对象创建到对象销毁的过程

3.7.1 bean 生命周期

（ 1 ）通过构造器创建 bean 实例（无参数构造）

（2）为 bean 的属性设置值和对其他 bean 引用（调用 set 方法）

（3）调用 bean 的初始化的方法（需要进行配置初始化的方法）

（4） bean 可以使用了（对象获取到了）

（5）当容器关闭时候，调用 bean 的销毁的方法（需要进行配置销毁的方法）

如果创建的是有参构造器的实例对象，则第一二步合成一步，共四步

3.7.2 演示 bean 生命周期

1.创建类


 
public class Order {
    private String oname;
 
    public Order() {
        System.out.println("第一步 执行无参数构造创建 bean 实例");
    }
 
    public void setOname(String oname) {
        this.oname = oname;
        System.out.println("第二步 调用 set 方法设置属性值");
    }
 
    // 初始化方法
    public void initMethod() {
        System.out.println("第三步 执行初始化的方法");
    }
 
    // 销毁方法
    public void destroyMethod() {
        System.out.println("第五步 执行销毁的方法");
    }
}

2.编写xml文件


	
	<bean id="order" class="com.chenyixin.spring5.demo_3_ioc_collection.bean.Order"
		  init-method="initMethod"
		  destroy-method="destroyMethod">
		<property name="oname" value="手机"/>
	bean>

3.演示：


@Test
    public void testOrder() {
        ApplicationContext context = new ClassPathXmlApplicationContext("demo3_ioc_bean.xml");
        Order order = context.getBean("order", Order.class);
        System.out.println("第四步 获取创建 bean 实例对象");
        System.out.println(order);
 
        // 对象需要手动销毁
        // close方法是 ClassPathXmlApplicationContext 中方法
        ((ClassPathXmlApplicationContext)context).close();
 
    }

4.结果：

3.7.3 添加 bean 的后置处理器，bean 生命周期+2步

（1）通过构造器创建 bean 实例（无参数构造）

（2）为 bean 的属性设置值和对其他 bean 引用（调用 set 方法）

（3）把 bean 实例传递 bean 后置处理器的方法 postProcessBeforeInitialization

（4）调用 bean 的初始化的方法（需要进行配置初始化的方法）

（5）把 bean 实例传递 bean 后置处理器的方法 postProcessAfterInitialization

（6）bean 可以使用了（对象获取到了）

（7）当容器关闭时候，调用 bean 的销毁的方法（需要进行配置销毁的方法）

3.7.4 如何添加bean 的后置处理器

1. 创建类，实现接口 BeanPostProcessor，创建后置处理器

2. 实现 BeanPostProcessor 中的 postProcessBeforeInitialization 方法与 postProcessAfterInitialization 方法

3. 在配置文件中创建该类的 bean标签，因为该类实现接口 BeanPostProcessor，使该类成为了后置处理器，该类的 bean标签会对其所在的xml配置文件中的所有bean标签的类添加后置处理器

3.7.5 演示添加后置处理器效果

1. 创建后置处理器类


public class MyBeanPost implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("在初始化之前执行的方法");
        return bean;
    }
 
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("在初始化之后执行的方法");
        return bean;
    }
}

2. 在xml配置文件中添加后置处理器


	
	<bean id="order" class="com.chenyixin.spring5.demo_3_ioc_collection.bean.Order"
		  init-method="initMethod"
		  destroy-method="destroyMethod">
		<property name="oname" value="手机"/>
	bean>
	<bean id="myBeanPost" class="com.chenyixin.spring5.demo_3_ioc_collection.bean.MyBeanPost"/>

3.测试：


 @Test
    public void testOrder() {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("demo3_ioc_bean.xml");
        Order order = context.getBean("order", Order.class);
        System.out.println("第四步 获取创建 bean 实例对象");
        System.out.println(order);
 
        // 对象需要手动销毁
        // close方法是 ClassPathXmlApplicationContext 中方法
        context.close();
    }

4.结果：

3.8 IOC 操作 Bean 管理（xml 自动装配）

3.8.1 什么是自动装配

自动装配 :就是根据指定装配规则（属性名称或者属性类型），Spring 自动将匹配的bean对象属性值进行注入

就是对类中的对象属性值自动注入

Spring IOC容器可以自动装配Bean，需要做的是在的autowire属性里面指定自动装配的模式；
        byType（根据类型自动装配）,若在IOC容器中有多个与目标Bean类型一致的bean，在这种情况下，Spring将无法判断哪个Bean最合适该属性，所以不能执行自动装配。
        byName（根据名称自动装配），必须将目标bean的名称和属性名设置的完全相同；

        constructor（通过构造器自动装配），当bean中存在多个构造器时候，此种自动装配方式将会很复杂（不推荐使用）。

3.8.2 演示自动装配过程

1. 创建bean类


public class Dept {
    private Integer did;
    private String dname;
 
    public void setDid(Integer did) {
        this.did = did;
    }
 
    public void setDname(String dname) {
        this.dname = dname;
    }
 
    @Override
    public String toString() {
        return "Dept{" +
                "did=" + did +
                ", dname='" + dname + '\'' +
                '}';
    }
}


public class Emp {
    private Integer eid;
    private String ename;
    private Dept dept;
 
    public void setEid(Integer eid) {
        this.eid = eid;
    }
 
    public void setEname(String ename) {
        this.ename = ename;
    }
 
    public void setDept(Dept dept) {
        this.dept = dept;
    }
 
    @Override
    public String toString() {
        return "Emp{" +
                "eid=" + eid +
                ", ename='" + ename + '\'' +
                ", dept=" + dept +
                '}';
    }
}

2. 编写配置文件


<beans xmlns="http://www.springframework.org/schema/beans"
	   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	   xmlns:p="http://www.springframework.org/schema/p"
	   xsi:schemaLocation="http://www.springframework.org/schema/beans 
http://www.springframework.org/schema/beans/spring-beans.xsd">
 
	<bean id="dept" class="com.chenyixin.spring5.demo_3_ioc_collection.auto.Dept"
		  p:did="100" p:dname="技术部"/>
	
	<bean id="emp" class="com.chenyixin.spring5.demo_3_ioc_collection.auto.Emp"
		  p:eid="005" p:ename="王五" p:dept-ref="dept">
	bean>
 
	
	
	<bean id="emp" class="com.chenyixin.spring5.demo_3_ioc_collection.auto.Emp" 
		  p:eid="005" p:ename="王五" autowire="byName"/>
	
	
	<bean id="emp" class="com.chenyixin.spring5.demo_3_ioc_collection.auto.Emp" 
		p:eid="005" p:ename="王五" autowire="byType"/>
beans>

3.测试


@org.junit.Test
    public void test() {
        ApplicationContext context = new ClassPathXmlApplicationContext("demo3_ioc_auto.xml");
        Emp emp = context.getBean("emp", Emp.class);
        System.out.println(emp);
    }

4.结果：

3.8.3 XML配置里面Bean自动装配的缺点

        在Bean配置文件里面设置autowire进行自动装配将会装配Bean的所有属性，然而，若只希望装配个别属性的时候，autowire属性就不够灵敏了；

        autowire属性要么根据类型自动装配，要么根据名称自动装配，不能两者兼而得之；

        一般情况下，在实际的项目中，很少使用自动装配的功能，因为和自动装配功能所带来的的好处比起来，明确清晰的配置文档更有说服力一些。

3.9 IOC 操作 Bean 管理(外部属性文件)

        在很多时候，我们的类中属性可能不止一个，那么我们按照xml方式进行配置的时候就需要多次使用property标签进行属性的注入，一旦属性多了，使用起来就会很麻烦。

        那么我们可以将一些固定的值提前配置好，使用时直接引用就行。

        常见的就是针对数据库操作时的连接！我们可以将数据库名称、用户名、密码、url等提前配置好，然后使用的时候直接引入即可。（我们这边就以德鲁伊为例）

前提准备：引入德鲁伊连接池依赖 jar 包

3.9.1 直接配置数据库信息


	<bean id="driverClassName" class="com.alibaba.druid.pool.DruidDataSource">
		<property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
		<property name="url" value="jdbc:mysql://localhost:3306/userDb"/>
		<property name="username" value="root"/>
		<property name="password" value="root"/>
	bean>

3.9.2 把外部 properties 属性文件引入到 spring 配置文件中

1. 创建外部属性文件，properties 格式文件，写数据库信息

2. 引入 context 名称空间（操作与之前util相同）

红色部分为添加的部分

2. 编写xml文件

在 spring 配置文件使用标签引入外部属性文件


	<context:property-placeholder location="jdbc.properties"/>
	
	<bean id="driverClassName" class="com.alibaba.druid.pool.DruidDataSource">
		<property name="driverClassName" value="${prop.driverClassName}"/>
		<property name="url" value="${prop.url}"/>
		<property name="username" value="${prop.username}"/>
		<property name="password" value="${prop.password}"/>
	bean>

3.9.3 通过属性文件实现属性注入

org.springframework.beans.factory.config.PropertyPlaceholderConfigurer 类可以将 .properties(key/value形式)文件中一些动态设定的值(value)，在XML中替换为占位该键($key$)的值，.properties文件可以根据客户需求，自定义一些相关的参数，这样的设计可提供程序的灵活性。

1. 创建外部属性文件，properties 格式文件

2. 创建类


public class Person {
    private Integer id;
    private String name;
    private String sex;
    
    public void setId(Integer id) {
        this.id = id;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public void setSex(String sex) {
        this.sex = sex;
    }
 
    @Override
    public String toString() {
        return "Person{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                '}';
    }
}

3.编写xml文件


<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
	   							http://www.springframework.org/schema/beans/spring-beans.xsd
						   http://www.springframework.org/schema/context
	   							http://www.springframework.org/schema/context/spring-context.xsd">
 
	
	<bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
		<property name="locations">
			<list>
				<value>person.propertiesvalue>
			list>
		property>
	bean>
 
	<bean id="person" class="com.chenyixin.spring5.demo_4_ioc_druid.Person">
		<property name="id" value="${prop.id}"/>
		<property name="name" value="${prop.name}"/>
		<property name="sex" value="${prop.sex}"/>
	bean>
 
beans>

4.测试：


@Test
    public void test() {
        ApplicationContext context = new ClassPathXmlApplicationContext("demo4_ioc_person.xml");
        Person person = context.getBean("person", Person.class);
        System.out.println(person);
    }

5.结果：

4.IOC 操作 Bean 管理(基于注解方式)

4.1 什么是注解

（1）注解是代码特殊标记，格式：@注解名称(属性名称=属性值, 属性名称=属性值..)

（2）使用注解，注解作用在类上面，方法上面，属性上面

（3）使用注解目的：简化 xml 配置

4.2 Spring 针对 Bean 管理中创建对象提供注解

⑴ @Conponent：通用注解

   ⑵ @Service：通常用于业务层注释

   ⑶ @Contruller：通常用于Web层注释

   ⑷ @Repository：通常用于持久层（Dao层）注释

        * 上面四个注解功能是一样的，都可以用来创建 bean 实例,放哪都一样，只是可以增加可读性

4.3 基于注解方式实现对象创建

1. 引入依赖

2. 在xml文件中开启组件扫描

开启组件扫描，XML文件识别规定路径下的注释内容
如果扫描多个包，多个包使用逗号隔开，也可以直接扫描包的上层目录。


<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
	   http://www.springframework.org/schema/beans/spring-beans.xsd
	   http://www.springframework.org/schema/context
	   http://www.springframework.org/schema/context/spring-context.xsd">
 
	
	
	<context:component-scan base-package="com.chenyixin.spring5"/>
beans>

3. 创建类，在类上面添加创建对象注解

在需要用注解方式创建的类上面加上可被XML解析识别的注解

Spring针对Bean管理中创建对象提供的注解的value属性是用来标识当前类(相当于bean标签中的id值)，默认值是类名称的第一个字母小写


// @Service(value = "userService")
@Service  // 相当于 
public class UserService {
    public void add() {
        System.out.println("我是 UserService 的 add 方法！！！");
    }
}

4. 测试：


@Test
    public void testUserService() {
        ApplicationContext context = new ClassPathXmlApplicationContext("demo5_ioc2.xml");
        UserService userService = context.getBean("userService", UserService.class);
        userService.add();
    }

5.结果：

4.4 开启组件扫描细节配置

①user-default-filters="false"表示现在不使用默认的filter，使用自己配置的filter，context:include-filter，是指需要扫描的注释


	<context:component-scan base-package="com.chenyixin.spring5" use-default-filters="false">
		<context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
	context:component-scan>

② context:exclude-filter，设置不进行扫描的注释内容


	<context:component-scan base-package="com.chenyixin.spring5">
		<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
	context:component-scan>

4.5 基于注解方式实现属性注入

可以注入属性的标签@Autowired，@Qualifier，@Resource，@Value

4.5.1 @Autowired：根据属性类型进行自动装配

@Autowired：使用在字段上用于根据类型依赖注入，使用该注解定义属性，不需要添加该属性的Set方法

1. 把 service 和 dao 对象创建，在 service 和 dao 类添加创建对象注解

2.在 service 注入 dao 对象，在 service 类添加 dao 类型属性，在属性上面使用注解

代码示例：


public interface UserDao {
    public void update();
}
@Repository
public class UserDaoImpl implements UserDao {
    @Override
    public void update() {
        System.out.println("我是 UserDaoImpl 类的 update 方法");
    }
}


// @Service(value = "userService")
@Service  // 相当于 
public class UserService {
 
    //定义 dao 类型属性
    //不需要添加 set 方法
    //添加注入属性注解
    @Autowired
    private UserDao userDao;
 
    public void add() {
        System.out.println("我是 UserService 的 add 方法！！！");
        userDao.update();
    }
}

测试：


@Test
    public void testUserService() {
        ApplicationContext context = new ClassPathXmlApplicationContext("demo5_ioc2.xml");
        UserService userService = context.getBean("userService", UserService.class);
        userService.add();
    }

结果：

4.5.2 @Qualifier：根据名称进行注入

这个 @Qualifier 注解的使用，和上面 @Autowired 一起使用

⑴@Qualifier注解用来标识是调用哪一个Bean类

⑵注意：需要加载的Bean类也要加上注解，XML加载时才会扫描到他，进行加载

⑶注意：Value值填的是Bean类的注解的唯一标识值，如果未指定，是其Bean类的首字母小写

代码示例：


@Repository(value = "userDaoImpl2")
public class UserDaoImpl2 implements UserDao {
    @Override
    public void update() {
        System.out.println("我是 UserDaoImpl2 类的 update 方法");
    }
}


 
// @Service(value = "userService")
@Service  // 相当于 
public class UserService {
 
    //添加注入属性注解
    @Autowired // 根据类型进行注入
    @Qualifier(value = "userDaoImpl2") //根据名称进行注入
    private UserDao userDao;
 
    public void add() {
        System.out.println("我是 UserService 的 add 方法！！！");
        userDao.update();
    }
}

测试代码同上

结果：

4.5.3 @Resource：可以根据类型注入，可以根据名称注入

@Resource：相当于@autowired+@Qualifier，按照名称进行注入

代码示例：


 
// @Service(value = "userService")
@Service  // 相当于 
public class UserService {
 
    // //添加注入属性注解
    // @Autowired // 根据类型进行注入
    // @Qualifier(value = "userDaoImpl2") //根据名称进行注入
    // private UserDao userDao;
 
    // @Resource // 根据类型进行注入
    @Resource(name="userDaoImpl") //根据名称进行注入
    private UserDao userDao;
 
 
    public void add() {
        System.out.println("我是 UserService 的 add 方法！！！");
        userDao.update();
    }
}

4.5.4 @Value：注入普通类型属性


 
// @Service(value = "userService")
@Service  // 相当于 
public class UserService {
 
    // //添加注入属性注解
    // @Autowired // 根据类型进行注入
    // @Qualifier(value = "userDaoImpl2") //根据名称进行注入
    // private UserDao userDao;
 
    // @Resource // 根据类型进行注入
    @Resource(name="userDaoImpl") //根据名称进行注入
    private UserDao userDao;
 
    @Value(value = "aaa")
    private String name;
 
    public void add() {
        System.out.println("我是 UserService 的 add 方法！！！"+name);
        userDao.update();
    }
}

结果：

4.6 完全注解开发

4.6.1 创建配置类，完全替代XML配置文件

⑴为该类添加注解@Configuration，以示是注解配置类

⑵添加注解@ComponentScan，设置注解扫描路径

代码示例：


@Configuration //作为配置类，替代 xml 配置文件
@ComponentScan(basePackages = {"com.chenyixin.spring5"})
public class SpringConfig {
}

4.6.2 编写测试方法获取IOC容器的语句


@Test
    public void test() {
        ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
        UserService userService = context.getBean("userService", UserService.class);
        userService.add();
    }

结果：

相关阅读:
android 默认开启谷歌定位精准度
 270_JSON_设置xxxValue为一个JSON对象类型且复制上一层value数据到xxxValue中
 【WLAN】Android 13 WIFI 连接流程
 Java—修饰符
 6.9平衡二叉树（LC110-E）
估计流量矩阵的方法
 CAN 通信-底层
 每日一题：2022.11.11最后的简单模拟题
 [CISCN 2019 初赛]Love Math
STM8S系列基于STVD开发，标准外设库函数开发环境搭建
原文地址：https://blog.csdn.net/weixin_65637841/article/details/126140100

Java框架 Spring5--IOC

1. IOC的概念和原理

1.1 什么是 IOC

1.2 IOC 底层原理（xml 解析、工厂模式、反射）

1.2.1 原始方式和工厂模式的对象创建和对象之间的调用过程

1.2.2 IOC的对象创建和对象之间的调用过程

2. IOC 接口

3. IOC 操作 Bean 管理（基于 xml 方式）

3.1 IOCBean 管理（概念）

3.2 IOC操作 Bean管理（基于 xml 方式）

3.2.1 基于 xml 方式创建对象

3.2.2 基于 xml 方式注入属性

3.2.3 注入方式1：使用 set 方法进行注入

3.2.4 注入方式2：使用有参数构造进行注入

3.2.5 p 名称空间注入

3.3 IOC 操作 Bean 管理（xml 注入其他类型属性）

3.3.1 字面量

3.3.2 注入属性-外部 bean

3.3.3 注入属性-内部 bean

3.3.4 注入属性-级联赋值

3.3.5 小结（个人理解）

3.4 IOC 操作 Bean 管理（xml 注入数组、集合属性）

3.4.1 xml 注入数组、集合属性

3.4.2 在集合里面设置对象类型值

3.4.3 把集合注入部分提取出来

3.5 IOC 操作 Bean 管理（FactoryBean）

3.6 IOC 操作 Bean 管理（bean 作用域）

3.6.1 在 Spring 里面，设置创建 bean 实例 在默认情况下，bean 是单实例对象

3.6.2 设置单实例还是多实例

3.7 IOC 操作 Bean 管理（bean 生命周期）

3.7.1 bean 生命周期

3.7.2 演示 bean 生命周期

3.7.3 添加 bean 的后置处理器，bean 生命周期+2步

3.7.4 如何添加bean 的后置处理器

3.7.5 演示添加后置处理器效果

3.8 IOC 操作 Bean 管理（xml 自动装配）

3.8.1 什么是自动装配

3.8.2 演示自动装配过程

3.8.3 XML配置里面Bean自动装配的缺点

3.9 IOC 操作 Bean 管理(外部属性文件)

3.9.1 直接配置数据库信息

3.9.2 把外部 properties 属性文件引入到 spring 配置文件中

3.9.3 通过属性文件实现属性注入

4.IOC 操作 Bean 管理(基于注解方式)

4.1 什么是注解

4.2 Spring 针对 Bean 管理中创建对象提供注解

4.3 基于注解方式实现对象创建

4.4 开启组件扫描细节配置

4.5 基于注解方式实现属性注入

4.5.1 @Autowired：根据属性类型进行自动装配

4.5.2 @Qualifier：根据名称进行注入

4.5.3 @Resource：可以根据类型注入，可以根据名称注入

4.5.4 @Value：注入普通类型属性

4.6 完全注解开发

4.6.1 创建配置类，完全替代XML配置文件

4.6.2 编写测试方法获取IOC容器的语句

3.6.1 在 Spring 里面，设置创建 bean 实例在默认情况下，bean 是单实例对象