`
啸笑天
  • 浏览: 3466040 次
  • 性别: Icon_minigender_1
  • 来自: China
社区版块
存档分类
最新评论

java模拟spring ioc

阅读更多

 

<?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="junit.test12.PersonDaoBean"/>
          <bean id="personService" class="junit.test12.PersonServiceBean">
           	<property name="id" value="24"/>
          	<property name="name" value="zyj"/>
          	<!--  <property name="personDao" ref="personDao"/> -->
          </bean>
</beans>

 

package junit.test12;

import java.util.ArrayList;
import java.util.List;

/**
 * xml中的<bean/>的定义
 * @author Administrator
 *
 */
public class BeanDefinition {
	private String id;
	private String clazz;
	private List<PropertyDefinition> propertyDefinitions=new ArrayList<PropertyDefinition>();
	
	
	public BeanDefinition(String id, String clazz) {
		super();
		this.id = id;
		this.clazz = clazz;
	}
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public String getClazz() {
		return clazz;
	}
	public void setClazz(String clazz) {
		this.clazz = clazz;
	}
	public List<PropertyDefinition> getPropertyDefinitions() {
		return propertyDefinitions;
	}
	public void setPropertyDefinitions(List<PropertyDefinition> propertyDefinitions) {
		this.propertyDefinitions = propertyDefinitions;
	}
	

	
	
} 

 

 

package junit.test12;

public class PropertyDefinition {
	private String name;
	private String ref;
	private String value;
	
	public PropertyDefinition(String name, String ref,String value) {
		super();
		this.name = name;
		this.ref = ref;
		this.value=value;
	}

	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;
	}

	public String getValue() {
		return value;
	}

	public void setValue(String value) {
		this.value = value;
	}
	
	
	
	
	
	
}

 

 

 

package junit.test12;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD,ElementType.METHOD})
public @interface UserDefinedResource {
	public String name() default "";
}
 

//使用dom4j读取spring配置文件

package junit.test12;

import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import junit.test12.BeanDefinition;

import org.apache.commons.beanutils.ConvertUtils;
import org.apache.commons.beanutils.Converter;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.XPath;
import org.dom4j.io.SAXReader;
/**
 * 自定义容器
 * @author Administrator
 *
 */
public class UserDefinedClassPathXMLApplicationContext {
	private List<BeanDefinition> beanDefinitions=new ArrayList<BeanDefinition>();
	private Map<String, Object> sigletons=new HashMap<String, Object>();
	
	public UserDefinedClassPathXMLApplicationContext(String filename){
		this.readXML(filename);
		this.instanceBeans();
		this.annotationInject();
		this.injectObject();
	}
	


	/**
	 * 读取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);
			XPath xPath=document.createXPath("//ns:beans/ns:bean");//创建beans/bean查询路径。从根路径开始
			Map<String, String> nsMap=new HashMap<String, String>();
			nsMap.put("ns", "http://www.springframework.org/schema/beans");//加入命名空间
			xPath.setNamespaceURIs(nsMap);//设置命名空间
			List<Element> beans=xPath.selectNodes(document);//获取文档下所有bean节点 
			for (Element element : beans) {
				String id=element.attributeValue("id");
				String clazz=element.attributeValue("class");
				BeanDefinition beanDefinition=new BeanDefinition(id, clazz);
				XPath xPath2=element.createXPath("ns:property");//从相对路径开始
				xPath2.setNamespaceURIs(nsMap);
				List<Element> propertys=xPath2.selectNodes(element);
				for (Element element2 : propertys) {
					String name=element2.attributeValue("name");
					String ref=element2.attributeValue("ref");
					String value=element2.attributeValue("value");
					PropertyDefinition propertyDefinition=new PropertyDefinition(name, ref,value);
					beanDefinition.getPropertyDefinitions().add(propertyDefinition);
				}
				beanDefinitions.add(beanDefinition);
			}	
		} catch (DocumentException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}	
	/**
	 * 完成bean的实例化
	 */
	private void instanceBeans(){
		try {
			for (BeanDefinition beanDefinition : beanDefinitions) {
				if (beanDefinition.getClazz()!=null&&!"".equals(beanDefinition.getClazz().trim())) {
					sigletons.put(beanDefinition.getId(), Class.forName(beanDefinition.getClazz()).newInstance());
				}
			}
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (InstantiationException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	/**
	 * 为bean对象的属性注入值
	 * @throws IntrospectionException 
	 * @throws InvocationTargetException 
	 * @throws IllegalAccessException 
	 * @throws IllegalArgumentException 
	 */
	private void injectObject()  {
		try {
			for (BeanDefinition beanDefinition : beanDefinitions) {
				Object bean=sigletons.get(beanDefinition.getId());
				if (bean!=null) {
					PropertyDescriptor[] ps=Introspector.getBeanInfo(bean.getClass()).getPropertyDescriptors();
					for(PropertyDefinition propertyDefinition:beanDefinition.getPropertyDefinitions()){
					for (PropertyDescriptor propertyDescriptor : ps) {
						if (propertyDefinition.getName().equals(propertyDescriptor.getName())) {
							Method setterMethod=propertyDescriptor.getWriteMethod();//获取属性的setter方法
							if (setterMethod!=null) {
								Object temp=null;
								if (propertyDefinition.getRef()!=null&&!"".equals(propertyDefinition.getRef().trim())) {
									temp=sigletons.get(propertyDefinition.getRef());
								}else if (propertyDefinition.getValue()!=null&&!"".equals(propertyDefinition.getValue().trim())) {
									temp=ConvertUtils.convert(propertyDefinition.getValue(), propertyDescriptor.getPropertyType());
								}
							setterMethod.setAccessible(true);//防止setter方法为private
							setterMethod.invoke(bean, temp);//把引用对象注入到属性
							}
							break;
						}
					}
					}
				}
				
			}
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	/**
	 * 通过注解实现注入依赖对象
	 * @throws IntrospectionException 
	 * @throws InvocationTargetException 
	 * @throws IllegalAccessException 
	 * @throws IllegalArgumentException 
	 */
	private void annotationInject(){
		try {
			for (String beanName : sigletons.keySet()) {
				Object bean=sigletons.get(beanName);
				if (bean!=null) {
					PropertyDescriptor[] ps=Introspector.getBeanInfo(bean.getClass()).getPropertyDescriptors();
					for (PropertyDescriptor propertyDescriptor : ps) {
					Method setterMethod=propertyDescriptor.getWriteMethod();
					if (setterMethod!=null&&setterMethod.isAnnotationPresent(UserDefinedResource.class)) {
						UserDefinedResource userDefinedResource=setterMethod.getAnnotation(UserDefinedResource.class);
						Object temp = null;
						if(userDefinedResource.name()!=null && !"".equals(userDefinedResource.name())){
							//一旦指定了name属性,就只能按名称装配了
							temp = sigletons.get(userDefinedResource.name());
						}else{
							temp = sigletons.get(propertyDescriptor.getName());
							if(temp==null){
								for(String key : sigletons.keySet()){
									if(propertyDescriptor.getPropertyType().isAssignableFrom(sigletons.get(key).getClass())){
										temp = sigletons.get(key);
										break;
									}
								}
							}								
						}
						setterMethod.setAccessible(true);
						setterMethod.invoke(bean, temp);//把引用对象注入到属性
					}
					}
					
					Field[] fields = bean.getClass().getDeclaredFields();
					for(Field field : fields){
						if(field.isAnnotationPresent(UserDefinedResource.class)){
							UserDefinedResource userDefinedResource = field.getAnnotation(UserDefinedResource.class);
							Object temp = null;
							if(userDefinedResource.name()!=null && !"".equals(userDefinedResource.name())){
								temp = sigletons.get(userDefinedResource.name());
							}else{
								temp = sigletons.get(field.getName());
								if(temp==null){
									for(String key : sigletons.keySet()){
										if(field.getType().isAssignableFrom(sigletons.get(key).getClass())){
											temp = sigletons.get(key);
											break;
										}
									}
								}								
							}
							field.setAccessible(true);//允许访问private字段
							field.set(bean, temp);
						}
					}
					
				}
			}
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} 
	}
	
	
	/**
	 * 获取bean实例
	 * @param beanName
	 * @return
	 */
	public Object getBean(String beanName){
		return this.sigletons.get(beanName);
	}
	
}
 

 

package junit.test12;

import static org.junit.Assert.*;
import junit.test12.PersonService;
import junit.test12.UserDefinedClassPathXMLApplicationContext;

import org.junit.Test;

public class SpringTest {

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

}
 

 

 

 

 

 

 

分享到:
评论

相关推荐

    以注解方式模拟Spring IoC AOP

    模拟Spring的IoC,我们可以创建一个简单的容器类,其中包含一个Map来存储bean。然后使用注解处理器扫描带有特定注解(如`@Component`)的类,并将它们注册到容器中。当需要注入依赖时,容器可以解析注解并自动装配。...

    模拟spring ioc过程

    这个"模拟spring ioc过程"的学习例子是基于Java语言的,旨在帮助理解Spring框架中的这两个核心概念。在Java工程中,我们通常会通过配置文件(如XML或Java配置类)来定义bean的定义和它们之间的依赖关系。在实际运行...

    java练习之模拟SPRING IOC,我的SUMMER

    这个练习分为三个主要部分,旨在帮助我们掌握XML配置文件的读取,模拟Spring的IoC机制,以及对Struts框架的简单模拟。下面将逐一解析这些知识点。 **1. XML读取** XML(Extensible Markup Language)是一种通用的...

    模拟Spring的IOC

    **模拟Spring的IOC** 在Java世界中,Spring框架以其强大的依赖注入(Dependency Injection,简称DI)和控制反转(Inversion of Control,简称IOC)能力,成为企业级应用开发的首选框架之一。理解并模拟Spring的IOC...

    模拟spring IOC非常好的事例

    下面我们将深入探讨这个"模拟spring IOC非常好的事例"所涵盖的知识点。 首先,我们需要理解什么是IOC。IOC是一种设计模式,它的主要思想是将对象的创建和管理权交给一个外部容器,而不是由对象自身来负责。这样可以...

    反射模拟springIOC.rar

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

    模拟Spring IoC

    在这个模拟Spring IoC的项目中,我们可以深入理解以下几个关键知识点: 1. **容器的概念**:Spring IoC容器是管理对象及其依赖关系的核心组件。在这个模拟项目中,会有一个类或接口扮演容器的角色,负责创建对象、...

    模拟spring ioc技术

    本篇文章将详细解析“模拟Spring IOC技术”的核心概念,并通过一个小Demo帮助你深入理解IOC的工作原理。 首先,我们来解释一下什么是IOC和DI。控制反转(IOC)是编程中的一个设计原则,它改变了对象获取依赖的方式...

    SpringIoc示例代码

    Spring IOC,全称Inversion of Control,即“控制反转”,是Spring框架的核心特性之一。在传统的Java应用程序中,对象的创建和管理通常由开发者自己控制。而在Spring IOC中,这种控制权被反转,对象的创建、初始化、...

    简单模拟springIoc容器

    在`YQIoc`这个压缩包中,可能包含了实现简单模拟Spring IoC容器的代码。通常,这个模拟会包含以下几个部分: 1. **Bean定义**:这是描述对象如何创建和配置的数据结构。在我们的例子中,bean定义可能是以XML形式...

    java 解析xml,模拟spring框架ioc

    在提供的压缩包文件"xml_bean"中,可能包含了示例的XML配置文件和相关的Java类,你可以通过分析这些文件来加深对Java解析XML和模拟Spring IOC的理解。实际项目中,Spring框架提供了更高级的功能,如自动扫描、注解...

    基于java简单模拟实现spring_ioc

    在这个项目中,“基于java简单模拟实现spring_ioc”显然是为了帮助开发者理解Spring的IoC容器是如何工作的,以及如何通过Java代码来模拟这个过程。 首先,让我们了解什么是Spring的IoC。IoC是一种设计模式,它将...

    模拟springIOC

    在本文中,我们将深入探讨“模拟Spring IOC”的概念,以及如何通过自己实现的简单依赖注入来理解这个核心的Spring框架特性。Spring IOC,即Inversion of Control(控制反转),是软件设计模式的一种,它在Spring框架...

    SpringIOC和AOP实现机制模拟

    Spring框架是Java开发中不可或缺的一部分,它通过提供控制反转(IOC)和面向切面编程(AOP)等核心特性,极大地简化了企业级应用的构建。让我们深入探讨这两个概念及其在Spring中的实现机制。 首先,Spring的控制...

    spring IOC实现(墨者革离)

    在这个名为"spring_IOC实现(墨者革离)"的项目中,我们可以通过模拟城门叩问的编剧场景来理解这一概念。 首先,控制反转的基本思想是将对象的创建和依赖关系的管理从应用程序中分离出来,交给一个外部容器(在...

    Spring IOC AOP MVC 简单例子

    例如,`SpringIOC`目录中的配置文件(如`applicationContext.xml`)用于定义bean的定义和它们之间的依赖关系。通过XML或注解方式声明bean,Spring可以自动管理bean的实例化、初始化和销毁,从而简化了代码并提高了可...

    使用Java注解模拟spring ioc容器过程解析

    使用Java注解模拟Spring IOC容器过程解析 Java注解是一种特殊的语法结构,用于提供元数据来描述程序元素,如类、方法、字段等。Spring框架的IOC(Inversion of Control,控制反转)容器是Spring框架的核心组件之一...

    动手写框架,模拟简易的SpringIOC.rar

    描述中的链接指向了CSDN博客的一个文章,虽然具体内容无法直接复制到这里,但我们可以根据文章标题推测,该文章详细介绍了如何从零开始构建一个简单的IOC容器,以此来模拟Spring框架的工作原理。通过这种方式,学习...

    模拟Spring的Ioc功能

    本篇文章将详细探讨如何利用jdom2解析XML文档以及通过反射机制来模拟Spring的IoC功能。 首先,理解IoC的基本概念。IoC意味着不再由应用程序直接创建对象,而是由一个容器(如Spring IoC容器)来负责对象的生命周期...

Global site tag (gtag.js) - Google Analytics