spring框架中的IOC实现

最新推荐文章于 2024-05-03 11:47:20 发布

Thepatterraining

最新推荐文章于 2024-05-03 11:47:20 发布

阅读量411

点赞数

分类专栏： java 文章标签： spring java

本文链接：https://blog.csdn.net/Thepatterraining/article/details/127853231

版权

java 专栏收录该内容

4 篇文章 2 订阅

订阅专栏

spring

IOC控制反转

这里先说一下IOC，再说IOC在spring框架中的使用。

IOC的概念

IOC这个缩写有很多意思，比如

智慧城市智能运行中心(IOC)
奥林匹克运动的领导机构

但是呢，我们这里说的是面向对象编程中的一种设计原则。他的全称是Inversion Of Control即控制反转。这里有两个单词控制和反转。这两个单词单独拿出来会发现，都缺少主语。比如

谁控制了谁?
什么东西发生反转了呢?

控制

这里说一下第一个问题，谁控制了谁呢？看下面的代码


public class main{

    public static void main(String[] args) {
        Person person = new Person();
        person.setName("tony");
        System.out.println(person.getName());
    }
}

class Person{
    private String name;

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return this.name;
    }
}

很显然，在这里，Person类的person对象的一切都控制在main函数里面。main函数创建它，使用它，销毁它。所以在当前上下文中，main控制了person。

反转

上面的写法main函数控制了person对象，这是一种紧耦合的关系，如果person发生了改变，我们就需要改变main。反转是控制权的反转。现在person的控制权在main这里，我们将它反转一下。不在用main控制它。那么我们加一个简单工厂看一下呢。


class Factory{
    public static Person createPerson() {
        return new Person();
    }
}

public static void main(String[] args) {
    Person person = Factory.createPerson();
    person.setName("tony");
    System.out.println(person.getName());
}

这里可以看到person的控制权转交给了Factory工厂，而main只有使用权了。当然了作为示例代码，这里的控制只做了创建。

现在，由main控制person改为了Factory控制person。如果person发生了改变，我们只需要改变Factory，而不需要动业务逻辑。

当然了，这种程度的解耦依然不够，因为main还是和Factory有耦合关系，他还控制了Factory。我们可以扩大这个简单工厂，扩大后的简单工厂就不再是工厂了，而叫做容器。我们把所有的控制权都交给容器，让容器控制所有的类，对象。而在使用的时候我们去告诉容器我们要使用哪个对象，让容器给我们提供就可以了。

DI

依赖注入 DI全称Dependency Injection就可以实现我们告诉容器我们需要的对象，然后容器把对象注入给我们的功能。

具体的依赖注入实现方式每个语言，每个框架可能都不一样，这里以spring为例

public class main{

    @Autowired
    private Person person;
    
    public static void main(String[] args) {
        person.setName("tony");
        System.out.println(person.getName());
    }
}

可以看到，我们通过@Autowired注解告诉容器，我们需要一个Person类型的对象，然后让容器把这个对象注入到我们的person属性中。这里仅做示例使用，具体情况请以实际开发中为准，实际开发中应使用接口类型。

容器中的实现方式就类似刚才工厂中的，假设你需要Person类型的对象，就new Person返回，当然了，要更加复杂，比如可以根据名称来反射创建对象，可以更好的管理对象的生命周期，可以实现单例对象等等。

spring中的IOC

Spring中的IOC实现也是通过容器，但是怎么把类注入到容器中呢，也就是怎么告诉容器，你需要实例化哪些类呢？有两种方式，一种是XML配置方式，一种是注解方式。

XML配置方式

先创建一个XML文件，比如:

touch bean.xml

接下来编辑它。

vim bean.xml

无参数构造方式

重点在这个配置，通过bean这个标签来告诉容器我要把哪些类注册到容器中，其中id就是注册后的唯一标识，我们获取的时候也可以通过指定id来从容器中获取对象。而class是告诉容器，我们具体要注入的类的路径。但是这时候没有指定参数，也就是说类似于Person person = new Person()这样的注册，需要有无参构造器。

<?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="person" class="com.test.java.Person"></bean>

</beans>

使用的时候需要借助于Spring提供的容器获取,可以看一下效果是一样的。

public class main{
    
    public static void main(String[] args) {
        //这里先加载我们的XML配置文件
        BeanFactory ac = new ClassPathXmlApplicationContext("bean.xml");
        //通过容器获取一个对象,第一个参数也就是配置的id,第二个就是类
        Person person = ac.getBean("person", Person.class);
        person.setName("tony");
        System.out.println(person.getName());
    }
}

构造器构造参数方式

同样在上面的XML文件中进行修改，但这次我们需要加上参数，并且告诉容器是通过构造器来构造参数的，而不是set的方式。

我们只需要在原来的bean标签中，加入我们要传给构造器的参数就可以了。

使用constructor-arg标签，name就是参数名，value是对应的值。

<?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="person" class="com.test.java.Person">
       <constructor-arg name="name" value="tony"></constructor-arg>
    </bean>

</beans>

我们还需要改造一下原来的Person类，增加一个构造函数.

class Person{
    private String name;

    public Person(String name) {
        this.name = name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return this.name;
    }
}

看一下现在的main函数

public class main{
    
    public static void main(String[] args) {
        //这里先加载我们的XML配置文件
        BeanFactory ac = new ClassPathXmlApplicationContext("bean.xml");
        //通过容器获取一个对象,第一个参数也就是配置的id,第二个就是类
        Person person = ac.getBean("person", Person.class);
        // 这里不需要setName了，因为通过构造器注入参数了
        // person.setName("tony");
        System.out.println(person.getName());
    }
}

但是如果我们需要构造一个其他类的对象作为参数该怎么配置呢，毕竟我们总不能在value上面写new Class()吧哈哈。但是我们知道一个bean就是一个对象，那我们可以传一个bean进来就可以了。

来看一下配置方式.不再使用value了，因为value只能传基本类型这些，而其他的对象需要使用ref来传参。ref的值就是其他bean的id。

<?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="avatar" class="com.test.java.Avatar">
         <constructor-arg name="url" value="http://baidu.com"></constructor-arg>
    </bean>

    <bean id="person" class="com.test.java.Person">
       <constructor-arg name="name" value="tony"></constructor-arg>
       <constructor-arg name="avatar" ref="avatar"></constructor-arg>
    </bean>

</beans>

同样需要改造一下构造函数，增加一个avatar参数。

class Avatar{
    private String url;
    public Avatar(String url) {
        this.url = url;
    }
}

class Person{
    private String name;

    private Avatar avatar;

    public Person(String name, Avatar avatar) {
        this.name = name;
        this.avatar = avatar;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return this.name;
    }

    public String getAvatar() {
        return this.avatar.url;
    }
}

执行一下main函数。

public class main{
    
    public static void main(String[] args) {
        //这里先加载我们的XML配置文件
        BeanFactory ac = new ClassPathXmlApplicationContext("bean.xml");
        //通过容器获取一个对象,第一个参数也就是配置的id,第二个就是类
        Person person = ac.getBean("person", Person.class);
        // 这里不需要setName了，因为通过构造器注入参数了
        // person.setName("tony");
        System.out.println(person.getName());
        System.out.println(person.getAvatar());
    }
}

set方式传参

除了通过构造器传参，我们还可以写set函数来传参，比如setName和setAvatar。

class Avatar{
    private String url;
    // public Avatar(String url) {
    //     this.url = url;
    // }

    //增加set函数
    public void setUrl(String url) {
        this.url = url;
    }
}

class Person{
    private String name;

    private Avatar avatar;

    // public Person(String name, Avatar avatar) {
    //     this.name = name;
    //     this.avatar = avatar;
    // }

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return this.name;
    }

    public void setAvatar(Avatar avatar) {
        this.avatar = avatar;
    }

    public String getAvatar() {
        return this.avatar.url;
    }
}

修改XML配置文件，不在使用constructor-arg标签，而是换成property。不过除了标签名变了，其他的属性name,value,ref都是不变的。


<?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="avatar" class="com.test.java.Avatar">
         <property name="url" value="http://baidu.com"></property>
    </bean>

    <bean id="person" class="com.test.java.Person">
       <property name="name" value="tony"></property>
       <property name="avatar" ref="avatar"></property>
    </bean>

</beans>

执行一下main函数。

public class main{
    
    public static void main(String[] args) {
        //这里先加载我们的XML配置文件
        BeanFactory ac = new ClassPathXmlApplicationContext("bean.xml");
        //通过容器获取一个对象,第一个参数也就是配置的id,第二个就是类
        Person person = ac.getBean("person", Person.class);
        // 这里不需要setName了，因为通过构造器注入参数了
        // person.setName("tony");
        System.out.println(person.getName());
        System.out.println(person.getAvatar());
    }
}

自动注入

可以通过配置XML文件来使用自动注入，就不需要手动增加<property name="url" ref="avatar"></property>或<constructor-arg name="avatar" ref="avatar"></constructor-arg>的标签了，只需要配置一个属性autowire就可以了。但是这种的只适用于注入其他的bean。

autowire只有两个值，一个是byName，是通过bean的名称进行注入，比如你的属性名是avatar，就会查找id=avatar这个类。还有一个是byType，是通过bean的类型进行注入，比如类型是Avatar，那么就会查找class=Avatar的bean进行注入。

<?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="avatar" class="com.test.java.Avatar">
         <property name="url" value="http://baidu.com"></property>
    </bean>

    <bean id="person" class="com.test.java.Person" autowire="byName">
       <property name="name" value="tony"></property>
       <!-- <property name="avatar" ref="avatar"></property> -->
    </bean>

</beans>

XML读取外部配置文件

通过XML可以读取外部的配置文件，这样的话像数据库，redis连接这些就可以把host,name,password这些写到外部的配置文件中。

配置文件使用.properties后缀。比如spring.properties。

增加一个配置文件spring.properties。

spring.person.name=tony

修改XML直接从配置中读取person.name来注入。读取的时候还需要在XML中增加context命名空间。并通过context命名空间来读取配置文件

<?xml version="1.0" encoding="UTF-8"?>
<!-- 增加context命名空间 -->
<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/beans/spring-context.xsd">

    <!-- 读取配置文件 -->
    <context:property-placeholder location="classpath:spring.properties">

    <bean id="avatar" class="com.test.java.Avatar">
         <property name="url" value="http://baidu.com"></property>
    </bean>

    <bean id="person" class="com.test.java.Person" autowire="byName">
        <!-- 读取配置文件的值 -->
       <property name="name" value="${spring.person.name}"></property>
       <!-- <property name="avatar" ref="avatar"></property> -->
    </bean>

</beans>

注解方式

注解方式要比XML方式简单的多，其中原理就是不再手动配置，而是通过注解告诉Spring我是一个bean。快来注册我吧。

主要是这4个注解告诉Spring

@Component 单纯的说我是一个bean
@Service 和上面的一样，不过一般用在service类中，更加语义化
@Controller 和上面的一样，一般用在controller类中
@Repository 我也是一个bean

接下来我们告诉Spring，你需要扫描出所有带上面注解的类，把他们注册到容器中。这一步需要修改XML文件,需要配置<context:component-scan>标签，并且通过base-package属性告诉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 https://www.springframework.org/schema/context/spring-context.xsd">

    <context:component-scan base-package="com.test.java"></context:component-scan>

</beans>

在类上面增加注解


@Component
class Avatar{
    private String url;
    // public Avatar(String url) {
    //     this.url = url;
    // }

    //增加set函数
    public void setUrl(String url) {
        this.url = url;
    }
}

@Component
class Person{
    private String name;

    private Avatar avatar;

    // public Person(String name, Avatar avatar) {
    //     this.name = name;
    //     this.avatar = avatar;
    // }

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return this.name;
    }

    public void setAvatar(Avatar avatar) {
        this.avatar = avatar;
    }

    public String getAvatar() {
        return this.avatar.url;
    }
}

还可以自己指定扫描哪些注解，通过context:include-filter标签来指定。type类型写注解，expression指定扫描哪个注解。把标签放在context:component-scan这个里面就可以了。还需要在context:component-scan标签中指定，禁用默认的扫描方式。指定use-default-filters的属性为false.

<?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 https://www.springframework.org/schema/context/spring-context.xsd">

    <context:component-scan base-package="com.test.java" use-default-filters="false">
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Component" />
    </context:component-scan>

</beans>

还可以排除一些注解不进行扫描，通过context:exclude-filter标签来指定。type同样写注解，expression指定排除的注解。

<?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 https://www.springframework.org/schema/context/spring-context.xsd">

    <context:component-scan base-package="com.test.java" use-default-filters="false">
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Component" />
    </context:component-scan>

</beans>

把类注册到容器中以后，我们还需要在使用的时候告诉容器，我们需要从容器中获取这个类，有5个注解

@Autowired Spring提供的，基于类型注入的，可以放在setter方法上
@Qualifier Spring提供的，基于名称注入的，一般和@Autowired配合使用来通过value参数指定名称
@Resource Java提供的，可以基于类型或名称注入的,可以通过name参数来指定名称，可以放在setter方法上
@RequiredArgsConstructor lombok提供的，基于类型注入，通过增加一个构造函数来注入。
@Value Spring提供的，注入基本类型的注解，一般用来从配置文件取值。

@RequiredArgsConstructor是lombok提供的，兼容性较差，像写单元测试的时候就用不了，它会给你的类增加一个构造方法，而且只会给final类型的属性进行注入。


@Component
//增加注解
@RequiredArgsConstructor
class Person{
    private String name;

    //错误使用，因为没有final
    // private Avatar avatar;

    //正确使用，加上final
    private final Avatar avatar;

    // public Person(String name, Avatar avatar) {
    //     this.name = name;
    //     this.avatar = avatar;
    // }

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return this.name;
    }

    public void setAvatar(Avatar avatar) {
        this.avatar = avatar;
    }

    public String getAvatar() {
        return this.avatar.url;
    }
}

这个时候可以编译完以后查看.class文件，看到的是这样的


@Component
// 注解没有了
// @RequiredArgsConstructor
class Person{
    private String name;

    //错误使用，因为没有final
    // private Avatar avatar;

    //正确使用，加上final
    private final Avatar avatar;

    //增加了一个构造函数
    public Person(final Avatar avatar) {
        this.avatar = avatar;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return this.name;
    }

    public void setAvatar(Avatar avatar) {
        this.avatar = avatar;
    }

    public String getAvatar() {
        return this.avatar.url;
    }
}

@Autowired是spring提供的，在spring中不管是写业务还是写单元测试都可以使用，它可以放在要注入的属性上面，也可以放在setter方法上面。使用他的时候不需要final修饰。


@Component
class Person{
    private String name;

    //在需要的属性上面增加这个注解，不需要final修饰
    @Autowired
    private Avatar avatar;

    //错误使用，加上final
    // @Autowired
    // private final Avatar avatar;

    // public Person(String name, Avatar avatar) {
    //     this.name = name;
    //     this.avatar = avatar;
    // }

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return this.name;
    }

    //也可以加在setter方法上面
    @Autowired
    public void setAvatar(Avatar avatar) {
        this.avatar = avatar;
    }

    public String getAvatar() {
        return this.avatar.url;
    }
}

@Qualifier注解配合@Autowired使用，比如我们有一个头像的接口


interface IAvatar {
    String getUrl();
}

class maleAvatar implements IAvatar{
    public String getUrl() {
        return "male avatar";
    }
}

class femaleAvatar implements IAvatar{
    public String getUrl() {
        return "female avatar";
    }
}

这个时候我们在注入的时候如果只根据IAvatar来注入，容器就不知道我们需要哪个实现类了，所以我们需要指定类名.


@Component
class Person{
    private String name;

    //在需要的属性上面增加这个注解，不需要final修饰
    @Autowired
    //指定要注入的实现类
    @Qualifier(value="maleAvatar")
    private IAvatar avatar;

    //错误使用，加上final
    // @Autowired
    // private final Avatar avatar;

    // public Person(String name, Avatar avatar) {
    //     this.name = name;
    //     this.avatar = avatar;
    // }

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return this.name;
    }

    //也可以加在setter方法上面
    @Autowired
    @Qualifier(value="maleAvatar")
    public void setAvatar(IAvatar avatar) {
        this.avatar = avatar;
    }

    public String getAvatar() {
        return this.avatar.url;
    }
}

@Resource更像是上面两个的合体，并且是由java提供的。也是可以放在属性和setter上面，并且不需要final修饰。


@Component
class Person{
    private String name;

    //在需要的属性上面增加这个注解，不需要final修饰
    @Resource
    private Avatar avatar;

    //错误使用，加上final
    // @Resource
    // private final Avatar avatar;

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return this.name;
    }

    //也可以加在setter方法上面
    @Resource
    public void setAvatar(Avatar avatar) {
        this.avatar = avatar;
    }

    public String getAvatar() {
        return this.avatar.url;
    }
}

同样的，如果我们有多个实现类，需要指定可以通过它的name参数来指定。比如


@Component
class Person{
    private String name;

    //在需要的属性上面增加这个注解，不需要final修饰
    @Resource(name="femaleAvatar")
    private IAvatar avatar;

    //错误使用，加上final
    // @Resource
    // private final Avatar avatar;

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return this.name;
    }

    //也可以加在setter方法上面
    @Resource(name="femaleAvatar")
    public void setAvatar(IAvatar avatar) {
        this.avatar = avatar;
    }

    public String getAvatar() {
        return this.avatar.url;
    }
}

@Value可以注入基本类型，比如字符串这种，但是更多的是从配置文件中取值。比如

@Component
class Person{
    //直接注入tony字符串到name中
    @Value("tony")
    private String name;

    //从配置文件中取值
    //person:
    //  name: tony
    @Value("${person.name}")
    private String nameFromConfig;

    //在需要的属性上面增加这个注解，不需要final修饰
    @Resource(name="femaleAvatar")
    private IAvatar avatar;

    //错误使用，加上final
    // @Resource
    // private final Avatar avatar;

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return this.name;
    }

    //也可以加在setter方法上面
    @Resource(name="femaleAvatar")
    public void setAvatar(IAvatar avatar) {
        this.avatar = avatar;
    }

    public String getAvatar() {
        return this.avatar.url;
    }
}

Thepatterraining

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
spring框架中的IOC实现

但是呢，我们这里说的是`面向对象编程中的一种设计原则`。他的全称是`Inversion Of Control`即控制反转。这里有两个单词`控制`和`反转`。这两个单词单独拿出来会发现，都缺少主语。比如- 谁控制了谁?- 什么东西发生反转了呢?
复制链接

扫一扫