浅谈spring框架之IOC机制

最新推荐文章于 2020-06-06 00:57:16 发布

程序fa

最新推荐文章于 2020-06-06 00:57:16 发布

阅读量146

点赞数

分类专栏： Spring

本文链接：https://blog.csdn.net/qq_32403043/article/details/103253358

版权

Spring 专栏收录该内容

6 篇文章 1 订阅

订阅专栏

在上一篇文章中，我们主要讲了如何削弱类与类之间的耦合性，通俗点说，就是让两个类之间的关联性尽可能的降低。我们采用了一个配置文件和java反射技术来实现的。其实，二十多年前就已经有人为我们开发出这样的框架了。他就是spring框架。我们今天就学习一下spring框架。
我们采用maven形式来管理jar包。
第一步：新建一个maven项目（目录结构如下）。
建立两个类，一个测试类（TestMethod），一个业务逻辑类EntityServiceImpl
在这里插入图片描述
第二步：导入依赖（pom文件如下）

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.tff.demo</groupId>
    <artifactId>spring_02</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.0.RELEASE</version>
        </dependency>
    </dependencies>
</project>```

第三步：在类路径下面创建一个spring的配置文件bean.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:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/tx">
</beans>

到这里spring的基本开发环境就搭建完成了（当然，在这之前你肯定要配置maven仓库，jdk等）
作为初学者，我觉得我们在学spring框架时必须要搞清楚这么几个问题：
1.什么是IOC（控制反转）
2.什么是DI（依赖注入）
3.什么是AOP（面向切面编程）
我们先来看第一个问题，控制反转我们可以这样理解，who（谁）控制，怎么反转，我们一起来看一下：假设一个情景如下：
在项目开发过程中，我们一般都采用MVC设计模式，我们习惯用web层调用service层，Service层在调用dao层。那我们要这样实现这样的调用，就必须在web层加入service层的属性，在service层加入dao层的属性。那我们传统的解决方案如下：

//web层
EntityService service = new EntityServiceImpl();
//service层
EntityDao dao = new EntityDaoImpl();

如果是传统方式，那控制权就是我们程序员自己，我想在什么时候生产对象就在什么时候生产对象，这种new出来的对象你也可以理解为正转。
看看spring是如何产生对象的：
第一步：我们要配置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"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/tx">
        
    <bean id="EntityService" class="jdbc.service.EntityServiceImpl">
    </bean>
</beans>

就是采用一对bean标签来进行实例化bean对象的。这里我们先不说bean标签里面的内容。
测试代码如下：

public class TestMethod {
    //private static  EntityService entityService = new EntityServiceImpl();
    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");

        EntityServiceImpl entityService = (EntityServiceImpl) ac.getBean("EntityService");
        entityService.test();
	}
}

运行结果：
在这里插入图片描述
我们看到代码成功运行，并且调用了EntittyServiceImpl类的test()方法。这个过程当中，spring没有采用new关键字来生产对象。这就是spring的强大之处了。
反转：原来对象的创建是由我们程序员自己去创建，而现在是交给spring容器来帮我们创建了，我们需要的时候去取就可以了。这种关系的转变就是反转。这就是spring中控制反转的概念。
总结一下：可能上面说的有点乱。上一篇文章我们为了削弱类与类之间的耦合性时，我们采用properties配置文件和反射来动态创建我们需要的对象。而在20多年前，就有人已经做了这样的事情，那就是spring框架，在直白一点就是spring框架的IOC (控制反转)就是削弱类与类之间的耦合性。
我们在介绍一下bean标签，一个bean标签就可以对一个bean对象进行实例化。反过来说，我们有多少个要交给spring来实例化的对象就需要创建多少个bean 。spring帮我们创建以后，我们怎么去取那？就是我们测试类中所写的那些代码，可以分为以下几步：
第一步：加载spring的配置文件，这里是bean.xml。
如：ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
第二步：根据bean的id来得到相应的对象（id就是bean标签里面的id属性的值）。

EntityServiceImpl entityService = (EntityServiceImpl) ac.getBean("EntityService");

bean标签的属性详解：

	 id：id标签是bean的唯一标识，IoC容器中bean的id标签不能重复，否则报错。
	 
	name：name是bean的名称标识，在网上看到有的文章说name可以重复，但是我在Srping 4.0.4.RELEASE测试中，bean标签的name属性也是不能重复，且id和name属性也不能重复，name标签应该等同于id属性。
	
	备注：IoC容器中id的名称不能重复，name的名称不能重复，且id和name的名称也不能重复。另外id和name都可以指定多个名字，名字之间可用逗号、分号、或者空格间隔。
	
	 class：class属性是bean常用属性，为bean的全限定类名，指向classpath下类定义所在位置。
	 
	 factory-method：factory-method工厂方法属性，通过该属性，我们可以调用一个指定的静态工厂方法，创建bean实例。
	 
	 factory-bean：factory-bean就是生成bean的工厂对象，factory-bean属性和factory-method属性一起使用，首先要创建生成bean的工厂类和方法。
	 
	 init-method：init-method属性是bean的初始方法，在创建好bean后调用该方法。
	 
	 destory-method：destory-method属性是bean的销毁方法，在销毁bean之前调用该方法，一般在该方法中释放资源。
	 
	 scope：scope属性表示bean的作用范围，scope有4个值,稍后讲。
	 
	 autowire：autowire表示bean的自动装配，他的值很多，稍后讲。

接下来我们主要讲一下bean细节问题

bean对象的三种创建方式

第一种：使用默认的构造器来创建

这种方式也是我们经常用的一种方式，其实，前面那种就是使用默认的构造器来创建bean对象的（这种方式就是这个对象中一定要存在一个默认的构造函数存在）。
测试类中的写法都一样，我们只要看一下spring的配置文件

  <!--   使用默认的构造器来创建bean对象  -->
    <bean id="EntityService" class="jdbc.service.EntityServiceImpl" >
    </bean>

第二种：使用静态工厂方法来创建bean对象

配置文件如下：

<!--  使用静态工厂方法来创建bean对象  -->
    <bean id="StaticFactory" class="jdbc.service.StaticBeanFactoryClass" factory-method="getInstance">
    </bean>

模拟一个StaticBeanFactoryClass类，提供一个静态方法，可以通过这个静态方法实例化出这个类的对象。

package jdbc.service;
public class StaticBeanFactoryClass {
    private StaticBeanFactoryClass(){}

    public static StaticBeanFactoryClass getInstance(){
        return new StaticBeanFactoryClass();
    }
    //测试方法
    public void testStatic(){
        System.out.println("静态工厂方法创建bean对象测试方法");
    }
}

第三种：使用普通工厂方法来创建bean对象

这种方式也很常用，我们想要的对象很可能存在于某个jar包中，我们无法通过修改源码的方式来提供默认的构造函数。这个使用使用普通的工厂方法来创建我们想要的对象是最合适不过的了。
spring配置如下：

<!--  使用普通工厂方法来创建对象（使用某个类中方法来创建对象，并存入spring容器中） -->
    <bean id="beanFactory" class="jdbc.service.BeanFactory">
    </bean>
    <bean id="entityService" factory-bean="beanFactory" factory-method="getInstance"></bean>

工厂类如下：

package jdbc.service;

/***
 *  模拟一个工厂类（该类可能是存在jar包中的，我们无法通过修改源码的方式来提供默认的构造函数）
 */
public class BeanFactory {

    public EntityServiceImpl getInstance(){
        return new EntityServiceImpl();
    }
}

我们通过BeanFactory这个工厂类来得到一个EntityServiceImpl类。EntityServiceImpl才是我们想要的。不过，该类很可能是以jar包形式存在的，我们无法通过修改源码的方式来提供的默认的构造函数，只能借助这种普通工厂方法来创建。
测试类如下：

  ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        //默认构造器创建bean对象
        EntityServiceImpl entityService = (EntityServiceImpl) ac.getBean("EntityService");
        entityService.test();
        //使用静态工厂方法创建bean 对象
        StaticBeanFactoryClass beanFactoryClass = (StaticBeanFactoryClass) ac.getBean("StaticFactory");
        beanFactoryClass.testStatic();
        //使用普通工厂方法来创建bean对象
        EntityServiceImpl beanFactory1 = ac.getBean("entityService",EntityServiceImpl.class);
        beanFactory1.test();

好了，bean创建对象的三种方式我们就分享到此
接下来我们再看一下bean的作用范围

bean对象的作用范围

他是通过bean标签的scope属性来控制的。

bean标签的scope属性取值:

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

例如：

 <!--   使用默认的构造器来创建bean对象  -->
    <bean id="EntityService" class="jdbc.service.EntityServiceImpl" scope="singleton">
    </bean>

bean对象的生命周期

单例对象：
        出生：当容器创建时对象就出生
        活着：只要容器在，对象就一直活着
        死亡：容器销毁，对象消亡
        总结：单例对象的生命周期和容器相同
多例对象：
        出生：当我们使用对象时spring框架为我们创建
        活着：对象只要是在使用过程中就一直活着
        死亡：当对象长时间不用，且没有别的对象引用时，由Java垃圾回收器回收

我们可以通过bean标签里面的 init-method 和destory-method来测试对象的存活于消亡。
其实，这两个属性相当的重要，init-method里面我们可以指定程序运行之前的初始化工作，destory-method指定程序运行结束之前的释放内存工作
配置文件如下：

 <bean id="EntityService" class="jdbc.service.EntityServiceImpl" scope="singleton"
    init-method="init" destroy-method="destory">
    </bean>

其中的init和destory就是我们在EntityServiceImpl中定义的两个方法，方法名可以任意起，中文除外。
示例代码如下：

package jdbc.service;
public class EntityServiceImpl {
    public void test(){
        System.out.println("方法被调用了");
    }
    public void init(){
        System.out.println("查询数据之前必须先加载数据库驱动程序");
    }
    public void destory(){
        System.out.println("查询数据结束之后必须释放数据库连接");
    }
}

关于bean的细节我们就说这么多。
最后我们再说一下ApplicationContext这个类。我们发现，测试类基本上没有离开他，他给我们提供了spring框架的入口。相当的重要。
他有三个重要的实现类：
ClassPathXmlApplicationContext: 只能加载类路径下面的配置文件，之外的不能加载
FileSystemXmlApplicationContext: 可以加载磁盘任意位置的配置文件，绝对路径
AnnotationConfigApplication: 可以以注解的方式来加载配置文件
我们看一下ApplicationContext实现类图：
在这里插入图片描述
从上图我们可以看出，BeanFactory是顶层接口。其实，BeanFactory也可以作为spring框架的入口的。只不过他下面提供的方法相比ApplicationContext而言，有点少。
BeanFactory作为入口代码如下：

  Resource resource = new ClassPathResource("bean.xml");
  BeanFactory beanFactory = new XmlBeanFactory(resource);
  EntityService service =beanFactory.getBean("EntityService",EntityService.class);
  System.out.println(service);

基本上还是加载spring的配置文件，在得到一个beanFactory对象。

其实，他们两之间还有一个重要的区别：
BeanFactory在构建容器时，创建对象采用的策略是延迟加载，也就是，什么时候根据id来获取对象时才创建。
ApplicationContext在构建容器时，创建对象采用的策略是立即创建，也就是，只要配置文件读取完，对象就创建了。不过它还可以为Bean配置lazy-init=true来让Bean延迟实例化。
延迟实例化的优点：
应用启动的时候占用资源很少；对资源要求较高的应用，比较有优势

不延迟实例化的优点
所有的Bean在启动的时候都加载，系统运行的速度快；
在启动的时候所有的Bean都加载了，我们就能在系统启动的时候，尽早的发现系统中的配置问题
建议web应用，在启动的时候就把所有的Bean都加载了。（把费时的操作放到系统启动中完成）
IOC就分析到此（springDI和SpringAOP请看下篇），欢迎各路大神批评指正。

程序fa

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
浅谈spring框架之IOC机制

在上一篇文章中，我们主要讲了如何削弱类与类之间的耦合性，通俗点说，就是让两个类之间的关联性尽可能的降低。我们采用了一个配置文件和java反射技术来实现的。其实，二十多年前就已经有人为我们开发出这样的框架了。他就是spring框架。我们今天就学习一下spring框架。我们采用maven形式来管理jar包。第一步：新建一个maven项目（目录结构如下）。建立两个类，一个测试类（TestMetho...
复制链接

扫一扫

专栏目录