夯实spring(八):spring依赖注入--自动注入

冷不防 2024-03-23 19:23 35阅读 0赞

内容:

*  手动注入的不足
 *  Class.isAssignableFrom方法
 *  3种自动注入方式详解及案例
    
     *  按名称自动注入
     *  按类型自动注入
     *  按构造器进行自动注入
 *  按类型自动注入某种类型的所有bean给List和Map
 *  autowire=default介绍

上篇文章中介绍了依赖注入中的手动注入，所谓手动注入是指在xml中采用硬编码的方式来配置注入的对象，比如通过构造器注入或者set方法注入，这些注入的方式都存在不足，比如下面代码：

#### 手动注入的不足 ####

上篇文章中介绍了依赖注入中的手动注入，手动注入是指在xml中采用硬编码的方式来配置注入的对象，比如通过构造器注入或者set方法注入，这些注入的方式都存在不足。

public class A{
        
        private B b;
        private C c;
        private D d;
        private E e;
        ....
        private N n;
    }

**bean.xml**

**手动注入存在的问题：**

> 如果需要注入的对象比较多，比如A类中有几十个属性，那么上面的property属性是不是需要写几十个，此时配置文件代码量暴增  
> 如果A类中新增或者删除了一些依赖，还需要手动去调整bean xml中的依赖配置信息，否则会报错 总的来说就是不利于维护和扩展

#### Class.isAssignableFrom方法 ####

isAssignableFrom是Class类中的一个方法，看一下这个方法的定义：

public native boolean isAssignableFrom(Class<?> cls)

用法如下：

c1.isAssignableFrom(c2)

用来判断c2和c1是否相等，或者c2是否是c1的子类。

如:

public void isAssignableFrom(){
        
        System.out.println(Object.class.isAssignableFrom(Integer.class)); //true
        System.out.println(Object.class.isAssignableFrom(int.class)); //false
        System.out.println(Object.class.isAssignableFrom(List.class)); //true
        System.out.println(Collection.class.isAssignableFrom(List.class)); //true
        System.out.println(List.class.isAssignableFrom(Collection.class)); //false
    }

#### 自动注入 ####

> 自动注入是采用约定大约配置的方式来实现的，程序和spring容器之间约定好，遵守某一种都认同的规则，来实现自动注入。

<bean id="" class="" autowire="byType|byName|constructor|default" />

##### 按照名称进行注入（byName） #####

> spring容器会按照set属性的名称去容器中查找同名的bean对象，然后将查找到的对象通过set方法注入到对应的bean中，未找到对应名称的bean对象则set方法不进行注入  
> 需要注入的set属性的名称和被注入的bean的名称必须一致。

案例：

Dir.java

public class Dir {
        
        private String name;
        private Integer type;
    
        public String getName() {
        
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    
        public Integer getType() {
        
            return type;
        }
    
        public void setType(Integer type) {
        
            this.type = type;
        }
    
    }

Room.java

public class Room {
        
        private String name;
        private Integer floor;
    
        public String getName() {
        
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    
        public Integer getFloor() {
        
            return floor;
        }
    
        public void setFloor(Integer floor) {
        
            this.floor = floor;
        }
    }

DiAutowireByName.java

public class DiAutowireByName {
        
        private Dir dir;
        private Room room;
    
        public Dir getDir() {
        
            return dir;
        }
    
        public void setDir(Dir dir) {
        
            this.dir = dir;
        }
    
        public Room getRoom() {
        
            return room;
        }
    
        public void setRoom(Room room) {
        
            this.room = room;
        }
    }

DiAutowireByName.java中定义了两个属性：dir和room

现在在bean.xml中定义两个和DiAutowireByName.java中两个属性同名的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-4.3.xsd">
    
        <bean id="dir" class="com.chen.Dir">
            <property name="name" value="目录一"/>
            <property name="type" value="1"/>
        </bean>
    
        <bean id="room" class="com.chen.Room">
            <property name="name" value="会议室1"/>
            <property name="floor" value="2"/>
        </bean>
    
        <bean id="diautobyname" class="com.chen.DiAutowireByName" autowire="byName"></bean>
    
    
    </beans>

测试输出：

DiAutowireByName{
        dir=Dir{
        name='目录一', type=1}, room=Room{
        name='会议室1', floor=2}}

当配置了自动注入，还可以使用手动的方式对自动注入进行覆盖，手动的优先级更高一些

<bean id="room2" class="com.chen.Room">
            <property name="name" value="会议室2"/>
            <property name="floor" value="4"/>
        </bean>
       <bean id="diautobyname2" class="com.chen.DiAutowireByName" autowire="byName">
            <property name="room" ref="room2"/>//手动的方式
        </bean>

DiAutowireByName{
        dir=Dir{
        name='目录一', type=1}, room=Room{
        name='会议室2', floor=4}}

小结：

> spring容器创建diAutowireByName对应的bean时，会遍历DiAutowireByName类中的所有set方法，然后得到set对应的属性名称列表：\{“dir”,”room”\}，然后遍历这属性列表，在容器中查找和属性同名的bean对象，然后调用属性对应的set方法，将bean对象注入进去。按名称进行注入的时候，要求名称和set属性的名称必须同名

##### 按照类型进行自动注入 #####

> spring容器会遍历x类中所有的set方法，会在容器中查找和set参数类型相同的bean对象，将其通过set方法进行注入，未找到对应类型的bean对象则set方法不进行注入。
> 
> 需要注入的set属性的类型和被注入的bean的类型需要满足isAssignableFrom关系。
> 
> 按照类型自动装配的时候，如果按照类型找到了多个符合条件的bean，系统会报错。
> 
> set方法的参数如果是下面的类型或者下面类型的数组的时候，这个set方法会被跳过注入：
> 
> Object,Boolean,boolean,Byte,byte,Character,char,Double,double,Float,float,Integer,int,Long,Short,shot,Enum,CharSequence,Number,Date,java.time.temporal.Temporal,java.net.URI,java.net.URI,java.util.Locale,java.lang.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-4.3.xsd">
    
        <bean id="dir" class="com.chen.Dir">
            <property name="name" value="目录一"/>
            <property name="type" value="1"/>
        </bean>
    
        <bean id="room" class="com.chen.Room">
            <property name="name" value="会议室1"/>
            <property name="floor" value="2"/>
        </bean>
        <bean id="diautobyname3" class="com.chen.DiAutowireByName" autowire="byType"></bean>
    
    </beans>

**测试输出：**

DiAutowireByName{
        dir=Dir{
        name='目录一', type=1}, room=Room{
        name='会议室1', floor=2}}

##### 注入类型匹配的所有bean #####

按照类型注入还有2种的用法：

> 1.  一个容器中满足某种类型的bean可以有很多个，将容器中某种类型中的所有bean，通过set方法注入给一个java.util.List<需要注入的Bean的类型或者其父类型或者其接口>对象
> 2.  将容器中某种类型中的所有bean，通过set方法注入给一个java.util.Map<String,需要注入的Bean的类型或者其父类型或者其接口>对象

**案例：**  
创建一个接口和一个基类

public interface MyInterface1 {
        
    }

public class BaseService {
        
    }

创建两个类分别继承和实现上面的基类和接口

public class MyImpl1 extends BaseService implements MyInterface1 {
        
    }

public class MyImpl2 extends BaseService implements MyInterface1 {
        
    }

创建一个测试类，属性是上面的两个实现类的List集合和Map,并生成对应的set方法

package com.chen.test;
    
    import java.util.List;
    import java.util.Map;
    
    
    public class DiAutowireByTypeExtendAndImpl {
        
        //定义了4个属性，都是泛型类型的，都有对应的set方法。
        private List<MyInterface1> myInterface1List;
        private List<BaseService> baseServiceList;
        private Map<String, MyInterface1> myInterface1Map;
        private Map<String, BaseService> baseServiceMap;
    
        public List<MyInterface1> getMyInterface1List() {
        
            return myInterface1List;
        }
    
        /**
         * 参数类型是List<MyInterface1>，这个集合中元素的类型是MyInterface1，
         * spring会找到容器中所有满足MyInterface1.isAssignableFrom(bean的类型)的bean列表，将其通过set方法进行注入
         * @param myInterface1List
         */
        public void setMyInterface1List(List<MyInterface1> myInterface1List) {
        
            this.myInterface1List = myInterface1List;
        }
    
        public List<BaseService> getBaseServiceList() {
        
            return baseServiceList;
        }
    
        //同 setMyInterface1List
        public void setBaseServiceList(List<BaseService> baseServiceList) {
        
            this.baseServiceList = baseServiceList;
        }
    
        public Map<String, MyInterface1> getMyInterface1Map() {
        
            return myInterface1Map;
        }
    
        /**
         * 这个参数类型是一个map了，map的key是string类型，value是MyInterface1类型，spring容器会将所有满足MyInterface1类型的bean找到，
         * 按照name->bean对象这种方式丢到一个map中，
         * 然后调用set方法进行注入，最后注入的这个map就是bean的名称和bean对象进行映射的一个map对象。
         * @param myInterface1Map
         */
        public void setMyInterface1Map(Map<String, MyInterface1> myInterface1Map) {
        
            this.myInterface1Map = myInterface1Map;
        }
    
        public Map<String, BaseService> getBaseServiceMap() {
        
            return baseServiceMap;
        }
    
        //同 setMyInterface1Map
        public void setBaseServiceMap(Map<String, BaseService> baseServiceMap) {
        
            this.baseServiceMap = baseServiceMap;
        }
    }

**bean.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-4.3.xsd">
    
        <bean id="myimpl1" class="com.chen.test.MyImpl1"/>
        <bean id="myimpl2" class="com.chen.test.MyImpl2"/>
    
        <bean id="diAutowireByTypeExtendAndImpl" class="com.chen.test.DiAutowireByTypeExtendAndImpl" autowire="byType"></bean>
    
    </beans>

**测试输出**

public class Main {
        
        public static void main(String[] args) {
        
            ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath:bean.xml");
            DiAutowireByTypeExtendAndImpl diAutowireByTypeExtend = context.getBean(DiAutowireByTypeExtendAndImpl.class);
            //输出diAutowireByTypeExtend中的属性
            System.out.println("myInterface1List：" + diAutowireByTypeExtend.getMyInterface1List());
            System.out.println("baseServiceList：" + diAutowireByTypeExtend.getBaseServiceList());
            System.out.println("myInterface1Map：" + diAutowireByTypeExtend.getMyInterface1Map());
            System.out.println("baseServiceMap：" + diAutowireByTypeExtend.getBaseServiceMap());
        }
    
    }

myInterface1List：[com.chen.test.MyImpl1@51cdd8a, com.chen.test.MyImpl2@d44fc21]
    baseServiceList：[com.chen.test.MyImpl1@51cdd8a, com.chen.test.MyImpl2@d44fc21]
    myInterface1Map：{
        myimpl1=com.chen.test.MyImpl1@51cdd8a, myimpl2=com.chen.test.MyImpl2@d44fc21}
    baseServiceMap：{
        myimpl1=com.chen.test.MyImpl1@51cdd8a, myimpl2=com.chen.test.MyImpl2@d44fc21}

##### 按照构造函数进行自动注入 #####

> spring会找到x类中所有的构造方法（一个类可能有多个构造方法），然后将这些构造方法进行排序（先按修饰符进行排序，public的在前面，其他的在后面，如果修饰符一样的，会按照构造函数参数数量倒叙，也就是采用贪婪的模式进行匹配，spring容器会尽量多注入一些需要的对象）得到一个构造函数列表，会轮询这个构造器列表，判断当前构造器所有参数是否在容器中都可以找到匹配的bean对象，如果可以找到就使用这个构造器进行注入，如果不能找到，那么就会跳过这个构造器，继续采用同样的方式匹配下一个构造器，直到找到一个合适的为止。

**案例：**

public class DiAutowireByConstructor {
        
        private MyImpl1 myImpl1;
        private MyImpl2 myImpl2;
    
        public DiAutowireByConstructor(MyImpl1 myImpl1) {
        
            this.myImpl1 = myImpl1;
        }
    
        public DiAutowireByConstructor(MyImpl1 myImpl1, MyImpl2 myImpl2) {
        
            this.myImpl1 = myImpl1;
            this.myImpl2 = myImpl2;
        }
        @Override
        public String toString() {
        
            return "DiAutowireByConstructor{" +
                    "myImpl1=" + myImpl1 +
                    ", myImpl2=" + myImpl2 +
                    '}';
        }
    }

**测试输出**

public class Main {
        
        public static void main(String[] args) {
        
            ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath:bean.xml");
            DiAutowireByConstructor diAutowireByConstructor = context.getBean(DiAutowireByConstructor.class);
            System.out.println(diAutowireByConstructor);
        }
    
    }

DiAutowireByConstructor{
        myImpl1=com.chen.test.MyImpl1@2b2948e2, myImpl2=null}

> 从输出中可以看到调用的是DiAutowireByConstructor类中的第一个构造函数注入了MyImpl1 bean。
> 
> 构造函数匹配采用贪婪匹配，多个构造函数结合容器找到一个合适的构造函数，最匹配的就是第一个有参构造函数，而第二个有参构造函数的第二个参数在spring容器中找不到匹配的bean对象，所以被跳过了,如果多个构造函数都匹配，会执行多个。

##### autowire=default #####

> bean.xml的根元素为beans，注意根元素有个default-autowire属性，这个属性可选值有(no|byName|byType|constructor|default)，这个属性可以批量设置当前文件中所有bean的自动注入的方式，bean元素中如果省略了autowire属性，那么会取default-autowire的值作为其autowire的值，而每个bean元素还可以单独设置自己的autowire覆盖default-autowire的配置。

**总结**

> 1.  xml中手动注入存在的不足之处，可以通过自动注入的方式来解决，这里介绍了3种自动注入：通过名称自动注入、通过类型自动注入、通过构造器自动注入
> 2.  按类型注入中有个比较重要的是注入匹配类型所有的bean，可以将某种类型所有的bean注入给一个List对象，可以将某种类型的所有bean按照bean名称->bean对象的映射方式注入给一个Map对象。