Spring框架-IOC

最新推荐文章于 2024-07-17 14:23:51 发布

J___code

最新推荐文章于 2024-07-17 14:23:51 发布

阅读量435

点赞数

本文链接：https://blog.csdn.net/qq_41398418/article/details/123674282

版权

框架学习专栏收录该内容

33 篇文章 1 订阅

订阅专栏

1.框架概述

Spring 是轻量级的开源的 JavaEE 框架
Spring 可以解决企业应用开发的复杂性
Spring 有两个核心部分：IOC 和 Aop
IOC：控制反转，把创建对象过程交给 Spring 进行管理
Aop：面向切面，不修改源代码进行功能增强

特点：
方便解耦，简化开发
Aop 编程支持
方便程序测试
方便和其他框架进行整合
方便进行事务操作
降低 API 开发难度

2.入门案例

创建普通类以及普通方法：

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

创建 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">
    <!--配置 User 对象创建-->
    <bean id="user" class="com.psj.User"></bean>
</beans>

进行测试代码编写：

// 1.加载spring配置文件
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
// 2.获取配置创建的对象
User user = context.getBean("user", User.class);
System.out.println(user);
user.add();

3.IOC

3.1 什么是IOC

控制反转，把对象创建和对象之间的调用过程，交给 Spring 进行管理
目的是为了耦合度降低
入门案例就是 IOC 实现

3.2 底层原理

假设要在UserService类中调用UseDao的add方法，传统方式的耦合度太高，假设UserDao路劲改变了，调用的UserDao的其他类都要修改代码：

在这里插入图片描述

为了降低耦合度，可以使用工厂模式，这样其他要使用UserDao类的类通过调用工厂类间接实现，如果UserDao路径改变，此时不需要修改UserService类的代码，只要修改工厂类的代码即可：

在这里插入图片描述

在工厂模式中还是存在一定的耦合，所以采用IOC进一步降低耦合，三个重要的因素是xml解析、工厂模式以及反射。即使路径改变，也只需要修改xml文件即可：

在这里插入图片描述

IOC 思想基于 IOC 容器完成，IOC 容器底层就是对象工厂
Spring 提供 IOC 容器实现两种方式：

BeanFactory：IOC 容器基本实现，是 Spring 内部的使用接口，不提供开发人员进行使用(加载配置文件时候不会创建对象，在获取对象才去创建对象)：
// 使用BeanFactory时该步加载配置文件，此时不会创建对象，等到执行getBean才会创建对象
BeanFactory context = new ClassPathXmlApplicationContext("bean.xml");
User user = context.getBean("user", User.class);
ApplicationContext：BeanFactory 接口的子接口，提供更多更强大的功能，一般由开发人员进行使用(加载配置文件时候就会把在配置文件对象进行创建)：
// 使用ApplicationContext时，假如配置文件中有很多的bean对象，在该步加载配置文件时都会创建，不管用不用
ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
User user = context.getBean("user", User.class);
tips：

在开发中一般使用ApplicationContext，这样在启动服务器的时候就能创建好对象，而不是等到代码要创建对象时再创建

ApplicationContext有两个实现类：

FileSystemXmlApplicationContext：配置文件路径要求是在盘符下的路径

ClassPathXmlApplicationContext：配置文件路径要求是相对于src目录下的路径

3.3 操作 Bean 管理

3.3.1 什么是 Bean 管理

Bean 管理指的是两个操作：
Spring 创建对象：传统方式创建类的实例是通过new XXX，Spring也是调用构造器，只不过实现方式改变了
Spirng 注入属性：传统方式给类的属性赋值(注入属性)是通过set方法或者使用有参构造器，Spring也可以通过这两种方式，只不过实现方式变了

Bean 管理操作有两种方式：
基于 xml 配置文件方式实现
基于注解方式实现

3.3.2 基于 xml 方式

创建对象：<bean id="user" class="com.psj.User"></bean>
- 在 bean 标签有很多属性：
  - id 属性：唯一标识，就是一个别名
  - class 属性：类全路径（包类路径）
  - name属性：和id属性作用一样，使用几率很小
- 创建对象时候，默认执行无参数构造方法完成对象创建。假设类中只有有参构造器(默认创建的无参构造器就不存在了)，还是使用一样的方式创建对象会报错

注入属性：

通过set方法注入：

<bean id="user" class="com.psj.User">
    # 在类中一定要有相应属性的set方法。该name为类中的属性，不同于bean中的name
    <property name="username" value="psj"></property>
</bean>

通过有参构造器注入：

<bean id="user" class="com.psj.User">
    # 在类中一定要有相应的有参构造器(假设类中只有有参构造器，没写constructor-arg标签前会报错，写完后不会报错)
    <constructor-arg name="username" value="psj"></constructor-arg>
</bean>

p 名称空间注入：

<?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"  # 添加 p 名称空间在配置文件中
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    # 不同于constructor-arg，类中只有有参构造器时会报错
    <bean id="user" class="com.psj.User" p:username="psj"></bean>
</beans>

注入其他类型属性(都采取set方法注入)：

注入null 值：要给username设置null值，直接使用<property name="username" value=null></property>是不行的

<bean id="user" class="com.psj.User">
    <property name="username">
        <null/>
    </property>
</bean>

注入包含特殊符号的属性值：设置的值中包括了特殊符号，直接采取<property name="username" value="<<psj>>">是不行的

#1.把<和>进行转义 &lt; &gt;
<bean id="user" class="com.psj.User">
    <property name="username">
        <value>&lt;&lt;psj&gt;&gt;</value>
    </property>
</bean>  
<bean id="user" class="com.psj.User">
    <property name="username" value="&lt;&lt;psj&gt;&gt;"></property>
</bean>
#2.把带特殊符号内容写到 CDATA
<bean id="user" class="com.psj.User">
    <property name="username">
        <value><![CDATA[<<psj>>]]></value>
    </property>
</bean>

注入外部 bean：要实现UserService类调用UserDao类的操作

# UserDaoImpl类
public class UserDaoImpl implements UserDao{
    @Override
    public void update() {
        System.out.println("DAO UPDATE");
    }
}
# UserService类
public class UserService {
    // 要在xml中注入属性，需要set方法，而set方法需要在类中创建对象
    // 所以不是使用了Spring就可以完全不在类中创建对象
    private UserDao userDao1;

    public void setUserDao1(UserDao userDao1) {
        this.userDao1 = userDao1;
    }

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

<!--创建service和dao对象-->
<bean id="userService" class="com.psj.service.UserService">
    <!--注入UserDao对象-->
    <!--name是在UserService中创建的UserDao类型的属性名称
        ref是创建的UserDao类的bean标签id值-->
    <property name="userDao1" ref="userDao"></property>
</bean>
<!--不要调用UserDao，这是接口，接口不能实例化-->
<bean id="userDao" class="com.psj.dao.UserDaoImpl"></bean>

// 1.加载spring配置文件
ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
// 2.获取配置创建的对象
UserService userService = context.getBean("userService", UserService.class);
userService.add();  // 输出service add...和DAO UPDATE

注入内部 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.xml
<bean id="emp" class="com.psj.bean.Emp">
    <!--设置普通属性-->
    <property name="ename" value="psj"></property>
    <property name="gender" value="男"></property>
    <!--设置对象属性-->
    <property name="dept">
        <bean id="dept" class="com.psj.bean.Dept">
            <property name="dname" value="安保部"></property>
        </bean>
    </property>
</bean>
// 使用外部bean中ref效果是一样的
<bean id="emp" class="com.psj.bean.Emp">
    <!--设置普通属性-->
    <property name="ename" value="psj"></property>
    <property name="gender" value="男"></property>
    <!--设置对象属性-->
    <property name="dept" ref="dept"></property>
</bean>
<bean id="dept" class="com.psj.bean.Dept">
    <property name="dname" value="安保部"></property>
</bean>

级联赋值：

// 方法1：
<bean id="emp" class="com.psj.bean.Emp">
    <!--设置普通属性-->
    <property name="ename" value="psj"></property>
    <property name="gender" value="男"></property>
    <!--设置对象属性-->
    <property name="dept" ref="dept"></property>
</bean>
<bean id="dept" class="com.psj.bean.Dept">
    <property name="dname" value="安保部"></property>
</bean>
// 方法2：
<bean id="emp" class="com.psj.bean.Emp">
    <!--设置普通属性-->
    <property name="ename" value="psj"></property>
    <property name="gender" value="男"></property>
    <!--设置对象属性-->
    <property name="dept" ref="dept"></property>
    // 使用该方式的前提是Emp类中有getDept方法(Dept类中可以没有getDname方法)
    <property name="dept.dname" value="安保部"></property>
</bean>
<bean id="dept" class="com.psj.bean.Dept"></bean>

注入集合属性：

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

    private List<Course> courseList;

    public void setCourseList(List<Course> courseList) {
    this.courseList = courseList;
    }
    
    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 setMaps(Map<String, String> maps) {
        this.maps = maps;
    }
}

<bean id="stu" class="com.psj.bean.Stu">
        <!--数组类型属性注入-->
        <property name="courses">
            <array>
                <value>java</value>
                <value>数据库</value>
            </array>
        </property>
        <!--list 类型属性注入-->
        <property name="list">
            <list>
                <value>psj</value>
                <value>psw</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>

在集合中设置对象类型：

<bean id="course1" class="com.psj.bean.Course">
    <property name="cname" value="Spring5"></property>
</bean>
<bean id="course2" class="com.psj.bean.Course">
    <property name="cname" value="springMVC"></property>
</bean>
<property name="courseList">
    <list>
        <ref bean="course1"></ref>
        <ref bean="course2"></ref>
    </list>
</property>

使用 util 标签完成注入的提取:

<util:list id="nameList">
    <value>psj</value>
    <value>psw</value>
</util:list>
<bean id="name" class="com.psj.bean.Book">
    <property name="list" ref="nameList"></property>
</bean>

tips:

DI(依赖注入)就是注入属性，注入属性不只是Spring的概念

3.3.3 IOC 操作 Bean 管理-FactoryBean

Spring 有两种类型 bean：普通 bean和工厂 bean（FactoryBean）

普通 bean：在配置文件中定义 bean 属于什么类型就返回什么类型

// class中定义了Course类，在getBean("course1", Course.class)返回就是Course类
<bean id="course1" class="com.psj.bean.Course">
    <property name="cname" value="Spring5"></property>
</bean>

工厂 bean：返回类型可以和配置文件定义 bean的类型不一样(本质还是一个bean)

// 具体返回的类型由MyBean的getObject方法决定
<bean id="MyBean" class="com.psj.bean.MyBean"></bean>

public class MyBean implements FactoryBean<Course>{
    // 定义返回的类型,这里定义返回Course类
    @Override
    public Course getObject() throws Exception {
        Course course = new Course();
        course.setCname("psj");
        return course;
    }

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

    @Override
    public boolean isSingleton() {
        return false;
    }
}
// 使用创建的工厂bean
... 
Course course = context.getBean("MyBean", Course.class);  // 确定了要返回的类型后就写返回类型的class
System.out.println(course);

3.3.4 IOC 操作 Bean 管理-bean 作用域

bean作用域：即设置创建 bean 实例是单实例还是多实例(默认情况下为单实例对象）
// 单实例的情况
Book book1 = context.getBean("book", Book.class);
Book book2 = context.getBean("book", Book.class);
System.out.println(book1);  // com.psj.bean.Book@33c911a1
System.out.println(book2);  //com.psj.bean.Book@33c911a1
在 spring 配置文件 bean 标签里面有属性（scope）用于设置单实例还是多实例
设置 scope 值是 singleton 时候，加载 spring 配置文件时候就会创建单实例对象
设置 scope 值是 prototype 时候，不是在加载 spring 配置文件时候创建对象，在调用getBean 方法时候创建多实例对象
# prototype:多实例，singleton:单实例
<bean id="book" class="com.psj.bean.Book" scope="prototype"></bean>  

3.3.5 IOC 操作 Bean 管理-bean 生命周期

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

<bean id="orders" class="com.psj.bean.Orders" init-method="initMethod" destroy-method="destroyMethod">
    <property name="oname" value="手机"></property>
</bean>

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

    private String oname;

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

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

    //创建执行的销毁的方法
    public void destroyMethod() {
        System.out.println("第五步 执行销毁的方法");
    }
}
// ApplicationContext没有close方法，所以使用其子类ClassPathXmlApplicationContext
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
Orders orders = context.getBean("orders", Orders.class);
System.out.println("第四步 获取创建 bean 实例对象");
// 需要手动让 bean 实例销毁
context.close();
// 输出结果
//第一步 执行无参数构造创建 bean 实例
//第二步 调用 set 方法设置属性值
//第三步 执行初始化的方法
//第四步 获取创建 bean 实例对象
//com.psj.bean.Orders@482bce4f
//第五步 执行销毁的方法

tips:

如果加上 bean 的后置处理器，则生命周期变为7步：
1. 通过构造器创建 bean 实例（无参数构造）
2. 为 bean 的属性设置值和对其他 bean 引用（调用 set 方法）
3. 把 bean 实例传递 bean 后置处理器的其中一个方法 postProcessBeforeInitialization
4. 调用 bean 的初始化的方法（需要进行配置初始化的方法）
5. 把 bean 实例传递 bean 后置处理器的其中一个方法 postProcessAfterInitialization
6. 使用bean （即已经获取到对象）
7. 当容器关闭时候，调用 bean 的销毁的方法（需要进行配置销毁的方法）

<!--配置后置处理器,对于同一个配置文件中的所有bean都会自动生效-->
<bean id="myBeanPost" class="com.psj.bean.MyBeanPost"></bean>

public class MyBeanPost implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("在初始化前执行的方法");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("在初始化后执行的方法");
        return bean;
    }
}
//还是执行Orders orders = context.getBean("orders", Orders.class);
//输出结果
//第一步 执行无参数构造创建 bean 实例
//第二步 调用 set 方法设置属性值
//在初始化前执行的方法
//第三步 执行初始化的方法
//在初始化后执行的方法
//第四步 获取创建 bean 实例对象
//com.psj.bean.Orders@1649b0e6
//第五步 执行销毁的方法

3.3.6 IOC 操作 Bean 管理-xml 自动装配

手动装配：需要在bean的property中定义name和value，即指明为哪个属性指定什么值

<bean id="orders" class="com.psj.bean.Orders" init-method="initMethod" destroy-method="destroyMethod">
    <property name="oname" value="手机"></property>
</bean>

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

根据属性名称自动注入：

# 原始方式
<bean id="emp" class="com.psj.bean.Emp">
    <property name="dept" ref="dept"></property>
</bean>
<bean id="dept" class="com.psj.bean.Dept"></bean>
# 自动装配
<bean id="emp" class="com.psj.bean.Emp" autowire="byName"></bean>
 # 要求：被装配的bean中id值一定要和类中属性名字一样
<bean id="dept" class="com.psj.bean.Dept"></bean>

根据属性类型自动注入：

<bean id="emp" class="com.psj.bean.Emp" autowire="byType"></bean>
# 如果该文件中还有一个id值不同但是class相同的bean对象，此时不清楚调用哪个bean。此时根据属性名称就不会报错
<bean id="dept" class="com.psj.bean.Dept"></bean>

3.3.7 IOC 操作 Bean 管理-外部属性文件

假设在bean中配置数据库信息：

直接进行配置：

<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
     <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
     <property name="url" value="jdbc:mysql://localhost:3306/jdbc"></property>
     <property name="username" value="root"></property>
     <property name="password" value="xxxx"></property>
</bean>

引入外部的属性文件配置：

# 1.创建外部属性文件(假设名为jdbc.properties),写数据库信息
prop.driverClassName=com.mysql.jdbc.Driver
prop.url=jdbc:mysql://localhost:3306/jdbc
prop.username=root
prop.password=xxxx

# 2.在bean.xml引入 context 名称空间
xmlns:context="http://www.springframework.org/schema/context" 
http://www.springframework.org/schema/context 
http://www.springframework.org/schema/context/spring-context.xsd
# 3.使用标签引入外部属性文件
<context:property-placeholder location="classpath:jdbc.properties"/>
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="driverClassName" value="${prop.driverClassName}"></property>
    <property name="url" value="${prop.url}"></property>
    <property name="username" value="${prop.username}"></property>
    <property name="password" value="${prop.password}"></property>
</bean>

3.3.8 IOC 操作 Bean 管理-基于注解方式

什么是注解：
- 注解的概念：代码特殊标记
- 格式：@注解名称(属性名称=属性值, 属性名称=属性值…)
- 如何使用注解：注解作用在类上面，方法上面，属性上面
- 使用注解的目的：简化 xml 配置
Spring 针对 Bean 管理中为**创建对象(即创建bean实例)**提供的注解：
- @Component
- @Service
- @Controller
- @Repository

基于注解方式实现对象创建：

引入依赖：需要Spring-aop-xxx.jar的jar包
开启组件扫描：

<!--开启组件扫描
  如果扫描多个包，多个包使用逗号隔开
-->
<context:component-scan base-package="com.psj"></context:component-scan>
<!--示例1：
 use-default-filters="false" 表示现在不使用默认filter(即扫描base-package下的所有注解)，自己配置 filter(即自己指定哪些类型的注解)
 context:include-filter ，设置扫描哪些内容
-->
<context:component-scan base-package="com.psj" use-defaultfilters="false">
 // 按注解类型过滤扫描的内容，此时只扫描Controller注解
    <context:include-filter type="annotation" 	        					
    expression="org.springframework.stereotype.Controller"/>  
</context:component-scan>
<!--示例 2
 下面配置扫描包所有内容
 context:exclude-filter： 设置哪些内容不进行扫描(因为是扫描除了exclude外的所有，所以不设置use-defaultfilters)
-->
<context:component-scan base-package="com.psj">
	 <context:exclude-filter type="annotation" 
							expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

创建类，在类上面添加创建对象注解：

// 等价于<bean id="empService" class="com.psj.service.EmpService">
@Service(value = "empService")  // value可以省略，默认值是类名称(首字母小写)
public class EmpService {
    public void add(){}
}于注解方式实现属性注入

基于注解方式实现属性注入：

@Autowired：根据属性类型进行自动装配

// 在需要注入的类上添加注解(不是加在UserDao接口上，是加在实现类上)
@Repository
public class UserDaoImpl implements UserDao{
    @Override
    public void update() {
        System.out.println("DAO UPDATE");
    }
}
// service层
@Service(value = "empService")  // 等价于<bean id="empService" class="com.psj.service.EmpService">
public class EmpService {
    // 等价于<bean ...>
    //         <property name="userDao" ref="userDaoImpl"></property>
    //      </bean>
    // 如果在xml中注入属性，需要写属性的set方法，使用注解则不要
    @Autowired
    private UserDao userDao;
    public void add(){
        userDao.update();
    }
}

@Qualifier：根据名称进行注入(需要和@Autowired一起使用)

@Repository(value = "userDaoImpl2")
public class UserDaoImpl2 implements UserDao{
    @Override
    public void update() {
        System.out.println("DAO UPDATE2");
    }
}
// service层
@Service(value = "empService")  // 等价于<bean id="empService" class="com.psj.service.EmpService">
public class EmpService {
    @Autowired  // 当一个接口有多个实现类时，这些实现类所属类型都是UserDao，所以根据类型进行注入则会失败
    @Qualifier(value = "userDaoImpl2")  
    private UserDao userDao;
    public void add(){
        userDao.update();
    }
}

@Resource：可以根据类型注入，也可以根据名称注入

@Service(value = "empService")  // 等价于<bean id="empService" class="com.psj.service.EmpService">
public class EmpService {
    @Resource(name = "userDaoImpl2")  // 如果没有加name就是按照类型注入
    private UserDao userDao;
    public void add(){
        userDao.update();
    }
}

@Value：注入普通类型属性

@Service(value = "empService")  // 等价于<bean id="empService" class="com.psj.service.EmpService">
public class EmpService {
    // 等价于<bean ...>
    //         <property name="name" value="psj"></property>
    //      </bean>
    @Value(value = "psj")
    private String name;
}

tips:

上述四个不同的注解可以混用，目的都创建bean实例
@Resource是javax.annotation下的类，JDK11无法直接使用

3.3.9 完全注解开发

上述完成了对创建对象和属性注入的注解操作，但是还是需要一个bean.xml文件，而完全注解开发则把配置文件也用注解代替
操作步骤：

创建配置类，替代 xml 配置文件：
@Configuration  // 将该类作为配置类，代替xml文件
// 等价于配置文件中的<context:component-scan base-package="com.psj"></context:component-scan>
@ComponentScan(basePackages = {"com.psj"})  
public class SpringConfig {
}
编写测试类：
// 不是加载配置文件，而是加载类
ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
EmpService empService = context.getBean("empService", EmpService.class);
empService.add();