Spring理论基础-控制反转和依赖注入


第一次了解到控制反转(Inversion of Control)这个概念,是在学习Spring框架的时候。IOC和AOP作为Spring的两大特征,自然是要去好好学学的。而依赖注入(Dependency Injection,简称DI)却使得我困惑了挺久,一直想不明白他们之间的联系。
控制反转
控制反转顾名思义,就是要去反转控制权,那么到底是哪些控制被反转了?在2004年 Martin fowler 大神就提出了

“哪些方面的控制被反转了?”

这个问题,他总结出是依赖对象的获得被反转了。
在单一职责原则的设计下,很少有单独一个对象就能完成的任务。大多数任务都需要复数的对象来协作完成,这样对象与对象之间就有了依赖。一开始对象之间的依赖关系是自己解决的,需要什么对象了就New一个出来用,控制权是在对象本身。但是这样耦合度就非常高,可能某个对象的一点小修改就会引起连锁反应,需要把依赖的对象一路修改过去。

如果依赖对象的获得被反转,具体生成什么依赖对象和什么时候生成都由对象之外的IOC容器来决定。对象只要在用到依赖对象的时候能获取到就可以了,常用的方式有依赖注入和依赖查找(Dependency Lookup)。这样对象与对象之间的耦合就被移除到了对象之外,后续即使有依赖修改也不需要去修改原代码了。

总结一下,控制反转是指把对象的依赖管理从内部转移至外部。
依赖注入
控制反转是把对象之间的依赖关系提到外部去管理,可依赖是提到对象外面了,对象本身还是要用到依赖对象的,这时候就要用到依赖注入了。顾名思义,应用需要把对象所需要的依赖从外部注入进来。可以是通过对象的构造函数传参注入,这种叫做构造器注入(Constructor Injection)。如果是通过JavaBean的属性方法传参注入,就叫做设值方法注入(Setter Injection)。
不管是通过什么方式注入的,如果是我们手动注入的话还是显得太麻烦了。这时候就需要一个容器来帮我们实现这个功能,自动的将对象所需的依赖注入进去,这个容器就是前面提到的IOC容器了。
控制反转和依赖注入的关系也已经清晰了,它们本质上可以说是一样的,只是具体的关注点不同。控制反转的关注点是控制权的转移,而依赖注入则内含了控制反转的意义,明确的描述了依赖对象在外部被管理然后注入到对象中。实现了依赖注入,控制也就反转了。
例子

首先是传统的方式,耦合非常严重。
public class Main {

public static void main(String[] args) {
    OrderService service = new OrderService();
    service.test();
}

}
public class OrderService {

private OrderDao dao = new OrderDao();

public void test() {
    dao.doSomeThing();
}

}
public class OrderDao {

public void doSomeThing() {
    System.out.println("test");
}

}

接下来是没有使用容器的方式,松耦合了,但是手动注入非常的麻烦。

public class Main {

public static void main(String[] args) {
    Dao dao = new OrderDao();
    OrderService service = new OrderService(dao);
    service.test();
}

}
public interface Dao {

void doSomeThing();

}
public class OrderDao implements Dao {

@Override
public void doSomeThing() {
    System.out.println("test");
}

}
public class OrderService {

private Dao dao;

public OrderService(Dao dao) {
    this.dao = dao;
}

public void test() {
    dao.doSomeThing();
}

}

接下来使用容器造福人类。

// 引导类要放在项目根目录下,也就是在 src 下面
public class Main {

public static void main(String[] args) {
    // 生成容器
    Container container = new Container(Main.class);
    // 获取Bean
    OrderService service = container.getBean(OrderService.class);
    // 调用
    service.test();
}

}br/>@Component
public class OrderService {

@Autowired
private Dao dao;

public void test() {
    dao.doSomeThing();
}

public Dao getDao() {
    return dao;
}

public void setDao(Dao dao) {
    this.dao = dao;
}

}br/>@Component
public class OrderDao implements Dao {

@Override
public void doSomeThing() {
    System.out.println("test");
}

}
public interface Dao {

void doSomeThing();

}br/>@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
public @interface Component {
br/>}
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD,ElementType.METHOD})
public @interface Autowired {
}

public class Container {

private List<String> classPaths = new ArrayList<>();

private String separator;

private Map<Class, Object> components = new HashMap<>();

public Container(Class cls) {
    File file = new File(cls.getResource("").getFile());
    separator = file.getName();
    renderClassPaths(new File(this.getClass().getResource("").getFile()));
    make();
    di();
}

private void make() {
    classPaths.forEach(classPath -> {
        try {
            Class c = Class.forName(classPath);
            // 找到有 @ioc.Component 注解的类并实例化
            if (c.isAnnotationPresent(Component.class)) {
                components.put(c, c.newInstance());
            }
        } catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) {
            e.printStackTrace();
        }
    });
}

/**
 * 注入依赖
 */
private void di() {
    components.forEach((aClass, o) -> Arrays.stream(aClass.getDeclaredFields()).forEach(field -> {
        if (field.isAnnotationPresent(Autowired.class)) {
            try {
                String methodName = "set" + field.getType().getName().substring(field.getType().getName().lastIndexOf(".") + 1);
                Method method = aClass.getMethod(methodName, field.getType());
                if (field.getType().isInterface()) {
                    components.keySet().forEach(aClass1 -> {
                        if (Arrays.stream(aClass1.getInterfaces()).anyMatch(aClass2 -> aClass2.equals(field.getType()))) {
                            try {
                                method.invoke(o, components.get(aClass1));
                            } catch (IllegalAccessException | InvocationTargetException e) {
                                e.printStackTrace();
                            }
                        }
                    });
                } else {
                    method.invoke(o, components.get(field.getType()));
                }
            } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
                e.printStackTrace();
            }
        }
    }));
}

/**
 * 该方法会得到所有的类,将类的全类名写入到classPaths中
 *
 * @param file 包
 */
private void renderClassPaths(File file) {
    if (file.isDirectory()) {
        File[] files = file.listFiles();
        Arrays.stream(Objects.requireNonNull(files)).forEach(this::renderClassPaths);
    } else {
        if (file.getName().endsWith(".class")) {
            String classPath = file.getPath()
                    .substring(file.getPath().lastIndexOf(separator) + separator.length() + 1)
                    .replace(‘\\‘, ‘.‘)
                    .replace(".class", "");
            classPaths.add(classPath);
        }
    }
}

public <T> T getBean(Class c) {
    return (T) components.get(c);
}

}

后记
一些概念在脑海里总以为是清晰的,等实际用到或者是写成文字的时候就发现有很多不理解的地方。本文的目的就是梳理下概念,做些记录。这次自己尝试实现了下IOC容器,一开始写就知道自己之前的理解有问题了。好歹是写出了个能用的版本,用来应付文章中的例子。后面可以去参考下Spring的实现,估计能学到不少东西。
如果你现在在JAVA这条路上挣扎,也想在IT行业拿高薪,可以参加我们的训练营课程,选择最适合自己的课程学习,技术大牛亲授,7个月后,进入名企拿高薪。我们的课程内容有:Java工程化、高性能及分布式、高性能、深入浅出。高架构。性能调优、Spring,MyBatis,Netty源码分析和大数据等多个知识点。如果你想拿高薪的,想学习的,想就业前景好的,想跟别人竞争能取得优势的,想进阿里面试但担心面试不过的,你都可以来,q群号为:230419550

注:加群要求

1、具有1-5工作经验的,面对目前流行的技术不知从何下手,需要突破技术瓶颈的可以加。

2、在公司待久了,过得很安逸,但跳槽时面试碰壁。需要在短时间内进修、跳槽拿高薪的可以加。

3、如果没有工作经验,但基础非常扎实,对java工作机制,常用设计思想,常用java开发框架掌握熟练的,可以加。

4、觉得自己很牛B,一般需求都能搞定。但是所学的知识点没有系统化,很难在技术领域继续突破的可以加。

5.阿里Java高级大牛直播讲解知识点,分享知识,多年工作经验的梳理和总结,带着大家全面、科学地建立自己的技术体系和技术认知!

Spring理论基础-控制反转和依赖注入

原文地址:http://blog.51cto.com/13792737/2136761

时间: 2024-10-12 20:22:35

Spring理论基础-控制反转和依赖注入的相关文章

Spring 基础 控制反转和依赖注入

Spring框架两个最重要的知识点 1.IOC(控制反转)/DI(依赖注入):把整个项目中的所有对象交给Spring容器管理 IOC:取到对象 DI:对象的装配 依赖注入有两种方式: 1.      属性值注入方式 a.     普通类型 注入方式 b.bean注入方式 测试结果 在使用普通类型方式注入的时候,我们会有一些特殊字符,处理这种特殊字符时 我们会想使特殊字符保持原有的样子,这时候就要使用CDATA,就如上一张图片所示 2.构造参数注值方式 在一般情况,一个类会有一个默认的无参构造函数

spring(3)------控制反转(IOC)/依赖注入(DI)

一,spring核心概念理解 控制反转: 控制反转即IoC (Inversion of Control),它把传统上由程序代码直接操控的对象的调用权交给容器,通过容器来实现对象组件的装配和管理. 所谓的"控制反转"概念就是对组件对象控制权的转移,从程序代码本身转移到了外部容器. 没有控制反转这种模式前,你创建一个对象,在什么地方用,你得单独通过关键字new出来用, 但现在可以不用这样,你把new对象的权利交给spring配置文件,通过配置文件来'new', 就是权利的反转,你以前干的事

spring的控制反转和依赖注入

控制反转(Inversion of Control,IOC) 我们首先先来了解一下控制二字,也就是在控制"正"转的情况下,在任何一个有请求作用的系统当中,至少需要有两个类互相配合工作,在一个入口类下使用new关键字创建另一个类的对象实例,这就好比在面向对象编程的思想下,"我"充当一个入口类,在这个入口类中,我每次吃饭的时候都要买一双一次性筷子(每一次使用都要new一次),在这样的关系下,是"我"(即调用者)每次都要"主动"去买

Spring框架之控制反转和依赖注入

学Spring框架必须理解控制反转和依赖注入.下面各自举一个例子,来说明. IOC(控制反转):应用本身创建和维护的依赖对象:现在交由外部容器(Spring)来创建和维护:这个控制权的转移: 就叫做控制反转. 第一步:配置applicationContextcreateproject.xml和applicationcontext.xml(总体) <?xml version="1.0" encoding="UTF-8"?> <beans xmlns=

spring学习总结一----控制反转与依赖注入

spring作为java EE中使用最为广泛的框架,它的设计体现了很多设计模式中经典的原则和思想,所以,该框架的各种实现方法非常值得我们去研究,下面先对spring中最为重要的思想之一----控制反转(依赖注入)进行简单的总结. 一.控制反转与依赖注入的概念 在学习spring框架的时候,我们习惯性地将控制反转和依赖注入放在一起,其实,两者体现的思想原则都是差不多的,只不过控制反转是一种更广泛的程序操作理念,而依赖注入是一种更为具体的实现方法,总的来说,控制反转可以依靠依赖注入来实现. 1.控制

轻松了解Spring中的控制反转和依赖注入

我们回顾一下计算机的发展史,从最初第一台计算机的占地面积达170平方米,重达30吨,到现如今的个人笔记本,事物更加轻量功能却更加丰富,这是事物发展过程中的一个趋势,在技术领域中同样也是如此,企业级JavaBean(Enterprise JavaBean ,EJB)在创建之初是非常成功,但是时间一久人们便开始追逐更加方便更加简易和轻量级的技术框架实现,于是Spring就应运而生,并且Sring一直开始不断地涉及到其他领域(这里就不再多详谈了),而Spring的精髓当中就包括控制反转和依赖注入. 浅

spring的容器(控制反转、依赖注入)

一.spring的容器 ”容器“是spring的一个重要概念,其主要作用是完成创建成员变量,并完成装配. 而容器的特点”控制反转“和”依赖注入“是两个相辅相成的概念. 控制反转:我们在使用一个类型的实例实现某个功能时,需要先new出该类型的一个实例,并赋值给我们声明的某个引用变量,这样我们才能够使用该变量进行操作.而new和赋值本事我们自己的权限,此处便是将该控制权限反转交给了spring. 依赖注入:某个类型要完成一个功能往往需要其他类型的变量来完成,我们在程序中往往通过自己new的方式来完成

轻松了解Spring中的控制反转和依赖注入(二)

紧接上一篇文章<轻松了解Spring中的控制反转和依赖注入>讲解了SpringIOC和DI的基本概念,这篇文章我们模拟一下SpringIOC的工作机制,使我们更加深刻的理解其中的工作. 类之间的结构图如下 以下是代码 BeanFactor接口:在Spring源码中的定义是:持有对一定数量的Bean的定义,同时每个Bean都被唯一标识的对象(类),需要实现这个接口.根据对Bean的定义,该工厂将会返回一个包含Bean定义的对象的独立实例(原型设计模式),或者单例共享(一个不错的单例设计模式,)范

Spring控制反转和依赖注入

(1)为什么使用控制反转和依赖注入 调用者不用去关心被调用者的实现,不需要调用者亲自创建被调用者的实例,这些操作都交给框架去完成. 这种设计思想就是控制反转(Inversion of Control, IoC),同时,它还有另外一个名字就是依赖注入(Dependency Injection, DI). (2)什么是控制反转和依赖注入 控制反转(IoC)是将由程序控制的"对象间的依赖关系"转交给IoC容器来进行控制,被调用者的实例创建工作不再由调用者来完 成.通过控制反转,可以实现由外部