详解原生Spring中的控制反转和依赖注入-构造注入和Set注入

你的名字 2024-05-24 12:48 58阅读 0赞

![053765fa2bbb4b788f4e1e381d3096e4.jpeg][]

> ?? **学习交流群：**
> 
> ✅✅**1：这是孙哥suns给大家的福利！**
> 
> ✨✨**2：我们免费分享Netty、Dubbo、k8s、Mybatis、Spring...应用和源码级别的视频资料**
> 
> ??**3：QQ群：583783824** ?? **工作微信：BigTreeJava 拉你进微信群，免费领取！**
> 
> ??**4：本文章内容出自上述：Spring应用课程！**??
> 
> ??**5：以上内容，进群免费领取呦~** ????

**文章目录**

一：Spring中的注入

1：什么是注入

2：为什么注入

3：如何注入？

4：注入好处

5：Spring注入的过程

编辑二：Set注入详解

1：JDK内置类型

2：用户自定义类型

(一)：第一种方式

(二)：第二种方式

3：Set注入简化写法

(一)：基于属性的简化

(二)：基于p空间简化属性

三：构造注入

1：开发步骤

2：构造方法的重载

3：注入的总结

四：反转控制和依赖注入

1：什么叫做控制反转

2：什么是依赖注入

--------------------

## 一：Spring中的注入 ##

### 1：什么是注入 ###

注入就是通过Spring的工厂类和spring的配置文件，对Spring所创建的对象进行赋值，为成员变量进行赋值

### 2：为什么注入 ###

**为什么需要Spring工厂创建对象的时候给对象进行赋值呢？**  
1：通过配置文件进行注入也可以实现解耦合的这样的作用，直接写死在代码当中会引发耦合效应  
2：通过编码的方式为成员边量进行赋值会出现耦合，注入的方式会避免这样的耦合的作用

### 3：如何注入？ ###

这是注入的一种示例：为成员变量提供set和get方法，这是注入的第一步

### 4：注入好处 ###

使用Spring的依赖注入的好处就是可以基于Spring的配置文件来做对象的成员变量赋值工作，这样不需要在Java代码中显示的给对象成员变量赋值，起到了解耦合的作用！

### 5：Spring注入的过程 ###

Spring获取到配置文件路径之后，调用demo4j这个第三方组件来对xml配置文件进行解析，根据解析的内容创建对应的对象。对象创建之后，根据property标签中的配置的属性的值，根据对象的set和get方法进行赋值操作。

Spring会通过底层属性对应的set方法进行赋值才完成对应的赋值操作，这种方式我们也称为set注入

## ![530715d8b04640eeaa6d0cd8dcbbe3cb.png][]   二：Set注入详解 ##

针对于不同类型的成员变量，在标签中进行注入的方式也不一样，不过都得嵌套到property标签当中。

**JDK内置类型：**JDK自定义的数据类型或者叫引用类型。

**用户自定义类型：**用户自定义的类型

### 1：JDK内置类型 ###

1、string+8中基本类型。
            <property name = "id">
                <value>10</value>
            </property>
            <property name = "name">
                <value>xjr</value>
            </property>
            2、数组
            <property name="emails">
                
                <list>
                    <value>suns@pactera.com</value>
                    <value>cuilei@pactera.com</value>
                    <value>kaixin@pactera.com</value>
                </list>
            </property>
             3、set集合
                <set>
                    
                    <value>138111111111</value>
                    
                    <ref bean=""/>
                    
                    <set>
                    </set>
                </set>
            4、list集合
            <property name="address">
                <list >
                    
                    <value>zpark</value>
                    <value>shangdi</value>
                    <value>xierqi</value>
                    <set></set>
                    <ref></ref>
                    <list></list>
                </list>
            </property>
            5、map集合赋值方式
            <property name="qqs">
                
                <map>
                    <entry>
                        <key><value>suns</value></key>
                        <value>43222222222222</value>
                    </entry>
                    <entry>
                        <key><value>xiexei</value></key>
                        <value>43222222222222</value>
                    </entry>
    
                </map>
            </property>

properties类型的赋值中更加复杂的JDK类型比如说：date类型需要使用自定义类型转换器进行，这是在工厂的高级部分进行讲解。

### 2：用户自定义类型 ###

#### (一)：第一种方式 ####

1：第一步还是为成员变量提供get和set方法  
2：第二步在配置文件中进行注入

补充说明：  
1：通过这样一种编译时耦合与接口+配置文件中定义注入类型的这样的形式，最大程度上降低了代码的耦合型  
2：这种写法代码冗余，而且会重复创建某个对象。写一个bean标签就会创建一个对象，而且注入的这个对象不可能被复用只能在这个对象中被引用，被注入的对象多次创建就会浪费虚拟机内存的资源

以下是代码示例：

/*
         * @Description:给自定义引用类型赋值。
         * @Author: DaShu
         * @Date: 2021/5/28 16:02
         * result:说明配置文件当中这样写可以实现自定义类型的注入。
         */
        //<bean id="userService" class = "com.pactera.spring.UserServiceImpl">
        //    <property name="userDao">
        //        
        //        <bean class = "com.pactera.spring.UserDaoImpl"/>
        //    </property>
        //</bean>
        //<bean id="userService" class = "com.pactera.spring.UserServiceImpl">
        //    <property name="userDao">
        //        <ref bean="userDao"/>
        //    </property>
        //</bean>
        //<bean id="userDao" class="com.pactera.spring.UserDaoImpl"></bean>
        //<ref local = "">这个标签从spring4就已经废除了，这个只能引用本配置文件中的bean
        @Test
        public void test11() throws Exception {
            ApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext.xml");
            UserService userService = (UserService)ctx.getBean("userService");
            Class clazz = userService.getClass();
            Field userDao = clazz.getDeclaredField("userDao");
            userDao.setAccessible(true);
            //Object o = userDao.get(userService);
            //System.out.println(o.getClass().getTypeName());//com.pactera.spring.UserDaoImpl
            System.out.println(userDao.getGenericType());
            System.out.println(userDao.getName());
            System.out.println(userDao.get(userService).getClass().hashCode() == UserDaoImpl.class.hashCode());//true
        }

#### (二)：第二种方式 ####

![8b1418f86f16471782ef367a61364894.png][]

###    3：Set注入简化写法 ###

#### (一)：基于属性的简化 ####

执行test方法的快捷键是 ctrl+shift+f10
    这是jdk类型的注入的形式。
    <property name = "name">
        <value = "suns">
    </property> 
    该类型的简化写法
    <property name = "name" value = "suns"/>
    用value属性代替value标签。
    注意：通过value属性只能简化八中基本类型和String类型。
    
    用户自定义类型：
    <property name = "userDao">
        <ref bean = "userDao">
    </property> 
    <property name= "userDao" ref = "userDao"/>
    注意：这种方式只能替换ref属性的形式。

#### (二)：基于p空间简化属性 ####

适用于jdk的类型的简化：

![d5408e3016ba439bb7e8ea3595694ac5.png][]

alt+enter可以导入这个命名空间P的配置，在这个配置当中，有了这个命名空间之后，Property标签就没用了

![31a22a96f8864a6caefb7781d8434836.png][]

##    三：构造注入 ##

注入：通过Spring的配置文件，为成员变量赋值  
Set注入：Spring通过Set方法，通过配置文件，为成员变量赋值  
构造赋值：Spring通过构造方法，通过配置文件，为成员变量赋值

### 1：开发步骤 ###

提供有参构造方法、提供spring的配置文件进行配置

/*
         * @Description:用于测试构造工厂
         * @Author: DaShu
         * @Date: 2021/5/31 11:21
         */
        @Test
        public void test13(){
            ApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext.xml");
            Customer customer = (Customer) ctx.getBean("customer");
            System.out.println(customer.toString());//Customer{name='suns', age=102}
    
        }

###    2：构造方法的重载 ###

参数的个数不同时通过constructor-arg标签的个数进行区分  
参数相同时，通过在这个标签中引入type标签就可以解决

### 3：注入的总结 ###

Set注入 vs 构造注入，未来这两种我们到底是使用什么注入  
1：未来实战：使用set注入会更多，构造注入会更多，有重载，更麻烦，  
2：Spring底层他自己的一些对象的配置，也是使用大量的set的注入，构造注入用的比较少。

![bb08ec8983c5480aab1d6312d539ee55.png][]

## 四：反转控制和依赖注入 ##

### 1：什么叫做控制反转 ###

控制：控制值得是对于对象创建、程序变量赋值的控制权，控制和注入的关系不是并列的关系，控制翻转依赖注入的，注入是控制翻转中的一个环节，例如：直接在代码中完成对于成员边量的赋值，这提高了代码的耦合，这样的控制权是在代码中的，提高了耦合性，将成员变量的赋值权交给Spring工厂和他的配置文件，这样就通过注入的方式，控制权是在Spring上边，解开了耦合性。

控制反转也就是说：对于对象的创建、对象的成员变量的赋值的权利翻转到spring的工厂和配置文件当中，可以起到解耦合的作用，控制反转的好处解耦合的作用。

底层实现：工厂设计模式，反射+配置文件

代码编写中最好的降低耦合性的方式：  
反射+配置文件+耦合月接口，可以把代码的耦合性降低早最低。

![67bc2d8519b54ed298ebfeca0ababc2f.png][]

### 2：什么是依赖注入 ###

通过Spring的工厂和配置文件为对象的成员变量赋值，依赖：我需要你的时候，你就是我的依赖：比如说：Service层中的Dao层的对象，就可以说Service层依赖dao层。Dao层是Service层的依赖。我依赖谁，就可以把他作为成员变量通过，spring的配置文件，创建他的对象，给我注入。好处：解耦合，通过提供set，get方法，最终通过Spring的配置文件完成对象的创建和注入

[053765fa2bbb4b788f4e1e381d3096e4.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/24/e2eca3746bd64adca8db794a628faf50.jpeg
[530715d8b04640eeaa6d0cd8dcbbe3cb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/24/e1f39d0c7ff04233b31c21d944e65470.png
[8b1418f86f16471782ef367a61364894.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/24/721cdd12d3b540f8871f2c42e300a61d.png
[d5408e3016ba439bb7e8ea3595694ac5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/24/8672b98dd2a34fb1bba0809979c71977.png
[31a22a96f8864a6caefb7781d8434836.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/24/36c7123126cf4342a63b7d4d4ad40a57.png
[bb08ec8983c5480aab1d6312d539ee55.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/24/e8b824fba0dc441db357997e2973cf61.png
[67bc2d8519b54ed298ebfeca0ababc2f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/24/f8e8288d6b624e768ad4a02233b6d2f7.png