spring5-ioc容器-xml解析-操作bean

什么是IOC

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

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

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

IOC底层原理

（1）xml解析，工厂模式，反射

请添加图片描述

(2) IOC过程:

在这里插入图片描述

IOC接口（BeanFactory）

IOC思想基于IOC容器完成，IOC容器底层就是对象工厂
spring提供IOC容器实现两种方式：（两个接口）

（1）BeanFactory：IOC容器基本实现，是spring内部使用的接口，不提供给开发人员使用。
- 加载配置文件时候不会创建对象，在获取对象（使用）才去创建对象
（2）ApplicationContext：BeanFactory接口的子接口，提供更过更强大的功能，一般

由开发人员使用。
- 加载配置文件的时候就会把在配置文件对象进行创建
ApplicationContext接口有实现类

在这里插入图片描述

IOC操作Bean管理（基于xml）

什么是bean管理
- Bean管理指的是两个操作
（1）Spring创建对象

（2）Spring注入属性

Bean管理操作有两种方式

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

<!--      配置User对象创建-->
    <bean id="user" class="spring5.User"></bean>

在配置文件中，使用bean标签，标签里面加对应属性，就可以实现对象创建
在bean标签有很多属性，介绍常用的属性

（1）id属性：唯一标识

（2）class：类全路径（包全路径）

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

（2）基于xml方式注入属性

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

第一种注入方式：使用set方法进行注入

package spring5;

/**
 * 演示使用set方法进行注入属性
 */
public class Book {
      
      
    private String bname;
    private String bauthor;
    //set方法注入
    public void setBname(String bname){
      
      
        this.bname=bname;
    }
    public void setBauthor(String bauthor) {
      
      
        this.bauthor = bauthor;
    }
    public void testBook(){
      
      
        System.out.println(bname+","+bauthor);
    }
}

<bean id="book" class="spring5.Book">
    <property name="bname" value="天龙八部"></property>
    <property name="bauthor" value="金庸"></property>
</bean>

    @Test
    public void testBook(){
      
      
//        加载spring配置文件
        ApplicationContext context=
                new ClassPathXmlApplicationContext("bean1.xml");
//        获取配置创建对象
        Book book=context.getBean("book", Book.class);
        System.out.println(book);
        book.testBook();
    }

第二种注入方式：使用有参构造

public class Orders {
      
      
    private String oname;
    private String address;
    public Orders(String oname, String address) {
      
      
        this.oname = oname;
        this.address = address;
    }
}

<!--    使用有参构造注入属性-->
    <bean id="orders" class="spring5.Orders">
        <constructor-arg name="oname" value="abc"></constructor-arg>
        <constructor-arg name="address" value="陕西省"></constructor-arg>
    </bean>

    @Test
    public void testOrders(){
    
    
//        加载spring配置文件
        ApplicationContext context=
                new ClassPathXmlApplicationContext("bean1.xml");
//        获取配置创建对象
        Orders orders=context.getBean("orders", Orders.class);
        System.out.println(orders);
        orders.testOrders();
    }

第三种注入方式：使用p名称空间注入

（1）使用p名称空间注入，可以简化基于xml配置方式（底层也是set方法注入）

<?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: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="book" class="spring5.Book" p:bname="水浒传" p:bauthor="施耐庵"></bean>

两个尖括号的使用：

<!-- &lt;&lt; &gt;&gt;  两个尖括号-->
<!-- <![CDATA[<<金庸>>]]>-->
<bean id="book" class="spring5.Book">
    <property name="bname" value="&lt;&lt;天龙八部&gt;&gt;"></property>
    <property name="bauthor">
        <value><![CDATA[<<金庸>>]]></value>
    </property>
</bean>

spring5.Book@173ed316
<<天龙八部>>,<<金庸>>

注入属性-外部bean

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

public interface UserDao {
      
      
    void update();
}
public class UserDaoImpi implements UserDao{
      
      

    @Override
    public void update() {
      
      
        System.out.println("dao update..............");
    }
}

public class UserService {
      
      
    //创建UserDao类型的属性，生成set方法
    private UserDao userDao;
    public void setUserDao(UserDao userDao) {
      
      
        this.userDao = userDao;
    }
    public void add(){
      
      
        System.out.println("service add...............");
        //原始方式
//        UserDaoImpi userDaoImpi=new UserDaoImpi();
//        userDaoImpi.update();
          userDao.update();

    }
}

public class UserService {
      
      
    //创建UserDao类型的属性，生成set方法
    private UserDao userDao;
    public void setUserDao(UserDao userDao) {
      
      
        this.userDao = userDao;
    }
    public void add(){
      
      
        System.out.println("service add...............");
        //原始方式
//        UserDaoImpi userDaoImpi=new UserDaoImpi();
//        userDaoImpi.update();
          userDao.update();
    }
}

<?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">
<!--       service和dao对象创建-->
    <bean id="userService" class="spring5.service.UserService">
<!--        注入userDao对象-->
<!--        name属性：类里面有属性名称-->
<!--        ref属性：创建userDao对象bean标签id值-->
        <property name="userDao" ref="userDaoImpi"></property>
     </bean>
    <bean id="userDaoImpi" class="spring5.dao.UserDaoImpi"></bean>

</beans>

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

public class TestBean {
      
      
    @Test
    public void testUserService(){
      
      
//        加载spring配置文件
        ApplicationContext context=
                new ClassPathXmlApplicationContext("bean2.xml");
//        获取配置创建对象
        UserService userservice=context.getBean("userService", UserService.class);
        System.out.println(userservice);
        userservice.add();
    }
}

注入属性-内部bean和级联赋值

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

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

部门是一，员工是多

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

//部门类
public class Dept {
    
    
    private String dname;
    public void setDname(String dname) {
    
    
        this.dname = dname;
    }
}
// 员工类
public class Emp {
    
    
    private String ename;
    private String gender;
    //员工属于某一个部门，使用对象的形式表示
    private  Dept dept;
    public void setDept(Dept dept) {
    
    
        this.dept = dept;
    }
    public void setEname(String ename) {
    
    
        this.ename = ename;
    }
    public void setGender(String gender) {
    
    
        this.gender = gender;
    }
}

    @Test
    public void testDept(){
    
    
//        加载spring配置文件
        ApplicationContext context=
                new ClassPathXmlApplicationContext("bean3.xml");
//        获取配置创建对象
        Emp emp=context.getBean("emp", Emp.class);
        System.out.println(emp);
        emp.add();
    }

（3）在spring配置文件中进行配置（在属性property中还可以设置bean）

<!--       内部bean-->
    <bean id="emp" class="spring5.bean.Emp">
<!--        先设置两个普通的属性-->
        <property name="ename" value="lucy"></property>
        <property name="gender" value="女"></property>
<!--        设置对象属性-->
        <property name="dept">
            <bean id="dept" class="spring5.bean.Dept">
                <property name="dname" value="保安部"></property>
            </bean>
        </property>
    </bean>

（4）注入属性-级联赋值（和内部bean是一样的）

    <!--       内部bean-->
    <bean id="emp" class="spring5.bean.Emp">
        <!--        先设置两个普通的属性-->
        <property name="ename" value="lucy"></property>
        <property name="gender" value="女"></property>
<!--        级联赋值-->
        <property name="dept" ref="dept"></property>
    </bean>
    <bean id="dept" class="spring5.bean.Dept">
        <property name="dname" value="财务部"></property>
    </bean>

    <bean id="emp" class="spring5.bean.Emp">
        <!--        先设置两个普通的属性-->
        <property name="ename" value="lucy"></property>
        <property name="gender" value="女"></property>
<!--        级联赋值-->
        <property name="dept" ref="dept"></property>
        <property name="dept.dname" value="技术部"></property>  //设置get方法这里也可以
    </bean>

IOC操作Bean管理（基于注解）

注入集合属性值

注入数组类型属性
注入List集合类型属性
注入Map集合类型属性
注入Set集合类型属性

（1）创建这些集合并生成set方法

public class Stu {
    
    
    //1.数组类型的属性
    private String[] courses;
    //2.List集合类型属性
    private List<String> list;
    //3.创建一个Map集合属性
    private Map<String,String> map;
    private Set<String> set;

    public void setSet(Set<String> set) {
    
    
        this.set = set;
    }
    public void setList(List<String> list) {
    
    
        this.list = list;
    }
    public void setMap(Map<String, String> map) {
    
    
        this.map = map;
    }
    public void setCourses(String[] courses) {
    
    
        this.courses = courses;
    }
}
    @Test
    public void testCollection(){
    
    
        ApplicationContext context=new ClassPathXmlApplicationContext("bean1.xml");
        Stu stu=context.getBean("stu",Stu.class);
        stu.test();
    }

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

<!--        集合类型属性的注入-->
       <bean id="stu" class="spring5.collectionType.Stu">
           <property name="courses">
               <array>
                   <value>java课程</value>
                   <value>数据库课程</value>
               </array>
           </property>
<!--           list集合-->
           <property name="list">
               <list>
                   <value>张安</value>
                   <value>王五</value>
               </list>
           </property>
<!--           map集合-->
           <property name="map">
               <map>
                   <entry key="张三" value="男"></entry>
                   <entry key="李四" value="女"></entry>
               </map>
           </property>
<!--           set集合-->
           <property name="set">
               <set>
                   <value>mysql</value>
                   <value>redis</value>
               </set>
           </property>
       </bean>

注入集合对象值

（1）在集合里面设置对象类型值

<!--           注入list集合类型，值是对象-->
           <property name="listCouse" >
               <list>
                   <ref bean="couse1" ></ref>
                   <ref bean="couse2" ></ref>
                   <ref bean="couse3" ></ref>
               </list>
           </property>
           
<!--    创建多个couse对象-->
    <bean id="couse1" class="spring5.collectionType.Couse">
        <property name="cname" value="spring框架"></property>
    </bean>
    <bean id="couse2" class="spring5.collectionType.Couse">
        <property name="cname" value="mysql"></property>
    </bean>
    <bean id="couse3" class="spring5.collectionType.Couse">
        <property name="cname" value="java"></property>
    </bean>

（2）把集合注入部分提取出来做一个公共部分

在spring的配置文件中先引入一个名称空间util

<?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:p="http://www.springframework.org/schema/p"
       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">
<!--        集合类型属性的注入-->
</beans>

<!--        集合类型属性的注入-->
        <util:list id="bookList">
            <value>易筋经</value>
            <value>九阴真经</value>
            <value>酒养生功</value>
        </util:list>
<!--    提取lsit集合属性注入使用-->
    <bean id="book" class="spring5.collectionType.Book">
        <property name="list" ref="bookList">
        </property>
    </bean>

IOC操作Bean管理（FactoryBean）

Spring有两种类型Bean，一种普通Bean，另外一种工厂Bean
普通bean ：在配置文件中定义的类型就是文件中返回的类型

工厂bean：定义的类型可以和返回的类型不一样

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

public class Mybean implements FactoryBean<Couse> {
      
      
    //定义返回Bean
    @Override
    public Couse getObject() throws Exception {
      
      
        Couse couse=new Couse();
        couse.setCname("aaaa");
        return couse;
    }
    @Override
    public Class<?> getObjectType() {
      
      
        return null;
    }
}
    @Test
    public void test3(){
      
      
        ApplicationContext context=new 					ClassPathXmlApplicationContext("bean3.xml");
        Couse mybean=context.getBean("myBean", Couse.class);
        System.out.println(mybean);
    }

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

<bean id="myBean" class="factorybean.Mybean.Mybean"></bean>

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

在spring里面，设置创建Bean实例是单实例还是多实例
在spring里面，默认情况下，bean是单实例对象

在这里插入图片描述

拿到的地址是相同的

如何在设置是单实例还是多实例

（1）在spring配置文件中bean标签里面有

（2）scope属性值

第一个值默认值，singleton，表示是单实例

第二个值 prototype，表示是多实例对象
```
<bean id="myBean" class="factorybean.Mybean.Mybean" scope="prototype"></bean>
```

在这里插入图片描述

设置成多实例之后拿到的地址值是不相同的

（3）singleton和prototype区别

第一 singleton单实例，prototype是多实例

第二设置singleton时候，加载spring配置文件时候就会创建实例对象

设置prototype时候，调用getBean方法创建实例对象

IOC操作bean的生命周期：

生命周期

（1）从对象创建到对象销毁的过程

bean生命周期

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

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

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

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

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

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

<bean id="orders" class="factorybean.Mybean.Orders" init-method="initMethod" destroy-method="destroyMethod">
       <property name="oname" value="手机"></property>
</bean>

    @Test
    public void testBean4(){
    
    
//        ApplicationContext context=new ClassPathXmlApplicationContext("bean4.xml");
        //这里直接调用子接口
        ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext("bean4.xml");
        Orders orders=context.getBean("orders", Orders.class);
        System.out.println("第四步 获取创建bean实例对象");
        System.out.println(orders);
        //手动bean实例销毁
//      ((ClassPathXmlApplicationContext) context).close();
        context.close();
    }

运行结果：
第一步，执行无参构造创建bean实例
第二步调用set方法设置属性值
第三步执行初始化的方法
第四步获取创建bean实例对象
factorybean.Mybean.Orders@74d1dc36
第五步执行销毁的方法

bean 的后置处理器，bean的生命周期有七步

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

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

（3）把bean实例传递给bean后置处理器方法
```
postProcessBeforeInitialization
```
（4）调用bean的初始化方法（需要进行配置）

（5）把bean实例传递bean后置处理器的方法
```
postProcessAfterInitialization
```
（6）bean可以使用了(对象获取到了)

（7）当容器关闭时候，调用bean的销毁方法（需要进行配置销毁方法）
演示添加后置处理器效果

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

public class MybeanPsot 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;
    }

}

<!--       后置处理器-->
       <bean id="myBeanPost" class="factorybean.Mybean.MybeanPsot"></bean>

运行结果：

第一步，执行无参构造创建bean实例
第二步调用set方法设置属性值
在初始化之“前”执行的方法
第三步执行初始化的方法
在初始化之“后”执行的方法
第四步获取创建bean实例对象
factorybean.Mybean.Orders@53045c6c
第五步执行销毁的方法

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

什么是自动装配

（1）根据指定装配规则（属性名或者属性类型），Spring自动将匹配的属性值进行注入

演示自动装配过程

（1）根据属性名称自动注入

<!--       后置处理器
           实现自动装配
           bean标签属性autowire，配置自动装配
           autowire属性常用两个值：
           byName根据属性名称注入 ，注入的值和类属性名称一一样
           byType根据属性类型注入，
-->
       <bean id="emp" class="autowire.Emp" autowire="byName">
<!--              <property name="dept" ref="dept"></property>-->
       </bean>
<!--       引入外部bean-->
       <bean id="dept" class="autowire.Dept"></bean>

		// 根据属性类型进行注入,但是有多个类型会报错
       <bean id="emp" class="autowire.Emp" autowire="byType">
<!--              <property name="dept" ref="dept"></property>-->
       </bean>
<!--       引入外部bean-->
       <bean id="dept" class="autowire.Dept"></bean>
</beans>

IOC操作Bean管理（外部属性文件）

直接配置数据库信息

（1）配置德鲁伊连接池

（2）引入德鲁伊连接池依赖jar包

<!--       直接配置连接池-->
       <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
              <property name="driverClassName" value="${com.mysql.jdbc.Driver}"></property>
              <property name="url" value="jdbc:mysql://localhost:3306/userDb"></property>
              <property name="username" value="root"></property>
              <property name="password" value="root"></property>

       </bean>

引入外部属性配置数据库连接池

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

prop.driverClass=com.mysql.jdbc.Driver
prop.url=jdbc:mysql://localhost:3306/userDb
prop.userName=root
prop.password=123456

（2）把外部properties属性文件引入到spring配置文件中

*引入context名称空间

<?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:p="http://www.springframework.org/schema/p"
       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="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
              <property name="driverClassName" value="${com.mysql.jdbc.Driver}"></property>
              <property name="url" value="jdbc:mysql://localhost:3306/userDb"></property>
              <property name="username" value="root"></property>
              <property name="password" value="root"></property>
       </bean>
</beans>