001_Spring5-IOC容器-Bean管理-XML方式

一、IOC容器

1、什么是IOC（控制反转）

a）把对象创建和对象之间的调用过程，交给Spring进行管理

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

2、IOC底层

a）xml解析、工厂模式、反射

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

a）BeanFactory接口：IOC容器基本实现是Spring内部接口的使用接口，不提供给开发人员进行使用（加载配置文件时候不会创建对象，在获取对象时才会创建对象。）

b）ApplicationContext接口：BeanFactory接口的子接口，提供更多更强大的功能，提供给开发人员使用（加载配置文件时候就会把在配置文件对象进行创建）推荐使用！

4、ApplicationContext接口的实现类（具体根据API文档查看）

二、IOC容器-Bean管理

IOC操作Bean管理

a）Bean管理就是两个操作：（1）Spring创建对象；（2）Spring注入属性

基于XML配置文件创建对象

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

基于XML方式注入属性（DI：依赖注入（注入属性））

a）set方式注入

1
2
3
4
5
6
7
8
9
10
//（1）传统方式： 创建类，定义属性和对应的set方法
public class Book {
    //创建属性
    private String bname;

    //创建属性对应的set方法
    public void setBname(String bname) {
        this.bname = bname;
    }
}
1
2
3
4
5
6
7
8
9
<!--（2）spring方式： set方法注入属性-->
<bean id="book" class="com.atguigu.spring5.Book">
    <!--使用property完成属性注入
        name：类里面属性名称
        value：向属性注入的值
    -->
    <property name="bname" value="Hello"></property>
    <property name="bauthor" value="World"></property>
</bean>

b）有参构造函数注入

1
2
3
4
5
6
7
8
9
10
11
//（1）传统方式：创建类，构建有参函数
public class Orders {
    //属性
    private String oname;
    private String address;
    //有参数构造
    public Orders(String oname,String address) {
        this.oname = oname;
        this.address = address;
    }
  }
1
2
3
4
5
<!--（2）spring方式：有参数构造注入属性-->
<bean id="orders" class="com.atguigu.spring5.Orders">
    <constructor-arg name="oname" value="Hello"></constructor-arg>
    <constructor-arg name="address" value="China！"></constructor-arg>
</bean>

c）p名称空间注入（了解即可）

1
2
3
4
5
6
7
8
9
<!--1、添加p名称空间在配置文件头部-->
<?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"		<!--在这里添加一行p-->

<!--2、在bean标签进行属性注入（算是set方式注入的简化操作）-->
    <bean id="book" class="com.atguigu.spring5.Book" p:bname="very" p:bauthor="good">
    </bean>

注入空值和特殊符号

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<bean id="book" class="com.atguigu.spring5.Book">
    <!--（1）null值-->
    <property name="address">
        <null/><!--属性里边添加一个null标签-->
    </property>
    
    <!--（2）特殊符号赋值-->
     <!--属性值包含特殊符号
       a 把<>进行转义 &lt; &gt;
       b 把带特殊符号内容写到CDATA
      -->
    <property name="address">
        <value><![CDATA[<<南京>>]]></value>
    </property>
</bean>

注入属性-外部bean

a）创建两个类service和dao类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class UserService {//service类

    //创建UserDao类型属性，生成set方法
    private UserDao userDao;
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void add() {
        System.out.println("service add...............");
        userDao.update();//调用dao方法
    }
}

public class UserDaoImpl implements UserDao {//dao类

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

b）在spring配置文件中进行配置

1
2
3
4
5
6
7
8
9
<!--1 service和dao对象创建-->
<bean id="userService" class="com.atguigu.spring5.service.UserService">
    <!--注入userDao对象
        name属性：类里面属性名称
        ref属性：创建userDao对象bean标签id值
    -->
    <property name="userDao" ref="userDaoImpl"></property>
</bean>
<bean id="userDaoImpl" class="com.atguigu.spring5.dao.UserDaoImpl"></bean>

基于XML方式注入内部bean和级联赋值

a）注入属性-内部bean

1
2
3
（1）一对多关系：部门和员工
一个部门有多个员工，一个员工属于一个部门（部门是一，员工是多）
（2）在实体类之间表示一对多关系，员工表示所属部门，使用对象类型属性进行表示
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
//部门类
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;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
<!--内部bean-->
    <bean id="emp" class="com.atguigu.spring5.bean.Emp">
        <!--设置两个普通属性-->
        <property name="ename" value="Andy"></property>
        <property name="gender" value="女"></property>
        <!--设置对象类型属性-->
        <property name="dept">
            <bean id="dept" class="com.atguigu.spring5.bean.Dept"><!--内部bean赋值-->
                <property name="dname" value="宣传部门"></property>
            </bean>
        </property>
    </bean>

b）注入属性-级联赋值

1
2
3
4
5
6
7
8
9
10
11
<!--方式一：级联赋值-->
<bean id="emp" class="com.atguigu.spring5.bean.Emp">
    <!--设置两个普通属性-->
    <property name="ename" value="Andy"></property>
    <property name="gender" value="女"></property>
    <!--级联赋值-->
    <property name="dept" ref="dept"></property>
</bean>
<bean id="dept" class="com.atguigu.spring5.bean.Dept">
    <property name="dname" value="公关部门"></property>
</bean>
1
2
3
4
 //方式二：生成dept的get方法（get方法必须有！！）
public Dept getDept() {
    return dept;
}
1
2
3
4
5
6
7
8
9
10
11
 <!--级联赋值-->
<bean id="emp" class="com.atguigu.spring5.bean.Emp">
    <!--设置两个普通属性-->
    <property name="ename" value="jams"></property>
    <property name="gender" value="男"></property>
    <!--级联赋值-->
    <property name="dept" ref="dept"></property>
    <property name="dept.dname" value="技术部门"></property>
</bean>
<bean id="dept" class="com.atguigu.spring5.bean.Dept">
</bean>

IOC 操作 Bean 管理——xml 注入集合属性**

1、注入数组类型属性 2、注入 List 集合类型属性 3、注入 Map 集合类型属性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//（1）创建类，定义数组、list、map、set 类型属性，生成对应 set 方法
public class Stu {
    //1 数组类型属性
    private String[] courses;
    //2 list集合类型属性
    private List<String> list;
    //3 map集合类型属性
    private Map<String,String> maps;
    //4 set集合类型属性
    private Set<String> sets;
    
    public void setSets(Set<String> sets) {
        this.sets = sets;
    }
    public void setCourses(String[] courses) {
        this.courses = courses;
    }
    public void setList(List<String> list) {
        this.list = list;
    }
    public void setMaps(Map<String, String> maps) {
        this.maps = maps;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
<!--（2）在 spring 配置文件进行配置-->
<bean id="stu" class="com.atguigu.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="maps">
        <map>
            <entry key="JAVA" value="java"></entry>
            <entry key="PHP" value="php"></entry>
        </map>
    </property>
    <!--set类型属性注入-->
    <property name="sets">
        <set>
            <value>MySQL</value>
            <value>Redis</value>
        </set>
    </property>
</bean>

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

1
2
3
4
5
//学生所学多门课程
private List<Course> courseList;//创建集合
public void setCourseList(List<Course> courseList) {
    this.courseList = courseList;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<!--创建多个course对象-->
<bean id="course1" class="com.atguigu.spring5.collectiontype.Course">
    <property name="cname" value="Spring5框架"></property>
</bean>
<bean id="course2" class="com.atguigu.spring5.collectiontype.Course">
    <property name="cname" value="MyBatis框架"></property>
</bean>

<!--注入list集合类型，值是对象-->
<property name="courseList">
    <list>
        <ref bean="course1"></ref>
        <ref bean="course2"></ref>
    </list>
</property>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<!--第一步：在 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:util="http://www.springframework.org/schema/util" <!--添加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">  <!--添加util名称空间-->
    
<!--第二步：使用 util 标签完成 list 集合注入提取-->
<!--把集合注入部分提取出来-->
 <!--1 提取list集合类型属性注入-->
    <util:list id="bookList">
        <value>易筋经</value>
        <value>九阴真经</value>
        <value>九阳神功</value>
    </util:list>

 <!--2 提取list集合类型属性注入使用-->
    <bean id="book" class="com.atguigu.spring5.collectiontype.Book" scope="prototype">
        <property name="list" ref="bookList"></property>
    </bean>
</beans>

FactoryBean

1
2
3
1、Spring 有两种类型 bean，一种普通 bean，另外一种工厂 bean（FactoryBean）
2、普通 bean：在配置文件中定义 bean 类型就是返回类型
3、工厂 bean：在配置文件定义 bean 类型可以和返回类型不一样 第一步 创建类，让这个类作为工厂 bean，实现接口 FactoryBean 第二步 实现接口里面的方法，在实现的方法中定义返回的 bean 类型
1
2
3
4
5
6
7
8
9
10
public class MyBean implements FactoryBean<Course> {

    //定义返回bean
    @Override
    public Course getObject() throws Exception {
        Course course = new Course();
        course.setCname("abc");
        return course;
    }
}
1
2
<bean id="myBean" class="com.atguigu.spring5.factorybean.MyBean">
</bean>
1
2
3
4
5
6
7
@Test
public void test3() {
 ApplicationContext context =
 new ClassPathXmlApplicationContext("bean3.xml");
 Course course = context.getBean("myBean", Course.class);//返回值类型可以不是定义的bean类型！
 System.out.println(course);
}

bean 作用域

在 Spring 里面，默认情况下，bean 是单实例对象，下面进行作用域设置：

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

1
2
3
4
5
<!-- 单实例, 默认即单实例 -->
<bean id="singletonUser" class="cn.ysliu.User" scope="singleton" />

<!-- 多实例 -->
<bean id="prototypeUser" class="cn.ysliu.User" scope="prototype" />

（3）singleton 和 prototype 区别
a）singleton 单实例，prototype 多实例
b）设置 scope 值是 singleton 时候， 加载 spring 配置文件时候就会创建单实例对象

​ 设置 scope 值是 prototype 时候，不是在加载 spring 配置文件时候创建对象， 在调用 getBean 方法时候创建多实例对象

bean 生命周期

1、生命周期 ：从对象创建到对象销毁的过程

2、bean 生命周期

1
2
3
4
5
6
7
1.通过构造方法创建对象
2.通过set方法注入属性
3.Bean后置处理器-init-Method之前
4.调用对象初始化方法(init-Method)
5.Bean后置处理器-init-Method之后
6.获取到备案、对象
7.调用对象销毁方法(destroy-Method)

3、演示 bean 生命周期 ：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class Dog {

  public Dog() {
    System.out.println("第一步：通过构造方法创建对象");
  }

  private String name;

  public Dog setName(String name) {
    System.out.println("第二步：通过set方法注入属性");
    this.name = name;
    return this;
  }

  public void initMethod() {
    System.out.println("第四步：调用对象初始化方法");
  }

  public void destroyMethod() {
    System.out.println("第七步：调用对象销毁方法");
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/**
 * Bean后置处理器
 */
public class MyBeanPostProcessor implements BeanPostProcessor {

  @Override
  public Object postProcessBeforeInitialization(Object bean, String beanName)
      throws BeansException {
    System.out.println("第三步：Bean后置处理器-init-Method之前");
    return bean;
  }

  @Override
  public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
    System.out.println("第五步：Bean后置处理器-init-Method之后");
    return bean;
  }
}
1
2
3
4
5
6
7
<!-- 对象生命周期 -->
<bean id="dog" class="cn.ysliu.lifecycle.Dog" init-method="initMethod" destroy-method="destroyMethod">
    <property name="name" value="二哈" />
</bean>

<!-- 让spring管理自定义的bean后置处理器实现 -->
<bean class="cn.ysliu.lifecycle.MyBeanPostProcessor" />
1
2
3
4
5
6
7
@Test
public void testLifeCycle() {
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans7.xml");
    context.getBean("dog", Dog.class);
    System.out.println("第四步：获取到context中管理的bean");
    context.close();
}

外部属性文件

1.引入相关jar包：Druid（德鲁伊）连接池依赖 jar 包，mysql-connector-java MySql驱动jar包

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

1
2
3
4
jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/userDb
jdbc.userName=root
jdbc.password=123456
  1. 引入context 名称空间，把外部 properties 属性文件引入到 spring 配置文件中，并配置bean
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<?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: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:property-placeholder location="jdbc.properties"/>

  <!-- 配置数据库连接池配置 -->
  <bean id="dataSources" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="driverClassName" value="${jdbc.driverClassName}" />
    <property name="url" value="${jdbc.url}" />
    <property name="username" value="${jdbc.userName}" />
    <property name="password" value="${jdbc.password}" />
  </bean>
</beans>