Spring学习 | Bean管理-基于xml

---

学习视频：https://www.bilibili.com/video/BV1Vf4y127N5

一、Bean管理简介

概述：Bean管理就是对象管理，指的就是两个操作

1. Spring 创建对象：创建对象默认采用的是无参构造器，所以类的定义中必须有无参构造器的声明或者不添加有参构造器
2. Spring 注入属性：也就是 DI——Dependency Injection 依赖注入

常见八股文：DI与IOC的区别

Bean管理操作的两种方式

1. 基于xml 文件实现
2. 基于注解方式实现（推荐）

---

二、使用xml管理Bean

2.1 创建对象

在spring配置文件（spring.xml）使用标签并添加对应属性

<bean id="u" class="com.Key.spring.bean.User">bean>

标签中两个重要属性

• id：对象的唯一标识
• class：对象的全类名

2.2 注入属性

PS：2.2.2~2.2.5只使用了set方法进行注入

2.2.1 普通类型属性

使用set() 方法进行注入

1. 定义一个类，添加setProperty() 方法

   /**
    * User实体类
    *  - 成员变量一：name
    *  - 成员变量二：age
    */
   public class User {
       private String name;
       private int age;
   
       public void setName(String name) {
           this.name = name;
       }
   
       public void setAge(int age) {
           this.age = age;
       }
   }
   

2. 在xml 文件中的标签中添加标签，并添加相应属性

   <bean id="u" class="com.Key.spring.bean.User">
       <property name="name" value="周瑜">property>
       <property name="age" value="24">property>
   bean>
   

   标签中的两个属性

   • name：属性名。注意这里是对应的是属性名，即与方法setXxx() 中的xxx对应，不一定是成员变量名

   • value：对应属性值（成员变量的值）

p名称空间注入：set() 方法注入的简化操作（了解即可）

1. 在配置文件中的标签中创建p名称空间：xmlns:p="http://www.springframework.org/schema/p"

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

2. 直接在标签的属性栏上添加属性 p:property 进行属性的注入

   注入外部Bean的写法：p:uDao-ref="uDao"

   <bean id="u" class="com.Key.spring.bean.User" p:name="周瑜" p:age="24">bean>
   

使用有参构造器进行注入

1. 定义一个类，添加有参构造器

   public class User {
       private String name;
       private int age;
   
       public User(String username, int age) {
           this.name = username;
           this.age = age;
       }
   }
   

2. 在xml 文件中的标签中添加标签，并添加对应属性

   <bean id="u" class="com.key.spring.bean.User">
       <constructor-arg name="username" value="诸葛亮">constructor-arg>
       <constructor-arg name="age" value="21">constructor-arg>
   bean>
   

   标签的重要属性

   • name：有参构造器中形参的名称。注意这里对应的是形参名，不一定是属性名，也不一定是成员变量名
   • value：对应属性值（成员变量值）
   • index：成员变量在类中定义的先后次序，从0开始

2.2.2 特殊类型属性

引入概念——字面量：Java 中将数据称为字面量，如在int a = 2;中，a是变量，2就是字面量

注入null值：直接在标签体中添加标签即可

<property name="name">
    <null/>
property>

注入带特殊符号的属性值：特殊符号是指在xml 中有特殊用法的敏感字符，如<、>、&等

1. 使用转义字符代替特殊符号

2. 使用标签和CDATA区域，把带有特殊符号值放在CDATA区域，如把"<<三国演义>>"赋值给属性bookName

   <property name="bookName">
       <value>>]]>value>
   property>
   

注入数组、集合类型属性（List 和数组注入方式一样，这里只演示数组）

• 数组或集合元素类型为普通类型

  ① 创建一个类用于测试，类中定义有数组类型、set类型和Map类型的属性

  public class Students {
      private String[] course;
      private Map<String,String> stuMap;
      private Set<String> stuSet;
  
      public void setCourse(String[] course) {
          this.course = course;
      }
  
      public void setStuMap(Map<String, String> stuMap) {
          this.stuMap = stuMap;
      }
  
      public void setStuSet(Set<String> stuSet) {
          this.stuSet = stuSet;
      }
  }
  

  ② 在spring配置文件中创建对象，并注入各个类型的属性（都是在标签中添加）

  • 数组或List 集合类型注入：添加或标签，然后在或标签体中添加进行赋值

    <list>
        <value>高数value>
        <value>c语言value>
    list>
    

  • set 集合类型注入：添加标签，然后在标签体中添加进行赋值

    <set>
        <value>set1value>
        <value>set2value>
    set>
    

  • map 集合类型注入：添加标签，然后在标签体中添加标签，在标签的属性中进行赋值

    <map>
        <entry key="周一" value="上课">entry>
        <entry key="周日" value="放假">entry>
    map>
    

    标签的两个属性

    • key：对应map 集合中的键key
    • value：对应map 集合中的值value

• 数组或集合元素类型为对象（数组、集合类型的操作都是相似的，这里只演示List 集合）

  ① 创建课程类，在学生类中添加元素类型是课程类的集合属性——private List stuCourse;

  public class Course {
      private String cname;
  
      public void setCname(String cname) {
          this.cname = cname;
      }
  }
  

  ② 在spring 配置文件中创建多个课程类对象，然后再学生对象的创建中注入对应集合属性，集合中添加创建好的多个课程对象，将标签换成，并通过bean 属性赋值

  
  <bean id="c1" class="com.Key.spring.ioc.bean.Course">
      <property name="cname" value="java实验课">property>
  bean>
  <bean id="c2" class="com.Key.spring.ioc.bean.Course">
      <property name="cname" value="c语言实验课">property>
  bean>
  <bean id="c3" class="com.Key.spring.ioc.bean.Course">
      <property name="cname" value="数据结构实验课">property>
  bean>
  
  
  <bean id="stu" class="com.Key.spring.ioc.bean.Students">
      
  
      
      <property name="stuCourse">
          <list>
              <ref bean="c1">ref>
              <ref bean="c2">ref>
              <ref bean="c3">ref>
          list>
      property>
  bean>
  

  标签的属性——bean：集合中每个元素对象对应的唯一标识id 值

• 通过util 名称空间实现数组或集合类型的注入（将集合类型属性的注入单独取出来）

  ① 在spring 配置文件的根标签的属性栏中创建util 名称空间

  • 添加属性——xmlns:util="http://www.springframework.org/schema/util"
  • 在xsi:schemaLocation属性的原有值后添加http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd

  创建util 名称空间的方法（通用）

  • 将属性xmlns的值http://www.springframework.org/schema/beans中的beans换成util
  • 将属性xsi:schemaLocation的原有值http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd中的所有beans都换成util

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

  ② 在创建对象的外部使用 标签对集合类型属性进行赋值（其他集合类型的赋值类似——、）

  
  <util:list id="utilList">
      <value>大物value>
      <value>离散value>
  util:list>
  

  ③ 把已经注入完成的集合类型属性添加到对象中：在标签中采用 ref 属性，与注入对象类属性的方式类似

  
  <bean id="stu" class="com.Key.spring.ioc.bean.Students">
      
  
      <property name="course" ref="utilList">property>
  bean>
  

2.2.3 对象类型属性

用法：用于有调用关系的类之间，比如service类和dao类

① 创建好service类和dao类，在service类中定义dao类的成员变量，根据成员变量调用其方法

/**
 * 注意：这里只是简单演示，实操的时候需要添加接口类，在实现类进行以下操作
 */
public class UserService {
    private UserDao uDao;

    // 要加上对应的set方法
    public void setUDao(UserDao uDao) {
        this.uDao = uDao;
    }

    public void update() {
        // 调用dao类对象的方法
        uDao.update();

        // code...
    }
}  

② 在spring配置文件中创建service类对象和dao类对象，并在service类对象中注入属性，有外部和内部两种方式

• 外部Bean方式注入：在外部创建好属性对应的类对象，然后根据外部Bean的唯一标识id 进行注入

    
    <bean id="uDao" class="com.Key.spring.dao.UserDao">bean>
    
    
    <bean id="uService" class="com.Key.spring.service.UserService">
        <property name="uDao" ref="uDao">property>
    bean>
  

  标签中的两个属性

  • name：属性名

  • ref：对象类型属性在外部创建时标签中的id值（唯一标识）

• 内部Bean的方式注入：直接在标签体（内部）中使用标签创建属性对应的类对象

  
  <bean id="uService" class="com.Key.spring.service.UserService">
      <property name="uDao">
          <bean id="uDao" class="com.Key.spring.dao.UserDao">bean>
      property>
  bean>
  

2.2.4 级联赋值

① 创建部门类和员工类，在员工类中添加部门类型的成员变量，表示两者一对多的关系

② 在spring 配置文件中创建两个类的对象，并对员工属性的注入中同时对其所在的部门的属性进行赋值，实现级联赋值

• 通过外部Bean或内部Bean的方式（这里只演示外部）

  
  <bean id="dept" class="com.Key.spring.bean.Department">
      <property name="deptName" value="技术部">property>
  bean>
  
  
  <bean id="emp" class="com.Key.spring.bean.Employee">
      <property name="empName" value="孙尚香">property>
      <property name="gender" value="女">property>
      <property name="empDept" ref="dept">property>
  bean>
  

• 通过对象.属性（这里对象是指员工中的部门属性）的方式（这里是基于外部Bean的方式，内部Bean的方式也可以）

  • 先在员工类中添加部门属性对应的get方法，不然无法找到对象.属性中的对象

  • 在员工对象创建的标签体中添加

  
  <bean id="dept" class="com.Key.spring.bean.Department">bean>
  
  
  <bean id="emp" class="com.Key.spring.bean.Employee">
      <property name="empName" value="孙尚香">property>
      <property name="gender" value="女">property>
      <property name="empDept" ref="dept">property>
      <property name="empDept.deptName" value="销售部">property>
  bean>
  

2.2.5 自动装配

PS：一般使用注解方式实现自动装配，不使用xml 文件；而且自动装配适用于自定义对象类型的属性

概述：只需声明属性的名称或者属性的类型即可完成属性的注入，不需要使用标签手动给各个属性赋值

用法：在标签中添加属性——autowire，属性值有两种

• byName：表示根据Bean 的属性名来赋值，自定义的对象创建的标签中的id值必须与对象类型的属性名保持一致

• byType：表示根据Bean 的属性类型来赋值，属性对应的对象创建在同一个xml 文件中只能出现一次，即同一个xml 文件不能创建与属性对应对象的类型一样的对象

  当autowire的值为byType 时，spring 会根据属性的类型找到对应的对象（根据标签中的class属性值），然后将该对象赋值给对应属性，如果同一个xml 文件中出现多个类型一样的对象，spring 就不知道哪一个才是需要赋值的，会报错

2.3 FactoryBean

概述：spring 中有两种类型的Bean，一种是普通的Bean，一种是工厂Bean——Factory

普通Bean和工厂Bean的区别

• 普通Bean：在配置文件中定义的bean 类型和返回类型是一样的
• 工厂Bean：在配置文件中定义的bean 类型和返回类型可以不一样

FactoryBean的实现

1. 创建一个类，实现FactoryBean 接口，作为自定义的工厂对象MyBean

2. 在spring配置文件中创建自定义的工厂对象

   <bean id="myBean" class="com.Key.spring.bean.MyBean">bean>
   

3. 在自定义的工厂类中实现接口的 getObject()方法，方法中定义实际返回的bean 类型（泛型 T）

   public class MyBean implements FactoryBean<User> {
       @Override
       public User getObject() throws Exception {
           // 创建User对象并返回
           return new User("曹操", 43);
       }
   }
   

2.4 注入外部属性

引入概念——Druid数据库连接池属性信息

• 数据库驱动类：prop.driverClass=com.mysql.jdbc.Driver（MySQL 5之后是 com.mysql.cj.jdbc.Driver）
• 数据库地址：prop.url=jdbc:mysql://localhost:3306/xxx
• 数据库用户名：prop.username=root
• 数据库用户密码：prop.password=***

概述：一般用于配置数据库连接的属性信息，需要注入的文件一般命名为 jdbc.properties

使用步骤

1. 创建 jdbc.properties 文件，文件中输入对应的数据库连接信息（druid 的需要的数据库连接信息）

2. 在spring 配置文件中引入context 名称空间（创建方法略，可参考util 名称空间的创建）

3. 在spring 配置文件中使用context 名称空间中的 标签将外部属性文件 jdbc.properties 引入

   <context:property-placehoder location="classpath:jdbc.properties"/>
   

   标签的属性——location：外部属性文件的位置，如果文件在src目录下，可直接写为 classpath:jdbc.properties

4. 在标签中使用标签注入外部属性，使用方法与注入其他普通类型属性一样，但 value 的值用表达式代替，表达式为——${属性文件中属性名}（EL表达式？）

   <bean id="dataSource" class="com.alibaba.druid.pool.DriverDataSource">
       <property name="driverClassName" value="${prop.driverClass}">property>
       <property name="url" value="${prop.url}">property>
       <property name="username" ref="${prop.username}">property>
       <property name="password" value="${prop.password}">property>
   bean>
   

   PS：标签中的name属性值都是DriverDataSource 类中的属性，所以是固定的，不是自定义的