Spring之IOC（一）

最新推荐文章于 2024-07-18 16:02:28 发布

喵先森爱吃鱼

最新推荐文章于 2024-07-18 16:02:28 发布

阅读量195

点赞数

分类专栏： Spring 文章标签： spring java 后端

本文链接：https://blog.csdn.net/dingd1234/article/details/121238566

版权

Spring 专栏收录该内容

21 篇文章 1 订阅

订阅专栏

一、概念和原理

1、什么是IOC

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

2、IOC底层原理

xml解析、工厂模式、反射
（1）xml 配置文件，配置创建的对象

　<bean id="dao" class="com.atguigu.UserDap"></bean>

（2）Service类和dao类，创建工厂类

class UserFactory{
	public static UserDao getDao(){
		String classValue = class属性值;  // 1、xml解析
		Class clazz = Class.forName(classValue); //2、通过反射创建对象
		return (UserDao) clazz.newInstance();
	}
}

二、BeanFactory 接口

（1）IOC思想基于 IOC 容器完成，IOC 容器底层就是对象工厂。
（2）Spring 提供 IOC 容器实现方式有两种（两个接口）：

BeanFactory：IOC 容器基本实现，是 Spring 内部的使用接口，不提供开发人员进行使用。加载配置文件时候不会创建对象，在获取对象（使用）时才去创建对象。
ApplicationContext：BeanFactory 接口的子接口，提供更多更强大的功能，一般由开发人员进行使用。加载配置文件时就会创建对象。
（3）ApplicationContext 接口的实现类

三、IOC 操作 Bean 管理

什么是 Bean 管理

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

Bean 管理操作有两种方式

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

1、基于 xml 方式

（1）基于 xml 方式创建对象

<bean id="user" class="com.company.User"></bean>

在 Spring 配置文件中，使用 bean 标签，标签里面添加对应属性，就可以实现对象创建。
bean 标签属性：
id 属性：唯一标识
class 属性：类全路径（包类路径）
创建对象的时候，默认执行无参构造方法完成对象创建。

（2）基于 xml 方式注入属性
DI：依赖注入，就是属性注入
（3）第一种注入方式：使用 set 方式进行注入

创建类，定义属性和对应的 set 方法

public class Book {
    private String bname;
    private String bauthor;

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

    public void setBauthor(String bauthor) {
        this.bauthor = bauthor;
    }
}

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

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       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.xsd">

    <bean id="book" class="com.company.testdemo.Book">
        <!--使用 property 完成属性注入
            name：类里面的属性名称
            value：向属性注入的值
        -->
        <property name="bname" value="易筋经"></property>
        <property name="bauthor" value="达摩老祖"></property>
    </bean>
</beans>

结果验证

@Test
    public void testBook(){
        // 1、加载Spring配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");

        // 2、获取配置创建的对象
        Book book = context.getBean("book", Book.class);
        System.out.println(book.toString());
    }

结果：在这里插入图片描述
（4）第二种注入方式：使用有参构造进行注入

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

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

    public Orders(String oname, String address) {
        this.oname = oname;
        this.address = address;
    }
}

在 Spring 配置文件中进行配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       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.xsd">

    <!--有参构造注入属性-->
    <bean id="orders" class="com.company.testdemo.Orders">
        <constructor-arg name="oname" value="电脑"></constructor-arg>
        <constructor-arg name="address" value="China"></constructor-arg>
    </bean>
</beans>

（5）p 名称空间注入

在配置文件中添加 p 名称空间xmlns:p="http://www.springframework.org/schema/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 id="book" class="com.company.testdemo.Book" p:bname="九阳神功" p:bauthor="无名氏"></bean>

（6）xml注入字面量

null 值

输出结果：
属性值包含特殊符号
以“<< >>" 为例
第一种方式：将特殊符号进行转义

<bean id="book" class="com.company.testdemo.Book">
        <!--属性值包含特殊符号：
            把<>进行转义 &lt; &gt;
        -->
        <property name="bname" value="&lt;&lt;神雕侠侣&gt;&gt;"></property>
        <property name="bauthor">
            <null></null>
        </property>
    </bean>

输出结果：
在这里插入图片描述
第二种方式：把带特殊符号的内容写到 CDATA 中，格式为<![CDATA[内容]]>

<bean id="book" class="com.company.testdemo.Book">
        <!--属性值包含特殊符号：
            把带特殊符号的内容写到 CDATA 中
        -->
        <property name="bname">
            <value><![CDATA[<<神雕侠侣>]]></value>
        </property>
        <property name="bauthor">
            <null></null>
        </property>
    </bean>

输出结果：
在这里插入图片描述
（7）注入属性——外部bean

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

在这里插入图片描述
UserDao：

package com.company.dao;

public interface UserDao {
    void update();
}

UserDaoImpl:

package com.company.dao.impl;

import com.company.dao.UserDao;

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

UserService：

package com.company.service;

import com.company.dao.UserDao;

public class UserService {
    // 创建 UserDao 类型属性，生成 set 方法
    private UserDao userDao;

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

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

xml配置文件：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       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.xsd">

    <bean id="userService" class="com.company.service.UserService">
        <property name="userDao" ref="userDaoImpl"></property>
    </bean>

    <bean id="userDaoImpl" class="com.company.dao.impl.UserDaoImpl"></bean>

</beans>

代码测试：

@Test
    public void testBean5(){
        // 1、加载Spring配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("bean5.xml");

        // 2、获取配置创建的对象
        UserService userService = context.getBean("userService", UserService.class);
        userService.add();
    }

结果输出：

dao update..............
service add..........

（8）注入属性——内部bean

一对多关系：部门和员工
一个部门有多个员工，一个员工属于一个部门
部门是一，员工是多
在实体类之间表示一对多关系，员工表示所属部门，使用对象类型属性进行表示

部门类：

package com.testSpring;

public class Dept {
    private String dname;

    public void setDname(String dname) {
        this.dname = dname;
    }

    @Override
    public String toString() {
        return "Dept{" +
                "dname='" + dname + '\'' +
                '}';
    }
}

员工类：

package com.testSpring;

public class Emp {
    private String ename;
    private String gender;

    // 员工属于某一个部门，使用对象形式表示
    private Dept dept;

    public void setGender(String gender) {
        this.gender = gender;
    }

    public void setEname(String ename) {
        this.ename = ename;
    }

    public void setDept(Dept dept) {
        this.dept = dept;
    }

    @Override
    public String toString() {
        return "Emp{" +
                "ename='" + ename + '\'' +
                ", gender='" + gender + '\'' +
                ", dept=" + dept +
                '}';
    }

}

xml配置文件方式一：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       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.xsd">

    <bean id="emp" class="com.testSpring.Emp">
        <property name="ename" value="张三"></property>
        <property name="gender" value="男"></property>
        <property name="dept" ref="dept"></property>
    </bean>

    <bean id="dept" class="com.testSpring.Dept">
        <property name="dname" value="综合部"></property>
    </bean>

</beans>

xml配置文件方式二：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       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.xsd">

    <bean id="emp" class="com.testSpring.Emp">
        <property name="ename" value="张三"></property>
        <property name="gender" value="男"></property>
        <property name="dept">
            <bean id="dept" class="com.testSpring.Dept">
                <property name="dname" value="综合部"></property>
            </bean>
        </property>
    </bean>

</beans>

测试代码：

@Test
    public void testBean6(){
        // 1、加载Spring配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("bean6.xml");

        // 2、获取配置创建的对象
        Emp emp = context.getBean("emp", Emp.class);
        System.out.println(emp.toString());

    }

结果输出：

Emp{ename='张三', gender='男', dept=Dept{dname='综合部'}}

（9）xml注入集合属性

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

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

package com.testCollection;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;

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

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

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

    // set 集合类型属性
    private Set<String> sets;

    public void setCourses(String[] courses) {
        this.courses = courses;
    }

    public void setLists(List<String> lists) {
        this.lists = lists;
    }

    public void setMaps(Map<String, String> maps) {
        this.maps = maps;
    }

    public void setSets(Set<String> sets) {
        this.sets = sets;
    }

    @Override
    public String toString() {
        return "Stu{" +
                "courses=" + Arrays.toString(courses) +
                ", lists=" + lists +
                ", maps=" + maps +
                ", sets=" + sets +
                '}';
    }
}

步骤二：在 Spring 配置文件中进行设置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       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.xsd">

    <bean id="stu" class="com.testCollection.Stu">
        <!--数组类型属性注入-->
        <property name="courses">
            <array>
                <value>java</value>
                <value>数据库</value>
                <value>计算机组成原理</value>
            </array>
        </property>
        <!--list类型属性注入-->
        <property name="lists">
            <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>

</beans>

测试代码：

@Test
    public void testCollection(){
        // 1、加载Spring配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("testCollection.xml");

        // 2、获取配置创建的对象
        Stu stu = context.getBean("stu", Stu.class);
        System.out.println(stu.toString());

    }

输出结果：

Stu{courses=[java, 数据库, 计算机组成原理], lists=[张三, 李四], maps={JAVA=java, PHP=php}, sets=[MySQL, Redis]}

（10）在集合里面设置对象类型值
Course类：

package com.testCollection;

public class Course {
    private String cname;

    public void setCname(String cname) {
        this.cname = cname;
    }

    @Override
    public String toString() {
        return "Course{" +
                "cname='" + cname + '\'' +
                '}';
    }
}

Student 类：

package com.testCollection;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class Student {

    // list 集合类型属性
    private List<Course> lists;


    public void setLists(List<Course> lists) {
        this.lists = lists;
    }

    @Override
    public String toString() {
        return "Student{" +
                "lists=" + lists +
                '}';
    }
}

Spring配置文件：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       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.xsd">

    <bean id="student" class="com.testCollection.Student">

        <!--list类型属性注入-->
        <property name="lists">
            <list>
                <ref bean="course1"></ref>
                <ref bean="course2"></ref>
            </list>
        </property>
    </bean>


    <bean id="course1" class="com.testCollection.Course">
        <property name="cname" value="JAVA"></property>
    </bean>
    <bean id="course2" class="com.testCollection.Course">
        <property name="cname" value="数据库"></property>
    </bean>

</beans>

测试代码：

@Test
    public void testCollection1(){
        // 1、加载Spring配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("testCollection1.xml");

        // 2、获取配置创建的对象
        Student stu = context.getBean("student", Student.class);
        System.out.println(stu.toString());

    }

输出结果：

Student{lists=[Course{cname='JAVA'}, Course{cname='数据库'}]}

（11）使用 util 标签完成 list 集合类型属性注入提取
注意事项：
需在 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"       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/util https://www.springframework.org/schema/util/spring-util.xsd"
>

创建 Book 类

package com.testCollection;

import java.util.ArrayList;
import java.util.List;

public class Book {
    private List<String> list;

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

    @Override
    public String toString() {
        return "Book{" +
                "list=" + list +
                '}';
    }
}

配置xml文件

<?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"       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/util https://www.springframework.org/schema/util/spring-util.xsd"
>

    <util:list id="bookList">
        <value>神雕侠侣</value>
        <value>射雕英雄传</value>
        <value>鹿鼎记</value>
    </util:list>

    <bean id="book" class="com.testCollection.Book">
        <property name="list" ref="bookList"></property>
    </bean>
</beans>

喵先森爱吃鱼

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring之IOC（一）

一、概念和原理1、什么是IOC（1）IOC：控制反转，把对象创建和对象之间的调用过程，交给 Spring 进行管理。（2）使用 IOC 的目的：为了降低耦合度。2、IOC底层原理xml解析、工厂模式、反射（1）xml 配置文件，配置创建的对象　<bean id="dao" class="com.atguigu.UserDap"></bean>（2）Service类和dao类，创建工厂类class UserFactory{ public static UserDa
复制链接

扫一扫

专栏目录