spring DI依赖注入

概念：所谓依赖注入就是指：在运行期，由外部容器动态地将依赖对象注入到另一个对象的组件中。

实例：

创建实体类：User.java

package cn.xxs.entity;

public class User {
	private Integer id;
	private String name;
	public User() {
		super();
		// TODO Auto-generated constructor stub
	}
	public User(Integer id, String name) {
		super();
		this.id = id;
		this.name = name;
	}
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@Override
	public String toString() {
		return "User [id=" + id + ", name=" + name + "]";
	}
	
	
}

创建接口：UserDao.java

package cn.xxs.dao;

public interface UserDao {

	public void print();
}

接口的实现：UserDaoImpl.java

package cn.xxs.dao.impl;

import cn.xxs.dao.UserDao;

public class UserDaoImpl implements UserDao{

	@Override
	public void print() {
		System.out.println("可以打印了");		
	}
}

创建接口：UserService.java

package cn.xxs.service;

public interface UserService {
	
	public void print();

}

接口的实现：UserServiceImpl.java

package cn.xxs.service.impl;

import cn.xxs.dao.UserDao;
import cn.xxs.service.UserService;

public class UserServiceImpl implements UserService{

	private UserDao userDao;
	
	//只需设置getter和setter方法，它可自动注入过来
	public UserDao getUserDao() {
		return userDao;
	}

	public void setUserDao(UserDao userDao) {
		this.userDao = userDao;
	}

	@Override
	public void print() {		
		userDao.print();
	}

}

测试类UserAction.java

package cn.xxs.action;

import org.junit.Test;

import cn.xxs.entity.User;
import cn.xxs.service.UserService;
import cn.xxs.util.BeanUtil;

public class UserAction {
	
	private UserService userService;	
	
	//在action层中，同样需设置getter和setter方法，把需要的ben注入过来
	public UserService getUserService() {
		return userService;
	}

	public void setUserService(UserService userService) {
		this.userService = userService;
	}

	@Test
	public void test() {	
		//但是 还是需要读取一次bean.xml配置文件，但其他层已经在bean.xml中配置好了，不需要读取配置文件
		userService = (UserService) BeanUtil.getBean("userService");	
		userService.print();
		
		User user = (User) BeanUtil.getBean("userBean");
		System.out.println(user.toString());
	}
}

创建工具类BeanUtil.java

package cn.xxs.util;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class BeanUtil {	
	public static Object getBean(String beanName) {
		return new ClassPathXmlApplicationContext("bean.xml").getBean(beanName);
	}
}

配置bean.xml

构造器注入三种方式：

默认情况：如果bean定义中的构造器参数类型明确，那么bean定义中的参数顺序就是对应构造器参数的顺序。

1.构造器参数属性名：通过制定相应的字段名匹配

2.构造器参数的索引：通过制定index索引序列

3.构造器参数类型匹配：通过制定对应的type类型匹配

<?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.xsd">  
      <!-- id:定义一唯一的名字
    class:指的是把那个类交给spring管理
     -->     
    <bean id="userDao" class="cn.xxs.dao.impl.UserDaoImpl"></bean>
     
     <bean id="userService" class="cn.xxs.service.impl.UserServiceImpl">
     	<!--name:指的是userService定义的属性的名字userDao
     		ref:把所需要的bean注入当前类，userDaoImpl上面配置的bean的id
      	 -->
     	<property name="userDao" ref="userDao"></property>
     </bean> 
     
     <bean id="userAction" class="cn.xxs.action.UserAction">
     	<property name="userService" ref="userService"></property>
     <!-- 在bean.xml中可以配置属性注入方式实现，这样使用可以减少去读取配置文件 -->
     </bean> 
     
     <bean id="userBean" class="cn.xxs.entity.User">
     
     	<!--<constructor-arg name="id" value="5810"></constructor-arg>
     	<constructor-arg name="name" value="注入"></constructor-arg>-->
     	
     	<!--<constructor-arg index="0" value="5810"></constructor-arg>
     	<constructor-arg index="1" value="注入"></constructor-arg>-->
     	
     	<constructor-arg type="java.lang.Integer" value="5810"></constructor-arg>
     	<constructor-arg type="java.lang.String" value="注入"></constructor-arg>
     </bean>
     
</beans>  

结果：