博客

Spring Framework系统架构：

IOC容器与依赖注入的引入：

IOC：Inversion of Control—反转控制

为什么要使用它呢？

我们先来看下图的代码实现方式，我们通常将业务处理和数据处理写在不同的类中：

但如果业务发生改变， 所对应的实现类不再是BookDaoImpl了，那么代码需要重新编写，测试和编译等，这样一来所产生的成本大大提高，不仅如此，由于我们在类中写了其他功能的实现，就导致我们的代码耦合度偏高，而

java追求的则是“高内聚，低耦合”

，因为

低耦合的模块便于进行单元测试，且便于维护，代码关系过于紧密，往往改一小段代码，需要整个项目做很大的改动，所以在实际开发中应该尽量避免过高的耦合

那么要如何解决这种问题呢？

既然是由于我们在类中写了其他功能的实现，那么我们不写这个实现，耦合度不就低了吗？但我们如果仅仅是不写，耦合度是降低了，但是代码无法运行了呀，因为没有实现类的对象了

那么这个对象我们不能自己写，但又不能没有，由此对于上述的这种问题，解决方案为：

使用对象时，在程序中不要主动使用new产生对象，转换为由外部提供对象

，这也就是

Ioc思想

：

将对象的创建控制权由程序转移到外部

那么这种思想的目的或者说效果到底是什么呢？

其实很简单，就是为了

解耦


那么这种思想我们如何去实现呢？

就是通过我们接下来要学习的spring技术，

spring技术提供了一个Ioc容器，用来充当Ioc思想的“外部”


那么也就是说，我们上述提到的导致耦合度偏高的代码，可以放在这个容器中实现，

Ioc容器负责对象的初始化创建等工作，被创建或管理的对象在Ioc容器中被统称为Bean

但这似乎是有问题的，如下所示，此时的Ioc容器中有service对象和dao对象，假设我们现在需要使用service对象，那么直接从Ioc容器中拿取，但这似乎不太行，因为service对象的使用需要依赖dao对象，而Ioc此时我们只是拿到了service对象

既然service需要依赖dao对象才能运行，而这两个对象又都在Ioc容器中，由此Ioc又替我们做了一个工作，就是

将二者进行绑定

，使其在容器中也包含有这种依赖关系，而这项工作被称为

依赖注入

(Dependency Injection)—-

在容器中，建立bean与bean之间的依赖关系的过程，被称为依赖注入

无论是我们上述谈到的

Ioc容器还是依赖注入，引入它们想要实现的共同目标即为充分解耦，使用Ioc容器管理Bean,在Ioc容器内将所有依赖关系的bean进行关系绑定(DI),而最终呈现的效果就是：

使用对象时不仅可以直接从Ioc容器中获取，并且获取到的bean已经绑定了所有的依赖关系


在IDE中实现spring的入门应用:

首先创建一个新的项目：

创建类：

package xysfxy;

public class Hello_spring {
    public void showMessage(){
        System.out.println("hello,spring");
    }
}


由于我们可通过指定获取IOC容器，因此这里spring配置文件的名字可自行命名

，

我们是基于XML来管理bean，因此在spring-xml文件中，我们需要配置bean标签

，编写spring配置文件：

applicantsContext.xml：


id是每个bean对象的唯一标识符，名称可以自行创建

，

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">
<bean id="hellospring" class="xysfxy.Hello_spring"></bean>
</beans>

pom.xml文件中导入依赖：

<?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>org.example</groupId>
    <artifactId>SSM6</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>18</maven.compiler.source>
        <maven.compiler.target>18</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties><dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.2.10.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13.1</version>
        <scope>test</scope>
    </dependency>
</dependencies>

</project>

编写测试类：

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import xysfxy.Hello_spring;

public class Hello_springtext {
    @Test
    public void test(){
    //ApplicationContext是Spring中的核心接口和容器，允许容器通过应用程序上下文环境创建、获取、管理bean
    //ClassPathXmlApplicationContext：可以加载类路径下的配置文件，要求配置文件必须在类路径之下[将该xml文件放在resources目录下]
    
       //获取IOC容器
        ApplicationContext ioc=new ClassPathXmlApplicationContext("applicantsContext.xml");
        //获取bean对象--通过id获取，需要将其转换为对应的类型
        Hello_spring helloSpring=(Hello_spring) ioc.getBean("hellospring");
        helloSpring.showMessage();
    }
}

消息成功输出，对象获取成功！

使用IOC 进行对象的管理和创建时，无参构造不能缺失:

创建实体类：

package xysfxy;

public class student {
    private  Integer sid;
    private  String sname;
    private  Integer age;
    private  String gender;

    public Integer getSid() {
        return sid;
    }

    public void setSid(Integer sid) {
        this.sid = sid;
    }

    public String getSname() {
        return sname;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public void setSname(String sname) {
        this.sname = sname;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    @Override
    public String toString() {
        return "studnet{" +
                "sid=" + sid +
                ", sname=" + sname +
                ", age=" + age +
                ", gender='" + gender + '\'' +
                '}';
    }

    public student(Integer sid, String name, Integer age, String  gender ) {
        this.age=age;
        this.sname=sname;
        this.gender=gender;
        this.sid = sid;
    }
}

编写对应的spring.xml文件：

applicantsContext.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="student1" class=" xysfxy.student"></bean>
</beans>

此时编译器就已经报错了：没有匹配的构造器…

测试类：

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import xysfxy.student;

public class student_text {
    @Test
    public void test(){
        ApplicationContext ioc=new ClassPathXmlApplicationContext("applicantsContext.xml");
        //通过id获取bean对象，需要将获取到的对象强制转化为实体类的
       student student=(student) ioc.getBean("student1");
        System.out.println(student);
    }
}

下述报错：缺少无参构造

点开XML文件，我们发现报错为：没有一个匹配的构造器在student类中

上述报错原因如下：

通过IOC进行对象管理，在底层使用的是工厂模式

，我们在没有学习spring之前创建对象使用的是new构造方法，那么spring是如何创建构造方法的呢？我们要

想获取IOC容器是通过配置文件中的bean标签的class属性对象的对象类型，这个类型并不是确定的，因为spring.xml文件中可以配置多个bean，在类型不确定的情况下，我们应通过反射创建对象，而在IOC容器中，正好是通过反射＋工厂模式进行对象的管理和创建

，我们知道了类型之后，

通过反射中的class.forName，再通过class中的newInstace方法来创建实例化对象，而这个过程正要用到无参构造，无参构造是固定的，但有参构造并不是，在有参构造中，包含的是成员变量的赋值，而这一过程可以进行重载，一个类可以重载很多个有参构造，因此，我们需要知道大部分使用反射进行对象创建的都需要使用无参构造


解决办法,加上无参构造：

成功输出，由于我们并没有给成员变量赋值，因此它输出的是默认值

获取bean的三种方式和注意事项：

通过IOC容器获取bean时，我们会发现可提供的方法有很多，我们可以通过id，类型，id+类型等

上述的案例中，我们就是根据bean的id值获取bean对象的，这里就不过多重复了，主要说一下其他的方法，需要

注意的就是通过id获取到的bean对象需要通过强制类型转换为实体类对象

，而根据类型获取就不存在这个问题

2：根据类型获取：

 //根据类型获取的bean对象就是我们的实体类对象，因此并不需要强制转换类型
 student student1= ioc.getBean(student.class);
 
 //输出获取到的对象值
 System.out.println(student1);

与通过id获取到的结果完全一样！

上述我们说到

id是每一个bean对象唯一的标识符

，那么IOC进行获取的时候，能够

通过id值准确无误的找到我们要获取的bean对象

，但我们也说过，一个beans子标签中可以出现多个bean标签，那么当我们在spring.xml文件中的beans标签中写了多个bean标签，并且他们的

类型都是student

，那么IOC容器通过类型获取bean对象时，会获取到哪一个呢？

如下所示：

<bean id="student1" class=" xysfxy.student"></bean>
<bean id="student2" class=" xysfxy.student"></bean>

测试结果如下：


IOC并没有获取到他们其中的一个，而是直接给我们报错

，报错内容为：不唯一的bean定义异常， 其实早在学习mybatis框架时，我们就说过，

如果当使用框架遇到模棱两可，我们都想不清楚到底是哪一个的时候， 框架一定会报错，因为它也想不清楚到底是哪个


由此我们可以得出一个结论，

根据类型获取bean时，要求IOC容器中只有一个

类型匹配

的bean

上述我们是由于有多个类型匹配的bean而引发的异常，但如果一个都没有呢？还会报错吗？

一试便知！

我们将配置文件中有关student类的bean标签删除，再次运行程序！

测试结果如下，编译器报错：没有找到匹配的bean对象

小结：

若没有一个类型匹配的bean，此时抛出异常：NoSuchBeanDefinitionException
若有多个类型匹配的bean，此时抛出异常：NoUniqueBeanDefinitionException

3：根据类型+id值获取：

测试类中：

 student student2=ioc.getBean("student1", student.class);
 System.out.println(student2);

输出如下所示，这种获取方式也能够正确的获取到bean对象：

说到这里，我们已经介绍了三种获取bean对象的方式：


第一种通过id获取

，

确保能够准确无误的获取到bean对象，但它需要强制转换成我们实体类类型


第二种通过class获取

，

不需要强制转换类型，但可能会出现一个都未匹配到或者匹配到多个的异常发生


第三种通过id和class进行获取

，

既不需要强制转换类型，也不会出现多个bean对象类型都匹配的问题

，那么这三种方式到底那种是我们所推荐的呢？

其实是第二种根据bean的类型获取，原因是：上述我们在进行第二种方式获取bean对象的测试中，那种现象其实是几乎不会发生的，因为

在IOC容器中一个类型的bean只需要配置一个，因为bean既可以单例也可以多例

，下述为出现多个同类型bean的问题代码：

<bean id="student1" class=" xysfxy.student"></bean>
<bean id="student2" class=" xysfxy.student"></bean>

该代码是想通过第一个bean标签获取一个student类的一个对象，又想通过第二个bean标签获取一个新的student类的对象，这样显然是多余的，我们可以

根据bean标签的scope属性去设置它的单例和多例

，如下所示：

我们

没有必要给一个类设置多个bean

，因此上述三种获取bean的方式中，

根据类型获取bean对象的方式是我们最常用的

扩展：

Question1:bean标签中的类可以写接口吗？

答案：不能

因为

一个bean对应一个对象该对象将来是要实例化的，而接口并不能进行实例化

，

因此在bean标签中的class属性我们只能写一个具体的类型，而不是接口

Question2:如果组件类实现了接口，根据接口类型可以获取bean吗？

答案：可以，但前提是bean必须唯一


组件类其实就是bean所管理的对象， 一个由bean所管理的对象就叫一个组件类


举例：

编写person接口：

package xysfxy;

public interface person {
}

让student类实现该接口！

在测试类中获取该bean对象：

 //方式1：通过类型获取bean对象，再将该对象进行上转型至接口
 person student1= ioc.getBean(student.class);
 System.out.println(student1);
 
 //方式2：通过该类实现的接口或者继承的父类而获取bean对象
 person person=ioc.getBean( person.class);
 System.out.println(person);

无论上述那种方式均可以！

Question3:如果一个接口有多个实现类，这些实现类都配置了bean，根据接口类型可以获取bean吗？

答案：不可以，因为bean不唯一

这种情况就是我们上述在学习根据类获取bean对象时，所描述的那种特殊情况，spring也不知道要找哪一个

小结：

根据类型来获取bean时，在满足bean唯一性的前提下，其实只是看：

对象 instanceof 指定的类型[判断一个对象是否属于指定类型的操作符。它返回一个布尔值，如果对象是指定类型或其子类的实例，则返回true]

的返回结果，只要返回的是true就可以认为和类型匹配，能够获取到，也就是说通过bean的类型，bean所继承的类类型，bean所实现的接口的类型都可以获取到bean