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
python
**粗体** _斜体_ [链接](http://example.com) `代码` - 列表 > 引用。你还可以使用@来通知其他用户。