乐趣区

关于java:SpringIOCDI自动装配

jiezi

什么是 IOC

IOC 全称是 Inversion of Control（管制反转），所谓管制反转是对于程序自身而言，以前咱们在创建对象的时候是本人通过 new 创立进去，而当初咱们把这个势力交给了 Spring 去做，让它帮咱们去创建对象和治理对象，对对象的控制权反转给了 Spring

什么是 DI

DI 全称是 Dependency Injection（依赖注入），所谓依赖注入是对于 Spring 的 IOC 容器而言 ，以前咱们在给对象的属性赋值时有两种渠道，一种是通过带参数的构造方法，另一种是通过 set 办法。而当初 IOC 容器在创建对象的同时把属性的值注入进去。
什么是依赖：比方 A 对象的属性里有 B 对象，那么就叫 A 依赖 B

Spring 的 DI 实例

  • 依赖注入有两种形式，一种是基于对象的构造函数，另一种是基于对象属性对象的 set 办法，根本实现思路是这样的：

    • 基于构造函数：Spring 参考 bean 配置，提取出 bean 对象的参数，通过构造方法实例化 bean 对象
    • 基于属性的 set 方
    • 法：Spring 参考 bean 配置，首先先通过无参的构造方法实例化 bean 对象，而后通过 set 办法设置 bean 对象的属性
  • 注入根本数据类型（8 大根本数据类 +String）
/* User.java */
public class User {
     private String account;
     private String password;
     private Float balance;
     public User(String account, String password, Float balance) {
            this.account = account;
     this.password = password;
     this.balance = balance;
     }
        public User(){System.out.println("User 对象创立了");
     }
        @Override
     public String toString() {
            return "User{" +
                    "account='" + account + '''+", password='"+ password +''' +
                    ", balance=" + balance +
                    '}';
     }
        public String getAccount() {System.out.println("set 办法调用了");
     return account;
     }
        public void setAccount(String account) {this.account = account;}
        public String getPassword() {return password;}
        public void setPassword(String password) {this.password = password;}
        public Float getBalance() {return balance;}
        public void setBalance(Float balance) {this.balance = balance;}
}
/* main 函数 */
public class TestMain {public static void main(String[] args) {System.out.println(userDao.selectUserByAccount("2018"));
         AbstractApplicationContext factory = new ClassPathXmlApplicationContext("ApplicationContext.xml");
         User user = (User) factory.getBean("user");
         System.out.println(user);
     }
}
<!-- 配置文件 -->
<?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
 https://www.springframework.org/schema/beans/spring-beans.xsd">
     <bean id="user" class="com.cjh.domain.User">
         <property name="account" value="2019"></property>
         <property name="password" value="123"></property>
         <property name="balance" value="777"></property>
     </bean>
</beans>

如果是根本数据类型 /String 的话，间接通过 value 写入要传递的值，底层会依据属性的具体类型将 value 转换成对应的数据类型

  • 注入聚合对象

    • 如果是对象外面套了另一个对象，有两种写法，一种是在 bean 外面配置一个 bean，另一种是在 bean 外面引入一个内部 bean

    • 第一种写法

      /* person.java */
public class Person {
     private String name;
     // 引入了下面的 user 对象
     private User user;
     public Person(){}
        @Override
     public String toString() {
            return "Person{" +
                    "name='" + name + '''+", user="+ user +'}';
     }
        public String getName() {return name;}
        public void setName(String name) {this.name = name;}
        public User getUser() {return user;}
        public void setUser(User user) {this.user = user;}
}
      // 主函数
public class TestMain {public static void main(String[] args) {System.out.println(userDao.selectUserByAccount("2018"));
             ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext.xml");
             Person person = (Person) context.getBean("person");
             System.out.println(person);
     }
}
      <!-- 配置文件 -->
<?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
 https://www.springframework.org/schema/beans/spring-beans.xsd">
     <bean id="person" class="com.cjh.domain.Person">
         <property name="name" value="john"></property>
         <property name="user">
             <bean id="user" class="com.cjh.domain.User">
                 <property name="account" value="2019"></property>
                 <property name="password" value="123"></property>
                 <property name="balance" value="777"></property>
             </bean>
         </property> 
     </bean>
</beans>

    • 第二种写法

      • 通过 property 标签中的 ref 属性引入一个内部变量
<!-- 配置文件 -->
<?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
 https://www.springframework.org/schema/beans/spring-beans.xsd">
     <bean id="person" class="com.cjh.domain.Person">
         <property name="name" value="john"></property>
         <property name="user" ref="user"></property>
     </bean>
     <bean id="user" class="com.cjh.domain.User">
         <property name="account" value="2019"></property>
         <property name="password" value="123"></property>
         <property name="balance" value="777"></property>
     </bean>
</beans>

  • 注入汇合

    • 注入 List、set、map、properties 汇合
//TestCollection.java
package com.cjh.domain;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
public class TestCollection {
     private List<String> list;
     private Set<String> set;
     private Map<Integer, String> map;
     private Properties properties;
     public TestCollection(){}
        @Override
     public String toString() {
            return "TestCollection{" +
                    "list=" + list +
                    ", set=" + set +
                    ", map=" + map +
                    ", properties=" + properties +
                    '}';
     }
        public List<String> getList() {return list;}
        public void setList(List<String> list) {this.list = list;}
        public Set<String> getSet() {return set;}
        public void setSet(Set<String> set) {this.set = set;}
        public Map<Integer, String> getMap() {return map;}
        public void setMap(Map<Integer, String> map) {this.map = map;}
        public Properties getProperties() {return properties;}
        public void setProperties(Properties properties) {this.properties = properties;}
    }
// 主函数
public class TestMain {public static void main(String[] args) {System.out.println(userDao.selectUserByAccount("2018"));
     ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext.xml");
     TestCollection collection = (TestCollection) context.getBean("testCollection");
     System.out.println(collection);
     }
}
<!-- 配置信息 -->
<?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
 https://www.springframework.org/schema/beans/spring-beans.xsd">
     <bean id="testCollection" class="com.cjh.domain.TestCollection">
         <property name="list">
             <list value-type="java.lang.String">
                 <value>12</value>
                 <value>13</value>
                 <value>14</value>
                 <value>15</value>
             </list> 
         </property> 
         <property name="set">
             <set value-type="java.lang.String">
                 <value>abc</value>
                 <value>def</value>
                 <value>ghi</value>
                 <value>jkl</value>
                 <value>mno</value>
             </set> 
         </property> 
         <property name="map">
             <map key-type="java.lang.Integer" value-type="java.lang.String">
                 <entry key="1" value="a"/>
                 <entry key="2" value="b"/>
                 <entry key="3" value="c"/>
             </map> 
         </property> 
         <property name="properties">
             <props value-type="String">
                 <prop key="a">1</prop>
                 <prop key="b">2</prop>
                 <prop key="c">3</prop>
             </props>
         </property> 
     </bean>
</beans>
  • 注入 null 和空字符串
<bean id="person" class="com.cjh.domain.Person">
 <property name="name" value=""></property>
 <property name="user">
 <null></null> </property></bean>

如上的配置中，value 什么都不给就默认为 ”” 空串，如果须要注入 null, 须要应用 null 标签，如果间接用 value=”null”，Spring 会把它解析成字符串 null

主动拆卸

  • byName：在获取以后 bean 对象的时候，会依据以后对象的属性名，在配置文件下找到 id/name 属性与之一样的 bean 对象，拆卸给以后 bean 对象（通过属性的 set 办法）

    • 留神：这里我本人手动试过，当属性名与 bean 标签的 name/id 名不统一，然而 set 办法 (set 办法的命名规定：set+ 属性名) 的属性名与 name/id 统一，也是能够拆卸胜利的
    • 所以我得出：Spring 是依据 set 办法的后缀属性名字与 bean 标签中的 name/id 匹配（集体意见）

  • byType：在获取以后 bean 对象的时候，依据以后对象属性的类型，在配置文件下找到雷同类型的 bean 对象，并拆卸给以后 bean 对象（通过属性的 set 办法）

    • 如果 beans 下存在多个雷同类型的 bean 对象，那么会报错

    • 如果以后 bean 对象的属性类型是接口、抽象类或者一般类的父类，有三种状况

      • 当属性对应的 set 办法的参数也是上述三种类型，如果 beans 下只有一个与之匹配的可实例化类型（子类 / 一般类的父类），那么拆卸胜利
      • 当属性对应的 set 办法的参数也是上述三种类型，然而 beans 下有多个与之匹配的可实例化类型，那么报错
      • 当属性对应的 set 办法的参数是可实例化的类型，并且 beans 下只有一个与之匹配的类型，拆卸胜利，如果有多个，那么报错

  • constructor：依据带参的构造方法进行拆卸

    • 依据构造方法的参数名和 bean 标签的 id/name 名是否统一

    • 依据构造方法的参数类型和 bean 标签的 class 类型是否统一

      • 如果构造方法的参数类型是父类，那么 beans 下要有惟一与之匹配的 bean 对象（呈现多个不拆卸）
    • 以上两点满足其中 1 点即可拆卸
  • no：不反对主动拆卸性能
退出移动版