夯实spring(七):spring依赖注入--手动注入

痛定思痛。 2024-03-23 18:11 81阅读 0赞

内容:

*  介绍xml中依赖注入的配置
 *  构造器注入的3种方式详解
 *  set方法注入详解
 *  注入容器中的其他bean的2种方式
 *  其他常见类型注入详解

**依赖**  
前面说过，A类中的功能需要调用B类中的方法时，说明这两个类（A和B）之间存在依赖关系。

public class A{
        
    	private B b;
    
    	public void ma(){
        
    		b.mb();	
    	}
    }

public class B{
        
    	public void mb(){
        
    		System.out.print("hello!");
    	}
    }

A中的ma方法中需要调用B的mb方法，说明A依赖于B，如果B不存在，此时UserControler无法对外提供ma操作。

**那么我们创建A的时候就要给B设置值即就是初始化依赖对象，设置（或初始化）的方法有两种：**

*  **通过构造器设置依赖对象**

public class A{
        
    	private B b;
    	public A( B b){
        
    		this.b=b;
    	}
    	public void ma(){
        
    		this.b.mb();	
    	}
    }
    
    
    //A使用
    B b= new B();
    A a= new A(b);

*  **通过set方法设置依赖对象**

public class A{
        
    	private B b;
    	public void setB( B b){
        
    		this.b=b;
    	}
    	public void ma(){
        
    		this.b.mb();	
    	}
    }
    
    
    //A使用
    B b= new B();
    A a= new A();
    a.setB(b);

**上面的初始化方法，Spring对提供支持，这个在spirng中叫做依赖注入**

#### spring依赖注入 ####

> spring中依赖注入主要分为手动注入和自动注入，本文主要说一下手动注入，手动注入需要我们明确配置需要注入的对象。
> 
> 上面回顾了，将被依赖方注入到依赖方，通常有2种方式：构造函数的方式和set属性的方式，spring中也是通过这两种方式实现注入的，下面详解2种方式。

##### 1，通过构造器注入 #####

分为3种注入方式：

1.  根据构造器参数索引注入
2.  根据构造器参数类型注入
3.  根据构造器参数名称注入

###### 1.1 根据构造器参数索引注入 ######

> constructor-arg 指定构造器的参数  
> index：构造器参数的位置，从0开始  
> value：构造器参数的值，value只能用来给简单的类型设置值，value对应的属性类型只能为byte,int,long,float,double,boolean,Byte,Long,Float,Double,枚举，spring容器内部注入的时候会将value的值转换为对应的类型，如果是其他引用类型，使用ref。

**案例：**

public class Dir {
        
        private Integer id;
        private String name;
        private int sort;
        private File file;
    
        public Dir(String name) {
        
            this.name = name;
        }
    
        public Dir(Integer id, String name, int sort,File file) {
        
            this.id = id;
            this.name = name;
            this.sort = sort;
            this.file = file;
        }
        
        @Override
        public String toString() {
        
            return "Dir{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    ", sort=" + sort +
                    ", file=" + file +
                    '}';
        }
    }

public class File {
        
        private Integer id;
        private String name;
        private Integer sort;
    }

**bean.xml**

**测试输出**

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

Dir{
        id=null, name='我是通过一个参数的构造方法创建的', sort=null, file=null}
    Dir{
        id=1, name='我是通过四个参数的构造方法创建的', sort=101, file=com.chen.File@7c29daf3}

**小结:**

> 参数位置的注入对参数顺序有很强的依赖性，若构造函数参数位置被调整过，会导致注入出错。
> 
> 不过通常情况下，不建议去在代码中修改构造函数，如果需要新增参数的，可以新增一个构造函数来实现，这样不会影响目前已有的功能。

###### 1.2，根据构造器参数类型注入 ######

> constructor-arg 用户指定构造器的参数
> 
> type：构造函数参数的完整类型，如：java.lang.String,int,double
> 
> value：构造器参数的值，value只能用来给简单的类型设置值，其他引用类型使用ref

**案例**

**bean.xml**

**测试输出**

Dir{
        id=1, name='我是通过四个参数的构造方法创建的,根据类型注入', sort=101, file=com.chen.File@30b8a058}

**小结：**

> 实际上按照参数位置或者按照参数的类型注入，都有一个问题，很难通过bean的配置文件，知道这个参数是对应类中的那个属性的，代码的可读性不好，比如我想知道这每个参数对应类中的那个属性，必须要去看类的源码，下面要介绍按照参数名称注入的方式比上面这2种更优秀一些。

###### 1.3，根据构造器参数名称注入 ######

> constructor-arg 用户指定构造器的参数
> 
> name：构造参数名称
> 
> value：构造器参数的值，value只能用来给简单的类型设置值，其他引用类型使用ref

**方法参数名称**

> java通过反射的方式可以获取到方法的参数名称，不过源码中的参数通过编译之后会变成class对象，通常情况下源码变成class文件之后，参数的真实名称会丢失，参数的名称会变成arg0,arg1,arg2这样的，和实际参数名称不一样了，如果需要将源码中的参数名称保留在编译之后的class文件中，编译的时候需要用下面的命令：

javac -parameters java源码

但是难以保证编译代码的时候，操作一定会带上-parameters参数，所以方法的参数可能在class文件中会丢失，导致反射获取到的参数名称和实际参数名称不符。  
参数名称可能不稳定的问题，spring提供了解决方案，通过ConstructorProperties注解来定义参数的名称，将这个注解加在构造方法上面，如下：

@ConstructorProperties({
        "第一个参数名称", "第二个参数的名称",..."第n个参数的名称"})
    public 类名(String p1, String p2...,参数n) {
        
    }

**案例**

//在Dir中添加一个构造方法
        @ConstructorProperties({
        "name","sort","file"})
        public Dir(String name, int sort, File file) {
        
            this.name = name;
            this.sort = sort;
            this.file = file;
        }

**bean.xml**

**测试输出**

Dir{
        id=null, name='我是通过四个参数的构造方法创建的,根据参数名字注入', sort=23, file=com.chen.File@7d0587f1}

##### 2，通过setter注入 #####

通常情况下，我们的类都是标准的javabean，javabean类的特点：

1.  属性都是private访问级别的
2.  属性通常情况下通过一组setter（修改器）和getter（访问器）方法来访问
3.  setter方法，以set开头，后跟首字母大写的属性名，如：setUserName，简单属性一般只有一个方法参数，方法返回值通常为void;
4.  getter方法，一般属性以get开头，对于boolean类型一般以is开头，后跟首字母大写的属性名，如：getUserName，isOk；

**spring对符合javabean特点的类，提供了setter方式的注入，会调用对应属性的setter方法将被依赖的对象注入进去。**

案例：

**bean.xml**

**测试输出**

File{
        id=1, name='文件1', sort=1}

**注意: 使用sette注入setter方法一定要存在，否则会报错**  
![在这里插入图片描述][f6f5c5d1bb454478b535ec6370237fcf.png]  
**小结：**

> setter注入相对于构造函数注入要灵活一些，构造函数需要指定对应构造函数中所有参数的值，而setter注入的方式没有这种限制，不需要对所有属性都进行注入，可以按需进行注入。

##### 3，注入容器中的bean #####

上面介绍的都是注入普通类型的对象，都是通过value属性来设置需要注入的对象的值的，value属性的值是String类型的，spring容器内部自动会将value的值转换为对象的实际类型。

若依赖的对象是容器中的其他bean对象的时候，需要用下面的方式进行注入。

*  ref属性方式
 *  内置bean的方式

###### 3.1，ref属性方式 ######

将上面的constructor-arg或者property元素的value属性名称替换为ref，ref属性的值为容器中其他bean的名称，如：  
构造器方式，将value替换为ref：

<constructor-arg ref="需要注入的bean的名称"/>

setter方式，将value替换为ref：

这个比较好理解就不写案例了

###### 3.2，内置bean的方式 ######

构造器的方式：

<constructor-arg>
        <bean class=""/>
    </constructor-arg>

setter方式：

**案例**

**bean.xml**

**测试输出**

Dir{
        id=null, name='目录111', sort=303, file=File{
        id=1, name='文件2', sort=1}}

##### 4，其他类型注入（List、Set、Map、数组(array)、Properties） #####

public class DiOtherTypeModel {
        
        private List<String> list1;
        private Set<File> set1;
        private Map<String, Integer> map1;
        private int[] array1;
        private Properties properties1;
        public List<String> getList1() {
        
            return list1;
        }
        public void setList1(List<String> list1) {
        
            this.list1 = list1;
        }
        public Set<File> getSet1() {
        
            return set1;
        }
        public void setSet1(Set<File> set1) {
        
            this.set1 = set1;
        }
        public Map<String, Integer> getMap1() {
        
            return map1;
        }
        public void setMap1(Map<String, Integer> map1) {
        
            this.map1 = map1;
        }
        public int[] getArray1() {
        
            return array1;
        }
        public void setArray1(int[] array1) {
        
            this.array1 = array1;
        }
        public Properties getProperties1() {
        
            return properties1;
        }
        public void setProperties1(Properties properties1) {
        
            this.properties1 = properties1;
        }
        @Override
        public String toString() {
        
            return "DiOtherTypeModel{" +
                    "list1=" + list1 +
                    ", set1=" + set1 +
                    ", map1=" + map1 +
                    ", array1=" + Arrays.toString(array1) +
                    ", properties1=" + properties1 +
                    '}';
        }
    }

**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="file" class="com.chen.File">
        <property name="id" value="1"/>
        <property name="name" value="文件1"/>
        <property name="sort" value="1"/>
        </bean>
    
        <bean id="diOtherType" class="com.chen.DiOtherTypeModel">
            
            <property name="list1">
                <list>
                    <value>Spring</value>
                    <value>SpringBoot</value>
                </list>
            </property>
    
            
            <property name="set1">
                <set>
                    <ref bean="file"/>
                    <ref bean="file"/>
                    <ref bean="file"/>
                </set>
            </property>
    
    
            
            <property name="map1">
                <map>
                    <entry key="目录1" value="30"/>
                    <entry key="目录2" value="28"/>
                </map>
            </property>
    
    
            
            <property name="array1">
                <array>
                    <value>10</value>
                    <value>9</value>
                    <value>8</value>
                </array>
            </property>
    
    
    
            
            <property name="properties1">
                <props>
                    <prop key="key1">java1</prop>
                    <prop key="key2">java2</prop>
                    <prop key="key3">java3</prop>
                </props>
            </property>
        </bean>
    </beans>

**测试输出：**

DiOtherTypeModel{
        list1=[Spring, SpringBoot], set1=[File{
        id=1, name='文件1', sort=1}], map1={
        目录1=30, 目录2=28}, array1=[10, 9, 8], properties1={
        key3=java3, key2=java2, key1=java1}}

**小结：**

> 这些注入方式还有其他，只要记住一种就可以了

**总结：**

> 本文主要讲解了xml中bean的依赖注入，都是采用硬编码的方式进行注入的，这种是手动的方式  
> 注入普通类型通过value属性或者value元素设置注入的值；注入对象如果是容器的其他bean的时候，需要使用ref属性或者ref元素或者内置bean元素的方式  
> 还介绍了其他几种类型List、Set、Map、数组、Properties类型的注入，后面将介绍spring为我们提供的自动注入。

[f6f5c5d1bb454478b535ec6370237fcf.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/e13a5604d16440e2a00367ca18a7d5b0.png