在写完《IOC原理分析》,本来就准备写这个《简单Spring实现》的,
但是因为复习数据结构和Collection,就一直拖到现在了,今天还是抽一天时间来把这个的总结和代码都写了吧.
恩,《IOC原理分析》中已经很详细的说明了Spring的IOC理念,在这里,就不累述了。
今天我们要做以下几件事 :
一.进行OO分析, 给出代码框架
二.代码实现
三.测试
OO分析以及代码实现:
首先:
在IOC原理分析中,我们曾指出,系统是通过一个外部的XML文件,来控制对象之间的引用关系。
我们需要通过配置一个XML文件来控制对象之间的关系,这个XML文件的结构,我们先设计一个外部DTD来确定.
<?xml version="1.0" encoding="utf-8"?>
<!--自己定义的Spring中使用的xml模板-->
<!--因为这只是自己练习的DEMO,所以定义的肯定不够完善,只是使之先能简单的完成一些功能
如果要更丰富的话,可以定义更多规则的,比如每个类对象是不是单例的等等,这里就不写了-->
<!ELEMENT beans (bean*)>
<!ELEMENT bean (property)>
<!--property的子属性
要么是直接使用的值传递类型,此时,设置value属性的类型为#PCDATA类型
要么是需要指向其他引用的引用类型,此时,设置该元素为空元素,
-->
<!ELEMENT property (value|ref)>
<!ELEMENT value (#PCDATA)>
<!ELEMENT ref EMPTY>
<!--设置bean的属性
每个bean必须有个ID属性,因为这个属性是唯一的表示这个bean,所以属性类型为ID,特征为#REQUIRED,每个bean还必须有class属性,每个类可以有多个对象,所以此属性不唯一,但是必须-->
<!ATTLIST bean id ID #REQUIRED>
<!ATTLIST bean class CDATA #REQUIRED>
<!--设置每个property的属性
-->
<!ATTLIST property name CDATA #REQUIRED>
<!--设置ref元素的id属性类型为IDREF,值类型为#REQUIRED
通过让它指向别的Bean的ID来完成完成引用(依赖就是这样的注入)-->
<!ATTLIST ref id IDREF #REQUIRED>
然后:
在XML中,每个对象都是用一个Bean标签包裹的.
我们还需要一个Bean类来保存XML中声明的每一个对象,Bean类中应该有ID,TYPE,Properties等三个属 性.
ID是这个Bean的唯一标识
Type是这个Bean的类型(全类名)
Properties用来保存这个Bean对象中的所有属性,用HashMap<String,Object>来实现
1.key是这个属性的属性名
2.value是属性的属性值,如果value是字符等值类型,则支持存入该值,如果value是引用传递类型(对象),则value是这个对象对应的bean
package cn.javamzd.MySpring;
import java.util.HashMap;
import java.util.Map;
/**
* XML中,每一个bean对象的结构
*/
public class Bean {
private String ID;//对象名
private String type;//类型
private Map<String,Object> properties=new HashMap<String,Object>();//对象的各个属性列表
/**
* 设置这个Bean的key属性,值为value
* @param key
* @param value
*/
public void setProperty(String key,Object value){
properties.put(key, value);
}
//ID、type对应的setter()、getter()方法
}
其次:
因为一个XML声明文件中可能会很多个Bean标签。
所以我们需要一个Beans类,用来保存所有Bean信息。
用个一个HashMap<String,Bean>实现,key为bean的ID,Value为这个Bean对象.
package cn.javamzd.MySpring;
import java.util.HashMap;
import java.util.Map;
/**
* 用来保存配置文件中的所有Bean对象
*
*/
public class Beans {
//保存所有从Bean对象ID到Bean对象的映射
private Map<String,Bean> beanMap=new HashMap<String,Bean>();
public Map<String, Bean> getBeanMap() {
return beanMap;
}
/**
* 加入一个Bean对象
* @param name 对象名
* @param obj 对象
* @return 加入状态
*/
public boolean setBean(String name,Bean bean){
beanMap.put(name, bean);
return true;
}
/**
* 根据Bean对象名,取得该Bean对象
* @param name 对象名
* @return 对象
*/
public Bean getBean(String name){
return beanMap.get(name);
}
}
再次:
有了XML文件,有了解析需要得到的Bean对象和Beans对象。
我们还需要一个XMLParser类,用来解析XML文件,得到我们配置好的Beans对象。
package cn.javamzd.MySpring;
import java.io.File;
import java.io.FileReader;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import org.xml.sax.InputSource;
import org.xml.sax.XMLReader;
import cn.javamzd.spring.Util.SpringConfigCH;
/**
* 此类是个工具类
* 用来设置通过SAX解析配置的XML文件
* 得到其中的各个Bean的属性,并且保存到Beans当中去
*/
public class XMLParser {
/**
* 通过XML的文件路径,解析该XML文件,返回Beans对象
* @param path
* @return
*/
public Beans parser(String path) {
// 设置接收XML中返回的对象队列的队列
//因为一个XML文档对应一个Context对象,每个Context对象对应一个beans对象
//所以,在方法内部生成产生此beans
Beans beans=new Beans();
try {
// 得到解析工厂对象
SAXParserFactory factory = SAXParserFactory.newInstance();
// 得到一个解析对象
SAXParser parser = factory.newSAXParser();
// 得到解析器
XMLReader reader = parser.getXMLReader();
// 设置处理器
// 此处是重点。利用值传递
reader.setContentHandler(new SpringConfigCH(beans));
//将文件路径封装为满足解析需要的InputSource类型
InputSource source=new InputSource(new FileReader(new File(path)));
// 设置需要解析的文档对象
reader.parse(source);
} catch (Exception e) {
e.printStackTrace();
}
return beans;
}
}
再次:
有了解析XML文件得到的Beans对象后,我们得到的还只是在XML文件中配置的每个对象的属性,并没有得到真正的对象
我们还需要一个Encoder方法,将Bean对象中的信息通过反射,动态生成我们需要的对象.
Encoder得到配置的每个类的具体对象后,这个对象还不太方便给我们的系统灵活运用。
我们还需要一个Context对象,将我们Encoder得到的每一个对象,放入这个Context对象中,可以通过对象的ID,取得这个对象。
显然,我们应该让系统中,没一个XML配置文档对应一个Context对象,文档中配置的所有对象都可以在Context中找到
和Beans类似,我们应该在Context中用一个Map来保存从ID到每一个Obj的映射
package cn.javamzd.MySpring;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
public class Context {
// 用来保存解码得到的从对象ID到这个对象对应的对象的映射
private Map<String, Object> container = new HashMap<String, Object>();
/**
* 每一个XML文档对应一个Context对象 ,此Context对象中保存XML文档中声明的所有对象
* 在实例化该类时传入XML文件地址,根据XML文件地址将所有对象都解析放入Context对象中的容器当中
* @param path
*/
public Context(String path) {
// 解析path路径对应的XML文档,得到beans对象
XMLParser parser = new XMLParser();
Beans beans = parser.parser(path);
// 遍历Beans取出每个Bean,解码Bean
Map<String, Bean> beanMap = beans.getBeanMap();
// 1.2.得到迭代器
Iterator<String> it = beanMap.keySet().iterator();
// 1.3.遍历迭代器,取出其中的key和value
while (it.hasNext()) {
String beanID = it.next();
Bean bean = beanMap.get(beanID);
//解码bean对象,得到Object对象
Object obj=encoder(bean);
//将beanID和Obj放入beans当中
this.setBean(beanID, obj);
}
}
/**
* 解析Bean对象,生成对应的Object对象
*
* @param bean
* @return
*/
private Object encoder(Bean bean) {
String id = bean.getId();
String type = bean.getType();
try {
Class c = Class.forName(type);
Object obj = c.newInstance();
//一.取出bean当中设置的属性信息,设置到Obejct对象当中
//1.取出所有属性
//1.1.取得Bean中设置的所有属性
Map<String, Object> properties = bean.getProperties();
//1.2.得到迭代器
Iterator<String> it=properties.keySet().iterator();
//1.3.遍历迭代器,取出其中的key和value
while(it.hasNext()){
String fieldName=it.next();
Object value=properties.get(fieldName);
//如果属性是值传递类型,此时value的值,就是在XML中对其设定的值
//如果属性是引用类型,value此时还是解析XML时存入在properties当中的一个个Bean对象
if(value instanceof Bean){
//取得value对应的Object对象
value=getBean(((Bean) value).getId());
}
//2.将取得的所有属性,调用对象的setter()方法,设置到对象当中
// 2.1.根据属性名,取得对象的setter()方法名
String methodName=getMethodName4Field(fieldName);
//2.1通过属性名,找到对应的属性的类型(通过方法名找方法时,需要方法的参数)
Field field=c.getDeclaredField(fieldName);
Class fType=field.getType();
// 2.2.根据方法名,取得对应方法
Method method= c.getMethod(methodName, fType);
// 2.3.调用setter方法
method.invoke(obj, value);
}
return obj;
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (SecurityException e) {
e.printStackTrace();
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
} catch (NoSuchFieldException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
/**
* 根据属性名,拼凑得到setter()方法名
* @param name
* @return
*/
private String getMethodName4Field(String name) {
String methodName = "set" + name.substring(0,1).toUpperCase()
+ name.substring(1, name.length());
return methodName;
}
/**
* 设置对象的ID,和这个ID对应的对象的映射关系
*
* @param id
* @param bean
* @return
*/
public void setBean(String id, Object bean) {
container.put(id, bean);
}
/**
* 通过对象的ID,取得这个对象
*
* @param id
* @return
*/
public Object getBean(String id) {
return container.get(id);
}
}
测试
Spring容器写完后,我们可以给个样例进行测试
假设有个Person类,Person类可以有宠物 ,可以让宠物叫
package cn.javamzd.spring.pojo;
public class Person {
private Animal pet;//宠物
public void setPet(Animal pet) {
this.pet = pet;
}
public void petSay(){
pet.say();
}
}
宠物Animal为个借口,各个具体的宠物Dog,Cat等等位实现类
package cn.javamzd.spring.pojo;
public interface Animal {
public void say();
}
package cn.javamzd.spring.pojo;
public class Dog implements Animal{
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public void say() {
System.out.println("Dog--->"+name);
}
}
我们用一下条件进行测试,可以覆盖到注入的值类型和引用类型两种情况
测试的XML文件为
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE beans SYSTEM "G:\\Android\\MySpring\\src\\cn\\javamzd\\MySpring\\SpringConfig.dtd">
<!-- 此配置文件来用配置对象之间的关系,以及每一个对象的内容 -->
<beans>
<bean id="wangcai" type="cn.javamzd.spring.pojo.Dog">
<property name="name">
<value>wangcai</value>
</property>
</bean>
<bean id="zhangsan" type="cn.javamzd.spring.pojo.Person">
<property name="pet">
<ref id="wangcai"/>
</property>
</bean>
</beans>
用来测试的Test类
package cn.javamzd.MySpring;
import cn.javamzd.spring.pojo.Person;
public class Test {
/**
* @param args
*/
public static void main(String[] args) {
Context c=new Context("G:\\Android\\MySpring\\src\\cn\\javamzd\\MySpring\\config.xml");
Person zhangsan=(Person)c.getBean("zhangsan");
zhangsan.petSay();
}
}
好了,结果很显然,我就不说了
至此,我们的一个简单的Spring容器已经算是完全实现好了,我们可以很爽的进行IOC了。
当然,还是那句,这只是一个我画了一天时间设计出来的DEMO,肯定还会有比较多bug的,在很多严格追求代码质量和安全的人眼里
或许我这写的也全是些垃圾吧。
个人练习,欢迎大家拍砖!
分享到:
相关推荐
自己实现的简单Spring 容器 非常简单..........
Spring容器的通俗理解及简单写法 手动写一个非常粗犷且简单的IOC容器。 用到了java的一些基础知识,比如说读取文件资源,反射,自定义注解的实现及使用等
我们从一个简单的容器开始,一步步的重构,最后实现一个基本的Spring框架的雏形,为了帮助我们更加深入的理解Spring的IoC...【SSH进阶之路】一步步重构容器实现Spring框架——彻底封装,实现简单灵活的Spring框架(十一)
自己实现的简易的模拟Spring的IoC容器,实现注解自动装配
自主实现的简易Spring框架,通过注解实现IoC容器和AOP。
【SSH进阶之路】一步步重构容器实现Spring的IoC——从一个简单的容器开始(八) 【SSH进阶之路】一步步重构容器实现Spring的IoC——解决容器对组件的“侵入式”管理的两种方案--服务定位器和IoC容器(九) 【SSH进阶之路...
本篇文章主要介绍了Spring实现一个简单的SpringIOC容器,具有一定的参考价值,感兴趣的小伙伴们可以参考一下。
之前一直想仔细研究研究spring容器技术的原理,参考别人的实现发现比想象的要简单。
简单的模仿Spring Ioc 配置文件属性只支持id class name ref,其他的没做解析
在我们使用Spring.NET框架的时候,首先需要实例化Spring.NET容器, 然后调用IoC容器IObjectFactory接口中GetObject方法获取容器中的对象。通过这一点就可以告诉我们制作IoC容器需要写一个获取XML文件内容的方法和申明...
框架: Spring 实现了使用简单的组件配置组合成一个复杂的应用. 在 Spring 中可以使用 XML 和 Java 注解组合这些对象 一站式:在 IOC 和 AOP 的基础上可以整合各种企业应用的开源框架和优秀的第三方类库 (实际上 ...
第5章:对Spring容器进行解构,从内部探究Spring容器的体系结构和运行流程。此外,我们还将对Spring容器一些高级主题进行深入的阐述。 第6章:我们从Spring AOP的底层实现技术入手,一步步深入到Spring AOP的...
有关于Spring,我们最常用的两个功能就是IOC和AOP,前几篇文章从源码级别介绍了Spring容器如何为我们生成bean及bean之间的依赖关系 下面我们接着来看AOP的源码实现。 有关于AOP,我们在面试中也被无数次问到...
也就是实例化一个类 不再由调用者来完成 通常由 Spring 容器来完成 然后注入调用者 因此称为控制反转 也称为依赖注入 ">javaEE 开发中 现在最成熟的框架之一应该就是spring了 spring框架最强大的地方就是实现了依赖...
框架: Spring 实现了使用简单的组件配置组合成一个复杂的应用. 在 Spring 中可以使用 XML 和 Java 注解组合这些对象 一站式:在 IOC 和 AOP 的基础上可以整合各种企业应用的开源框架和优秀的第三方类库 (Spring ...
课程设计的作业,实现了的ioc功能的spring框架,希望对大家有帮助
3.3 Spring容器内部对象的创建 12 Spring容器内部对象创建拓展: 12 3.3.1使用类构造器实例化(默认无参数) 14 3.3.2使用静态工厂方法实例化(简单工厂模式) 14 3.3.3初始化(创建)bean时机 15 Lazy-init初始化bean的...
核心容器四个包 spring-beans-4.2.4.RELEASE.jar ...commons-logging相当于一个日志接口,log4j相当于该接口的实现,如果不添加log4j包也可以,因为commons-logging也有一个简单的实现会自动使用。
参考别人博文,边看边学(基本照着敲)的一个简单IOC容器demo,通过注解的方式实现注入。就0积分吧哈哈哈