Spring2.5.6的注入讲解

1，setter注入（最重要）

首先是一个model实体：

public class User {
	private String username;
	private String password;
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
}

然后是service层：

public class UserService {
	private UserDAO userDAO ;
	public void add(User user) {
		userDAO.save(user);
	}
//	public UserDAO getUserDAO() {
//		return userDAO;
//	}
	public void setUserDAO(UserDAO userDAO) {//给成员属性userdao加set方法
		this.userDAO = userDAO;
	}
}

定义dao的接口：

public interface UserDAO {
	public void save(User user);
}

接口的实现:

public void save(User user) {
		System.out.println("user saved!");
	}

配置:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">

  <bean id="u" class="com.syyz.dao.impl.UserDAOImpl">
  </bean>
	
  <bean id="userService" class="com.syyz.service.UserService">
  	<property name="userDAO" ref="u" /><!--这边直接用ref，可以不用再重新创建bean-->
  		
  </bean>
  

</beans>

junit的测试类：

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.bjsxt.model.User;
public class UserServiceTest {

	@Test
	public void testAdd() throws Exception {
		ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
		UserService service = (UserService)ctx.getBean("userService");
		User u = new User();
		u.setUsername("zhangsan");
		u.setPassword("zhangsan");
		service.add(u);
	}

}

构造注入:（不常用）

只有两个地方不同：

service层：

public class UserService {
	
	private UserDAO userDAO;  
	public void add(User user) {
		userDAO.save(user);
	}
//	public UserDAO getUserDAO() {
//		return userDAO;
//	}
//	public void setUserDAO(UserDAO userDAO) {
//		this.userDAO = userDAO;
//	}
	//这里加一个userDao这个成员属性的构造函数
	public UserService(UserDAO userDAO) {
		super();
		this.userDAO = userDAO;
	}
}

配置：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">

  <bean id="u" class="com.syyz.dao.impl.UserDAOImpl">
  </bean>
	
  <bean id="userService" class="com.syyz.service.UserService">
  	<!-- 
  	<property name="userDAO" ref="u" />
  	 -->
  	 <constructor-arg>
  	 	<ref bean="u"/>
  	 </constructor-arg>
  </bean>
  
  

</beans>

接口注入：(基本不用)

仔细看看文档，这种方法主要是用在Singleton的Object中使用非Singleton的Bean时，通过lookup-method的那个方法来取得非Singleton的Bean。一般用的不多，在用这种定义之前最好想明白你的需求。

 

 

· 先建立一个包：javamxj.spring.basic.lookup ，然后把以下5个文件放在这个包下。

 

Hello.java.

package javamxj.spring.basic.lookup; public interface Hello {     public Random getRandom();     public abstract Random createRandom(); }

 

 

Random.java

package javamxj.spring.basic.lookup; public class Random {     private int i = (int) (100 * Math.random());     public void printRandom() {         System.out.println("输出随机整数:  " + i);     } }

 

 

HelloAbstract.java

package javamxj.spring.basic.lookup; public abstract class HelloAbstract implements Hello {     private Random random;     public Random getRandom() {         return random;     }     public void setRandom(Random random) {         this.random = random;     }     public abstract Random createRandom(); }

 

 

beans.xml

<?xml version="1.0" encoding="GBK"?> <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN""http://www.springframework.org/dtd/spring-beans.dtd"> <beans>     <bean id="ran" class="javamxj.spring.basic.lookup.Random"singleton="false"/>          <bean id="hello"class="javamxj.spring.basic.lookup.HelloAbstract">         <lookup-method name="createRandom" bean="ran"/>         <property name="random">             <ref local="ran"/>         </property>     </bean>      </beans>

 

 

Main.java

package  javamxj . spring . basic . lookup ;

import  org . springframework . beans . factory . BeanFactory ;
import org . springframework . beans . factory . xml . XmlBeanFactory ;
import  org . springframework . core . io . ClassPathResource ;
import  org . springframework . core . io . Resource ;

public  class Main {
     public  static  void main( String[] args) {

        Resource res =  new ClassPathResource( "javamxj/spring/basic/lookup/beans.xml");
        BeanFactory ft =  new XmlBeanFactory(res);

        Hello h = (Hello) ft.getBean( "hello");

         Random r1 = h.getRandom();
         Random r2 = h.getRandom();
         System.out.println( "没有采用Lookup方法注入：");
         System.out.println( "Random 的两个实例指向同一个引用："+ (r1 == r2));
        r1.printRandom();
        r2.printRandom();

         Random r3 = h.createRandom();
         Random r4 = h.createRandom();
         System.out.println( " /n 采用Lookup方法注入：");
         System.out.println( "Random 的两个实例指向同一个引用："+ (r3 == r4));
        r3.printRandom();
        r4.printRandom();

    }

}

 

 

 

简单说明一下：

 

· Hello是一个接口类，实现面向接口编程。

 

· Random类用来输出随机整数。

 

· HelloAbstract是一个抽象类，包含了一个属性：random，还包含一个抽象方法createRandom()，如果这个方法不是抽象的，spring会重写已有的实现。

 

· beans.xml中定义了两个bean，ran指向Rondom类，注意它不是singleton的；hello指向HelloAbstract类，其中的random属性指向ran，createRandom方法也指向ran。

 

· 在Main类中，Hello类分别利用getRandom()和createRandom()方法来调用Random类。

 

· 这次需要将 spring-framework主目录/lib/cglib 目录中的cglib-nodep-2.1_2.jar加入到项目的 Libraries中，使用其中的动态代理。

 

 

运行结果：

 

没有采用Lookup方法注入：
Random 的两个实例指向同一个引用：true
输出随机整数:  98
输出随机整数:  98

 

采用Lookup方法注入：
Random 的两个实例指向同一个引用：false
输出随机整数:  51
输出随机整数:  26