Spring XML 注入

Spring XML 注入

依賴注入：

從Spring 容器中取出對象，注入到須要的地方。

根據所須要瞭解的注入方式建立下方的類。

建立UserServiceImpl類

package com.arno.service.impl;
​
import com.arno.dao.UserDao;
import com.arno.entity.User;
import com.arno.service.UserService;
​
public class UserServiceImpl implements UserService {
 private UserDao userDao;
 public void setUserDao(UserDao userDao){
 this.userDao=userDao;
 }
 @Override
 public boolean addUser(User user) {
 System.out.println("UserSerivceImpl.addUser()");
 userDao.addUser(user);
 return false;
 }
​
 @Override
 public boolean updateUser(User user) {
 System.out.println("UserSerivceImpl.updateUser()");
 userDao.updateUser(user);
 return false;
 }
​
}
​

建立UserDaoImpl類

package com.arno.dao.impl;
​
import com.arno.dao.UserDao;
import com.arno.entity.User;
​
public class UserDaoImpl implements UserDao {
 private String driverClass;
 private int port;
 private String dbUserName;
 private String dbPassword;
 
 public void setDriverClass(String driverClass) {
 this.driverClass = driverClass;
 }
​
 public void setPort(int port) {
 this.port = port;
 }
​
 public void setDbUserName(String dbUserName) {
 this.dbUserName = dbUserName;
 }
​
 public void setDbPassword(String dbPassword) {
 this.dbPassword = dbPassword;
 }
​
 @Override
 public int addUser(User user) {
 System.out.println("UserDaoImpl.adduser()");
 System.out.println(driverClass+"   "+port+"   "+dbUserName+"   "+dbPassword);
 return 0;
 }
​
 @Override
 public int updateUser(User user) {
 System.out.println("UserDaoImpl.updateuser()");
 return 0;
 }
​
}

建立Message類

package com.arno.collection;
​
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
​
public class Message {
 private List list;
 private Set set;
 private Map map;
 private Properties props;
 public List getList() {
 return list;
 }
 public void setList(List list) {
 this.list = list;
 }
 public Set getSet() {
 return set;
 }
 public void setSet(Set set) {
 this.set = set;
 }
 public Map getMap() {
 return map;
 }
 public void setMap(Map map) {
 this.map = map;
 }
 public Properties getProps() {
 return props;
 }
 public void setProps(Properties props) {
 this.props = props;
 }
 @Override
 public String toString() {
 return "Message [list=" + list + ", set=" + set + ", map=" + map + ", props=" + props + "]";
 } 
}

注入數據的方式：

setter方式注入：

1.單值注入

在xml中建立UserDaoImpl 對象，而且注入4個屬性值

<!-- 告知spring建立 UserDaoImpl對象        對象名:userDao
 此對象中注入4個數據
 property節點對應一個set方法
 name="driverClass"  driverClass->DriverClass->setDriverClass
 setDriverClass字符串去UserDaoImpl類中匹配setDriverClass的方法
 value="com.mysql.jdbc.Driver"
 -->
 <bean id="userDao"  class="com.arno.dao.impl.UserDaoImpl">
 <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
 <property name="port" value="3306"></property>
 <property name="dbUserName" value="root"></property>
 <property name="dbPassword" value="root"></property>
 </bean>

2.對象注入

在xml中建立UserDaoImpl 對象，注入4個屬性值，對象命名爲userDao，注入下方名爲userService的對象中

<!-- 告知spring建立 UserDaoImpl對象        對象名:userDao
 -->
 <bean id="userDao"  class="com.arno.dao.impl.UserDaoImpl">
 <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
 <property name="port" value="3306"></property>
 <property name="dbUserName" value="root"></property>
 <property name="dbPassword" value="root"></property>
 </bean>
 <!-- 告知spring建立 UserServiceImpl對象  對象名:userService
 userService對象中須要UserDaoImpl類的對象
 或
 userService對象中須要UserDao接口的對象
 proerty屬性節點,每個property節點都會對應一個setter方法
 name="userDao" userDao->UserDao->setUserDao
 拿setUserDao這個字符串做爲方法的名稱去UserServiceImpl類中尋找是否有setUserDao的方法
 若是有就反射調用setUserDao方法,方法的參數就是ref="userDao"
 ref="userDao"  ref:reference引用    userDao 是spring容器中的一個對象名稱
 -->
 <bean id="userService" class="com.arno.service.impl.UserServiceImpl">
 <property name="userDao" ref="userDao"></property>
 </bean>

3.集合注入（直接注入和間接注入）

直接注入,建立Message對象，經過標籤直接注入屬性值

<!-- 直接集合注入 -->
 <bean id="message1" class="com.arno.collection.Message">
 <property name="list">
 <list>
 <value>北京</value>
 <value>上海</value>
 <value>廣州</value>
 <ref bean="hello"></ref>
 </list>
 </property>
 <property name="set">
 <set>
 <value>北京</value>
 <value>上海</value>
 <value>廣州</value>
 <ref bean="hello"></ref>
 </set>
 </property>
 <property name="map">
 <map>
 <entry key="bj" value="北京"></entry>
 <entry key="sh" value="上海"></entry>
 <entry key="gz" value="廣州"></entry>
 </map>
 </property>
 <property name="props">
 <props>
 <prop key="bj">北京</prop>
 <prop key="sh">上海</prop>
 <prop key="gz">廣州</prop>
 </props>
 </property>
 </bean>

間接注入,建立Hello對象和集合。建立Message對象，經過標籤引用hello對象和集合注入到Message對象的屬性中

<!-- 間接集合注入 -->
 <bean id="hello" class="com.arno.ioc.Hello"></bean>
 <util:list id="ulist">
 <value>北京</value>
 <value>上海</value>
 <value>廣州</value>
 <ref bean="hello"></ref>
 </util:list>
 <util:set id="uset">
 <value>北京</value>
 <value>上海</value>
 <value>廣州</value>
 <ref bean="hello"></ref>
 </util:set>
 <util:map id="umap">
 <entry key="bj" value="北京"></entry>
 <entry key="sh" value="上海"></entry>
 <entry key="gz" value="廣州"></entry>
 <entry key="hello" value-ref="hello"></entry>
 </util:map>
 <util:properties id="uprops">
 <prop key="bj">北京</prop>
 <prop key="sh">上海</prop>
 <prop key="gz">廣州</prop>
 </util:properties>
 <bean id="message2" class="com.arno.collection.Message">
 <property name="list" ref="ulist"></property>
 <property name="set" ref="uset"></property>
 <property name="map" ref="umap"></property>
 <property name="props" ref="uprops"></property>
 </bean>

4.屬性注入（把屬性文件中的數據注入給對象中）

${}方式： 建立mysql.properties文件(注意規避關鍵詞)

jdbc_driverClass=com.mysql.jdbc.Driver
 jdbc_url=jdbc:mysql://localhost:3306/tesdb
 jdbc_userName=root
 jdbc_userPassword=root

建立jdbcUtil1和jdbcUtil2類

public class JDBCUtil1 {
 private String driverClass;
 private String url;
 private String userName;
 private String userPassword;
 getter and setter(生成get/set方法)
 }

經過${}方式取得mysql.properties內容並注入到jdbcUtil1對象中

<!-- 用spring把屬性文件的內容加載到spring容器中 ,多個屬性文件用逗號間隔-->
 <context:property-placeholder location="classpath:conf/mysql.properties"/>
 
 <bean id="jdbcUtil1" class="com.arno.properties.JDBCUtil1">
 <property name="driverClass" value="${jdbc_driverClass}"></property>
 <property name="url" value="${jdbc_url}"></property>
 <property name="userName" value="${jdbc_userName}"></property>
 <property name="userPassword" value="${jdbc_userPassword}"></property>
 </bean>

{}方式： 經過#{}方式取得mysql.properties內容並注入到jdbcUtil1對象中

<!-- 用spring把屬性文件的內容加載到spring容器中 ,多個屬性文件用逗號間隔-->
 <util:properties id="manyProperties"
 location="classpath:conf/mysql.properties"></util:properties>
 
 <bean id="jdbcUtil2" class="com.arno.properties.JDBCUtil2">
 <property name="driverClass" value="#{manyProperties.jdbc_driverClass}"></property>
 <property name="url" value="#{manyProperties.jdbc_url}"></property>
 <property name="userName" value="#{manyProperties.jdbc_userName}"></property>
 <property name="userPassword" value="#{manyProperties.jdbc_userPassword}"></property>
 </bean>

5.空值注入

空值兩種："" 空字符串和null 空指針

建立Kong類

package com.arno.kong;
​
public class Kong {
 private String str1;
 private String str2;
 public String getStr1() {
 return str1;
 }
 public void setStr1(String str1) {
 this.str1 = str1;
 }
 public String getStr2() {
 return str2;
 }
 public void setStr2(String str2) {
 this.str2 = str2;
 }
 
}

建立Kong對象，注入「」和null

<!--str1存儲的是空字符串 ,str2存儲的null-->
 <bean id="kong" class="com.arno.kong.Kong">
 <property name="str1" value=""></property>
 <property name="str2">
 <null />
 </property>
 </bean>

上面的五種方式用setter方式把數據注入到須要的對象中

構造方式注入：

用構造方法注入數據: 建立Hello對象和ConstructorClass對象，並經過ConstructorClass構造方法注入Hello對象和屬性值

<bean id="hello" class="com.arno.ioc.Hello"></bean>
 <bean id="constructorClass" class="com.arno.constructor.ConstructorClass">
 <constructor-arg index="0" value="張三"></constructor-arg>
 <constructor-arg index="1" value="20"></constructor-arg>
 <constructor-arg index="2" ref="hello"></constructor-arg>
 
 </bean>

建立ConstructorClass類，並建立構造方法

ConstructorClass.java
 public class ConstructorClass {
 private String name;
 private String  age;
 private Hello hello;
 
 public ConstructorClass(String name, String age, Hello hello) {
 this.name = name;
 this.age = age;
 this.hello = hello;
 }
 public String getName() {
 return name;
 }
 public String getAge() {
 return age;
 }
 public Hello getHello() {
 return hello;
 }
 
 }

總結:在開發中用setter方法是最多,也最經常使用,靈活也最好

在開發中構造注入不經常使用,構造注入數據通常用在框架中居多

autowire 自動裝配

byType 根據類型注入， 建立User對象，根據User對象中須要注入的屬性，在spring容器中尋找是否有對應類型的對象,若是有就注入 前提:在spring容器中對應的類類型不能兩個及以上

<bean id="user" 
 class="com.arno.autowire.User"
 autowire="byType">
 </bean>

byName根據名字注入，例如User中有Dog類須要注入，而且User類中有setDog()方法，根據setDog方法名，去掉set並首字母小寫獲得名字dog，在spring容器中尋找是否有對應名字的對象，而後經過set方法進行注入。

<!-- 
 autowire="byName"  按照名稱自動裝配
 過程:首先搜索User類,類種須要兩個對象,分別是Cat類和Dog類
 且類中有setCat方法,setCat->Cat->cat,拿cat去spring容器中尋找是否有此對象
 -->
 <bean id="user" 
 class="com.arno.autowire.User"
 autowire="byName">
 </bean>