IOC 的底层原理和Bean管理XML方式、xml注入集合属性

_妲己

已于 2022-11-30 16:15:06 修改

阅读量519

点赞数

文章标签： java spring 开发语言

于 2022-11-30 16:09:18 首次发布

本文链接：https://blog.csdn.net/m0_57448314/article/details/128091436

版权

ICO操作Bean管理（xml 注入其他类型属性）

注入属性-外部bean

注入属性 - 内部 bean 和级联赋值

IOC 操作Bean管理（xml注入集合属性）

在spring配置文件进行配置

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

把集合部分注入提取出来

什么是IOC

控制反转，把对象创建和对象之间的调用过程，交给Spring进行管理
使用IOC目的，为了降低耦合度

IOC底层管理

xml解析、工厂模式、反射

IOC的实现原理—反射与工厂模式的结合

工厂模式

下面是原始的模式

耦合度太高导致service 和到任何一个发生变化，另一个都会发生变化，所以我们需要将耦合度降低，并且降低到最低限度。

再看看工厂模式，下图通过工厂模式降低 service 和 Dao 的耦合性，最终的目的是将耦合度降低到最低限度。

IOC 的过程

第一步：xml配置文件，配置创建的对象

<bean id= "dao" class="com.aiguigu.UserDao"></bean>

第二步，有service类和dao类，创建工厂类。

之前是直接new一个对象，但现在不这样做了，现在通过xml 解析和反射来完成。

由xml 解析来获取上面的值，然后通过反射得到编码文件创建对象

目的：进一步降低耦合度

IOC 接口

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

2.Spring 提供IOC容器实现两种方式：（有两个接口）

BeanFactory ：IOC容器基本实现，是spring 内部的使用接口，不提供开发人员进行使用

ApplicationContext ：BeanFactory 接口的子接口，提供更多强大的功能，一般由于开发人员进行使用。

加载配置文件时候就会把配置文件对象进行创建。

ApplicationContext 接口有实现类：

IOC 操作Bean 原理

什么是Bean管理

Bean 管理指的是两个操作：Spring 创建对象、Spring注入属性。

如下，在创建对象过程中获取属性就叫bean管理。

创建了一个userName 属性，然后向username中设置值

public class User {

    private String userName;

    public void add() {
        System.out.println("add....");
    }
}

Bean 管理操作有两种方式

第一种：基于xml 配置方式实现

第二种：基于注解方式实现

IOC 操作Bean 管理（基于xml方式）

1. 基于xml 配置方式创建对象

配置User对象创建

<bean id= "dao" class="com.aiguigu.UserDao"></bean>

1. 在spring 配置文件中，使用bean标签，标签里面添加对应属性，就可以实现对象创建。

2. 在bean标签有很多属性，介绍常用的属性：

id 属性：唯一标识

class属性：类全路径（包类路径）

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

2. 基于xml方式注入属性

DI ：依赖注入，就是注入属性

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

public class Book {

    //使用set方法进行注入属性
    //创建属性
    private String bname;

    private String bautbur;
    //创建属性对应的set方法
    public void setBautbur(String bautbur) {
        this.bautbur = bautbur;
    }

    public void Book(String bname) {
        this.bname = bname;
    }
}

在spring 配置文件配置对象创建，配置属性注入

    <bean id="book" class="com.atguigu.spring5.Book">
        <!-- 使用property 完成属性注入
        name 类里面属性名称
        value ：向属性注入的值
        -->
       <property name="bname" value="异烟肼"></property>
       <property name="bautbur" value="贵妃椅"></property>
    </bean>

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

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

public class Orders {
    //属性
    private String oname;
    private String address;
    //有参构造
    public Orders(String oname, String address) {
        this.oname = oname;
        this.address = address;
    }
}

在spring配置文件中进行配置

    <!--有参构造注入属性-->
    <bean id="orders" class="com.atguigu.spring5.Orders">
        <constructor-arg name="oname" value="abc"></constructor-arg>
        <constructor-arg name="address" value="China"></constructor-arg>
    </bean>

p 名称空间注入

使用 p 名称空间注入，可以简化基于xml 配置方式。

第一步添加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">
</bean>

第二步进行属性注入，在bean标签里面进行操作

    <bean id="book" class="com.atguigu.spring5.Book" p:bname="spring入门" p:bautbur="spring5书籍"></bean>
</beans>

ICO操作Bean管理（xml 注入其他类型属性）

字面量

null

        <!--null值-->
        <property name="address">
            <null/>
        </property>

属性值包含特殊字符

把<>进行转义&lt；&；

把带特殊字符内容写到CDATA

        <property name="address">
            <value>
                <![CDATA[<<南京>>]]>
            </value>
        </property>

注入属性-外部bean

先看看原始的方式：创建 UserDao 对象

    public void add(){
        System.out.println("UserService  add...");
        //原始方式创建：创建 UserDao 对象
         UserDao userDao = new UserDaoImpI();
         userDao.update();
    }

下面用另一种方式创建，先创建Userdao、Userservice、UserImpI层，在UserDaoImpI中创建两个对象，然后在Userservice注入到里面，可以有参构造也可以用set构造，之前是使用字符串类型，一个一个地注入，现在使用的是Userdao是对象类型，也可以是属性也可以是字符串、对象都可以，现在Userservice里面把UserDaoImpI注入。

先创建两个类service类和dao类，在service调用dao里面的方法，在spring配置文件中进行配置

UserDao

package com.atguigu.spring5.dao;

public interface UserDao {
    public void update();
}

UserDaoImpI

package com.atguigu.spring5.dao;

public class UserDaoImpI implements UserDao{

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

UserService

public class UserService {

    //创建UserDao类型属性生成set方法
    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void add() {
        System.out.println("UserService  add...");
/*        //原始方式创建：创建 UserDao 对象
         UserDao userDao = new UserDaoImpI();*/
        userDao.update();
    }

}

xml 文件

    <!--service 和 dao 对象创建-->
    <bean id="userService" class="com.atguigu.spring5.dao.UserDao.UserService">
        <!--注入userDao对象
        name 属性值：类里面属性名称
        ref 属性：创建 userDao 对象bean标签id值
        -->
        <property name="userDao" ref="userDaoImpI">
        </property>

    </bean>

注入属性 - 内部 bean 和级联赋值

一对多关系：部门和员工

一个部门有多个员工，一个员工属于一个部门；部门是一，员工是多。

在实体类之间表示一对多关系，员工表示所属部门，使用对象类型属性进行表示。

部门类

//部门类
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;
    }
}

下面是内部bean ，内部bean效率较高，但大多数人喜欢外部bean的写法

<bean id="emp" class="com.atguigu.spring5.bean.Emp">  
    <!--设置两个普通属性 -->  
    <property name="ename" value="lucy"></property>  
    <property name="gender" value="女"></property>  
    <!--设置对象类型属性-->  
    <property name="dept>">  
        <bean id="dept" class="com.atguigu.spring5.bean.Dept">  
            <property name="dname" value ="安保部"></property>  
        </bean>  
    </property>  
</bean>

注入属性-级联赋值：

<bean id="emp" class="com.atguigu.spring5.bean.Emp">  
    <!--设置两个普通属性 -->  
    <property name="ename" value="lucy"></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>

IOC 操作Bean管理（xml注入集合属性）

注入数组类型属性
注入List集合类型属性
注入Map集合类型属性

创建类，定义数组、list、map、set 类型属性，生成对应set方法

public class Stu {
    //1. 数组类型属性
    private String[] courses;

    //2. list 集合类型属性
    private List<String> list;

    //3. map 集合类型属性
    private Map<String,String> map;

    //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 setMap(Map<String, String> map) {
        this.map = map;
    }
}

在spring配置文件进行配置

数组类型属性注入

    
        <!--1.数组类型属性注入-->
        <property name="courses">
            <array>
                <value>java课程</value>
                <value>数据库课程</value>
            </array>
        </property>

list 类型属性注入

        <!--2. list 类型属性注入-->
        <property name="list">
            <list>
                <value>张三</value>
                <value>小三</value>
            </list>
        </property>

map 类型注入

        <!--map 类型注入-->
        <property name="map">
            <map>
                <entry key="JAVA" value="java"></entry>
                <entry key="PHP" value="php"></entry>
            </map>
        </property>

set 类型属性注入

        <!--set类型属性注入-->
        <property name="sets">
            <set>
                <value>MySQL</value>
                <value>Redis</value>
            </set>
        </property>

集合类型属性注入

    <!--1. 集合类型属性-->
    <bean id="stu" class="com.atguigu.spring5.collectiontype.Stu">
        <!--1.数组类型属性注入-->
        <property name="courses">
            <array>
                <value>java课程</value>
                <value>数据库课程</value>
            </array>
        </property>
        <!--2. list 类型属性注入-->
        <property name="list">
            <list>
                <value>张三</value>
                <value>小三</value>
            </list>
        </property>
        <!--3. map 类型注入-->
        <property name="map">
            <map>
                <entry key="JAVA" value="java"></entry>
                <entry key="PHP" value="php"></entry>
            </map>
        </property>
        <!--4.set类型属性注入-->
        <property name="sets">
            <set>
                <value>MySQL</value>
                <value>Redis</value>
            </set>
        </property>
</bean>

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

创建多个course对象

    <!-- 创建多个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集合类型，值是对象

<!-- 注入list集合类型，值是对象-->
        <property name="courseList">
           <list>
               <ref bean="course1"></ref>
               <ref bean="course2"></ref>
           </list>
        </property>

把集合部分注入提取出来

在spring配置文件中引入名称空间until

<?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"
       xmlns:until="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">

使用until标签完成list集合注入提取

    <!--1. 提取list集合类型属性注入-->
    <until:list id="booklist">
        <value>JOJO</value>
        <value>南计划</value>
        <value>破解</value>
    </until:list>

提取list集合类型属性注入使用

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

测试类

     @Test
    public void testCollection2(){
        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean2.xml");
        Book stu = context.getBean("book", Book.class);
        stu.test();
    }

输出

public class Book {
    public List<String> list;

    public void setList(List<String> list) {
        this.list = list;
    }
    public void test(){
        System.out.println(list);
    }

}

_妲己

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
IOC 的底层原理和Bean管理XML方式、xml注入集合属性

Bean 管理指的是两个操作：Spring 创建对象、Spring注入属性。如下，在创建对象过程中获取属性就叫bean管理。创建了一个userName 属性，然后向username中设置值。
复制链接

扫一扫