Spring5笔记（一）Bean管理XML方式

1.IOC

1. 什么是IOC

   Ioc—Inversion of Control，即“控制反转”，不是什么技术，而是一种设计思想。在Java开发中，Ioc意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制。

2. IOC原理

   xml解析 工厂模式 反射

   原始方式

工厂模式

通过工厂模式创建对象：使用static关键字创建静态方法getDao，静态方法可以直接通过类名调用，UserService通过工厂可以获得UserDao对象。这种模式降低了Service和Dao之间的耦合度。

2. IOC（接口）

1.IOC思想基于IOC容器完成，IOC容器底层就是对象工厂

2.Spring提供IOC容器实现的两个接口：

• BeanFactory ：Spring内部使用的接口，加载配置文件时不会创建对象，获取对象时才会使用

• ApplicationConetext：BeanFactory的子接口，提供功能更加强大。 加载配置文件时就会创建对象

3.IOC操作Bean管理

1. 什么是Bean管理

• 创建对象

• 注入属性

2. Bean管理操作的两种方式

• 基于xml配置文件方式

<!--    配置people对象创建-->
    <bean id="people" class="com.zhu.pojo.People"></bean>
复制代码

（1）在Spring配置文件中，使用bean标签，标签里添加对应的属性就可以创建对象。

（2）bean标签常用属性：id属性：唯一标识 **class属性：**类全路径

（3）创建对象时默认执行无参构造方法

3.基于XMl方式注入属性

​ (1)DI:依赖注入

第一种方式使用set方法注入。

public class Book {
    private String Bname;
    private String Bauthor;

    public void setBname(String bname) {
        Bname = bname;
    }
    public void setBauthor(String bauthor) {
        Bauthor = bauthor;
    }
    public void test(){
        System.out.println(Bname+""+Bauthor);
    }
}
复制代码

<bean id="book" class="com.zhu.pojo.Book">
        <!--  使用property完成属性注入      -->
        <property name="bname" value="朝花夕拾"/>
        <property name="bauthor" value="鲁迅"/>
</bean>
复制代码

@Test
public void testBook(){
    ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
    Book book = context.getBean("book", Book.class);
    System.out.println(book);
    book.test();
}
复制代码

第二种方式使用有参数构造注入。

<!--    有参构造注入-->
<bean id="orders" class="com.zhu.pojo.Orders">
    <constructor-arg name="oName" value="Computer"/>
    <constructor-arg name="address" value="China"/>
</bean>
复制代码

public class Orders {
    private String oName;
    private String address;

    //  有参构造
    public Orders(String oName, String address) {
        this.oName = oName;
        this.address = address;
    }

    public void test() {
        System.out.println(oName + " " + address);
    }
}
复制代码

@Test
public void testOrders(){
    ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
    Orders orders = context.getBean("orders",Orders.class);
    System.out.println(orders);
    orders.test();
}
复制代码

• 基于注解方式

4.IOC操作Bean管理（XML注入其他属性）

1.字面量

​ (1) null 值

<property name="bauthor">
    <null/>
</property>
复制代码

2.外部Bean

service类调用dao类

<bean id="userServiceImpl" class="com.zhu.service.UserServiceImpl">
        <!--        注入userDao对象-->
        <property name="userdao" ref="userDaoImpl"></property>
</bean>
<bean id="userDaoImpl" class="com.zhu.Dao.UserDaoImpl"></bean>
复制代码

3.内部bean

(1)一对多：

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);
    }
}
复制代码

public class Dept {
    private String dName;

    public void setdName(String dName) {
        this.dName = dName;
    }

    @Override
    public String toString() {
        return "Dept{" +
                "dName='" + dName + '\'' +
                '}';
    }
}
复制代码

<bean id="emp" class="com.zhu.pojo.Emp">
    <property name="eName" value="Jack"/>
    <property name="gender" value="男"/>
    <property name="dept">
        <bean id="dept" class="com.zhu.pojo.Dept">
            <property name="dName" value="开发"/>
        </bean>
    </property>
</bean>
复制代码

4.注入数组，list，map，set 类型属性

public class Stu {
    // 数组类型属性
    private String[] courses;
    //集合类型属性
    private List<String> list;
    //map类型
    private Map<String,String> maps;
    private Set<String> set;

    public void setSet(Set<String> set) {
        this.set = set;
    }

    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;
    }
    public void test(){
        System.out.println(Arrays.toString(courses));
        System.out.println(list);
        System.out.println(maps);
        System.out.println(set);
    }
}
复制代码

<bean id="stu" class="com.zhu.pojo.Stu"> 
    <property name="courses" >
        <array>
            <value>java开发</value>
            <value>Linux运维</value>
        </array>
    </property>
    <property name="list">
        <list>
            <value>张三</value>
            <value>李四</value>
        </list>
    </property>
    <property name="maps">
        <map>
            <entry key="JAVA" value="java"></entry>
            <entry key="JSP" value="JSP"></entry>
        </map>
    </property>
    <property name="set">
        <set>
            <value>Mysql</value>
            <value>redis</value>
        </set>
    </property>
</bean>
复制代码

在集合中设置对象类型值

<property name="courseList">
    <list>
        <ref bean="course1"></ref>
        <ref bean="course2"></ref>
    </list>
</property>
复制代码

<bean id="course1" class="com.zhu.pojo.Course">
    <property name="courses">
        <value>Spring5课程</value>
    </property>
</bean>
<bean id="course2" class="com.zhu.pojo.Course">
    <property name="courses">
        <value>Mybatis课程</value>
    </property>
</bean>
复制代码

5.IOC操作Bean管理（bean的作用域）

1.在Spring里创建的bean实例默认是单实例

2.设置多实例

<bean id="book" class="com.zhu.pojo.Book" scope="prototype">
复制代码

3.singleton和prototype的区别

设置scope值为singleton时，加载spring配置文件就会创建单实例对象

ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
复制代码

设置scope值为prototype时，在调用getbean方法时创建多实例对象

Book book1= context.getBean("book", Book.class);
复制代码

6.IOC操作Bean管理（bean生命周期）

1.通过构造器创建bean实例（无参构造器）

2.为bean的属性设置值（调用set方法）

3.把bean实例传递bean后置处理器的方法postProcessBeforeInitialization

4.调用bean的初始化方法（需要进行配置）

6.bean可以使用（对象获取到了）

7.当容器关闭，调用bean的销毁方法（需要进行配置销毁方法 ”）

<bean id="book" class="com.zhu.pojo.Book" init-method="initMethod" destroy-method="destroy">
复制代码

package com.zhu.pojo;

public class Book {
    private String Bname;
    private String Bauthor;

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

    public void setBname(String bname) {
        Bname = bname;
        System.out.println("第二部 调用set方法设置属性的值");
    }

    public void setBauthor(String bauthor) {
        Bauthor = bauthor;
    }

    public void test() {
        System.out.println(Bname + "" + Bauthor);
    }

    public void initMethod(){
        System.out.println("第三步 调用初始化方法");
    }
    public void destroy(){
        System.out.println("第五步 执行销毁方法");
    }
}
复制代码

@Test
public void testBook(){
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
    Book book1= context.getBean("book", Book.class);
    System.out.println("第四步 获取bean实例对象");
    book1.test();
    context.close();
}
复制代码

第一步：执行无参构造创建bean实例
第二部 调用set方法设置属性的值
第三步 调用初始化方法
第四步 获取bean实例对象
朝花夕拾null
第五步 执行销毁方法

Process finished with exit code 0

复制代码