JAVA-4-[Spring框架]基于XML方式的Bean管理

1 Spring IOC容器

(1)IOC底层原理
(2)IOC接口(BeanFactory)
(3)IOC操作Bean管理(基于XML)
(4)IOC操作Bean管理(基于注释)

1.1 IOC概念

(1)控制反转(Inversion of Control)，把对象的创建和对象之间的调用过程，交给Spring进行管理。
(2)使用IOC目的：为了降低耦合度。
(3)IOC底层原理：xml解析、工厂模式、反射。
工厂模式：降低耦合度。
反射：得到类的字节码文件。

1.2 IOC底层原理

在UserService类中调动用UserDao类中的方法。

class UserService{
    
    
	execute()
	{
    
    
		
	}
}

class UserDao{
    
    
	add()
	{
    
    
		...
	}
}

1.2.1 原始方式(耦合度高)

1.2.2 工厂模式(解耦)

1.2.3 IOC过程 (最低耦合度)

1.3 IOC接口

1、IOC思想基于IOC容器完成，IOC容器底层就是对象工厂。
2、Spring提供IOC容器实现两种方式:(两个接口)
(1)BeanFactory：IOC容器基本实现，是Spring内部使用的接口，不提供开发人员进行使用。
加载配置文件时不会创建对象，在获取对象或使用对象时才会创建。

(2)ApplicationContext：BeanFactory接口的子接口，提供更多更强大的功能，一般由开发人员进行使用。
加载配置文件时，就会把在配置文件中的对象都进行创建。
3、ApplicationContext中的实现类
(1)FileSystemXmlApplicationContext
(2)ClassPathXmlApplicationContext

1.4 Bean管理

1、什么是Bean管理
Bean管理指的是两个操作：
(1)Spring创建对象
(2)Spring注入属性
2、Bean管理操作有两种方式：
(1)基于xml配置文件方式实现
(2)基于注解方式实现

2 基于xml方式

2.1 创建对象

2.1.1 new方法(原始)

HellowWorld hello = new HelloWorld();

2.1.2 xml方式(spring)

1、基于xml方式创建对象
<!--配置HellowWorld对象创建-->
<bean id="helloWorld123" class="HelloWorld"></bean>
(1)在spring配置文件中，使用bean标签，
标签里面添加对应属性，就可以实现对象创建。
(2)在bean标签中有很多属性
id属性：唯一标识。
class属性：类全路径(包名+类名)。
name属性：与id属性功能相似，已不再使用。
(3)创建对象的时候，默认也是执行无参数构造方法

2.2 set方法注入属性

2、 基于xml方式注入属性
DI:依赖注入，就是注入属性
第一种注入方式：使用set方法进行注入
步骤：创建类，定义属性和对应的set方法
步骤：在spring的配置文件中进行配置。

第二种注入方式：使用有参数构造进行注入
步骤：创建类，定义属性，创建属性对应有参数构造方法。
步骤：在spring的配置文件中进行配置。

2.2.1 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 getMessage(){
    
    
        System.out.println(bname+":"+bauthor);
    }

    public static void main(String[] args){
    
    
        // 使用时，先创建对象，再用set方法注入属性
        Book book = new Book();
        book.setBname("孔乙己");
        book.setBauthor("鲁迅");

        book.getMessage();
    }

}

2.2.2 xml方式(spring)

使用property完成属性注入
name：类里面属性名称
value：向属性注入的值

<bean id="book" class="Book">
        <property name="bname" value="孙子兵法" />
        <property name="bauthor" value="孙子" />
</bean>

使用方式

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class zzz {
    
    
    public static void main(String[] args) {
    
    
        // 1 加载spring配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
        // 2 获取配置创建的对象
        Book book = (Book) context.getBean("book");
        
        book.getMessage();
    }
}

2.3 有参构造注入属性

2、 基于xml方式注入属性
DI:依赖注入，就是注入属性
第一种注入方式：使用set方法进行注入
步骤：创建类，定义属性和对应的set方法
步骤：在spring的配置文件中进行配置。

第二种注入方式：使用有参数构造进行注入
步骤：创建类，定义属性，创建属性对应有参数构造方法。
步骤：在spring的配置文件中进行配置。

2.3.1 构造方法(原始)

右键->Generate->选择生成有参构造

public class Orders {
    
    
	//创建属性
    private String oname;
    private String address;
    // 创建有参构造
    public Orders(String oname, String address) {
    
    
        this.oname = oname;
        this.address = address;
    }
    
    public void getMessage(){
    
    
        System.out.println(oname+":"+address);
    }
    public static void main(String[] args){
    
    
    	// 使用时
        Orders order = new Orders("lily","NewYork");
        order.getMessage();
    }
}

2.3.2 xml方式(spring)

<!--有参构造注入属性-->
<bean id="orders" class="Orders">
    <constructor-arg name="oname" value="lucy"/>
    <constructor-arg name="address" value="china"/>
</bean>

使用方式

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class zzz {
    
    
    public static void main(String[] args) {
    
    
        // 1 加载spring配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
        // 2 获取配置创建的对象
        Orders order = (Orders) context.getBean("orders");

        order.getMessage();
    }
}

2.4 p名称空间注入

(1)使用p名称空间注入，可以简化基于xml的set方法注入
第一步 添加p名称空间在配置文件中
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:p="http://www.springframework.org/schema/p"
       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-3.0.xsd">
   
第二步 进行属性注入，在bean标签中进行操作
<bean id="book" class="Book" p:bname="天龙八部" p:bauthor="金庸"></bean>

2.5 注入null和特殊字符

一、字面量
(1)null值
<bean id="book" class="Book">
    <property name="bname" value="孙子兵法" />
    <property name="bauthor">
        <null/>
    </property>
</bean>

输出如下:孙子兵法:null

(2)属性值包含特殊符号
方式一：把<>进行转移 &lt;&gt;
<bean id="book" class="Book">
    <property name="bname" value="孙子兵法" />
    <property name="bauthor" value="&lt;&lt;孙子&gt;&gt;"/>
</bean>
方式二：把带特殊符号内容写到CDATA
<bean id="book" class="Book">
    <property name="bname" value="孙子兵法" />
    <property name="bauthor">
        <value><![CDATA[<<老子>>]]></value>
    </property>
</bean>

2.6 注入外部Bean

web层，service层，dao层。

2、注入属性-外部bean
(1)创建两个类service类和dao类
(2)在service中调用dao
(3)在spring配置文件中配置

2.6.1 原始方式

一、Dao层接口
代码文件UserDao.java

package dao;

public interface UserDao {
    
    
    public void update();
}

二、Dao层接口实现
代码文件UserDaoImpl.java

package dao;

public class UserDaoImpl implements UserDao{
    
    

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

三、service层
代码文件UserService.java

package service;

import dao.UserDao;
import dao.UserDaoImpl;

public class UserService {
    
    
    public void add(){
    
    
        System.out.println("service add ......");

        // 在service层中调用Dao层
        // 创建UserDao对象
        UserDao userdao = new UserDaoImpl();
        userdao.update();
    }
    public static void main(String[] args) {
    
    
        UserService userservice = new UserService();
        userservice.add();
    }
}

2.6.2 xml方式

一、Dao层接口
代码文件UserDao.java
二、Dao层接口实现
代码文件UserDaoImpl.java
三、service层
代码文件UserService.java

package service;

import dao.UserDao;

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

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

四、beans.xml配置文件

<!-- 1 service和dao对象创建-->
<bean id="userservice123" class="service.UserService">
    <!--注入userDao对象
        name属性：类里面的属性名称
        ref属性：创建userDao对象bean标签id值
    -->
    <property name="userDao" ref="userDaoImpl123"/>
</bean>
<bean id="userDaoImpl123" class="dao.UserDaoImpl"></bean>

五、测试使用

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import service.UserService;

public class zzz {
    
    
    public static void main(String[] args) {
    
    
        // 1 加载spring配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
        // 2 获取配置创建的对象
        UserService userservice = (UserService) context.getBean("userservice123");
        userservice.add();
    }
}

2.7 注入内部Bean

(1)一对多关系：部门和员工
一个部门有多个员工，一个员工属于一个部门
(2)在实体类间表示一对多关系,员工所属部门，使用对象类型属性表示

一、Dept.java

//部门类
public class Dept {
    
    
    private String dname;
    public void setDname(String dname) {
    
    
        this.dname = dname;
    }
    public String getDname() {
    
    
        return dname;
    }
}

二、Emp.java

//员工类
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;
    }
    
    public void getMessage(){
    
    
        System.out.println(ename+":"+gender+":"+dept);
    }
}

三、beans.xml配置文件

<!--内部bean-->
<bean id="emp" class="Emp">
    <!--设置两个普通属性-->
    <property name="ename" value="lily"/>
    <property name="gender" value="女"/>
    <!--设置对象类型属性-->
    <property name="dept">
        <bean id="dept" class="Dept">
            <property name="dname" value="人力资源部"/>
        </bean>
    </property>
</bean>

四、测试

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;


public class zzz {
    
    
    public static void main(String[] args) {
    
    
        // 1 加载spring配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
        // 2 获取配置创建的对象
        Emp emp = (Emp) context.getBean("emp");
        emp.getMessage();
    }
}

2.8 级联赋值

(1)第一种写法：
<!--级联赋值-->
<bean id="emp" class="Emp">
    <!--设置两个普通属性-->
    <property name="ename" value="lily"/>
    <property name="gender" value="女"/>
    <!--级联赋值-->
    <property name="dept" ref="dept12"/>
</bean>
<bean id="dept12" class="Dept">
    <property name="dname" value="人力资源部"/>
</bean>

(2)第二种方法
<!--级联赋值-->
<bean id="emp" class="Emp">
    <!--设置两个普通属性-->
    <property name="ename" value="lily"/>
    <property name="gender" value="女"/>
    <!--级联赋值-->
    <property name="dept" ref="dept12"/>
    <property name="dept.dname" value="技术部"/>
</bean>
<bean id="dept12" class="Dept">
    <property name="dname" value="人力资源部"/>
</bean>

第二种方法需要注意：

3 Spring IoC容器

IoC(Inverse of Control)控制反转。
IoC指的是将对象的创建权交给Spring去创建。使用Spring之前，对象的创建都是由我们使用new创建，而使用Spring之后，对象的创建都交给了Spring框架。

IoC容器是Spring的核心，也可以称为Spring容器。Spring通过IoC容器来管理对象的实例化和初始化，以及对象从创建到销毁的整个生命周期。

Spring中使用的对象都由IoC容器管理，不需要我们手动使用new运算符创建对象。由 IoC容器管理的对象称为Spring Bean，Spring Bean就是Java对象，和使用new运算符创建的对象没有区别。

Spring通过读取XML或Java注解中的信息来获取哪些对象需要实例化。

Spring提供2种不同类型的IoC容器，即BeanFactory和ApplicationContext容器。

3.1 BeanFactory容器

BeanFactory是最简单的容器，由org.springframework.beans.factory.BeanFactory接口定义，采用懒加载(lazy-load)，所以容器启动比较快。

BeanFactory 提供了容器最基本的功能。

为了能够兼容 Spring集成的第三方框架(如BeanFactoryAware、InitializingBean、DisposableBean)，所以目前仍然保留了该接口。

简单来说，BeanFactory就是一个管理Bean的工厂，它主要负责初始化各种Bean，并调用它们的生命周期方法。

BeanFactory 接口有多个实现类，
最常见的是org.springframework.beans.factory.xml.XmlBeanFactory。
使用BeanFactory需要创建XmlBeanFactory类的实例，
通过XmlBeanFactory类的构造函数来传递Resource对象。如下所示。
Resource resource = new ClassPathResource("Beans.xml"); 
BeanFactory factory = new XmlBeanFactory(resource);  

MainApp.java文件

package net.biancheng;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;

public class MainApp {
    
    
    public static void main(String[] args) {
    
    
        Resource resource = new ClassPathResource("Beans.xml");
        BeanFactory factory = new XmlBeanFactory(resource);
        HelloWorld obj = (HelloWorld) factory.getBean("helloWorld123");
        obj.getMessage();
    }
}

在主程序当中，需要注意以下两点：
(1)第一步利用框架提供的XmlBeanFactory() API去生成工厂bean以及利用 ClassPathResource() API去加载在路径CLASSPATH下可用的bean配置文件。XmlBeanFactory() API负责创建并初始化所有的对象，即在配置文件中提到的 bean。

(2)第二步利用第一步生成的bean工厂对象的getBean()方法得到所需要的bean。 这个方法通过配置文件中的bean ID来返回一个真正的对象，该对象最后可以用于实际的对象。一旦得到这个对象，你就可以利用这个对象来调用任何方法。
后期这个XmlBeanFactory类被废除了。

3.2 ApplicationContext容器

ApplicationContext继承了BeanFactory接口，由 org.springframework.context.ApplicationContext接口定义，对象在启动容器时加载。ApplicationContext在BeanFactory的基础上增加了很多企业级功能，例如AOP、国际化、事件支持等。

ApplicationContext 接口有两个常用的实现类，具体如下。
(1)ClassPathXmlApplicationContext
该类从类路径ClassPath中寻找指定的XML配置文件，并完成ApplicationContext的实例化工作，具体如下所示。

ApplicationContext applicationContext = new ClassPathXmlApplicationContext(String configLocation);

在上述代码中，configLocation参数用于指定Spring配置文件的名称和位置，如 Beans.xml。
(2)FileSystemXmlApplicationContext
该类从指定的文件系统路径中寻找指定的 XML 配置文件，并完成ApplicationContext的实例化工作，具体如下所示。

ApplicationContext applicationContext = new FileSystemXmlApplicationContext(String configLocation);

它与 ClassPathXmlApplicationContext 的区别是：在读取 Spring 的配置文件时，FileSystemXmlApplicationContext 不会从类路径中读取配置文件，而是通过参数指定配置文件的位置。即 FileSystemXmlApplicationContext 可以获取类路径之外的资源，如“F:/workspaces/Beans.xml”。