初学spring：控制反转和依赖注入

1、在传统程序设计中，是由程序控制对象之间的依赖关系，耦合度高。控制反转（Inversion of Control：简称Ioc）（也称为依赖注入）是将由程序控制“对象间的依赖关系”转交给Ioc容器来控制，通过外部容器控制各个类之间的关系，大大降低了耦合度。

2、依赖注入的实现方式：属性注入和构造方法注入。

  属性注入（setter Injection）：是指在接受注入的类定义属性的setter 方法，并且在配置文件中定义需要注入的属性。

 注：注入的属性值可以是对象实例，需要用<ref >元素来注入。

 spring 配置信息：applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
		"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
	<!-- id指定bean 的访问名称，class指定bean的实现类 -->
	<bean id="messageBean" class="com.test.spring.MessageBean">
		<property name="message"><!-- name指定bean实现类的属性 -->
			<value>Spring framework web project test config file:beans-config.xml!</value><!--指定了向bean属性注入的值 -->
		</property>
	</bean>
	
	<bean id="refBean" class="com.test.spring.RefBean">
		<property name="info">
			<value>RefBean : 属性注入!</value>
		</property>
	</bean>
	
	<bean id="comBean" class="com.test.spring.ComBean">
		<property name="refBean">
			<ref local="refBean"></ref>
		</property>
		
		<property name="message">
			<value>comBean : 属性注入!</value>
		</property>
	</bean>
</beans>

测试类：

package com.test.spring;
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.context.ApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils;

public class SpringWebTest extends HttpServlet{
	/**
	 * serialVersionUID
	 */
	private static final long serialVersionUID = 1L;
	
	@Override
	protected void doGet(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		//super.doGet(req, resp);
		this.doPost(request, response);
	}

	@Override
	protected void doPost(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		// TODO Auto-generated method stub
		//super.doPost(request, response);
		response.setCharacterEncoding("utf-8");
		PrintWriter out = response.getWriter();

		ApplicationContext ac = WebApplicationContextUtils.getWebApplicationContext(this.getServletContext());
		MessageBean message = (MessageBean)ac.getBean("messageBean");
		out.print(message.getMessage());
		ComBean comBean = (ComBean)ac.getBean("comBean");
		out.print(comBean.getMessage());
		out.print(comBean.getRefBean().getInfo());
		out.close();//close
	}
}

构造方法注入：是通过类的构造方法来完成依赖关系的设置

两个Bean：MethodBean 和RefBean

public class MethodBean {
private String name;
private RefBean refBean;

/**
*  无参构造器
*/
public MethodBean(){
}
/**
* 带参数构造函数
* @param name
* @param refBean
*/
public MethodBean(String name,RefBean refBean){
this.name = name;
this.refBean = refBean;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public RefBean getRefBean() {
return refBean;
}
public void setRefBean(RefBean refBean) {
this.refBean = refBean;
}
}

public class RefBean {
	private String info;
	public String getInfo() {
		return info;
	}
	public void setInfo(String info) {
		this.info = info;
	}
}

说明：MethodBean写了两个构造方法，其中无参构造方法是供spring在通过反射机制创建对象的实例时调用的。

如果类中没有无参构造方法，用户只能采用构造注入方式注入。

spring配置：

<bean id="methodBean" class="com.test.spring.MethodBean">
		<constructor-arg>
			<ref local="refBean"></ref>
		</constructor-arg>
                <constructor-arg>
			<value>Method 方法测试！</value>
		</constructor-arg>
 </bean>
<bean id="refBean" class="com.test.spring.RefBean">
	<property name="info">
		<value>RefBean : 属性注入!</value>
	</property>
</bean>

说明：
<constructor-arg>元素的顺序很重要的。尽量跟构造器参数的顺序保持一致。事实上，可以通过属性type和index来避免<constructor-arg>顺序和
构造器参数顺序不一致的问题。type属性用来指定参数的类型，index熟悉用来指定参数的顺序号，从0开始。例如：

<constructor-arg>
			<value type="int">123</value>
		</constructor-arg>
<constructor-arg>
			<value type="java.lang.String">45</value>
		</constructor-arg>