`

Spring的IOC机制

Spring IOC 
阅读更多

         IOC，直观地讲，就是容器控制程序之间的关系，而非传统实现中，由程序代码直接操控。这也就是所谓“控制反转”的概念所在。控制权由应用代码中转到了外部容器，控制权的转移是所谓反转。IoC还有另外一个名字——“依赖注入（Dependency Injection）”。从名字上理解，所谓依赖注入，即组件之间的依赖关系由容器在运行期决定，形象地说，即由容器动态地将某种依赖关系注入到组件之中。 

         下面我根据spring源码 简单实现自己的依赖注入  通过xml形式配置   在对象中获取xml文件 获取定义好的bean 从而对bean对应的class 实现实例化   使用接口形式

 

接口

 

Java代码 复制代码 收藏代码
  1. public interface PersonDao {   
  2.   
  3.     public void add();   
  4.   
  5. }  
public interface PersonDao {

	public void add();

}
 

实现类

Java代码 复制代码 收藏代码
  1. package cn.leam.dao.impl;   
  2.   
  3. import cn.leam.dao.PersonDao;   
  4.   
  5. public class PersonDaoBean implements PersonDao {   
  6.     public void add(){   
  7.         System.out.println("执行add()方法");   
  8.     }   
  9. }  
package cn.leam.dao.impl;

import cn.leam.dao.PersonDao;

public class PersonDaoBean implements PersonDao {
	public void add(){
		System.out.println("执行add()方法");
	}
}
 

服务接口

Java代码 复制代码 收藏代码
  1. public interface PersonService {   
  2.   
  3.     public void save();   
  4.   
  5. }  
public interface PersonService {

	public void save();

}

 

服务实现类

Java代码 复制代码 收藏代码
  1. public class PersonServiceBean implements PersonService {   
  2.     private PersonDao personDao;   
  3.        
  4.     public PersonDao getPersonDao() {   
  5.         return personDao;   
  6.     }   
  7.   
  8.     public void setPersonDao(PersonDao personDao) {   
  9.         this.personDao = personDao;   
  10.     }   
  11.        
  12.     public void save(){   
  13.         personDao.add();   
  14.     }   
  15. }  
public class PersonServiceBean implements PersonService {
	private PersonDao personDao;
	
	public PersonDao getPersonDao() {
		return personDao;
	}

	public void setPersonDao(PersonDao personDao) {
		this.personDao = personDao;
	}
	
	public void save(){
		personDao.add();
	}
}
 

 

首先配置beans.xml    配置DAO,SERVICE实现类

 

Xml代码 复制代码 收藏代码
  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">  
  6.            <bean id="personDao" class="cn.leam.dao.impl.PersonDaoBean"></bean>  
  7.           <bean id="personService" class="cn.leam.service.impl.PersonServiceBean">  
  8.             <property name="personDao" ref="personDao"></property>  
  9.           </bean>  
  10. </beans>   
<?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="personDao" class="cn.leam.dao.impl.PersonDaoBean"></bean>
          <bean id="personService" class="cn.leam.service.impl.PersonServiceBean">
          	<property name="personDao" ref="personDao"></property>
          </bean>
</beans>
 

 

 

下面模拟spring对xml配置的类进行实例化

 

存放属性的对象

Java代码 复制代码 收藏代码
  1. public class prosDefinition {   
  2.     private String name;   
  3.     private String ref;   
  4.        
  5.     public ProsDefinition(String name, String ref) {   
  6.         this.name = name;   
  7.         this.ref = ref;   
  8.     }   
  9.        
  10.     public String getName() {   
  11.         return name;   
  12.     }   
  13.     public void setName(String name) {   
  14.         this.name = name;   
  15.     }   
  16.     public String getRef() {   
  17.         return ref;   
  18.     }   
  19.     public void setRef(String ref) {   
  20.         this.ref = ref;   
  21.     }   
  22.        
  23. }  
public class prosDefinition {
	private String name;
	private String ref;
	
	public ProsDefinition(String name, String ref) {
		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;
	}
	
}
 

 

存放bean的 对象

Java代码 复制代码 收藏代码
  1. public class Definition {   
  2.     private String id;   
  3.     private String className;   
  4.     private List<ProsDefinition> propertys = new ArrayList<ProsDefinition>();   
  5.        
  6.     public Definition(String id, String className) {   
  7.         this.id = id;   
  8.         this.className = className;   
  9.     }   
  10.     public String getId() {   
  11.         return id;   
  12.     }   
  13.     public void setId(String id) {   
  14.         this.id = id;   
  15.     }   
  16.     public String getClassName() {   
  17.         return className;   
  18.     }   
  19.     public void setClassName(String className) {   
  20.         this.className = className;   
  21.     }   
  22.     public List<PropertyDefinition> getPropertys() {   
  23.         return propertys;   
  24.     }   
  25.     public void setPropertys(List<PropertyDefinition> propertys) {   
  26.         this.propertys = propertys;   
  27.     }   
  28.        
  29. }  
public class Definition {
	private String id;
	private String className;
	private List<ProsDefinition> propertys = new ArrayList<ProsDefinition>();
	
	public Definition(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> getPropertys() {
		return propertys;
	}
	public void setPropertys(List<PropertyDefinition> propertys) {
		this.propertys = propertys;
	}
	
}
 

 

这里是关键点  所有代码都在这里    使用dom4j 解析xml文件中的bean  并获取id和class  再判断元素中是否有引用元素对其一并获取出来存放才Map中 利用java反射一个一个进行实例化

Java代码 复制代码 收藏代码
  1. /**  
  2.  * 学习版容器  
  3.  *  
  4.  */  
  5. public class LeamClassPathXMLApplicationContext {   
  6.     private List<Definition> beanDefines = new ArrayList<Definition>();   
  7.     private Map<String, Object> sigletons = new HashMap<String, Object>();   
  8.        
  9.     public LeamClassPathXMLApplicationContext(String filename){   
  10.         this.readXML(filename);   
  11.         this.instanceBeans();   
  12.         this.injectObject();   
  13.     }   
  14.     /**  
  15.      * 为bean对象的属性注入值  
  16.      */  
  17.     private void injectObject() {   
  18.         for(Definition beanDefinition : beanDefines){   
  19.             Object bean = sigletons.get(beanDefinition.getId());   
  20.             if(bean!=null){   
  21.                 try {   
  22.                     PropertyDescriptor[] ps = Introspector.getBeanInfo(bean.getClass())   
  23.                                                       .getPropertyDescriptors();   
  24.                     for(ProsDefinition propertyDefinition : beanDefinition.getPropertys()){   
  25.                         for(PropertyDescriptor properdesc : ps){   
  26.                         if(propertyDefinition.getName().equals(properdesc.getName())){   
  27.                                 Method setter = properdesc.getWriteMethod();   
  28.                                     //获取属性的setter方法 ,private   
  29.                                 if(setter!=null){   
  30.                                 Object value = sigletons.get(propertyDefinition.getRef());   
  31.                                 setter.invoke(bean, value);//把引用对象注入到属性   
  32.                                 }   
  33.                                 break;   
  34.                             }   
  35.                         }   
  36.                     }   
  37.                 } catch (Exception e) {   
  38.                 }   
  39.             }   
  40.         }   
  41.     }   
  42.     /**  
  43.      * 完成bean的实例化  
  44.      */  
  45.     private void instanceBeans() {   
  46.         for(Definition beanDefinition : beanDefines){   
  47.             try {   
  48.                 if(beanDefinition.getClassName()!=null && !"".   
  49.                                    equals(beanDefinition.getClassName().trim()))   
  50.                               sigletons.put(beanDefinition.getId(),    
  51.                                   Class.forName(beanDefinition.getClassName()).newInstance());   
  52.             } catch (Exception e) {   
  53.                 e.printStackTrace();   
  54.             }   
  55.         }   
  56.            
  57.     }   
  58.     /**  
  59.      * 读取xml配置文件  
  60.      * @param filename  
  61.      */  
  62.     private void readXML(String filename) {   
  63.            SAXReader saxReader = new SAXReader();      
  64.             Document document=null;      
  65.             try{   
  66.              URL xmlpath = this.getClass().getClassLoader().getResource(filename);   
  67.              document = saxReader.read(xmlpath);   
  68.              Map<String,String> nsMap = new HashMap<String,String>();   
  69.              nsMap.put("ns","http://www.springframework.org/schema/beans");//加入命名空间   
  70.                  //创建beans/bean查询路径         
  71.                 XPath xsub = document.createXPath("//ns:beans/ns:bean");   
  72.              xsub.setNamespaceURIs(nsMap);//设置命名空间   
  73.              List<Element> beans = xsub.selectNodes(document);//获取文档下所有bean节点    
  74.              for(Element element: beans){   
  75.                 String id = element.attributeValue("id");//获取id属性值   
  76.                 String clazz = element.attributeValue("class"); //获取class属性值           
  77.                 BeanDefinition beanDefine = new BeanDefinition(id, clazz);   
  78.                 XPath propertysub =  element.createXPath("ns:property");   
  79.                 propertysub.setNamespaceURIs(nsMap);//设置命名空间   
  80.                 List<Element> propertys = propertysub.selectNodes(element);   
  81.                 for(Element property : propertys){                     
  82.                         //元素内部引用的属性也获取   
  83.                     String propertyName = property.attributeValue("name");   
  84.                     String propertyref = property.attributeValue("ref");   
  85.                     ProsDefinition propertyDefinition =    
  86.                          new ProsDefinition(propertyName, propertyref);   
  87.                     beanDefine.getPropertys().add(propertyDefinition);   
  88.                 }   
  89.                 beanDefines.add(beanDefine);   
  90.              }    
  91.             }catch(Exception e){      
  92.                 e.printStackTrace();   
  93.             }   
  94.     }   
  95.     /**  
  96.      * 获取bean实例  
  97.      * @param beanName  
  98.      * @return  
  99.      */  
  100.     public Object getBean(String beanName){   
  101.         return this.sigletons.get(beanName);   
  102.     }   
  103. }  
/**
 * 学习版容器
 *
 */
public class LeamClassPathXMLApplicationContext {
	private List<Definition> beanDefines = new ArrayList<Definition>();
	private Map<String, Object> sigletons = new HashMap<String, Object>();
	
	public LeamClassPathXMLApplicationContext(String filename){
		this.readXML(filename);
		this.instanceBeans();
		this.injectObject();
	}
	/**
	 * 为bean对象的属性注入值
	 */
	private void injectObject() {
		for(Definition beanDefinition : beanDefines){
			Object bean = sigletons.get(beanDefinition.getId());
			if(bean!=null){
				try {
					PropertyDescriptor[] ps = Introspector.getBeanInfo(bean.getClass())
                                                      .getPropertyDescriptors();
					for(ProsDefinition propertyDefinition : beanDefinition.getPropertys()){
						for(PropertyDescriptor properdesc : ps){
						if(propertyDefinition.getName().equals(properdesc.getName())){
								Method setter = properdesc.getWriteMethod();
                                    //获取属性的setter方法 ,private
								if(setter!=null){
								Object value = sigletons.get(propertyDefinition.getRef());
								setter.invoke(bean, value);//把引用对象注入到属性
								}
								break;
							}
						}
					}
				} catch (Exception e) {
				}
			}
		}
	}
	/**
	 * 完成bean的实例化
	 */
	private void instanceBeans() {
		for(Definition beanDefinition : beanDefines){
			try {
				if(beanDefinition.getClassName()!=null && !"".
                                   equals(beanDefinition.getClassName().trim()))
	                          sigletons.put(beanDefinition.getId(), 
                                  Class.forName(beanDefinition.getClassName()).newInstance());
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		
	}
	/**
	 * 读取xml配置文件
	 * @param filename
	 */
	private void readXML(String filename) {
	       SAXReader saxReader = new SAXReader();   
	        Document document=null;   
	        try{
	         URL xmlpath = this.getClass().getClassLoader().getResource(filename);
	         document = saxReader.read(xmlpath);
	         Map<String,String> nsMap = new HashMap<String,String>();
	         nsMap.put("ns","http://www.springframework.org/schema/beans");//加入命名空间
                 //创建beans/bean查询路径      
                XPath xsub = document.createXPath("//ns:beans/ns:bean");
	         xsub.setNamespaceURIs(nsMap);//设置命名空间
	         List<Element> beans = xsub.selectNodes(document);//获取文档下所有bean节点 
	         for(Element element: beans){
	            String id = element.attributeValue("id");//获取id属性值
	            String clazz = element.attributeValue("class"); //获取class属性值        
	            BeanDefinition beanDefine = new BeanDefinition(id, clazz);
	            XPath propertysub =  element.createXPath("ns:property");
	            propertysub.setNamespaceURIs(nsMap);//设置命名空间
	            List<Element> propertys = propertysub.selectNodes(element);
	            for(Element property : propertys){	            	
                        //元素内部引用的属性也获取
	            	String propertyName = property.attributeValue("name");
	            	String propertyref = property.attributeValue("ref");
	            	ProsDefinition propertyDefinition = 
                         new ProsDefinition(propertyName, propertyref);
	            	beanDefine.getPropertys().add(propertyDefinition);
	            }
	            beanDefines.add(beanDefine);
	         } 
	        }catch(Exception e){   
	            e.printStackTrace();
	        }
	}
	/**
	 * 获取bean实例
	 * @param beanName
	 * @return
	 */
	public Object getBean(String beanName){
		return this.sigletons.get(beanName);
	}
}

 

上面简单的依赖注入 基本完成 当然spring的源码会管家复杂  我们主要是理解其思想  下面我们来测试

 

Java代码 复制代码 收藏代码
  1. public class SpringTest {   
  2.   
  3.     @BeforeClass  
  4.     public static void setUpBeforeClass() throws Exception {   
  5.     }   
  6.   
  7.     @Test public void instanceSpring(){   
  8.         LeamClassPathXMLApplicationContext ctx = new  
  9.                                       LeamClassPathXMLApplicationContext("beans.xml");   
  10.         PersonService personService = (PersonService)ctx.getBean("personService");   
  11.         personService.save();          
  12.     }   
  13. }  
public class SpringTest {

	@BeforeClass
	public static void setUpBeforeClass() throws Exception {
	}

	@Test public void instanceSpring(){
		LeamClassPathXMLApplicationContext ctx = new
                                      LeamClassPathXMLApplicationContext("beans.xml");
		PersonService personService = (PersonService)ctx.getBean("personService");
		personService.save();		
	}
}

 

 

 

最终输出 说明实例化成功

 

执行add()方法

分享到：
| 利用反射机制模拟Hibernate的Session
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    实验一 Springioc基本操作.docx

    SpringIOC是Spring Framework中的核心组件之一，负责管理应用程序中的对象、依赖关系和生命周期。 在 Spring IOC 中，对象的创建和管理是通过 BeanFactory 或 ApplicationContext 实现的。BeanFactory 是 Spring ...

    spring ioc和aop原理流程图(详细)

    Spring 框架是Java开发中的核心框架，它主要由两...Spring的IOC和AOP机制使得开发者能够更专注于业务逻辑，而不是繁琐的依赖管理和横切关注点。了解和掌握这两个核心概念，对于高效地使用Spring框架进行开发至关重要。

    SpringIOC和AOP实现机制模拟

    通过这些机制，Spring的IOC和AOP不仅简化了对象的管理和关注点的分离，还提升了代码的可读性和可维护性。在实际项目中，结合使用Spring的IOC和AOP，我们可以构建出松散耦合、易于扩展的应用系统。例如，通过AOP处理...

    Spring IoC加载流程讲解

    Spring IoC 加载流程讲解 在本节中，我们将对 Spring IoC 加载流程进行详细的讲解，并探讨 IoC 思想和...通过了解 Spring IoC 加载流程，我们可以更好地理解 Spring 的核心机制，并更好地使用 Spring 框架进行开发。

    SpringIoc示例代码

    Spring IOC，全称Inversion of Control，即“控制反转”，是Spring框架的核心特性之一。在传统的Java应用程序中，对象的创建和...同时，这样的测试也有助于理解和学习Spring IOC的工作机制，提升对Spring框架的理解。

    spring ioc

    标题 "Spring IOC" 描述了我们讨论的核心主题——Spring 框架中的依赖注入（Inversion of Control，简称 IOC）机制。Spring 是一个广泛应用的 Java 应用开发框架，其核心特性之一就是IOC，它极大地简化了软件组件...

    Spring IOC.pdf

    IOC的设计模式是实现控制反转的机制，具体来说是一种称为“依赖注入”（Dependency Injection，简称DI）的模式。依赖注入是在运行期，由外部容器动态地将依赖关系注入到组件中。主要有以下几种依赖注入方式： 1. ...

    springioc和spring aop

    Spring通过反射机制来实现这一过程，比如在上述的`TestIOC`例子中，Spring能够根据类名动态地创建对象，并通过setter方法注入属性值，实现了对象的实例化和配置。 **依赖注入（DI）**有多种实现方式，包括构造器...

    简洁版的spring ioc自行实现 研究spring 加载机制

    简洁版的spring ioc自行实现，不到10个类，描述了加载机制，是研究IOC DI的好材料，能够了解IOC原理。目标是了解基本原理，所以没考虑循环引用的情况 完整的ECLIPSE工程，直接导入就可使用。 里面有测试例子，单步...

    Spring IoC源码深度剖析开源架构源码2021.pdf

    标题《Spring IoC源码深度剖析开源架构源码2021.pdf》和描述《Spring IoC源码深度剖析开源架构源码2021.pdf》表明该文档主要面向于分析Spring框架中控制反转（IoC）容器的核心源码，解析和理解其内部的工作机制及...

    Java反射_Spring IOC

    Java反射和Spring IOC是Java开发中的两个重要概念，它们在构建灵活、可扩展的应用程序时起着关键作用。本文将深入探讨这两个主题，并提供相关的学习资源。 首先，让我们了解一下Java反射。Java反射机制是Java语言的...

    springioc的详细讲解

    综上所述，Spring的IOC容器是通过控制反转和依赖注入实现的一种高级组件管理机制，它极大地简化了Java应用的复杂性，促进了松耦合和可测试性的提升。理解并熟练运用Spring IOC容器是掌握Spring框架的关键。通过阅读...

    以注解方式模拟Spring IoC AOP

    本篇将深入探讨如何通过注解方式来模拟Spring的这两种机制，帮助你理解其底层原理。 ### 1. 依赖注入（IoC） 依赖注入是Spring框架的核心特性之一，它通过反转对象创建和管理的控制权，使得应用程序组件之间的耦合...

    spring ioc+mvc代码

    《深入理解Spring IOC+MVC：从零构建自己的框架》 在软件开发领域，Spring框架因其强大的功能和灵活性而备受推崇，特别是其核心的控制反转（IOC）和模型视图控制器（MVC）设计模式。本文将通过分析并实现一个简化版...

    Spring ioc源码解读

    ### Spring IoC源码解读 #### 一、Spring IoC 容器概述 Spring框架的核心功能之一便是依赖注入（Dependency Injection, DI），而这一功能主要通过IoC容器来实现。在Spring框架中，IoC容器负责管理应用对象的生命...

    模拟spring IOC非常好的事例

    接下来，Spring的DI机制会在运行时自动装配这些bean。当创建`exampleBean`时，Spring会查找并注入`dependencyBean`的实例，而无需在`ExampleClass`的构造函数或初始化方法中显式地创建它。这使得代码更简洁，更易于...

    spring ioc以及事物架构图

    Spring的IoC容器和事务管理机制为Java开发者提供了一套完整的解决方案，极大地简化了应用开发过程。通过对容器初始化流程及关键组件的理解，可以帮助开发者更好地利用Spring框架的各项功能，提升应用的性能和稳定性...

    Spring-ioc-jar

    5. **生命周期管理**: Spring容器还提供了对Bean生命周期的管理，包括初始化回调、销毁回调、Bean的后处理器等机制，允许开发者在特定阶段插入自定义逻辑。 6. **AOP代理**: Spring的IOC容器与AOP框架紧密集成，...

    Spring IoC简单示例-注解配置-Maven构建

    在本文中，我们将深入探讨Spring框架的核心特性——控制反转（Inversion of Control，简称IoC）和依赖注入（Dependency Injection，简称DI），以及如何通过注解配置和Maven项目构建来实现这一概念。Spring框架是Java...

    反射模拟springIOC.rar

    1. **配置文件解析**：在`springIOC_0602`项目中，我们有一个XML配置文件，它定义了bean的声明和它们的依赖。JDOM库被用来读取这个文件，解析bean的定义，包括bean的类名、属性、依赖等。 2. **Bean的创建**：解析...

Magicbox
Global site tag (gtag.js) - Google Analytics