IT修真院_JAVA

Spring中的IOC是什么,为什么要用IOC而不是New创建对

2017-11-28  本文已影响0人  刻砺思

大家好,我是IT修真院上海分院第02期学员,一枚正直善良的java程序员。
今天给分享一下修真院java任务一中关于spring IOC的相关知识。
1.背景介绍
在面向对象编程中,其基本思路是实现对象之间的低耦合,高内聚,而在传统的Java代码编写中,如果有某个对象A依赖于其他对象B,在使用时,需要先创建所依赖的对象B,传入对象A,然后才能对对象A进行操作,这种方式提高了代码的耦合度,十分不利于重构和维护
采用spring的依赖注入,可以促进代码的松散耦合。借助这种方式,对象无需知道依赖来自何处,或者依赖的实现方式,确保了低耦合
2.知识剖析
传统方式,需要先用new关键词,或者是通过工厂类来创建一个所依赖的对象,传入当前对象:

public class T2 {
    private T1 t1;
    public void setT1(T1 t1) {
        this.t1 = t1;
    }
    private String p1 = "this is T2: ";
    public void print(){
        System.out.println(p1);
        t1.print();
    }
}

如上,T2类依赖于T1类,当需要调用T2的方法时,需要先创建T1对象:

 @Test
    public void testT2_T1(){
        T1 t1 = new T1();
        T2 t2 = new T2();
        t2.setT1(t1);
        t2.print();
    }

IOC,Inversion of Control,控制反转,不是什么技术,而是一种设计思想,它包括依赖注入(Dependency Injection,简称DI)和依赖查找(Dependency Lookup)。在Java开发中,Ioc意味着将设计好的对象交给容器控制,而不是传统的在对象内部直接控制
DI—Dependency Injection,即“依赖注入”
需要理解一下几个问题:
谁依赖于谁:当然是应用程序依赖于IoC容器
为什么需要依赖:应用程序需要IoC容器来提供对象需要的外部资源
谁注入谁:很明显是IoC容器注入应用程序某个对象,应用程序依赖的对象
注入了什么:就是注入某个对象所需要的外部资源(包括对象、资源、常量数据)

spring提供了三种主要的方式来配置
1.在XML中进行显式配置
2.在Java中进行显式配置,JavaConfig
3.隐式的bean发现机制和自动装配

1.在XML中配置
类:

public class C1 {
    private String p1;
    private String p2;
    public void setP1(String p1) {
        this.p1 = p1;
    }
    public void setP2(String p2) {
        this.p2 = p2;
    }
    public void print(){
        System.out.println("this is C1: "+p1+p2);
    }
    public C1() {
    }
    public C1(String p1, String p2) {
        this.p1 = p1;
        this.p2 = p2;
    }
}

在xml配置文件中配置:

 <bean id="c1" class="xml.C1">
        <property name="p1" value="Hello"/>
        <property name="p2" value="Xml"/>
    </bean>

如果类依赖了其他对象:

public class C3 {
    private C1 c1;
    public void setC1(C1 c1) {
        this.c1 = c1;
    }
    public void print(){
        System.out.print("this is C3: ");
        c1.print();
    }
}

则需要进行装配:

<bean id="c3" class="xml.C3">
        <property name="c1" ref="c1"/>
    </bean>

2.在Java中进行显式配置

public class B1 implements B{
    private String p1;
    private String p2;
    public void setP1(String p1) {
        this.p1 = p1;
    }
    public void setP2(String p2) {
        this.p2 = p2;
    }
    public void print(){
        System.out.println("this is B1: "+p1+" "+p2);
    }
}

类B3依赖B1

public class B3 implements B{
    private B1 b1;
    public B3(B1 b1) {
        this.b1 = b1;
    }
    public void print(){
        System.out.print("this is B3: ");
        b1.print();
    }
}

创建一个配置类,使用注解@Configuration标注为配置类,bean会在此处装配:

@Configuration
public class Config {
    @Bean
    public B1 b1(){
        B1 b1 = new B1();
        b1.setP1("Hello");
        b1.setP2("JavaConfig");
        return b1;
    }
    @Bean
    public B3 b3(B1 b1){
        return new B3(b1);
    }
}

3.隐式的bean发现机制和自动装配
需要开启组件扫描:

@Configuration
@ComponentScan
public class Config {
}

只需要在原有的类上添加注解即可:

@Component()
public class A1 implements A{
    @Value("Hello")
    private String p1;
    @Value("World")
    private String p2;
    public void print(){
        System.out.println("this is A1: "+p1+" "+p2);
    }
}

A3依赖A1

@Component
public class A3 implements A{
    private A1 a1;
    @Autowired
    public A3(A1 a1) {
        this.a1 = a1;
    }
    public void print(){
        System.out.print("this is A3: ");
        a1.print();
    }
}

注解 @Autowired实现自动装配

问题:
@autowired注解注入时,如果有两个相同类型的bean时会出现什么情况
答,采用@autowired来实现自动装配时,如果有两个相同的bean,在不明确指定id的情况下,会报错发现两个相同类型的bean

控制反转和依赖注入是同一个概念吗
答,不是,控制反转是指创建对象的控制权由原来的在Java代码中转换到IOC容器中,依赖注入是指通过构造注入或set注入的方式将所依赖的对象注入,控制反转的概念包含了依赖注入,其内涵更加广泛

spring上下文和IOC容器是同一种东西吗
答,不是,spring应用上下文负责加载在xml或者是Java代码中配置bean的相关信息,IOC容器负责创建bean,并进行装配等操作

在什么情况下会用构造方法注入
答,对强依赖使用构造器注入,对可选择性的依赖使用属性注入

视频:https://v.qq.com/x/page/q05115ptt0o.html
PPT:https://ptteng.github.io/PPT/PPT-java/java-task1-spring-IOC.html#/1

上一篇 下一篇

猜你喜欢

热点阅读