依赖注入(DI)和控制反转(IOC)的详细讲解 spring容器(spring注解实现,而不是xml配置文件)

版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://lixuekai.blog.csdn.net/article/details/64915626

在看此片文章之前,请先看下面一片,是最基础的依赖注入和控制反转的spring简单实现。简单到看完就可以基本理解。
http://blog.csdn.net/qq_27093465/article/details/52547290
下面的这篇文章,和上边的那个文章,可能会有稍微重复。但也是为了理解这个术语。

   依赖注入(Dependency Injection)和控制反转(Inversion of Control)是同一个概念。
具体含义是:当某个角色(可能是一个Java实例,调用者)需要另一个角色(另一个Java实例,被调用者)的协助时,
在传统的程序设计过程中,通常由调用者来创建被调用者的实例。但在Spring里,创建被调用者的工作不再由调用者来完成,
因此,称为控制反转;创建被调用者实例的工作通常由Spring容器来完成,然后注入调用者,因此也称为依赖注入。


spring的控制反转:
把对象的创建、初始化、销毁等工作交给spring容器来做。由spring容器 控制对象的生命周期。


     不管是依赖注入,还是控制反转,都说明Spring采用动态、灵活的方式来管理各种对象。对象与对象之间的具体实现互
相透明。在理解依赖注入之前,看如下这个问题在各种社会形态里如何解决:一个人(Java实例,调用者)需要一把斧子(Java实
例,被调用者)。

   (1)原始社会里,几乎没有社会分工。需要斧子的人(调用者)只能自己去磨一把斧子(被调用者)。对应的情形为:Java程序
里的调用者自己创建被调用者。

   (2)进入工业社会,工厂出现。斧子不再由普通人完成,而在工厂里被生产出来,此时需要斧子的人(调用者)找到工厂,购
买斧子,无须关心斧子的制造过程。对应Java程序的简单工厂的设计模式。

   (3)进入“按需分配”社会,需要斧子的人不需要找到工厂,坐在家里发出一个简单指令:需要斧子。斧子就自然出现在他面前。
对应Spring的依赖注入。

   第一种情况下,Java实例的调用者创建被调用的Java实例,必然要求被调用的Java类出现在调用者的代码里。无法实现二者
之间的松耦合。

    第二种情况下,调用者无须关心被调用者具体实现过程,只需要找到符合某种标准(接口)的实例,即可使用。此时调用的代
码面向接口编程,可以让调用者和被调用者解耦,这也是工厂模式大量使用的原因。但调用者需要自己定位工厂,调用者与特定工
厂耦合在一起。

    第三种情况下,调用者无须自己定位工厂,程序运行到需要被调用者时,系统自动提供被调用者实例。事实上,调用者和被调
用者都处于Spring的管理下,二者之间的依赖关系由Spring提供。

    所谓依赖注入,是指程序运行过程中,如果需要调用另一个对象协助时,无须在代码中创建被调用者,而是依赖于外部的注入。
Spring的依赖注入对调用者和被调用者几乎没有任何要求,完全支持对POJO之间依赖关系的管理。依赖注入通常有两种:

(哎,POJO知道是啥吗?不知道的话,看链接,如下:POJO是什么,怎么理解,大师兄查了,看看吧。点我。)


1,两个接口的声明。

person接口

/**
 * 定义Person接口
 * <p>
 * Created by lxk on 2017/3/22
 */
interface Person {
    void useAxe();  //Person接口里定义一个使用斧子的方法
}
斧子接口 

/**
 * 定义Axe(斧子英文Axe)接口
 * <p>
 * Created by lxk on 2017/3/22
 */
interface Axe {
    String chop(); //Axe接口里有个砍(chop)的方法,返回String类型
}

2,两个实现类。

第一类斧子

import org.springframework.stereotype.Component;

/**
 * Axe的第二个实现类 SteelAxe 钢斧
 * 这个@Component 等价于 <bean id="steelAxe" class="..SteelAxe">
 * Created by lxk on 2017/3/22
 */
@Component
class SteelAxe implements Axe{

    /** 实现Axe接口的chop方法 */
    @Override
    public String chop() {
        return "钢斧砍柴真快";
    }
}
第二类斧子

import org.springframework.stereotype.Component;

/**
 * Axe的第一个实现类 StoneAxe 石斧
 * 这个@Component("stoneAxe") 等价于 <bean id="stoneAxe" class="..StoneAxe">
 * Created by lxk on 2017/3/22
 */
@Component("stoneAxe")
class StoneAxe implements Axe {

    /** 实现Axe接口的chop方法 */
    @Override
    public String chop() { return "石斧砍柴好慢"; }
}
人,使用斧子的实体。

import javax.annotation.Resource;

/**
 * Person的实现类(Chinese实现Person接口)
 *
 * Created by lxk on 2017/3/22
 */
@Component("chinese")
class Chinese implements Person {
    /** 面向Axe(斧子)接口编程,而不是具体的实现类 */
    @Resource(name = "stoneAxe")
    private Axe axe;

    /** 实现Person接口的useAxe方法 */
    public void useAxe() { System.out.println(axe.chop()); }
}

3,主方法测试类。

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * 依赖注入,使用注解实现
 * <p>
 * Created by lxk on 2017/3/22
 */
public class Main {
    public static void main(String[] args) {
        //因为是独立的应用程序,显式地实例化Spring的上下文。下面是启动spring容器代码:寻找配置文件实例化容器
        ApplicationContext context = new ClassPathXmlApplicationContext("com/lxk/spring/ioc/applicationContext.xml");
        //通过Person bean的id来获取bean实例,面向接口编程,因此
        //此处强制类型转换为接口类型
        Person p = (Person) context.getBean("chinese");
        //直接执行Person的userAxe()方法。
        p.useAxe();
    }
}

4,对应的配置文件,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"
       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-2.5.xsd">

    <context:component-scan base-package="com.lxk.spring.ioc"/>
</beans>

5,执行结果:


6,文件结构如下:



7,说明:

首先你要知道,在spring容器启动之后,会根据你的配置文件里面
<context:component-scan base-package="com.lxk.spring.ioc"/>
类扫描的注解解析器
这句话,去这个路径下面扫描所有类,其中带有注解的,他就会在spring容器中自动实例化一个对象
具体参考另外一篇文章:
http://blog.csdn.net/qq_27093465/article/details/52710925(spring类扫描注入-----类扫描的注解解析器)
可以看到在Chinese类里面可以直接使用石斧的chop方法。
你 不需要自己new一个对象,而是直接使用,声明一下,就可以使用了,你在spring项目里面会看到 大量的类似这个的用法。
不同的可能就是注解的名称不一样,主要有@Controller,@Service("xxxx"),@Resource(name = "xxx"),@Repository("xxx"),
等等,很多的类似的注解,都是这么个道理。都是将这些个类,托管给spring容器,哪里要使用,只要声明一下,就可以直接使用。

看了这个文章,你起码知道你整体做的spring项目里面他究竟是到底怎么在依赖注入和控制反转,而不是说,他不就是怎么怎么的。
还是说不明白。这里没有将依赖注入的构造注入和设值注入,在文章开头位置的那个链接里面详细讲解了。而且使用的是简单的xml配置
也给出了,如何复现我的这个测试环境的链接。


最后,觉得写的好的,对你有帮助的,不嫌弃麻烦的,点个赞,觉得不好的,提出来我改之,懒得提也可以,但是,麻烦,放下脚,不要踩我文章。


展开阅读全文

没有更多推荐了,返回首页