SpringIOC随笔（六）-依赖注入（DI）

「爱情、让人受尽委屈。」 2022-12-16 14:25 318阅读 0赞

SpringIOC随笔（六）-依赖注入（DI）

  • DI(Dependency Injection)
  • 概念：对象之间的关系的装配交给容器来管理。

  • 注入的方式：

    1. 构造注入：

      1. 顾名思义，构造注入就是使用构造方法注入，所以使用构造注入肯定要写对应的构造方法。下面直接上例子：

      public class User implements Serializable {
      private static final long serialVersionUID = 84601116866236075L;

      1. private String username;
      2.  private String password;
      3.    private Department department;
      5.    public User() {
      6.    }
      8.    public User(String username, String password) {
      9.        this.username = username;
      10.        this.password = password;
      11.    }
      13.    public User(String username, String password, Department department) {
      14.        this.username = username;
      15.        this.password = password;
      16.        this.department = department;
      17.    }
      19.    public String getUsername() {
      20.        return username;
      21.    }
      23.    public void setUsername(String username) {
      24.        this.username = username;
      25.    }
      27.    public String getPassword() {
      28.        return password;
      29.    }
      31.    public void setPassword(String password) {
      32.        this.password = password;
      33.    }
      35.    public Department getDepartment() {
      36.        return department;
      37.    }
      39.    public void setDepartment(Department department) {
      40.        this.department = department;
      41.    }
      43.    @Override
      44.    public String toString() {
      45.        return "User{" +
      46.                "username='" + username + '\'' +
      47.                ", password='" + password + '\'' +
      48.                ", department=" + department +
      49.                '}';
      50.    }

      }
      public class Department implements Serializable {
      private static final long serialVersionUID = -7390074405145933835L;

      1. private Integer id;
      3.    private String departmentName;
      5.    private String address;
      7.    public Department() {
      8.    }
      10.    public Department(Integer id, String departmentName, String address) {
      11.        this.id = id;
      12.        this.departmentName = departmentName;
      13.        this.address = address;
      14.    }
      16.    public Integer getId() {
      17.        return id;
      18.    }
      20.    public void setId(Integer id) {
      21.        this.id = id;
      22.    }
      24.    public String getDepartmentName() {
      25.        return departmentName;
      26.    }
      28.    public void setDepartmentName(String departmentName) {
      29.        this.departmentName = departmentName;
      30.    }
      32.    public String getAddress() {
      33.        return address;
      34.    }
      36.    public void setAddress(String address) {
      37.        this.address = address;
      38.    }
      40.    @Override
      41.    public String toString() {
      42.        return "Department{" +
      43.                "id=" + id +
      44.                ", departmentName='" + departmentName + '\'' +
      45.                ", address='" + address + '\'' +
      46.                '}';
      47.    }

      }

      1. 3. 
      2. ```xml
      3. <?xml version="1.0" encoding="UTF-8"?>
      4. <beans xmlns="http://www.springframework.org/schema/beans"
      5.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      6.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
      8.     <bean id="user" class="com.fxyh.spring.di.User">
      9.         <constructor-arg index="0" value="zhangsan"/>
      10.         <constructor-arg index="1" value="123456"/>
      11.         <!--ref方式-->
      12.         <!--<constructor-arg index="2" ref="department"/>-->
      13.         <constructor-arg index="2">
      14.             <!--内部bean方式-->
      15.             <bean class="com.fxyh.spring.di.Department">
      16.                 <constructor-arg index="0" value="2"/>
      17.                 <constructor-arg index="1" value="Ali"/>
      18.                 <constructor-arg index="2" value="hangzhou"/>
      19.             </bean>
      20.         </constructor-arg>
      21.     </bean>
      23.     <bean id="department" class="com.fxyh.spring.di.Department">
      24.         <constructor-arg index="0" value="1"/>
      25.         <constructor-arg index="1" value="Baidu"/>
      26.         <constructor-arg index="2" value="shengzhen"/>
      27.     </bean>
      29. </beans>
      1. @ContextConfiguration(“classpath*:applicationContext-di.xml”)
        @RunWith(SpringJUnit4ClassRunner.class)
        public class UserTest {
  1.                 @Autowired
  2.                 private User user;
  4.                 @Test
  5.                 public void test() {
  7.                     System.out.println(this.user);
  8.                 }
  9.             }
  10.     2.  这里使用的是Spring-test，然后省去了很多代码。
  12.          *      <dependency>
  13.                   <groupId>org.springframework</groupId>
  14.                   <artifactId>spring-test</artifactId>
  15.                   <version>4.3.21.RELEASE</version>
  16.                 </dependency>
  17.                 <dependency>
  18.                   <groupId>junit</groupId>
  19.                   <artifactId>junit</artifactId>
  20.                   <version>4.12</version>
  21.                   <scope>test</scope>
  22.                 </dependency>
  23. 2.  ### setter注入 ###
  25.     1.  使用setXxx方法注入的方式，这里不提了。
  26. 3.  ### 集合注入 ###
  28.     1.  array，list，set，map，properties注入。
  29.     2.      <bean id="collectionDemo" class="com.fxyh.spring.di.CollectionDemo">
  30.                     <property name="arrayValue">
  31.                         <array>
  32.                             <value>zhangsan</value>
  33.                             <value>lisi</value>
  34.                             <value>wangwu</value>
  35.                         </array>
  36.                     </property>
  37.                     <property name="listValue">
  38.                         <list>
  39.                             <value>beijin</value>
  40.                             <value>shanghai</value>
  41.                             <value>hangzhou</value>
  42.                             <value>shenzhen</value>
  43.                         </list>
  44.                     </property>
  45.                     <property name="setValue">
  46.                         <set>
  47.                             <value>aaa</value>
  48.                             <value>bbb</value>
  49.                             <value>ccc</value>
  50.                             <value>ddd</value>
  51.                         </set>
  52.                     </property>
  53.                     <property name="mapValue">
  54.                         <map>
  55.                             <entry key="key1" value="111"/>
  56.                             <entry key="key2" value="222"/>
  57.                             <entry key="key3" value="333"/>
  58.                             <entry key="key4" value="444"/>
  59.                         </map>
  60.                     </property>
  61.                     <property name="properties">
  62.                         <props>
  63.                             <prop key="driverClassName">com.mysql.jdbc.Driver</prop>
  64.                             <prop key="url">jdbc:mysql:///fxyh</prop>
  65.                             <prop key="username">root</prop>
  66.                             <prop key="password">root</prop>
  67.                         </props>
  68.                     </property>
  69.                 </bean>
  70.     3.      public class CollectionDemo implements Serializable {
  72.                 private static final long serialVersionUID = -4477381744799533624L;
  74.                 private String[] arrayValue;
  75.                 private List<String> listValue;
  76.                 private Set<String> setValue;
  77.                 private Map<String, Object> mapValue;
  78.                 private Properties properties;
  80.                 public String[] getArrayValue() {
  82.                     return arrayValue;
  83.                 }
  85.                 public void setArrayValue(String[] arrayValue) {
  87.                     this.arrayValue = arrayValue;
  88.                 }
  90.                 public List<String> getListValue() {
  92.                     return listValue;
  93.                 }
  95.                 public void setListValue(List<String> listValue) {
  97.                     this.listValue = listValue;
  98.                 }
  100.                 public Set<String> getSetValue() {
  102.                     return setValue;
  103.                 }
  105.                 public void setSetValue(Set<String> setValue) {
  107.                     this.setValue = setValue;
  108.                 }
  110.                 public Map<String, Object> getMapValue() {
  112.                     return mapValue;
  113.                 }
  115.                 public void setMapValue(Map<String, Object> mapValue) {
  117.                     this.mapValue = mapValue;
  118.                 }
  120.                 public Properties getProperties() {
  122.                     return properties;
  123.                 }
  125.                 public void setProperties(Properties properties) {
  127.                     this.properties = properties;
  128.                 }
  130.                 @Override
  131.                 public String toString() {
  133.                     return "CollectionDemo{" +
  134.                             "arrayValue=" + Arrays.toString(arrayValue) +
  135.                             ", listValue=" + listValue +
  136.                             ", setValue=" + setValue +
  137.                             ", mapValue=" + mapValue +
  138.                             ", properties=" + properties +
  139.                             '}';
  140.                 }
  141.             }
  142. 4.  ### 抽象Bean ###
  144.     1.  把公共的东西抽象出来，然后需要用到的使用parent。
  145.     2.      <bean id="abstractDemo" abstract="true">
  146.               <property name="id" value="1"/>
  147.               <property name="username" value="zhangsan"/>
  148.             </bean>
  149.             <bean id="abstractDemo1" class="com.fxyh.spring.di.AbstractDemo1" parent="abstractDemo">
  150.               <property name="password" value="123456"/>
  151.             </bean>
  152.             <bean id="abstractDemo2" class="com.fxyh.spring.di.AbstractDemo2" parent="abstractDemo">
  153.               <property name="age" value="22"/>
  154.             </bean>
  155.             <bean id="abstractDemo3" class="com.fxyh.spring.di.AbstractDemo3" parent="abstractDemo">
  156.               <property name="address" value="jiangxi"/>
  157.               <property name="id" value="2"/>
  158.             </bean>
  159.     3.  这里abstractDemo是抽象Bean，然后使用parent对应这个则对应的属性就会被赋值，并且在自己的bean中重新给这个属性赋值了，那么这个属性将会把抽象bean中的属性的值给覆盖掉。
  160. 5.  ### 自定义属性编辑器 ###
  162.     1.  `no matching editors or conversion strategy found`
  163.     2.  比如我注入的时候注入时间，我直接写字符串的时间，然后这肯定是会报错的，就上面说的那个错误，无法注入。
  164.     3.  所以我们需要自定义属性编辑器。
  165.     4.      import org.apache.commons.lang3.time.DateUtils;
  167.             import java.beans.PropertyEditorSupport;
  168.             import java.text.ParseException;
  169.             import java.util.Date;
  171.             public class CustomDatePropertyEditor extends PropertyEditorSupport {
  173.                 @Override
  174.                 public void setAsText(String text) throws IllegalArgumentException {
  176.                     Date date = null;
  177.                     try {
  179.                         date = DateUtils.parseDate(text, "yyyy-MM-dd");
  180.                     } catch (ParseException e) {
  182.                         e.printStackTrace();
  183.                     }
  185.                     this.setValue(date);
  186.                 }
  187.             }
  188.     5.      <bean id="person" class="com.fxyh.spring.di.Person">
  189.                     <property name="id" value="1"/>
  190.                     <property name="username" value="zhangsan"/>
  191.                     <property name="salary" value="#{10*new java.util.Random().nextInt(10)}"/>
  192.                     <property name="createDate" value="2019-06-30"/>
  193.                 </bean>
  195.                 <bean id="customEditorConfigurer" class="org.springframework.beans.factory.config.CustomEditorConfigurer">
  196.                     <property name="customEditors">
  197.                         <map>
  198.                             <entry key="java.util.Date" value="com.fxyh.spring.di.CustomDatePropertyEditor"/>
  199.                         </map>
  200.                     </property>
  201.                 </bean>
  202.     6.  自定义属性编辑器我们需要继承PropertyEditorSupport类，然后重写它的setAsText方法。现在已经不推荐使用了，推荐使用自定义转换器。
  203. 6.  ### 自定义转换器 ###
  205.     1.  实现Converter接口，注意：`org.springframework.core.convert.converter.Converter`包路径。
  206.     2.  然后实现convert方法，在里面写对应的逻辑。
  207.     3.      import org.apache.commons.lang3.StringUtils;
  208.             import org.apache.commons.lang3.time.DateUtils;
  209.             import org.springframework.core.convert.converter.Converter;
  211.             import java.text.ParseException;
  212.             import java.util.Date;
  214.             public class CustomDateConverter implements Converter<String, Date> {
  217.                 private String[] parsePatterns;
  219.                 public void setParsePatterns(String[] parsePatterns) {
  221.                     this.parsePatterns = parsePatterns;
  222.                 }
  224.                 @Override
  225.                 public Date convert(String source) {
  227.                     Date date = null;
  228.                     if (StringUtils.isBlank(source)){
  230.                         throw new IllegalArgumentException("");
  231.                     }
  232.                     try {
  234.                         date = DateUtils.parseDate(source, this.parsePatterns);
  235.                     } catch (ParseException e) {
  237.                         e.printStackTrace();
  238.                     }
  239.                     return date;
  240.                 }
  241.             }
  242.     4.      <bean id="conversionService" class="org.springframework.format.support.FormattingConversionServiceFactoryBean">
  243.                     <property name="converters">
  244.                         <set>
  245.                             <bean class="com.fxyh.spring.di.CustomDateConverter">
  246.                                 <property name="parsePatterns">
  247.                                     <array>
  248.                                         <value>yyyy-MM-dd</value>
  249.                                         <value>yyyy/MM/dd</value>
  250.                                     </array>
  251.                                 </property>
  252.                             </bean>
  253.                         </set>
  254.                     </property>
  255.                 </bean>
  256.     5.  这里注意这个转换器bean的id，我用其他的试都是没用，只有把id改成conversionService才能使用。

  • ByName&ByType

    • ByName：根据名称匹配
    • ByType：根据类型匹配
    • 这里有个比较经典的异常Caused by: org.springframework.beans.factory.NoUniqueBeanDefinitionException: No qualifying bean of type 'com.fxyh.spring.dao.UserDao' available: expected single matching bean but found 2: userDao111111,userDao
    • 这个接口有两个实现类，然后现在spring不知道选择哪个实现类注入就报这个异常了。

    • <?xml version=”1.0” encoding=”UTF-8”?>







    • 这里在beans上使用了default-autowire为byType，所以这个beans下的bean都会根据类型自动注入，而此时有userDao和userDao111111都是实现了UserDao接口，所以两个都符合要求，然后bean就不知道要注入哪一个了，而这里我们又在userService配置了autowire为byName，此时userService是根据名称来匹配的，则只有userDao一个匹配成功。（这里提供setter方法，然后把setter方法set去掉，然后第一个字母小写，就是名称）
    • 同时在配置中局部配置优先于全局配置！

  • 注解编程

    • @Autowired

      • 属于Spring框架的注解
      • 先按类型匹配，如果匹配不到再按名称匹配

    • @Resource

      • 属于JavaEE规范的注解
      • 先按名称匹配，如果匹配不到再按类型匹配

    • @Qualifier

      • 和@Autowired结合使用的时候，按照类型匹配，不按类型匹配。
      • @Resource原本就是按名称所以在它按名称找不到的时候，使用@Qualifier设置的名称匹配。

    • @Component

      • 把这个类注解为一个组件

    • @Repository

      • 数据库交互层使用的注解（Dao）

    • @Service

      • 服务层使用的注解

    • @Controller

      • 控制层使用的注解

    • @Configuration

      • 配置类注解

    • @Bean

      • 把这个方法注解成一个创建bean的方法。

    • 使用注解开发首先不能少了组件扫描，开启开关。

      • <?xml version=”1.0” encoding=”UTF-8”?>





    • 这里不贴测试用例了，自己写写测试用例测一测就ok了。

发表评论

表情：
评论列表 （有 0 条评论，318人围观）

还没有评论，来说两句吧...

相关阅读

    相关 DI依赖注入

    在DI（依赖注入）中，能注入的数据是有三种类型的： 1、基本类型和String 2、其他bean类型（在配置文件中或者注解配置过的bean对象） 3、复杂类型/集

    亦凉亦凉/ 0 赞/ 71 阅读

    相关 Spring依赖注入DI

    开头语：本文是我整理网上各种资料后整合而成的一篇文章。文中涉及到了代码重构、面向接口编程、持久化和工厂设计模式的内容。 1. Spring是什么?

    港控/mmm°港控/mmm°/ 0 赞/ 360 阅读

    相关 SpringIOC/DI

    spring笔记 高内聚低耦合: 工厂模式:通过第三方的类产生我们需要的产品(对象),用来解耦合 简单工厂: 1. 提供产品接口,之后让所有产品实现该接口 2.

    淡淡的烟草味﹌淡淡的烟草味﹌/ 0 赞/ 358 阅读

    相关 依赖注入2-DI

    IoC主要体现了这样一种设计思想：通过将一组通用流程的控制从应用转移到框架之中以实现对流程的复用，同时采用“好莱坞原则”是应用程序以被动的方式实现对流程的定制。我们可以采用若干

    r囧r小猫r囧r小猫/ 0 赞/ 496 阅读