Spring5 IOC框架详解（一）

最新推荐文章于 2023-06-30 09:00:00 发布

青铜哥布林

最新推荐文章于 2023-06-30 09:00:00 发布

阅读量1.5k

点赞数 8

分类专栏：笔记文章标签： spring

本文链接：https://blog.csdn.net/qq_25083447/article/details/104597542

版权

笔记专栏收录该内容

21 篇文章 8 订阅

订阅专栏

文章目录

一、Spring概述
- 1.1、Spring概述
- 1.2、Spring体系结构
二、IOC控制反转
三、spring的依赖注入（DI）
四、基本于javaConfig的注解配置

一、Spring概述

1.1、Spring概述

Spring是分层的java SE/EE应用full—stack（全栈式）轻量级开源框架，以IOC（反转控制）和AOP（面向切面编程）两个核心，使用Spring开发可以将Bean对象，Dao组件对象，Service组件对象等交给Spring容器来管理，这样使得很多复杂的代码在Spring中开发却变得非常的优雅和简洁，有效的降低代码的耦合度，极大的方便项目的后期维护、升级和扩展。提供了展现层MVC和持久层Spring JDBC以及业务层事务管理等众多的企业级应用技术

控制反转思想（用容器来进行类之间的联系）、面向切面编程思想（采用了设计模式中的动态代理模式）。它能使得我们可以很好的书写遵守开闭原则的软件代码，轻松面对需求的变更。

Spring是一个IOC(DI)和AOP容器框架
在这里插入图片描述

那么啥是IOC？啥是AOP呢？

我们知道在设计模式中，有个很重要的指导性思想叫开闭原则，亦称OCP原则：对扩展开放，对修改闭合。
啥意思呢？假设我们开发了一套管理系统，每收到一笔订单后，系统调用message.notify(Sender)给客户发送订单成功邮件（Sender是发送器类）。有天老板（也有可能是产品）突然要改个需求：将原来的向客户发送邮件改为发手机短信。你无需改动任何代码，只是在配置中将“发送器Sender”改成手机，就完成了工作。这里将发送器Sender作为参数传给message.notify方法，就是IoC(控制反转:Inverse of Control)。因为Sender不是在message.notify方法内生产的，而是在外部创建好，然后注入给message.notify方法使用的，这个过程中对Sender类的控制权移到了外部，因此叫控制反转。
过了几天，老板觉得收到订单后，除了要给客户发送通知外，还要扩展一个功能：给自己再发个通知（假设通知格式、内容不同于发给客户的）。这时本着OCP原则，我们不改动原有的任何代码，只需写新的通知功能的实现代码，然后装配到原来的程序上去就完成了。如果老板过几天说这功能不要了，那么你也可以很轻松的卸载下来。在发通知这个事情上，我们可以根据需要增加、删除任何事件，而不需要改动原有的程序，这就是AOP（Aspect Oriented Programming的缩写,意为:面向切面编程）。随着后面文章的深入，会专门对AOP做讲解，现在先了解一下就好。

上面说的Ioc，AOP这些方法，在没有spring的时侯，其实我们也能自己通过代码做到。现在有了spring，我们可以更轻松快捷做到以上的事情。

spring的优良特性

[1]非侵入式：基于Spring开发的应用中的对象可以不依赖于Spring的API

[2]控制反转：IOC——Inversion of Control，指的是将对象的创建权交给Spring去创建。使用Spring之前，对象的创建都是由我们自己在代码中new创建。而使用Spring之后。对象的创建都是由给了Spring框架。

[3]依赖注入：DI——Dependency Injection，是指依赖的对象不需要手动调用setXX方法去设置，而是通过配置赋值。

[4]面向切面编程：Aspect Oriented Programming——AOP

[5]容器：Spring是一个容器，因为它包含并且管理应用对象的生命周期

[6]组件化：Spring实现了使用简单的组件配置组合成一个复杂的应用。在 Spring 中可以使用XML和Java注解组合这些对象。

[7]一站式：在IOC和AOP的基础上可以整合各种企业应用的开源框架和优秀的第三方类库（实际上Spring 自身也提供了表述层的SpringMVC和持久层的Spring JDBC）

1.2、Spring体系结构

在这里插入图片描述
Spring框架分为四大模块：
Core核心模块。负责管理组件的Bean对象

spring-beans-4.0.0.RELEASE.jar

spring-context-4.0.0.RELEASE.jar

spring-core-4.0.0.RELEASE.jar

spring-expression-4.0.0.RELEASE.jar

面向切面编程

spring-aop-4.0.0.RELEASE.jar

spring-aspects-4.0.0.RELEASE.jar

数据库操作

spring-jdbc-4.0.0.RELEASE.jar

spring-orm-4.0.0.RELEASE.jar

spring-oxm-4.0.0.RELEASE.jar

spring-tx-4.0.0.RELEASE.jar

spring-jms-4.0.0.RELEASE.jar

Web模块

spring-web-4.0.0.RELEASE.jar

spring-webmvc-4.0.0.RELEASE.jar

spring-websocket-4.0.0.RELEASE.jar

spring-webmvc-portlet-4.0.0.RELEASE.jar

在Web应用程序应用场景中，典型的三层架构：数据模型层实现域对象；数据访问层实现数据访问；逻辑层实现业务逻辑；web层提供页面展示；所有这些层组件都由Spring进行管理，享受到Spring事务管理、AOP等好处，而且请求唯一入口就是DispachterServlet，它通过把请求映射为相应web层组件来实现相应请求功能。

二、IOC控制反转

2.1、什么是IOC？

控制反转思想（用容器来进行类之间的联系）。把对象创建的权利交>给框架或工厂，由框架或工程来控制创建对象的控制权。并非面向对象编程，是框架的重要特征。

程序耦合：就是程序与程序之间的依赖关系，例如：（类与类之依赖，方法与方法依赖等）。程序依赖关系越强，程序灵活机制越差，代码越臃肿。编码提倡高内聚，低耦合和的原则。

程序解耦：降低程序与程序之间的依赖关系。

试想一下，在未使用Spring以前，Service调用一个类都得自己创建一个对象，如果这个对象的名称改了呢，到时候是不是所有涉及到该代码块的DO都得修改，耦合度特别高

通过代码解释IoC思想：
未使用spring之前的程序代码，我们的controller层调用service层或service层调用dao层的接口，必须得new一个对象。不创建对象则代码无法通过编译期。而且每次调用都得创建一个对象，也就是该对象是非单列对象。如下：

/**
 * 模拟一个表现层，用于调用业务层
 */
public class Client {
    public static void main(String[] args) {
    //面向对象创建思想，创建什么对象及何时创建的控制权由自身决定。
        IAccountService as = new AccountServiceImpl();
            as.saveAccount();
        }
    }
}

/**
 * service层：账户的业务层实现类
 */
public class AccountServiceImpl implements IAccountService {
   //面向对象创建思想，创建什么对象及何时创建的控制权由自身决定。
    private IAccountDao accountDao = new AccountDaoImpl();    
    public void  saveAccount(){
        accountDao.saveAccount();
    }
}

这种做法增加了类与类之间、层与层之间的耦合性。

问：要解决怎么代码耦合问题我们该怎么做呢？
答：（1）需要一个配置文件（xml 或 properties）来配置service和Dao
配置Bean类要求唯一：唯一表示 = 全类名的方式（也就搜key =value的方式）
（2）通过读取配置文件内容，采用反射机制来创建对象

步骤：
1、新建一个bean.properties配置文件，里面分别存储Service和Dao层的实现类对象：

##采用key、value的形式。 对象=类名
accountService=com.service.Impl.AccountServiceImp
accountDao=com.Dao.Impl.AccountDaoImp

2、创建一个Bean工厂类来读取配置文件，不断的生产Bean对象：

package com.factory;
import java.io.InputStream;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
/**
 * 一个创建Bean对象的工厂
 *
 * Bean：在计算机英语中，有可重用组件的含义。
 * JavaBean：用java语言编写的可重用组件。
 *      javabean >  实体类
 *
 *   它就是创建我们的service和dao对象的。
 *
 *   第一个：需要一个配置文件来配置我们的service和dao
 *           配置的内容：唯一标识=全限定类名（key=value)
 *   第二个：通过读取配置文件中配置的内容，反射创建对象
 *
 *   我的配置文件可以是xml也可以是properties
 */
public class BeanFactory {
    //定义一个Properties对象
    private static Properties props;

    //定义一个Map,用于存放我们要创建的对象。我们把它称之为容器
    //使用这个容器解决对象非单列问题
    private static Map<String,Object> beans;

    //使用静态代码块为Properties对象赋值
    static {
        try {
            //实例化对象
            props = new Properties();
            //获取properties文件的流对象
            InputStream in = BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties");
            props.load(in);
            //实例化容器
            beans = new HashMap<String,Object>();
            //取出配置文件中所有的Key
            Enumeration keys = props.keys();
            //遍历枚举
            while (keys.hasMoreElements()){
                //取出每个Key
                String key = keys.nextElement().toString();
                //根据key获取value
                String beanPath = props.getProperty(key);
                //反射创建对象
                Object value = Class.forName(beanPath).newInstance();
                //把key和value存入容器中
                beans.put(key,value);
            }
        }catch(Exception e){
            throw new ExceptionInInitializerError("初始化properties失败！");
        }
    }

    /**
     * 根据bean的名称获取对象
     * @param beanName
     * @return
     */
    public static Object getBean(String beanName){
        return beans.get(beanName);
    }
}

3、修改controller层调用Service层的代码：

/**
 * 模拟一个表现层，用于调用业务层
 */
public class Client {
    public static void main(String[] args) {
        //IAccountService as = new AccountServiceImpl();
        
        for(int i=0;i<5;i++) {//可以生产多个Bean对象
           //创建什么对象及何时创建的控制权由工厂决定。
            IAccountService as = (IAccountService) BeanFactory.getBean("accountService");
            System.out.println(as);
            as.saveAccount();
        }
    }
}

4、修改service层调用Dao层的代码：

/**
 * 账户的业务层实现类
 */
public class AccountServiceImpl implements IAccountService {
//  private IAccountDao accountDao = new AccountDaoImpl();

    private IAccountDao accountDao = (IAccountDao)BeanFactory.getBean("accountDao");

    public void  saveAccount(){
        int i = 1;
        accountDao.saveAccount();
        System.out.println(i);
        i++;
    }
}

2.2、IOC底层原理

IOC的底层使用了xml文件解析、工厂模式、反射、单例模式

未使用IOC思想的程序（未使用工厂模式前）：
在这里插入图片描述
使用IOC思想的程序（使用工厂模式后）：

例子：
假如马爸爸想要开发一个某宝app，此时他得自己编程，自己去了解app转账业务，自己去设计产品……所有事都得亲力亲为，没有了马爸爸，某宝App就很难开发出来，下属就无从下手。此时，马爸爸和员工的耦合度就非常高，如果马爸爸请假一天不上班，那是不是所有员工就不用上班了?
为了解决此类问题，只能降低马爸爸和员工之间的依赖关系。在使用工厂模式以后，马爸爸设立一个部门（Bean工厂），里面聚集了各种人才（各种Bean对象），什么产品经理、业务主管、架构师…. 马爸爸只需要把自己手上的工作，通过交给相关的负责人就进行安排调度，就能很快的完成某宝App的开发任务，同时这样做也降低了马爸爸与员工之间的耦合度，就算马爸爸10天不上班，下属也能正常对App进行开发工作。如果此时为了保证app开发质量，马爸爸想要对开发进行质量管控，那么只需要往部门（Bean工厂）中招聘一个质控办主管，由他全权负责开发质量任务即可。

而IOC主要就是解决程序之间的耦合关系，工厂模式起到了至关重要的作用，原理如下：
在这里插入图片描述
原理：
1、 Spring容器解析bean.xml，通过bean.xml的配置拿到类路径
2、根据类路径，通过反射拿到字节码文件，然后创建对象
3、为了避免引发线程问题，提供了单例模式创建Bean对象

总结：
以上方法解决了两个问题：
（1）IOC主要就是解决程序之间的耦合关系。通过读取配置文件，利用工厂模式和反射的方式来创建对象，以此来降低代码的耦合，减少程序之间依赖。
（2）将每次调用Service层和Dao层接口都需要创建不同的对象修改成了单列模式。避免了多线程访问的时候出现线程安全问题

2.3、Spring基于XML的IOC环境搭建和入门

如何使用Spring解决程序耦合问题？下面通过spring入门案例来演示。

步骤：
1、创建“账户”数据表：

create table account(
	id int primary key auto_increment,
	name varchar(16),
	money float
)character set utf8 collate utf8_general_ci;

insert into account(name,money) values('张三',1007);
insert into account(name,money) values('李四',1000);
insert into account(name,money) values('王五',1020);

在这里插入图片描述

2、不使用骨架，创建一个Maven项目，并创建好文件夹：
在这里插入图片描述
分别写入java文件：

package com.it.ui;

import com.it.service.IAccountService;
import com.it.service.impl.AccountServiceImpl;
/**
 * 模拟一个表现层，用于调用业务层
 */
public class Client {
    public static void main(String[] args) {

        IAccountService accountService = new AccountServiceImpl();
        accountService.saveAccount();

    }
}

service：
在这里插入图片描述

package com.it.service;
/**
 * 账户业务层的接口
 */
public interface IAccountService {

    /**
     * 模拟保存账户
     */
    void saveAccount();
}

在这里插入图片描述

package com.it.service.impl;
import com.it.dao.IAccountDao;
import com.it.service.IAccountService;
/**
 * 账户的业务层实现类
 */
public class AccountServiceImpl implements IAccountService {

    private IAccountDao accountDao ;

    public AccountServiceImpl(){
        System.out.println("对象创建了");
    }

    public void  saveAccount(){
        accountDao.saveAccount();
    }
}

Dao：
在这里插入图片描述

package com.it.dao;
/**
 * 账户的持久层接口
 */
public interface IAccountDao {

    /**
     * 模拟保存账户
     */
    void saveAccount();
}

在这里插入图片描述

package com.it.dao.impl;
import com.it.dao.IAccountDao;
/**
 * 账户的持久层实现类
 */
public class AccountDaoImpl implements IAccountDao {

    public  void saveAccount(){
        System.out.println("保存了账户");
    }
}

3、导入spring-context jar包：
在这里插入图片描述
发现：

导入spring-context之后查看spring-context项目依赖关系：

发现此时的项目依赖就是Spring核心容易必备组件的jar包。

4、创建一个非中文名的配置文件，此处我们用xml作为配置文件：
在这里插入图片描述
在该文件中导入spring约束和把创建对象的工作交给Spring来管理（也是通过key=value的方式）：

<?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">

    <!--把对象的创建交给spring来管理-->
    <bean id="accountService" class="com.it.service.impl.AccountServiceImpl"></bean>

    <bean id="accountDao" class="com.it.dao.impl.AccountDaoImpl"></bean>
</beans>

5、获取Spring核心容器，并根据唯一id获取对象：

首先我们先了解一下Spring中类工厂结构图：
在这里插入图片描述
从上我们发现，想要获取核心容器对象，我们需要使用实现类，获取核心容易的方式有三种：
* ApplicationContext的三个常用实现类：
* ClassPathXmlApplicationContext：它可以加载类路径下的配置文件，要求配置文件必须在类路径下(.classPath)。不在的话，加载不了。(更常用)
*
* FileSystemXmlApplicationContext：指定配置文件路径，它可以加载磁盘任意路径下的配置文件(前提该磁盘必须有访问权限）
*
* AnnotationConfigApplicationContext：它是用于读取注解创建容器的。又点配置是用JavaConfig的方式来进行配置的。

 ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");

接下来我们先使用第一种来演示：
在这里插入图片描述

能正常输出对象内存地址，则案例成功。

总结：
（1）将创建对象和将对象存入容器中的工作交给Spring来做
（2）我们主要的做就是将配置信息存入配置文件，获取Spring容器对象，并根据Id从核心容器中取出对象。
（3）获取容器的方式有三种，常用的是：
ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
如果使用第二种：
ApplicationContext ac = new FileSystemXmlApplicationContext("D:\\zhy\\bean.xml");
第三种后面会讲。

此外在核心容器接口（ApplicationContent）中发现了还有一个子容器接口BeanFactory，那么区别是什么呢？：
在这里插入图片描述
答案：

1、 ApplicationContext: 单例对象适用。加载配置文件的时候就会把在配置文件中配置的对象进行创建。它在构建核心容器时，创建对象采取的策略是采用立即加载的方式。也就是说，只要一读取完配置文件马上就创建配置文件中配置的对象。
2、BeanFactory: 多例对象适用。在加载配置文件时候不会创建对象，在获取对象时候才去创建。它在构建核心容器时，创建对象采取的策略是采用延迟加载的方式。也就是说，什么时候根据id获取对象了，什么时候才真正的创建对象。
3、BeanFactory是Spring一个内部的使用的接口，一般不提供给开发人员进行使用。在加载配置文件时候不会创建对象，在获取对象时候才去创建。
特点：启动服务速度快，响应请求慢
ApplicationContext 是BeanFactory的一个子接口，提供了比BeanFactory更多，更强大的功能，一般提供给开发人员使用。加载配置文件的时候就会把在配置文件中配置的对象进行创建。
特点：启动服务慢，响应速度快

如果使用BeanFactory容器，可以使用下面代码段：

 //--------BeanFactory----------
 Resource resource = new ClassPathResource("bean.xml");
 BeanFactory factory = new XmlBeanFactory(resource);
 IAccountService as  = (IAccountService)factory.getBean("accountService");
 System.out.println(as);

当然，Spring是一个智能的容器，可以根据实际情况来分别使用不同的容器策略，接下来我们就会讲一下。

2.4、Bean对象管理（xml方式）

Bean对象的管理主要指：
1、Spring创建对象
2、Spring注入属性

说到配置配置文件，spring提供常用的就xml和javaConfig的注解两种方式。下面对xml的方式做一下详细说明。

2.4.1、基于xml配置创建Bean对象

xml配置：<bean> bean对象标签
id属性：bean容器里面的唯一标识
class属性：类所在全路径

我们下面就来讲价一下基于xml配置文件最常见的三中创建Bean的场景。
方式一：使用默认构造函数创建

解释：
在spring配置文件中使用<bean>标签，配以id和class属性之后，且没有其他属性和标签时，采用的就是默认构造器创建bean对象，此时如果类中没有默认构造函数，则对象无法创建bean对象。

修改AccountServiceImpl的无参构造修改成有参构造：
（声明了有参数构造，在不声明无参数构造的情况下，是没有无参构造的）
在这里插入图片描述

修改Client代码并执行程序：
在这里插入图片描述
结果： 由于不存在无参构造函数，所以实例化对象失败

结论：当在配置文件中写如下配置
<bean id="accountService" class="com.it.service.impl.AccountServiceImpl"></bean>
在没有其他属性出场，没有其他标签出场的时候，创建Bean对象中的是类中的无参构造函数。如果没有，则不能创建Bean对象。
注：一个类中有一个空构造函数，假如一旦声明了一个有参构造函数，在没声明空构造函数的情况下，此时默认的空构造函数就不存在，此时创建bean对象就会报错。

场景：在实际开发中使用到别人的jar包，可能会调用到一些别人写好的类，且是字节码文件无法修改，在别人写好的类里面如果没有创建空构造函数，但是有创建对象的方法，该怎么办呢？下面说一下方式二

方式二：使用普通工厂中的方法创建对象（使用某个类中的方法创建对象，并注入spring容器）
1、新建一个工厂包和工程类，此包和类用来模拟调用jar包中获取对象的方法：
在这里插入图片描述
模式字节码文件，里面没有空构造函数，但是有一个创建对象的getAccountService方法。那么我们如何通过该.class文件来创建对象呢？

2、修改配置文件，配置文件第二种配置方式：
在这里插入图片描述
3、执行测试：

结果：成功！

结论：如果想要调用到一个jar包中某个类的某个方法来创建对象，且这个类中没有无参构造函数，那么可以使用方法二来配置。

场景：如果调用到外部jar包中的类（即.class文件），且类中没有无参数构造，只提供一个静态方法来创建对象，那么此时又改怎么做的？

方式三：使用工厂中的静态方法创建对象（使用某个类中的静态方法创建对象，并注入spring容器

1、新建一个静态工程类，进行模拟.class文件：
在这里插入图片描述

2、第三种配置方式来配置xml：

 <!-- 第三种方式：使用工厂中的静态方法创建对象（使用某个类中的静态方法创建对象，并注入spring容器) -->
<bean id="accountService" class="com.it.factory.StaticFactory" factory-method="getAccountService"></bean>

结果成功！

总结：如果想要调用到一个jar包中的某个类的方法来获取对象，且这个类中没有无参构造函数，只有静态方法，那么可以使用方法三的配置来调用静态方法创建Bean对象。

2.4.2、Bean对象的作用域

问：spring容器多次创建一个的Bean对象，该对象会是单例的吗？
答案：YES 在Spring里面，默认情况下，bean是单实例对象。

验证：（这里我们使用第一中Bean创建方式来验证）
在这里插入图片描述
结果：输出 true （两个对象的内存地址是相同的，证明是同一个对象）

结论：spring创建的Bean对象默认是单列的。如果有需要设置成多例也是可以的。在Spring的<bean>标签中有一个属性scope=“”可以设置成多实例

知识
bean的作用范围调整
<bean>标签的scope=""属性：
作用：用于指定bean的作用范围
取值：常用的就是单例的和多例的

singleton：单例的（默认值）
prototype：多例的
request：作用于web应用的请求范围
session：作用于web应用的会话范围
global-session：作用于集群环境的会话范围（全局会话范围），当不是集群环境时，它就是session

singleton:在加载spring的配置文件(bean.xml)时，就会创建单实例对象。比如，启动服务的时候，Spring容器就会自动创建bean对象，单列模式下的bean随着Spring容器的创建而创建，销毁而销毁。所以单例模式的bean常常用于高频访问的对象使用，在启动服务时候就加载对象。
prototype：在需要用到该bean的时候，使用getBean()获取对象的时候，才会去创建一个新的对象。多例模式的bean在容器创建的时候不会去自动创建bean，所以加快了服务启动速度。只有在需要使用的时候才会去创建bean，通常用于低频率访问的bean对象。
request：当创建bean的时候，就会将bean放到cookie请求域中
session：当创建bean的时候，就会将bean放到session域中

这里我们用一个服务器集群的图来说明global-session的范围
在这里插入图片描述

2.4.3、Bean对象的生命周期

bean的整个声明周期：
1、通过构造器创建bean实例
2、为bean的属性设置值和其他bean引用（set方法等）
（bean前置处理）
3、调用bean的初始化方法（需求进行配置）
（bean后置处理）
4、获取到bean，可正常使用
5、当容器关闭的时候，调用bean中的销毁方法进行销毁（需求进行配置销毁方法）
以上五个步骤，大家可以在每个方法里面使用System.out.println()进行打印输出测试

知识
bean对象的生命周期
单例对象
出生：当spring容器创建时bean对象出生
活着：只要容器还在，对象一直活着
死亡：容器销毁，对象消亡
总结：单例对象的生命周期和容器相同
多例对象
出生：当我们使用到bean对象时，spring框架才为我们创建
活着：对象只要是在使用过程中就一直活着。
死亡：当对象长时间不用，且没有别的对象引用时，由Java的垃圾回收器回收，节省内存资源。
结论：当一个对象频繁使用时候，可以将该对象生命周期设置成单例，当一个对象偶尔使用时，可将其声明周期设置成多例。

单例对象生命周期测试：
1、新建一个Emp类：
在这里插入图片描述

2、修改Bean配置文件：
对象创建时调用initBean()方法，销毁时调用destroyBean()方法 在这里插入图片描述

3、执行测试：
在这里插入图片描述

结果：
在这里插入图片描述

疑问：结果未执行Bean的销毁方法，为什么这样呢？
答案：main方法作为所有程序的入口，当程序执行完毕之后就释放了内存，此时还未等执行销毁方法程序就结束了。
由于服务停止了，Spring容器才会销毁，容器销毁以后才会调用bean的销毁方法。所以这里我们可以写代码对bean对象进行手动销毁，然后测试bean否调用了销毁方法：

测试结果：

以上就是单例对象的生命周期的整个过程，实际上在从Bean对象从创建到销毁的整个生命周期过程中，还有两个步骤，就是在第三步调用Bean对象的的initBean()方法的前后，分别执行了bean的前置处理器和bean的后置处理器。现在我们来写下Bean的前置和后置处理器：
1、创建类，实现接口BeanPostProcessor，创建后置处理器
在这里插入图片描述
2、在xml中配置后置处理器

只要在bean.xml中配置的bean，都会去执行这个后置处理器。

3、进行测试：
在这里插入图片描述

多例对象生命周期测试：
在以上代码不修改的基础上，将配置文件中Bean对象的范围修改成多例：
在这里插入图片描述

此时再运行代码发现，虽然手动执行了关闭容器，但是还是不执行销毁的方法。因为多例Bean是创建出来使用完了以后就立马销毁的。

总结：spring框架是个很智能的框架，它可以通过感知到对象的作用范围是单例还是多例，从而来选择Bean对象的创建时机是立即还是延迟。

2.4.4、Bean对象的自动装配

 课题2.4.3其实就是我们常见的手动装备，下面我们来对2.4.3例子进行改进
 然后实现bena的自动装配。这里会用到关键属性 autowire=" "

1、byName：根据bean的 name 属性来实现自动装配。
其中byName根据bean的名称进行装配，需要特别注意的是bean的id值和类中的属性名称必须一致，否则无法获取到bean：
在这里插入图片描述
测试：

注意：不能同时注册两个相同id的bean，否则会报错：

2、byType：根据bean的 类型（包名.类名）来实现自动装配。
同样的，修改成byType是根据bean的 class属性类型来自动装配bean的
在这里插入图片描述
如果同时存在两个同类型的Bean，即可id不一样，Spring容器也不知道你想获取的是哪一个Bean，同样也会报错，如下：

总结：一般基于xml的配置方法，很少用到byName和byType，反而是基于注解的方式用的多一点。

2.5、外部属性文件引入

对数很多静态的，常用的参数配置，我们可以通过引入bean.xml的方式，使用外部文件上的参数给bean注入值。常见的场景如：连接数据库的配置

1、直接配置方式配置数据库的信息
（1）配置德鲁伊的连接池
（2）引入德鲁伊连接池的jar包：
在这里插入图片描述

（3）手动配置德鲁伊连接池的bean
在这里插入图片描述
（4）获取德鲁伊连接池对象，并输出测试：

2、引入外部配置文件进行数据库的连接池信息配置
（1）创建外部属性文件，properties格式文件，写数据库信息
在这里插入图片描述

（2）把外部的properties配置文件引入到Spring配置文件中
通过使用*context名称空间来引入。在bean.xml中引入名称空间：
在这里插入图片描述
完了以后就可以使用标签引入外部文件了

（3）引入外部配置文件，并修改bean配置：
在这里插入图片描述
（4）测试即可。

三、spring的依赖注入（DI）

以上我们说的创建Bean对象都是在没有带参数的构造函数的情况下，那如果想要创建一个带参数的构造函数该怎么办呢？下面就来学习一下依赖注入。

3.1、依赖注入（DI）概念

依赖注入Dependency Injection。IOC的作用是降低程序间的耦合（依赖关系），而依赖关系的管理以后都交给spring来维护。在当前类需要用到其他类的对象，由spring为我们提供，我们只需要在配置文件中说明。依赖关系的维护就称之为依赖注入。

知识：
依赖注入能注入的数据有三类：
（1）基本类型和String
（2）其他bean类型（在配置文件中或者注解已配置过的bean）
（3）复杂类型/集合类型

依赖注入注入的方式：有四种
第一种：使用构造函数提供
第二种：使用set方法提供
第三种：使用注解
第四种：使用P命名空间注入（该方用到了xml的约束方式，自己去了解）

3.2、基于xml依赖注入的两种方式

依赖注入的数据都是不经常变化的。如果经常变化的Bean不适合使用依赖注入。下面我们定义三种基本类型的数据来模拟依赖注入。

3.2.1、构造函数注入

方式一：构造函数注入

知识
构造函数注入：
使用的标签:<constructor-arg>
标签出现的位置：<bean>标签的内部
constructor-arg标签中的属性：
type：用于指定要注入的数据的数据类型，该数据类型也是构造函数中某个或某些参数的类型。该属性一般不单独使用，如果一个构造函数里面出现两个String类型数据，那么无法判断给哪个参数赋值，所以一般需要配合index属性使用。

index：用于指定要注入的数据给构造函数中指定索引位置的参数赋值。索引的位置是从0开始。该无法判断参数类型。一般需要配合“Type”属性使用。
name：用于指定给构造函数中指定名称的参数赋值。（更推荐使用name属性来注入）
=以上三个用于指定给构造函数中哪个参数赋值===================
value：用于提供基本类型和String类型的数据
ref：用于指定其他的bean类型数据。它指的就是在spring的IOC核心容器中已经配置过的的bean对象
优势：
获取bean对象时，注入数据是必须的操作，否则对象无法创建成功。（使用constructor-arg标签，不执行无参构造函数，只执行有参构造函数）
弊端：
改变了bean对象的实例化方式，如果用不到这些数据，也必须提供。（使用constructor-arg标签，不执行无参构造函数，只执行有参构造函数）

有参构造函数注入方式

1、选择一个类，定义三种不同类型的数据（数据类型才是重点），这里以修改service实现类为例子：

package com.it.service.impl;
import com.it.dao.IAccountDao;
import com.it.service.IAccountService;
import java.util.Date;
/**
 * 账户的业务层实现类
 */
public class AccountServiceImpl implements IAccountService {
    //如果是经常变化的数据，并不适用于注入的方式
    private String name;  //String类型
    private Integer age;  //引用类型
    private Date birthday; //其他类型

    public AccountServiceImpl(String name,Integer age,Date birthday){
        this.name = name;
        this.age = age;
        this.birthday = birthday;
    }

    public void  saveAccount(){
        System.out.println("service中的saveAccount方法执行了。。。"+name+","+age+","+birthday);
    }
}

2、给Bean.xml赋值，将值注入到有参数构造函数：
在这里插入图片描述
3、运行测试：

结果：Date类型不能进行转化。因为在Bean中的值'1994-03-13'，在配置文件中只是一个字符串，Spring容器只当做一个字符串处理，并不知道是一个Dete类型的。

4、由于Date类型无法正常注入，所以需要使用constructor-arg标签中的ref属性来进行引用，如下：
在这里插入图片描述
再测试运行即可解决问题。

总结：
使用<constructor-arg>标签，不执行无参构造函数，只执行有参构造函数。所以此时无论有没有值，必须注入值。

3.2.2、set方法注入

方式二：set方法注入（Set方式注入一定要有Set方法）

知识
set方式注入：
使用的标签:<property>
标签出现的位置：<bean>标签的内部
property标签中的属性：
name：用于指定给构造函数中指定名称的参数赋值。（更推荐使用name属性来注入）
=以上三个用于指定给构造函数中哪个参数赋值===================
value：用于提供基本类型和String类型的数据
ref：用于指定其他的bean类型数据。它指的就是在spring的Ioc核心容器中出现过（已经配置过的）的bean对象
优势：
创建对象时没有明确的限制，会直接使用默认（无参）构造函数。
弊端：
如果有某个成员必须有值，则获取对象是有可能set方法没有执行。

set注入方式步骤：
1、为了不覆盖构造注入方式，新创建一个类：
在这里插入图片描述
类中定义三个成员变量，一个无参构造函数，增加set方法：

2、修改Bean.xml文件为Set注入：
在这里插入图片描述

3、测试：
在这里插入图片描述

总结：
（1）Set注入方式与成员变量名无关，只与Set方法名称有关比如：成员变量是A，set方法名称是setA1，那么配置name的时候要配置成A1（自己去验证）
（2）Set注入默认会先执行无参构造函数，再执行Set方法

3.2.3、复杂类型/集合类型注入

集合类型注册实际上是选取构造函数注入或Set注入其中一种注入方式，将集合类型或其他类型进行注入。

选择Set方式注入复杂类型：
1、为了不覆盖以上两种方式，新建一个类，里面定义各种类型，并重写Set方法：
在这里插入图片描述

2、修改Bean.xml文件：

<bean id="accountService3" class="com.itheima.service.impl.AccountServiceImpl3">
       <property name="myStrs">
           <set>
               <value>AAA</value>
               <value>BBB</value>
               <value>CCC</value>
           </set>
       </property>

        <property name="myList">
            <array>
                <value>AAA</value>
                <value>BBB</value>
                <value>CCC</value>
            </array>
        </property>

        <property name="mySet">
            <list>
                <value>AAA</value>
                <value>BBB</value>
                <value>CCC</value>
            </list>
        </property>

        <property name="myMap">
            <props>
                <prop key="testC">ccc</prop>
                <prop key="testD">ddd</prop>
            </props>
        </property>

        <property name="myProps">
            <map>
                <entry key="testA" value="aaa"></entry>
                <entry key="testB">
                    <value>BBB</value>
                </entry>
            </map>
        </property>
    </bean>

在集合里面设置对象类型值
如果我们想要往List集合里面存放，该怎么做呢？
1、新建科目类，并提供Set方法：
在这里插入图片描述

2、新建学生类，并提供Set方法：
在这里插入图片描述

3、配置bean.xml
在这里插入图片描述
4、测试

5、优化：可以通过引入P名称空间，将配置文件公共部分提取出来
（1）新建一个bean2.xml，在`bean2.xml配置文件中引入名称空间 util
在这里插入图片描述
（2）提取list集合类型属性注入

（3）直接引用即可：

（4）测试：

总结：

复杂类型的注入/集合类型的注入：
用于给List结构集合注入的标签：list array set
用于个Map结构集合注入的标签：map proties
结构相同，标签可以互换使用
也就是实际开发中需要区分是List结构还是Map结构即可

3.2.4、P命名空间注入

这里我们随便说一下p命名空间的注入方式吧：
P命名空间的注入实际底层使用的还是set方式注入
在这里插入图片描述

3.2.5、注入内部Bean和级联赋值

场景：
假如两个实体之间存在级联关系，比如常见的省、市、县级联，还有员工与部门的级联，都已一对多的关系，那么此时我们该怎么注入Bean呢？

准备：
1、创建一个Emp类，且属性只提供set方法
在这里插入图片描述

2、dept类，同样只有set方法
在这里插入图片描述

3.2.5.1、注入内部Bean

在bean.xml中进行内部注入bean
在这里插入图片描述
写测试类进行测试：

3.2.5.2、外部Bean注入

在这里插入图片描述

3.2.5.3、级联赋值

1、首先需要在emp类中增加一个get方法：
在这里插入图片描述

2、修改配置文件配置：
在这里插入图片描述

3.2.6、作业

需求：
开发一个简单的《图书管理系统》，条件1：具备crud功能，条件2：使用三层架构完成，条件3：将三层架构修改成使用SpringIOC的基于xml的方式创建bean对象

3.3、FactoryBean（工厂Bean）

Spring有两种类型Bean，一种普通bean，另外一种工厂bean（FactoryBean），以上讲解的一直都是普通Bean

区别：
普通Bean：在配置文件中定义bean的类型就是返回类型。
如：定义的时候，类型是student，在获取bean的时候，也是student

FactoryBean：在配置文件中定义的bean的文件类型可以和返回值类型不一样。

1、创建类，让这个类作为工程bean，只要实现接口FactoryBean就是工厂bean。在实现的定义方法中返回bean类型
在这里插入图片描述

2、在配置文件中类型注入bean
在这里插入图片描述
3、测试：

总结：1、实际上Spring的底层用的也是FactoryBean
2、FactoryBean注入到容器中什么类型的bean由重写的getObject()方法决定

四、基本于javaConfig的注解配置

bean管理：指（1）创建bean对象（2）注入属性
操作bean的两种方式：
（1）基于xml配置文件方式实现（已学习）
（2）基于注解方式实现

1、什么是注解?
答：（1）注解是代码特殊标记，格式：@注解名称(属性名称 = 值，属性名称 = 值....)
（2）使用注解，注解作用在类上面，方法上面，属性上面
（3）目的：简化xml的配置，作用和xml配置方式是一样的
2、Spring针对Bean管理中创建对象提供注解

明确：SprinigIOC无论是xml配置和注解配置的方式，要实现的功能都是一样的，都是要降低程序间的耦合，只是配置形式不一样。这章主要是讲上一章的xml配置换成注解来讲。

准备工作：
1、新建一个Maven工程
在这里插入图片描述
2、导入Sprinig-context的jar包（Spring核心包），并在各个文件中准备代码：

bean.xml
（bean.xml不能直接注入接口，注入接口的时候，class属性要写子类的包路径）

<?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">

    <!--把对象的创建交给spring来管理-->
    <bean id="accountService" class="com.it.service.impl.AccountServiceImpl"></bean>

    <bean id="accountDao" class="com.it.dao.impl.AccountDaoImpl"></bean>
</beans>

AccountDao：
在这里插入图片描述

AccountDaoImpl：
在这里插入图片描述

IAccountService：
在这里插入图片描述

IAccountServiceImpl：
在这里插入图片描述

Client：
在这里插入图片描述
准备完毕。

曾经XML的配置：

<bean id="accountService"
class="com.itheima.service.impl.AccountServiceImpl"
scope=""
init-method=""
destroy-method=""
<property name="" value="" ref="">
</property>
</bean>

现在我们需要使用注解来替代XML配置，其中注解的分类和xml的差不多，如图：
在这里插入图片描述

4.1、用于创建对象的注解

在使用注解管理Bean’之前，先要往项目中导入一个aop依赖jar包：
在这里插入图片描述

用于创建容器对象的注解：
他们的作用就和在XML配置文件中编写一个<bean>标签实现的功能是一样的
@Component注解：
作用：用于把当前类作为对象存入spring容器中
属性：
value：用于指定bean的id。当我们不写时，它的默认值是当前类名，且首字母改小写。
@Controller：：一般用在表现层
@Service：一般用在业务层
@Repository：一般用在持久层
以上三个注解他们的作用和属性与@Component是一模一样。
他们三个是spring框架为我们提供明确的三层使用的注解，使我们的三层对象更加清晰。（实际上他们都是可以混用的，只是每一层用特定的注解是为了结构清晰）

4.1.1、@Component注解

@Component注解用于创建Bean对象。被@Component注解的类将创建一个Bean对象，并存入的Spring容器中。

@Component：
作用：用于把当前类作为对象存入spring容器中
属性：
value：用于指定bean的id。当我们不写时，它的默认值是当前类名，且首字母改小写。

步骤：
一、导入spring-aop的jar包：

二、开启组件扫描注解（告诉spring扫描指定路径上的注解）

如果想要同时扫描多个包也是可以的，中间使用","号隔开即可。
如：

第三步：在想要注入Spring容器的类上加上注解
（Spring容器会自动扫描该注解）

注: 注解里面的值可以不写，如果不写，Spring容器默认id为类名，且类名的首字母小写。比如类名为 User，那么默认id就是user

需知：在配置文件中，开发扫描的时候，可以配置对某些注解开启扫描，某些注解不开启扫描，如：

例子：
1、修改serviceImpl代码（暂时将ServiceImp作为Bean对象，因为注解一般是用于接口上的，这里为了方便演示就暂时写实现类上）：
在这里插入图片描述

2、告知Spring需要扫描的包，所以需要配置xml：
在这里插入图片描述
3、测试：

当然，也可以在注解上给Bean加上id，如：

此时获取Bean对象的时候就需要使用account

总结：
使用注解比XML的<Bean>方便的多，因为每个类创建一个bean对象都需要在XML中配置，但使用注解可以直接扫描整个包。具体使用xml还是注解看公司发展需要。

4.1.2、@Controller、@Service、@Repository注解

这三个注解的作用和@Component一模一样，都是用于创建Bean对象，区别在于：

Controller：：一般用在表现层
Service：一般用在业务层
Repository：一般用在持久层
以上三个注解他们的作用和属性与Component是一模一样。
他们三个是spring框架为我们提供明确的三层使用的注解，使我们的三层对象更加清晰
也就是四个标签可以随便替换用，没有限制。为了代码方便维护，建议使用分层的标签。

4.2、基本注解方式实现属性注入

4.2.1、@Autowired注解

用于注入数据的注解：
他们的作用就和在xml配置文件中的bean标签中写一个<property>标签的作用是一样的
Autowired: （根据类型进行注入）
作用：自动按照类型注入。只要容器中有唯一的一个bean对象类型（子类和实现类都可以）和要注入的变量类型匹配，就可以注入成功；
如果ioc容器中没有任何bean的类型和要注入的变量类型匹配，则报错；
如果Ioc容器中有多个类型匹配时：Autowired出现位置可以是变量上，也可以是方法上；其作用和基于xml方法的<bean id="" class="" autowire="byType" /> 作用是一致的。

上述的例子中，如果我们直接执行代码中的saveAccount()方法，那么会报空指针异常。如图所示：
在这里插入图片描述
异常的原因是因为没有给AccountServiceImpl类中的成员变量accountDao对象赋值，accountDao为null。所以我们接下来要解决的就是给成员变量IAccountDao赋值：

此时再运行测试，发现：
在这里插入图片描述

问：什么原因导致的呢？
答：现在我们要注入的类型变量类型是IAccountDao，那么请问，此时Spring容器中有这类类型和他的子类型么？如果Spring容器中没有这个类型，我们又从哪里拿值注入？所以我们需要先将IAccountDao的子类注入到容器中，才能解决才问题。

注入IAccountDaoImpl：
在这里插入图片描述

此时再来运行则没问题：
在这里插入图片描述
效果正常。

假如现在Dao接口有两个实现类，别且分别取了别名accountDao1和accountDao2注入到Spring容器中：

在这里插入图片描述

然后此时在service层：

然后此时再次运行，发现就会报错。

以上分别说了容器里面不存在Bean对象时使用注入数据、和容器里面存在一个Bean对象时注入数据的情况。那要是Spring容器中存在多个Bean类型的数据，会怎么样呢？下面我们通过原理图说明：
在这里插入图片描述

总结：
如果在容器中存在多个Bean对象，此时多个变量Bean对象的id和已注入数据的变量名不一致，此时也会报错。这为开发人员增加了限制。那么怎么解决这个问题呢？下面我们来说一下

4.2.2、@Qualifier注解

知识：
Qualifier （根据类bean的ID名称进行注入，需要配合@Autowired一起使用）
作用：在按照类中注入的基础之上再按照类名称注入。它在给类成员注入时不能单独使用，但是在给方法参数注入时可以。
value：用于指定注入Bean的ID。
根据属性名称进行自动注入，其作用跟基于xml方法的<bean id="" class="" autowire="byName" />作用是一样。

Qualifier不能单独使用，需要配合@Autowired一起使用。假如一个A类中同时有属性B类和C类，如果B类和C类的类型一致，那么此时肯定会报错，此时就需要配置@Qualifier一起使用，用@Qualifier根据bean的ID类指定到底注入容器哪一个类。

例如：当Spring容器中存在两个Bean对象的时候：

1、新建一个Dao实现类：
在这里插入图片描述
代码中注解分别为dao1和dao2：

在这里插入图片描述

2、serviceImple中使用@Autowired注入Bean：
在这里插入图片描述

问题：此时运行代码会调用的值是Spring容器中的dao1还是dao2呢？：
答案：都不会调用。在srping容器中有两个Bean，首先会根据类型去找，能找到dao1和dao2，其次会再根据定义的变量名称去找：

由于变量名称是accountDao，而不是dao1或dao2。所以此时注入失败。想要注入成功，有以下两种解决方案：
（1）将变量名修改成dao1或者dao2

（2）配合@Qualifier注解指定注入dao1还是dao2

总结：
1、注解@Qualifier不能单独使用，需要配合@Autowired一起使用。
可理解为注解@Autowired不能定义定义指定注入哪个Bean对象，没有value属性，如果需要指明调用注入哪个Bean对象，需要使用@Qualifier来指明。
2、@Qualifier的作用就是为指明注入Bean对象，所以它一般存在于容器中存在多个同类型或子类型的Bean对象的情况。

4.2.3、@Resource注解

@Resource （既可根据类型注入，也可以根据名称注入）
作用：既可根据类型注入，也可以根据名称注入。它可以独立使用。
属性：
name：用于指定bean的id，也就是一个@Resource可以顶@Autowired和@Qualifier同时使用。
当一个中只存在一个类型唯一的bean，此时直接使用@Resource是根据类型注入。如果存在两个相同类型的bean，此时可以在类型一致的情况下指定bean的Id进行注入，如@Resource(name ="dao1")

注：@Autowired和@Qualifiler都由Spring提供的注解。而且@@Resource注解是由JDK官方提供的，而Spring更建议我们使用自己提供的原生注解。

例如：
在这里插入图片描述

4.2.4、@Value注解

之前基于xml方法的配置，对于普通类型属性注入，是需要重写set方法，并通过<property>标签来注入值，而基于注解的十分简单，只需要使用@value即可。

总结：：
以上三个注入数据都只能注入其他类型的数据，而对于基本类型和String类型无法使用上述注解实现。另外，集合类型的注入只能通过XML的方式来实现。

知识：
@Value
作用：用于注入基本类型和String类型的数据。该注解的作用是将我们配置文件的属性读出来，有@Value(“${}”)和@Value(“#{}”)两种方式，区别之后介绍，先不多说上图感受

属性：
value：用于指定数据的值。它可以使用spring中SqEL（也就是spring的el表达式）。
写SqEL写法：${表达式}

具体怎么使用，参考帖子：
https://blog.csdn.net/woheniccc/article/details/79804600

4.2.5、完全注解开发

（1）创建配置类，代替xml配置文件
在这里插入图片描述
（2）创建一个部门类，一个员工类，并注入到容器中

在这里插入图片描述
（3）测试：

4.3、作用范围注解

@Scope作用和在bean标签中使用scope属性实现功能是一样的。
作用：用于指定bean的作用范围
属性：
value：指定范围的取值。常用取值有singleton和prototype。不写默认是单例的。

例如：
1、给类对象加上@Scope注解：
在这里插入图片描述
2、运行测试：

4.4、生命周期相关注解

知识：
@PreDestroy
作用：用于指定销毁方法
@PostConstruct作用：用于指定初始化方法

1、增加两个方法：
在这里插入图片描述

2、测试：
在这里插入图片描述
结果：

青铜哥布林

关注

8
点赞
踩
20

收藏

觉得还不错? 一键收藏
1
评论
Spring5 IOC框架详解（一）

一、Spring概述1.1、Spring概述 Spring是分层的java SE/EE应用full—stack（全栈式）轻量级开源框架，以IOC（反转控制）和AOP（面向切面编程）两个核心，提供了展现层MVC和持久层Spring JDBC以及业务层事务管理等众多的企业级应用技术 Spring为简化企业级开发而生，使用Spring开发可以将Bean对象，Dao组件对象，Service组件对...
复制链接

扫一扫