Spring四种注入方式(IOC)

Set方式
构造函数方式
静态工厂方式
实例化工厂方式

Set方式

public class SpringAction1 {
	// 注入对象springDao
	private SpringDao springDao;

	// 一定要写被注入对象的set方法
	public void setSpringDao(SpringDao springDao) {
		this.springDao = springDao;
	}

	public void ok() {
		springDao.ok();
	}
}

package test.spring1;

public class SpringDao {
	public void ok() {
		System.out.println("Spring dao");
	}
}

<bean name="springAction" class="test.spring1.SpringAction1">  
  <!-- 依赖注入,配置当前类中相应的属性  -->
  <property name="springDao" ref="springDao"></property>  
</bean>  
<bean name="springDao" class="test.spring1.SpringDao"></bean>

1 2	SpringAction1 springAction1 = (SpringAction1) ContextUtil.getBean("springAction", SpringAction1.class); springAction1.ok();

构造函数方式

public class SpringAction2 {
	// 注入对象springDao
	private SpringDao2 springDao;
	private User user;

	public SpringAction2(SpringDao2 springDao, User user) {
		this.springDao = springDao;
		this.user = user;
		System.out.println("构造方法调用springDao和user");
	}

	public void save() {
		user.setName("卡卡");
		springDao.save(user);
	}
}

public class SpringDao2 {
	public void ok() {
		System.out.println("Spring dao is 2");
	}

	public void save(User user) {
		System.out.println("Spring dao is 2 !! save user");
	}
}

package test.spring2;

public class User {
	private String name;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	
}

<bean name="springAction2" class="test.spring2.SpringAction2">  
   <!-- 创建构造器注入,如果主类有带参的构造方法则需添加此配置  -->
   <constructor-arg index="0" ref="springDao"></constructor-arg>  
   <constructor-arg index="1" ref="user"></constructor-arg>  
</bean>  
<bean name="springDao" class="test.spring2.SpringDao2"></bean>  
<bean name="user" class="test.spring2.User"></bean>

1 2	SpringAction2 springAction2 = (SpringAction2) ContextUtil.getBean("springAction2", SpringAction2.class); springAction2.save();

静态工厂方式

 public class SpringAction3 {
	// 注入对象
	private FactoryDao staticFactoryDao;

	// 注入对象的set方法
	public void setStaticFactoryDao(FactoryDao staticFactoryDao) {
		this.staticFactoryDao = staticFactoryDao;
	}
	
	public void staticFactoryOk() {
		staticFactoryDao.saveFactory();
	}
}

package test.spring3;

public class FactoryDao {
	
	public void saveFactory() {
		System.out.println("FactoryDao is  ");
	}
}

package test.spring3;

public class DaoFactory {
	// 静态工厂
	public static final FactoryDao getStaticFactoryDaoImpl() {
		System.out.println("进入静态工厂方法....");
		return new FactoryDao();
	}
}

 <bean name="springAction3" class="test.spring3.SpringAction3" >  
   <!-- 使用静态工厂的方法注入对象,对应下面的配置文件   --> 
    <property name="staticFactoryDao" ref="staticFactoryDao"></property>  
</bean>  
<!-- 此处获取对象的方式是从工厂类中获取静态方法   -->
<bean name="staticFactoryDao" class="test.spring3.DaoFactory"  factory-method="getStaticFactoryDaoImpl"></bean>

1 2	SpringAction3 springAction3= (SpringAction3) ContextUtil.getBean("springAction3", SpringAction3.class); springAction3.staticFactoryOk();

实例化工厂方式

package test.spring4;

import test.spring4.FactoryDao;

public class SpringAction4 {  
    //注入对象  
    private FactoryDao factoryDao;  
      
    public void factoryOk(){  
        factoryDao.saveFactory();  
    }  
  
    public void setFactoryDao(FactoryDao factoryDao) {  
        this.factoryDao = factoryDao;  
    }  
}

package test.spring4;

public class FactoryDao {
	
	public void saveFactory() {
		System.out.println("实例工厂的方法注入 is  ");
	}
}

package test.spring4;

import test.spring4.FactoryDao;

public class DaoFactory {  
    //实例工厂  
    public FactoryDao getFactoryDaoImpl(){  
        return new FactoryDao();  
    }  
}

 <bean name="springAction4" class="test.spring4.SpringAction4">  
    <!-- 使用实例工厂的方法注入对象,对应下面的配置文件 -->  
    <property name="factoryDao" ref="factoryDao"></property>  
</bean>  
      
<!-- 此处获取对象的方式是从工厂类中获取实例方法-->  
<bean name="daoFactory" class="test.spring4.DaoFactory"></bean>  
<bean name="factoryDao" factory-bean="daoFactory" factory-method="getFactoryDaoImpl"></bean>