• spring框架中的IOC实现

    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;
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    很显然，在这里，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());
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    这里可以看到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());
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    可以看到，我们通过@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()这样的注册，需要有无参构造器。

    
<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>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    使用的时候需要借助于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());
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    构造器构造参数方式

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

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

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

    
<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>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    我们还需要改造一下原来的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;
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    看一下现在的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());
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

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

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

    
<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>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    同样需要改造一下构造函数，增加一个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;
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30

    执行一下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());
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    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;
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39

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

    

<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>


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    执行一下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());
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    自动注入

    可以通过配置XML文件来使用自动注入，就不需要手动增加或的标签了，只需要配置一个属性autowire就可以了。但是这种的只适用于注入其他的bean。

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

    


    
         
    

    
       
       
    



    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    XML读取外部配置文件

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

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

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

    spring.person.name=tony

    • 1

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

    



    
    

    
         
    

    
        
       
       
    



    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    注解方式

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

    主要是这4个注解告诉Spring

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

    接下来我们告诉Spring，你需要扫描出所有带上面注解的类，把他们注册到容器中。这一步需要修改XML文件,需要配置标签，并且通过base-package属性告诉Spring我们要扫描哪个目录

    

<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>


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    在类上面增加注解

    
@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;
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42

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

    
<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>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

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

    
<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>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    把类注册到容器中以后，我们还需要在使用的时候告诉容器，我们需要从容器中获取这个类，有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;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34

    这个时候可以编译完以后查看.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;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34

    @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;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36

    @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";
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    这个时候我们在注入的时候如果只根据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;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39

    @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;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31

    同样的，如果我们有多个实现类，需要指定可以通过它的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;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31

    @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;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
  • 相关阅读:
    Git分支设计原则&分支常用操作练习
    Spring Boot集成支付宝电脑网站支付功能
    SpringMVC——数据提交的优化，四种跳转方式以及日期的处理
    渗透测试信息收集方法和工具分享
    ffmpeg 之ffmpeg 整理流程分析
    图片怎么改成jpg格式
    ARM资源记录《AI嵌入式系统：算法优化与实现》第八章（暂时用不到）
    数据库基础面试——优化问题
    第3章 Tomcat&servlet
    78. 子集
  • 原文地址：https://blog.csdn.net/Thepatterraining/article/details/127853231