Spring学习：Bean管理（XML方式）

一、Bean管理概述

1.1 Bean管理

1. Bean管理指的是两个操作（依赖注入），分别为：

• Spring创建对象（依赖）
• Spring注入属性（注入）

2. Bean 管理操作有两种方式 ：

• 基于xml配置文件方式实现
• 基于注解方式实现

1.2 基于XML方式创建对象

（1） 在spring配置文件中，使用bean标签，标签里面添加对应的属性，就可以实现对象的创建。如下所示：

（2）在Bean标签中有很多属性，如上例中的id、class。常见的属性及其含义如下：

• id属性： 唯一标识（别名）
• class属性：类全路径（包类路径）

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

二、 基于xml方式注入属性

DI:依赖注入

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

            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;
    }
}

            2. 在spring配置文件配置对象创建（标签），配置属性注入（标签内部的标签）。注入属性在创建对象的基础之上完成，先创建对象，在注入属性。

对xml方式使用set进行注入的测试：

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

测试结果： 

com.wyf.spring5.Book@3c46e67a
史记::司马迁

2.2 第二种注入方式：使用有参数的构造函数进行注入

            1. 创建 类，定义属性，创建属性对应的有参数构造方法

public class Orders {
    //属性
    private String name;
    private String address;
    //多参数构造函数
    public Orders(String name, String address) {
        this.name = name;
        this.address = address;
    }
}

            2. 在spring配置文件中进行配置：

对xml方式使用有参构造注入的测试：

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

测试结果：

com.wyf.spring5.Orders@74e52ef6
abc::china

 2.3  xml注入其他类型属性

2.3.1  字面量

        （1）设置null值：

           (2)  属性值包含特殊符号：

 
 
    >]]> 
 

2.3.2 注入属性-外部bean

示例：

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

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

        3） 在sping配置文件中进行配置。

userDao实现类：

public class UserDaoImpl implements UserDao{
    @Override
    public void updata() {
        System.out.println("dao updata....");
    }
}

 UserService类：

/**
 * 在UserService中调用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....");

//        /**
//         * 原始的调用方式
//         */
//        UserDao dao = new UserDaoImpl();
//        dao.updata();

        /**
         * Spring方式
         */
        userDao.updata();

    }
}

 配置文件将userDao注入到userService中：

2.3.3 注入属性—内部bean

示例：

        一对多关系，如部门和员工。一个部门有多个员工，一个员工属于一个部门，部门是一，员工是多 。  

        使用实体类表示一对多的关系如下所示：

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

    @Override
    public String toString() {
        return "Dept{" +
                "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;
    }

    public void add(){
        System.out.println(ename+"::"+gender+"::"+dept.toString());
    }
}

在spring配置文件中进行配置（配置为内部bean）：

 2.3.4  xml注入集合属性

  示例：

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

       （1）创建类，并在其中定义数组，list、map、set类型属性，生成对应的set方法

public class Stu {
    //1. 数组类型属性
    private String[] courses;
    //2.list集合类型属性
    private List list;
    //3.Map集合类型属性
    private Map maps;
    //4. set集合类型属性
    private Set sets;
    
    //学生所学的多门课程
    private List courseList;
    public void setCourseList(List courseList) {
        this.courseList = courseList;
    }
    
    public void setCourses(String[] courses) {
        this.courses = courses;
    }
    public void setList(List list) {
        this.list = list;
    }
    public void setMaps(Map maps) {
        this.maps = maps;
    }
    public void setSets(Set sets) {
        this.sets = sets;
    }
}

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

    
    
        
        
            
                数学
                英语
            
        
        
        
            
                java
                C++
                C#
            
        
        
        
            
        
        
        
            
                Mysql
                Redis
            
        
    

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

     5. 把集合注入部分提取出来

         (1) 在 spring 配置文件中引入名称空间 util 

       （2）使用 util 标签完成 list 集合注入提取 

 
     
    易筋经 
    九阴真经 
    九阳神功 
 
 
 
     
 

三、FactoryBean

        Spring 有两种类型 bean，一种普通 bean，另外一种工厂 bean（FactoryBean)。

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

            第一步 创建类，让这个类作为工厂 bean，实现接口 FactoryBean 
            第二步 实现接口里面的方法，在实现的方法中定义返回的 bean 类型 ,如下方法getObject

import com.wyf.collectionType.Course;
import org.springframework.beans.factory.FactoryBean;

public class MyBean implements FactoryBean{

    /**
     * 定义返回bean对象
     * 此处返回Course类型
     * @return
     * @throws Exception
     */
    @Override
    public Course getObject() throws Exception {
        Course course = new Course();
        course.setCname("abc");
        return course;
    }

    @Override
    public Class getObjectType() {
        return null;
    }

    @Override
    public boolean isSingleton() {
        return FactoryBean.super.isSingleton();
    }
}

配置文件：

测试代码：

    @Test
    public void TestBean5(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean5.xml");
        Course myBean = context.getBean("mybean",Course.class);
        System.out.println(myBean);
    }

        虽然定义的类型为MyBean，但是工程Bean返回的是Course类型。

四、Bean作用域及声明周期

 4.1 Bean作用域

        在Spring中，Bean作用域用于确定那种类型的Bean实例应该从Spring容器中返回给调用者 ，即设置创建bean实例是单实例还是多实例。Spring中默认情况下Bean是单实例的。

默认情况获取Bean:

    @Test
    public void TestBean4(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean4.xml");
        Stu stu = context.getBean("stu",Stu.class);
        Stu stu2 = context.getBean("stu",Stu.class);
        System.out.println(stu);
        System.out.println(stu2);
    }

程序输出结果表明stu和stu2是同一个对象，也就是单实例：

com.wyf.collectionType.Stu@2a5c8d3f
com.wyf.collectionType.Stu@2a5c8d3f

4.2 设置Bean为单实例或多实例

        在 spring 配置文件 bean 标签里面有属性（scope）用于设置单实例还是多实例 。scope 属性值 如下：

• 第一个值 默认值，singleton，表示为单实例对象。
• 第二个值 prototype, 表示是多实例对象。

在配置文件中设置scope属性值为多实例： 

程序运行结果表明是两个不同的对象：

com.wyf.collectionType.Stu@2a5c8d3f
com.wyf.collectionType.Stu@752325ad

singleton 和 prototype 区别 ：
        1. singleton 单实例，prototype 多实例 
        2. 设置 scope 值是 singleton 时候，加载 spring 配置文件时候就会创建单实例对象，设置 scope 值是 prototype 时候，不是在加载 spring 配置文件时候创建对象，在调用getBean 方法时候创建多实例对象 。

4.3 Bean的生命周期

        生命周期是指从对象创建到对象销毁的过程。

Bean的生命周期过程如下：

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

 示例如下：

public class Orders {
    //无参构造
    public Orders(){
        System.out.println("第一步 执行无参构造，创建bean实例");
    }

    private String onname;
    public void setOnname(String onname) {
        this.onname = onname;
        System.out.println("第二步 调用set方法设置属性值");
    }

    //创建执行的初始化的方法
    public void initMethod(){
        System.out.println("第三步 执行初始化方法");
    }

    //创建执行的销毁的方法
    public void destroyMethod() {
        System.out.println("第五步 执行销毁的方法");
    }
}

配置文件如下：

测试代码如下：

    @Test
    public void TestBean5(){
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean5.xml");
        Orders orsers = context.getBean("orders",Orders.class);
        System.out.println("第四步 获取创建 bean实例对象 ");
        System.out.println(orsers);
        //手动让bean实例销毁
        context.close();
    }

程序运行结果：

第一步 执行无参构造，创建bean实例
第二步 调用set方法设置属性值
第三步 执行初始化方法
第四步 获取创建 bean实例对象 
com.wyf.bean.Orders@22555ebf
第五步 执行销毁的方法

加上bean 的后置处理器，其实bean 生命周期有七步 ：

（1）通过构造器创建 bean 实例（无参数构造） 
（2）为 bean 的属性设置值和对其他 bean 引用（调用 set 方法） 
（3）把bean 实例传递 bean后置处理器的方法 postProcessBeforeInitialization 
（4）调用 bean 的初始化的方法（需要进行配置初始化的方法）

（5）把bean 实例传递 bean 后置处理器的方法 postProcessAfterInitialization 
（6）bean 可以使用了（对象获取到了） 
（7）当容器关闭时候，调用 bean 的销毁的方法（需要进行配置销毁的方法）

五、xml自动装配（很少使用，一般用注解）

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

（1）根据属性名称自动注入 。注入值bean的 id值和类属性名称一样

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

六、结束

        本文是对尚硅谷Spring教程的学习笔记，主要介绍了基于xml的spring属性注入。