Spring、Spring依赖注入与编码剖析Spring依赖注入的原理

Spring依赖注入

新建PersonIDao 和PersonDao底实现Save方法:

public interface PersonIDao {
	public void save();
}

public class PersonDaoImpl  implements PersonIDao{
	@Override
	public void save() {
		System.out.println("我是dao的Save方法");
	}
}

在Bean.xml中注入PersonIDao，并将PersonIDao注入到PersonService中：

<bean id="personIDao" class="cn.dao.impl.PersonDaoImpl" />
	<bean id="personIService" class="cn.server.impl.PersonServiceImpl">
		<property name="personIDao" ref="personIDao" />
	</bean>

在PersonService中添加PersonIDao类型属性并实现属性的set方法，然后调用PersonIDao的save方法

public class PersonServiceImpl implements PersonIService {
	private PersonIDao personIDao;
 
	public PersonIDao getPersonIDao() {
		return personIDao;
	}
	public void setPersonIDao(PersonIDao personIDao) {
		this.personIDao = personIDao;
	}
	@Override
	public void save() {
		personIDao.save();
	}
}

然后测试：

@Test
	public void testSave() {
		AbstractApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");
		PersonIService personIService=(PersonIService)ac.getBean("personIService");
		personIService.save();
	}

编码剖析Spring依赖注入的原理

通过编码的方法式来剖析Spring 依赖注入的原理方法，新建PropertyDefinition类用来承载Bean中注入的property的属性：

public class PropertyDefinition {
	private String name;
	private String ref;
	public PropertyDefinition(){}
	public PropertyDefinition(String name, String ref) {
		super();
		this.name = name;
		this.ref = ref;
	}
 
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getRef() {
		return ref;
	}
	public void setRef(String ref) {
		this.ref = ref;
	}
}

新建BeanDefinition用来承载解析到的Bean属性

public class BeanDefinition {
	private String id;
	private String className;
	private List<PropertyDefinition> properties=new ArrayList<PropertyDefinition>();
	public BeanDefinition(){}
	public BeanDefinition(String id, String className) {
		this.id = id;
		this.className = className;
	}
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public String getClassName() {
		return className;
	}
	public void setClassName(String className) {
		this.className = className;
	}
	public List<PropertyDefinition> getProperties() {
		return properties;
	}
	public void setProperties(List<PropertyDefinition> properties) {
		this.properties = properties;
	}
}

新建OtherClassPathXMLApplicationContext 用来解析bean.xml

public class OtherClassPathXMLApplicationContext {
	private List<BeanDefinition> list=new ArrayList<BeanDefinition>();
	private Map<String,Object> beans=new HashMap<String, Object>();
 
	public OtherClassPathXMLApplicationContext(String fileName){
		this.readXML(fileName);
		this.instanceBeans();
		this.instanceProperties();
	}
	private void instanceBeans(){
		for(BeanDefinition bean : list){
			try {
				// 创建Bean实例，并放到Map中
				if(bean.getClassName()!=null && !bean.getClassName().trim().equals("")){
					beans.put(bean.getId(), Class.forName(bean.getClassName()).newInstance());
				}
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}
	private void instanceProperties(){
		for(BeanDefinition beanDefinition : list){
			Object bean=beans.get(beanDefinition.getId());
			if(bean!=null){
				 try {
					// 获取bean下所有的属性定义描述
					PropertyDescriptor[] ps = Introspector.getBeanInfo(bean.getClass()).getPropertyDescriptors();
					for(PropertyDefinition propertyDefinition : beanDefinition.getProperties()){
						for(PropertyDescriptor propertyDescriptor : ps){
							// 如果bean下的属性名字与当前的BeanDefinition下的属性名称一样的话，则将引用对象注入到属性
							if(propertyDefinition.getName().equals(propertyDescriptor.getName())){
								Method setter=propertyDescriptor.getWriteMethod(); // 获取Bean的所有写入的方法 即 setter方法
								setter.setAccessible(true); // true: 直接访问私有属性，将例子中的私有属性改值。
								Object value=beans.get(propertyDefinition.getRef());
								setter.invoke(bean, value);  // 把引用对象注入属性
								break;
							}
						}
					}
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}
	}
	private void readXML(String fileName){
		SAXReader saxReader = new SAXReader();
		Document doc=null;
		try{
			// JAVA里面对于类进行调用配置资源的文件数据，以this.getClass().getResourceAsStream()来读取比较合适。
			// 路径采用相对路径直接可以从工程的path路径去找。
			URL xmlpath=this.getClass().getClassLoader().getResource(fileName);
			doc=saxReader.read(xmlpath);
			Map<String,String> nsMap=new HashMap<String,String>();
			nsMap.put("ns", "http://www.springframework.org/schema/beans"); // 加入命名空间
			XPath xsub=doc.createXPath("//ns:beans/ns:bean"); // 创建 beans/bean的查询路径
			xsub.setNamespaceURIs(nsMap); // 设置命名空间
			List beans=xsub.selectNodes(doc); // 获取文档下的所有bean节点
			for(Object node : beans){
				Element element=(Element)node;
				String id=element.attributeValue("id");
				String className=element.attributeValue("class");
				BeanDefinition bean=new BeanDefinition(id,className);
 
				// 编码剖析Spring依赖注入的原理
				// 加载bean下的Property
				XPath xproperty=element.createXPath("ns:property"); // 为xproperty 添加查询路径
				xproperty.setNamespaceURIs(nsMap);
				List properties=xproperty.selectNodes(element); // 查询出bean下的所有property
				for(Object propertyNode : properties){
					Element propertyElement=(Element)propertyNode;
					String name=propertyElement.attributeValue("name");
					String ref=propertyElement.attributeValue("ref");
					bean.getProperties().add(new PropertyDefinition(name, ref));
				}
				list.add(bean);
			}
 
		}catch(Exception e){
			e.printStackTrace();
		}
	}
	// 通过Id名称，获取Bean
	public Object getBean(String name){
		return beans.get(name);
	}
}

测试代码：

	@Test
	public void testSave2() {
		OtherClassPathXMLApplicationContext ac = new OtherClassPathXMLApplicationContext("beans.xml");
		PersonIService personIService=(PersonIService)ac.getBean("personIService");
		personIService.save();
	}