关于java: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>

关于java:Spring-XML-注入

Spring XML 注入

依赖注入：

注入数据的形式：

setter形式注入：

1.单值注入

2.对象注入

3.汇合注入（间接注入和间接注入）

4.属性注入（把属性文件中的数据注入给对象中）

5.空值注入

结构形式注入：

autowire 主动拆卸

评论

发表回复取消回复

更多文章

DDN HPC 存储硬件架构设计深度分析

探秘IO500：从Lustre并行文件系统出发，开启HPC存储性能新征程

苹果iOS打包的ipa应用无法安装？一篇文章带你了解可能的原因及排查方法

图解Golang：从零开始实现简易版过期LRU缓存

关于java:Spring-XML-注入

Spring XML 注入

依赖注入：

注入数据的形式：

setter形式注入：

1.单值注入

2.对象注入

3.汇合注入（间接注入和间接注入）

4.属性注入（把属性文件中的数据注入给对象中）

5.空值注入

结构形式注入：

autowire 主动拆卸

评论

发表回复 取消回复

更多文章

DDN HPC 存储硬件架构设计深度分析

探秘IO500：从Lustre并行文件系统出发，开启HPC存储性能新征程

苹果iOS打包的ipa应用无法安装？一篇文章带你了解可能的原因及排查方法

图解Golang：从零开始实现简易版过期LRU缓存

发表回复取消回复