(3) 利用 Setter方式实现 【第一种方式】 依赖注入,编码剖析Spring依赖注入的原理

设计模式 前端之家
前端之家收集整理的这篇文章主要介绍了(3) 利用 Setter方式实现 【第一种方式】 依赖注入,编码剖析Spring依赖注入的原理，前端之家小编觉得挺不错的，现在分享给大家，也给大家做个参考。
[java] view plain copy print ?
  1. import cn.itm.dao.PersonDao;
  4. public class PersonDaoBean implements PersonDao {
  7. public void add(){
  8. System.out.println("执行PersonDaoBean的add方法。。。");
  9. }
  10. }



[java] view plain copy print ?
  1. package cn.itm.dao;
  3. public interface PersonDao {
  5. public abstract void add();
  7. }


[java] view plain copy print ?
  1. package cn.itm.service.impl;
  3. import cn.itm.dao.PersonDao;
  4. import cn.itm.service.PersonService;
  6. public class PersonServiceBean implements PersonService{
  8. // 使用 Set方法 是实现依赖注入：
  9. private PersonDao personDao;
  12. public void setPersonDao(PersonDao personDao) {
  13. this.personDao = personDao;
  14. }
  17. public void save(){
  18. // 调用 依赖对象注入进来的方法了。
  19. personDao.add();
  20. }
  22. }


[java] view plain copy print ?
  1. package cn.itm.service;
  3. public interface PersonService {
  5. public abstract void save();
  7. }

[java] view plain copy print ?
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4. xsi:schemaLocation="http://www.springframework.org/schema/beans
  5. http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
  7. <bean id="personDao" class="cn.itm.dao.impl.PersonDaoBean"></bean>
  9. <bean id="personService" class="cn.itm.service.impl.PersonServiceBean" >
  10. <!-- 实现 注入 -->
  11. <property name="personDao" ref="personDao"></property>
  12. </bean>
  15. </beans>


测试类：

[java] view plain copy print ?
  1. package junit.test;
  4. import org.junit.BeforeClass;
  5. import org.junit.Test;
  6. import org.springframework.context.ApplicationContext;
  7. import org.springframework.context.support.ClassPathXmlApplicationContext;
  9. import cn.itm.service.PersonService;
  11. public class SpringTest {
  13. @BeforeClass
  14. public static void setUpBeforeClass() throws Exception {
  15. }
  17. // 专门用来实例化 Spring 容器的。
  18. @Test public void instanceSpring(){
  20. ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
  21. PersonService personService = (PersonService) ctx.getBean("personService");
  22. personService.save();
  24. }
  25. }

成功。


利用setter方式的好处：可以被多个bean使用。



下面利用编码剖析Spring依赖注入的原理：


[java] view plain copy print ?
  1. package junit.test;
  4. import java.beans.Introspector;
  5. import java.beans.PropertyDescriptor;
  6. import java.lang.reflect.Method;
  7. import java.net.URL;
  8. import java.util.ArrayList;
  9. import java.util.HashMap;
  10. import java.util.List;
  11. import java.util.Map;
  13. import org.dom4j.Document;
  14. import org.dom4j.Element;
  15. import org.dom4j.XPath;
  16. import org.dom4j.io.SAXReader;
  18. public class ItmClassPathXMLApplicationContext {
  20. private List<BeanDefinition> beanDefines = new ArrayList<BeanDefinition>();
  21. // 存放实例
  22. private Map<String,Object> sigletons = new HashMap<String,Object>();
  24. public ItmClassPathXMLApplicationContext(String fileName){
  25. this.readXML(fileName);
  26. this.instanceBeans();
  27. this.injectObject();
  28. }
  30. private void injectObject() {
  31. for(BeanDefinition beanDefinition : beanDefines){
  32. // 得到 bean 。。
  33. Object bean = sigletons.get(beanDefinition.getId());
  34. if(bean != null){
  35. try {
  36. // 得到 bean的属性描述：
  37. PropertyDescriptor[] ps = Introspector.getBeanInfo(bean.getClass()).getPropertyDescriptors();
  38. // 循环 bean里面的 所有的属性：
  39. for( PropertyDefinition propertyDefinition: beanDefinition.getPropertys()){
  40. for(PropertyDescriptor propertyDesc /*这里是 bean 里面的属性*/ : ps){
  41. if(propertyDefinition.getName().equals(propertyDesc.getName())){
  42. // 如果相等 说明是存在 于 这个bean的。。。
  43. Method setter = propertyDesc.getWriteMethod(); // 获取属性的 setter方法。
  44. // 最好做一下判断：
  45. if(setter != null){
  46. Object value = sigletons.get(propertyDefinition.getRef());
  47. setter.setAccessible(true); // 允许访问 私有的方法。。
  48. setter.invoke(bean,value);// 把引用对象注入到属性。
  49. }
  50. break;
  51. }
  52. }
  53. }
  54. } catch (Exception e) {
  55. e.printStackTrace();
  56. }
  57. }
  58. }
  59. }
  61. /**
  62. * 通过反射技术，完成 bean 的实例化：
  63. */
  64. private void instanceBeans() {
  65. for(BeanDefinition beanDefinition : beanDefines){
  66. try {
  67. if(beanDefinition.getClassName() != null && !"".equals(beanDefinition.getClassName().trim())){
  68. sigletons.put(beanDefinition.getId(),Class.forName(beanDefinition.getClassName()).newInstance());
  69. }
  70. } catch (Exception e) {
  71. e.printStackTrace();
  72. }
  73. }
  75. }
  79. /**
  80. * 读取 XML 的配置文件：
  81. * @param fileName
  82. */
  83. @SuppressWarnings("unchecked")
  84. private void readXML(String fileName) {
  85. // 创建读取器：
  86. SAXReader saxReader = new SAXReader();
  87. Document document = null;
  89. try{
  90. URL xmlPath = this.getClass().getClassLoader().getResource(fileName);
  91. document = saxReader.read(xmlPath); // 读取文件的内容。。。
  93. Map<String,String> nsMap = new HashMap<String,String>();
  94. nsMap.put("ns","http://www.springframework.org/schema/beans"); // 加入命名空间
  96. // 创建beans/bean 查询路径。
  97. XPath xsub = document.createXPath("//ns:beans/ns:bean");
  99. // 设置命名空间。
  100. xsub.setNamespaceURIs(nsMap);
  102. // 获取文档下 所有bean节点：
  103. List<Element> beans = xsub.selectNodes(document);
  104. for(Element element : beans){
  105. String id = element.attributeValue("id"); // 获取id属性值。
  106. String clazz = element.attributeValue("class"); // 获取 class 属性值。
  107. BeanDefinition beanDefine = new BeanDefinition(id,clazz);
  109. // 查询的相对路径：
  110. XPath propertysub = element.createXPath("ns:property");
  111. propertysub.setNamespaceURIs(nsMap);// 设置命名空间。
  113. List<Element> propertys = propertysub.selectNodes(element);
  114. for(Element property : propertys){
  115. String propertyName = property.attributeValue("name");
  116. String propertyRef = property.attributeValue("ref");
  117. System.out.println(propertyName + "==" + propertyRef);
  118. PropertyDefinition propertyDefinition = new PropertyDefinition(propertyName,propertyRef);
  120. // 放到 bean里面去：
  121. beanDefine.getPropertys().add(propertyDefinition);
  123. }
  124. beanDefines.add(beanDefine);
  125. }
  127. }catch(Exception e){
  128. e.printStackTrace();
  129. }
  130. }
  133. /**
  134. * 获取 bean实例
  135. * @param beanName
  136. * @return
  137. */
  138. public Object getBean(String beanName){
  139. return this.sigletons.get(beanName);
  140. }
  142. }

原文链接：https://www.f2er.com/javaschema/286743.html

猜你在找的设计模式相关文章

适配器模式-让不兼容的接口得以适配
适配器模式将一个类的接口转换成客户期望的另一个接口，使得原本接口不兼容的类可以相互合...
策略模式-定义一个算法族
策略模式定义了一系列算法族，并封装在类中，它们之间可以互相替换，此模式让算法的变化独...
设计模式之高质量代码
设计模式讲的是如何编写可扩展、可维护、可读的高质量代码，它是针对软件开发中经常遇到的...
模板方法模式-封装一套算法流程
模板方法模式在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中，使得子类可以在...
迭代器模式-统一集合的遍历方式
迭代器模式提供了一种方法，用于遍历集合对象中的元素，而又不暴露其内部的细节。
单例模式的五种实现方式及优缺点
单例模式（Singleton Design Pattern）保证一个类只能有一个实例，并提供一个全局访问点。
组合模式-统一的处理个别对象与组合对象
组合模式可以将对象组合成树形结构来表示“整体-部分”的层次结构，使得客户可以用一致的方...
装饰者模式-动态的包装原有对象的行为
装饰者模式能够更灵活的，动态的给对象添加其它功能，而不需要修改任何现有的底层代码。
观察者模式-将消息通知给观察者
观察者模式（Observer Design Pattern）定义了对象之间的一对多依赖，当对象状态改变的时候...
代理模式-访问对象的代理而非其本身
代理模式为对象提供一个代理，来控制对该对象的访问。代理模式在不改变原始类代码的情况下...
算法设计模式多媒体技术正则表达式ElasticsearchFlinkHadoopIDE
受约束摘*day25Java常用类库置信lamda留存持续录入年后正则表达式303.17regularexpre匹多模适20130322基础理论pathmunge涵义reectok需要转义的特资源分享validationex简明魔法里弄形如源码实现完备actionscript