IOC中基于XML的Bean管理

一. 什么是Bean管理

Bean管理是指的Spring创建对象和注入属性两个操作

• 创建对象：

/*一个例子*/
public class testSpring {
    
    
    //新建测试单元
    @Test
    public void testUser(){
    
    
        //1.加载Spring配置文件
        ApplicationContext context=
                new ClassPathXmlApplicationContext("bean1.xml");
        //2.获取创建对象
        User user=context.getBean("user", User.class);
        //3.执行方法
        System.out.println(user);
        user.HelloSpring();
    }
}

• 注入属性需要一一介绍：

Bean管理操作的两种方式

（1）配置文件方式基于XML
（2）注入属性方式

二. IOC Bean管理——基于XML

1. 创建对象

（1）在Spring的配置文件中，用<bean>标签创建对象
（2）<bean>标签的常见属性有：

id属性：类的唯一“别名”属性（name属性也是如此）
class属性：类全路径（包类路径）

//举例子
<!--配置User类的创建-->
<bean id="user" class="com.hello.spring.User"></bean>

（3）创建对象时候，默认也是执行无参数构造方法完成对象创建（如果写了有参构造函数，一定要写午餐构造函数，否则将会无法找到构造函数）

2. 注入属性

（1）set方法注入

在class中写入setElement方法，XML中用<bean>创建对象,<property>初始化属性值
举例子：

• Book对象要写setElement（）方法来设置值

package com.hello.spring;
public class Book {
    
    
    private String bName;
    private String bAuthor;
    //set方法注入
    public void setbName(String name){
    
    
        this.bName=name;
    }
    public void setbAuthor(String author){
    
    
        this.bAuthor=author;
    }
    //测试输出
    public void testDemo(){
    
    
        System.out.println(bName+":"+bAuthor);
    }
}

• XML中用<bean>创建对象,<property>初始化属性值

<!--set方法注入-->
<bean id="book" class="com.hello.spring.Book">
    <property name="bName" value="围城"></property>
    <property name="bAuthor" value="钱钟书"></property>
</bean>

注意，如果没有setElement方法，将会报错

• 测试程序

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

• 测试结果
  

（2）有参构造方法注入

在Class中创建有参构造方法，XML中用<bean>创建对象,<constructor-arg>初始化属性值

举例子

• 创建Order类，创建有参构造方法

package com.hello.spring;
public class Order {
    
    
    private String orderName;
    private String address;
    //Alt+Insert，有参构造
    public Order(String orderName, String address) {
    
    
        this.orderName = orderName;
        this.address = address;
    }
    public void testDemo(){
    
    
        System.out.println(orderName+":"+address);
    }
}

• XML中用<bean>创建对象,<constructor-arg>初始化属性值

<!--有参构造注入-->
<bean id="order" class="com.hello.spring.Order">
    <constructor-arg name="orderName" value="order1"></constructor-arg>
    <constructor-arg name="address" value="South Road"></constructor-arg>
</bean>

• 测试程序

    @Test
    public void testOrder(){
    
    
        //加载配置文件
        ApplicationContext context=new ClassPathXmlApplicationContext("bean1.xml");

        //获取创建对象
        Order order=context.getBean("order",Order.class);

        //调用方法
        System.out.println(order);
        order.testDemo();
    }

（3） p 名称空间注入（了解）

（4）注入字面量

• 注入null值

   <bean id="book" class="com.hello.spring.Book">
       <property name="bName">
           <null></null>
       </property>
   </bean>

• 注入属性值包含特殊符号 转义字符或者CDATA

1 把<>进行转义 &lt; &gt; 
2 把带特殊符号内容写到CDATA
<property name="address"> 
<value><![CDATA[<<南京>>]]></value>
</property>

（5）注入外部bean

• 创建两个类 service 类和 dao类
• 在 service 调用 dao里面的方法
• 在 spring 配置文件中进行配置，用ref属性链接到外部类

Dao类

UserDao类

UserService类：
原始的方法就是直接new一个对象然后进行调用：

这里用Spring的方法来进行调用：set方法注入

package com.hello.spring.service;

import com.hello.spring.dao.UserDao;

public class UserService {
    
    
    private UserDao userDao;

    //set方法注入属性
    public void setUserDao(UserDao userDao){
    
    
        this.userDao=userDao;
    }
    public void add(){
    
    
        System.out.println("Service add........");
        //调用
        userDao.updata();
    }
}

配置XML文件：

    <!--service和dao对象的创建-->
    <bean id="userService" class="com.hello.spring.service.UserService">
        <!--
        注入UserDao对象
        name属性：类里面的属性名称
        ref属性：是创建UserDao对象的bean标签id值，要和UserDao标签的id对应
        -->
        <property name="userDao" ref="userDao"></property>
    </bean>
    <!--注意要class要用实现类-->
    <bean id="userDao" class="com.hello.spring.dao.UserDaoImpl"></bean>

结果：

（6）注入内部Bean和级联赋值

内部Bean方式

• 在<property>标签中添加<bean>标签，在<bean>标签内部注入对象成员的属性值
• 一般还是更倾向于外部bean或者下面的级联的方式注入
  
  

 <bean id="emp" class="com.hello.spring.bean.Emp">
     <property name="ename" value="Jack"></property>
     <property name="gender" value="男"></property>
     <property name="dept">
         <bean id="dept" class="com.hello.spring.bean.Dept">
             <property name="dname" value="技术部门"></property>
         </bean>
     </property>
 </bean>

级联赋值1

• 在 spring 配置文件中进行配置，用ref属性链接到外部类，在外部类中进行注入各自的成员变量
• 外部类要用bean创建，property注入，所以要写入get方法

  <bean id="emp" class="com.hello.spring.bean.Emp">
      <property name="ename" value="Lucy"></property>
      <property name="gender" value="女"></property>
      <property name="dept" ref="dept"></property>
  </bean>
  <bean id="dept" class="com.hello.spring.bean.Dept">
      <property name="dname" value="干事部门"></property>
  </bean>

级联赋值2

• 在 spring 配置文件中进行配置，用ref属性链接到外部类，在外部类中进行注入各自的成员变量
• 再新建一个property，用.访问到外部类的属性值，并且用value进行初始化，所以要再父类中添加get方法以便获取
• 外部类要用bean创建，property注入，所以要写入get方法

        <bean id="emp" class="com.hello.spring.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>
        </bean>
        <bean id="dept" class="com.hello.spring.bean.Dept">
            <property name="dname" value="干事部门"></property>
        </bean>

（7）集合类型的注入

• 新建类，包含私有成员的集合类型

• 数组类型注入

 <!--数组类型注入-->
 <property name="course">
     <!--也可以用list标签-->
     <array>
         <value>java</value>
         <value>SQL</value>
     </array>
 </property>

• list类型注入

<!--list类型注入-->
<property name="lists">
    <list>
        <value>Jack</value>
        <value>Lucy</value>
    </list>
</property>

• map类型注入

<!--map类型注入-->
<property name="maps">
    <map>
        <entry key="JAVA" value="java"></entry>
        <entry key="PYTHON" value="python"></entry>
    </map>
</property>

• set类型注入

 <property name="sets">
     <set>
         <value>MySQL</value>
         <value>Redis</value>
     </set>
 </property>

（8）注入List<object>类型的集合

与一般注入集合不同，注入类型为对象的时候，需要添加对象的set方法，并且，配置XML的时候要用ref引入，而不能直接用value标签

        <bean id="stu" class="com.LinXiaoDe.spring5.collectionType.Stu">
            <property name="couserList">
                <list>
                    <ref bean="course1"></ref>
                    <ref bean="course2"></ref>
                </list>
            </property>
        </bean>
        <!--注入Couser对象1-->
        <bean id="course1" class="com.LinXiaoDe.spring5.collectionType.Course">
            <property name="couserName" value="CSAPP"></property>
        </bean>
        <!--注入Couser对象1-->
        <bean id="course2" class="com.LinXiaoDe.spring5.collectionType.Course">
            <property name="couserName" value="算法H"></property>
        </bean>

如何抽取对象并且作为公共部分

（1）在Spring的配置文件中引入名称空间util

（2）使用<util>提取list集合类型属性注入

（3）提取list集合类型属性注入使用

<?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: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">
    <!--1.提取list集合类型属性注入-->
        <util:list id="bookList">
            <value>CSAPP</value>
            <value>算法H</value>
            <value>Math</value>
        </util:list>
    <!--2.提取list集合类型属性注入使用-->
    <bean id="book" class="com.LinXiaoDe.spring5.collectionType.Book">
        <property name="lists" ref="bookList"></property>
    </bean>
</beans>

（9）注入工厂Bean

工厂Bean与普通Bean不同的是，普通Bean在配置文件中定义什么类型就返回什么类型；而工厂Bean返回类型和定义类型可能不一样。

• 第一步 创建类MyBean，让这个类作为工厂 bean，实现接口 FactoryBean
• 第二步 实现接口里面的方法，在实现的方法中定义返回的 bean类型
  
• 第三步配置文件，id属性和class都是用MyBean

<bean id="myBean" class="com.LinXiaoDe.spring5.factoryBean.MyBean"></bean>

• 第四步调用这个类，这个时候的返回类型要改成FactoryBean：

（10）bean 作用域

1、在 Spring 里面，设置创建 bean 实例是单实例还是多实例
2、在 Spring 里面，默认情况下，bean 是单实例对象


3、如何设置单实例还是多实例
（1）在 spring 配置文件 bean标签里面有属性（scope）用于设置单实例还是多实例 （2）scope 属性值 第一个值 默认值，singleton，表示是单实例对象 第二个值 prototype，表示是多实例对象


（3）singleton和 prototype 区别

• 第一 singleton单实例，prototype 多实例
• 第二 设置 scope 值是 singleton时候，加载 spring 配置文件时候就会创建单实例对象 设置 scope 值是 prototype 时候，不是在加载 spring 配置文件时候创建 对象，在调用

（11）bean的生命周期

1、生命周期 ——从对象创建到对象销毁的过程
2、bean 生命周期
（1）通过构造器创建 bean 实例（无参数构造）
（2）为 bean的属性设置值和对其他 bean引用（调用 set 方法）
（3）调用 bean的初始化的方法（需要进行配置初始化的方法）
（4）bean可以使用了（对象获取到了）
（5）当容器关闭时候，调用 bean的销毁的方法（需要进行配置销毁的方法）
3、演示 bean 生命周期

<bean id="order" class="com.LinXiaoDe.spring5.collectionType.Order" init-method="initMethond" destroy-method="destoryMethond">
    <property name="oname" value="This is your order"></property>
</bean>

4、bean 的后置处理器，bean 生命周期有七步
（1）通过构造器创建 bean 实例（无参数构造）
（2）为 bean的属性设置值和对其他 bean引用（调用 set 方法）
（3）把 bean 实例传递 bean 后置处理器的方法 postProcessBeforeInitialization
（4）调用 bean的初始化的方法（需要进行配置初始化的方法）
（5）把 bean实例传递 bean后置处理器的方法 postProcessAfterInitialization
（6）bean可以使用了（对象获取到了）
（7）当容器关闭时候，调用 bean的销毁的方法（需要进行配置销毁的方法）

• 在前面的基础上，添加后置处理器
  ①BeanPostProcessor
  
  ②配置后置处理器

<bean id="order" class="com.LinXiaoDe.spring5.collectionType.Order" init-method="initMethond" destroy-method="destoryMethond">
    <property name="oname" value="This is your order"></property>
</bean>
<!--配置后置处理器会给所有的类都会添加后置处理器-->
<bean id="myBeanPost" class="com.LinXiaoDe.spring5.collectionType.MyBeanPostProcessor"> </bean>

（12）xml 自动装配

1、什么是自动装配
（1）根据指定装配规则（属性名称或者属性类型），Spring自动将匹配的属性值进行入
2、演示自动装配过程
（1）根据属性名称自动注入

<!--实现自动装配 bean标签属性autowire，配置自动装配 autowire属性常用两个值： byName根据属性名称注入 ，注入值bean的id值和类属性名称一样 byType根据属性类型注入--> 

<bean id="emp" class="com.atguigu.spring5.autowire.Emp" autowire="byName">
<!--<property name="dept" ref="dept"></property>-->
</bean> 
<bean id="dept" class="com.atguigu.spring5.autowire.Dept"></bean>

（2）根据属性类型自动注入

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

（13）注入外部属性文件（以数据库配置为例）

应用场景：
如果一个类的属性很多，这个时候直接配置将会繁琐，这个时候可以将prob放在另外一个文件中，然后再引入到XML文件中，从而方便修改和配置。比如说再数据库的配置中使用。

1、直接配置数据库信息（原始）
（1）配置druid连接池

找到druid.jar包，将其引入到项目的lib下，File/projectStruct/Modules/Dependencies/+/Jar/druid

<?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">
    <!--直接配置druid连接池
    1.创建连接池对象
    2.注入属性值，驱动,URL，username，password....
    -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <!-- 获取properties文件内容，根据key获取，使用spring表达式获取 -->
        <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="12345678"></property>
    </bean>
</beans>

（2）引入druid连接池依赖 jar 包

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

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

• （2）引入 context 名称空间

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

（3）在Spring的配置文件中，用<context>标签把外部 properties 属性文件引入到 spring配置文件中

<!--引入外部属性文件-->
<context:property-placeholder location="classpath:jdbc.properties"/>

（4）配置连接池

<!--配置连接池--> 
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="${prop.driverClass}"></property> 
<property name="url" value="${prop.url}"></property> 
<property name="username" value="${prop.userName}"></property> 
<property name="password" value="${prop.password}"></property>
</bean>

完成配置