Spring IOC 依赖注入

目的：

         解决对象间的依赖。

核心概念:

         Spring最重要的核心概念是nverse of control,中文常译为”控制反转”,更具体的一个名字是Dependency Injection ,中文常译为”依赖注入”,使用spring,你不必自己在程序代码强护对象的依赖关系,只需在配置文件中加以定,spring核习容器会自动根据配置将依赖注入指定的对象。

      Ioc的抽象概念是:”依赖关系的转移”。

         Ioc的一些表现:”实现必须依赖抽象,而不是抽象依赖实现”,”应用程序不应依赖于容器,而是容器服务于应用程序”。

两种IoC类型:

1、setter注入：

优点：setter可以从父类继承

缺点：setter调用的次序不定

2、构造函数注入：

优点：一旦创建，组件始终处于一致的可用状态

缺点：不可被继承

          如果需要注入的组件太多，会使构造函数的参数过长。

实例演示(Java Project)：

Action：

<span style="font-size:14px;">public class PomainAction {

private IPomainService pomainService;

public PomainAction(){}

public PomainAction(IPomainService pomainService){
this.pomainService = pomainService;
}

//完成增加采购单的请求
public void addPomain(){
pomainService.addPomain();
}

public IPomainService getPomainService() {
return pomainService;
}

public void setPomainService(IPomainService pomainService) {
this.pomainService = pomainService;
}

}</span>

Dao：

<span style="font-size:14px;">//负责明细单的操作
public class PoitemDao {

public void addItem(){
System.out.println("增加明细单");
}

}</span><span style="font-size: 18px;">

</span>

<pre name="code" class="java"><span style="font-size:14px;">//负责采购单主单的操作
public class PomainDao {

public void add(){
System.out.println("增加主单");
}

}</span>

</pre><p></p><pre>

<span style="font-size:14px;">//负责产品的操作
public class ProductDao {
<span style="white-space: pre;">	</span>public void update(){
<span style="white-space: pre;">		</span>System.out.println("修改产品的在途数");

<span style="white-space: pre;">	</span>}
}</span>

Service接口：

public interface IPomainService {

void addPomain();

}

Service实现类：

<span style="font-size:14px;">public class PomainServiceImpl implements IPomainService{

private PomainDao pomainDao;
private PoitemDao poitemDao;
private ProductDao productDao;

public PomainServiceImpl(){}

public PomainServiceImpl(PomainDao pomainDao, PoitemDao poitemDao,
ProductDao productDao) {
this.pomainDao = pomainDao;
this.poitemDao = poitemDao;
this.productDao = productDao;
}

public void addPomain(){
System.out.println("设置connection不是自动提交");
pomainDao.add();
poitemDao.addItem();
productDao.update();

System.out.println("提交");

}

public PomainDao getPomainDao() {
return pomainDao;
}

public void setPomainDao(PomainDao pomainDao) {
this.pomainDao = pomainDao;
}

public PoitemDao getPoitemDao() {
return poitemDao;
}

public void setPoitemDao(PoitemDao poitemDao) {
this.poitemDao = poitemDao;
}

public ProductDao getProductDao() {
return productDao;
}

public void setProductDao(ProductDao productDao) {
this.productDao = productDao;
}

}</span>

applicationContext.xml (唯一的配置文件)：

<span style="font-size:14px;"><?xml version="1.0" encoding="UTF-8"?>
<beans
xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd" >

<bean id="pomainDao" class="com.aowin.dao.PomainDao"></bean>
<bean id="poitemDao" class="com.aowin.dao.PoitemDao"></bean>
<bean id="proDao" class="com.aowin.dao.ProductDao"></bean>

<!-- set方式注入，要有相应的set和get方法 -->
<bean id="pomainService" class="com.aowin.service.PomainServiceImpl">
<property name="pomainDao" ref="pomainDao"></property>
<property name="poitemDao" ref="poitemDao"></property>
<property name="productDao" ref="proDao"></property>
</bean>

<bean id="pomainAction" class="com.aowin.action.PomainAction">
<property name="pomainService" ref="pomainService"></property>
</bean>

<!-- 构造方法注入 -->
<bean id="pomainService2" class="com.aowin.service.PomainServiceImpl">
<constructor-arg index="0" ref="pomainDao"></constructor-arg>
<constructor-arg index="1" ref="poitemDao"></constructor-arg>
<constructor-arg index="2" ref="proDao"></constructor-arg>
</bean>
<bean id="pomainAction2" class="com.aowin.action.PomainAction">
<constructor-arg index="0" ref="pomainService2"></constructor-arg>
</bean>
</beans></span>

Test：

<span style="font-size:14px;">public class Test {
public static void main(String[] args) {
//使用spring获取对象
//		BeanFactory factory = new ClassPathXmlApplicationContext("applicationContext.xml");
//		PomainDao mainDao = (PomainDao) factory.getBean("pomainDao");
//		mainDao.add();

//		BeanFactory factory = new ClassPathXmlApplicationContext("applicationContext.xml");
//		PomainAction action = (PomainAction) factory.getBean("pomainAction");
//		action.addPomain();

BeanFactory factory = new ClassPathXmlApplicationContext("applicationContext.xml");
PomainAction action = (PomainAction) factory.getBean("pomainAction2");
action.addPomain();

}

}</span>

使用Spirng Ioc之前的Test(比较作用):

<span style="font-size:14px;">public class Test {
public static void main(String[] args) {
//构造方法注入
//		PomainDao mainDao = new PomainDao();
//		PoitemDao itemDao = new PoitemDao();
//		ProductDao proDao = new ProductDao();
//		IPomainService pomainService = new PomainServiceImpl(mainDao, itemDao, proDao);
//		PomainAction action = new PomainAction(pomainService);
//		action.addPomain();

//set方式注入
PomainDao mainDao = new PomainDao();
PoitemDao itemDao = new PoitemDao();
ProductDao proDao = new ProductDao();
PomainServiceImpl pomainService = new PomainServiceImpl();
PomainAction action = new PomainAction();

pomainService.setPomainDao(mainDao);
pomainService.setPoitemDao(itemDao);
pomainService.setProductDao(proDao);

action.setPomainService(pomainService);

action.addPomain();

}

}</span>

包结构：



总结：

1、重构前的项目，包结构与重构后的基本一致，唯一的不同之处便是缺少了applicationContext.xml配置文件。

2、重构前的项目，各个文件内容与重构后的一致，唯一不同的是test文件，重构前在test文件中对象之间的依赖关系较强，重构后在配置文件中解决依赖关系。

3、Spring IOC的作用就是解决对象之间的依赖关系，使用时不需要繁杂的new对象，对象之间的依赖关系只需要在配置文件中进行一次配置，可以达到多次使用。

备注：

    此文总结自培训时期的Spring框架的第一课《Spring1》