`
bxf12315
  • 浏览: 27331 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

自己编写ioc

    博客分类:
  • java
阅读更多
java 代码

这段时间,想学习些关于IOC和反射以及注释方面的东西。
想通过一个简单的例子来学习一下,我设想的例子是这样的。
1 首先 通过castor来读取bean配置信息
2 然后注册bean的class信息到容器中。
3 在client获取bean的时候,去检查bean是否需要通过代理来实现
4 然后分配不同的代理来实现一些诸如事务 log的功能。

这是一个初步的想法,但是我知道ioc容器应该不止是实现一个简单的反转控制的问题,希望能在以后加进去(说实话,还有点啥我都不知道)。

1 bean配置:

xml 代码
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <mybeans >  
  3. <bean id="first" name="first" implement="com.my.ioc.testpackage.MybeanOneImpl"></bean>  
  4. </mybeans>  

只是用最简单的一个描述。应该一眼能看出来。

2  配置读取

 2.1 使用castor读取xml的代码

java 代码
  1. public class XmlToBean {   
  2.   
  3.     public Mybean getBean() throws Exception {   
  4.         Mapping map = new Mapping();   
  5.         URL u = this.getClass().getClassLoader().getResource("com/my/ioc/config/config-mapping.xml");   
  6.         map.loadMapping(u);   
  7.         Unmarshaller un = new Unmarshaller(Mybean.class);   
  8.         File file = new File("myconfig.xml");   
  9.         file.getAbsoluteFile();   
  10.         Reader reader = new FileReader(file);   
  11.         // Unmarshaller unmarshaller = new Unmarshaller(map);   
  12.         un.setMapping(map);   
  13.         Mybean read = (Mybean) un.unmarshal(reader);   
  14.   
  15.         return read;   
  16.     }   
  17. }  

 

2.2 castor 的配置文件

 就是一个xml到bean的描述文件

xml 代码
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <!DOCTYPE mapping PUBLIC "-//EXOLAB/Castor Mapping DTD Version 1.0//EN"   
  3.     "http://castor.org/mapping.dtd">  
  4. <mapping>  
  5.     <class name="com.my.ioc.config.Mybean" auto-complete="true">  
  6.         <map-to xml="my_beans" />  
  7.         <field name="mybeans" type="com.my.ioc.config.ConfigBean" collection="arraylist">  
  8.             <bind-xml name="bean" node="element" />  
  9.         </field>  
  10.     </class>  
  11.     <class name="com.my.ioc.config.ConfigBean" auto-complete="true">  
  12.         <field name="id">  
  13.             <bind-xml name="id"  node="attribute"/>  
  14.         </field>  
  15.         <field name="name">  
  16.             <bind-xml name="name" node="attribute"/>  
  17.         </field>  
  18.         <field name="implement">  
  19.             <bind-xml name="implement"  node="attribute"/>  
  20.         </field>  
  21.     </class>  
  22. </mapping>  

 

2.3 然后就是配置的bean了

 好像介绍的顺序不太对。

 

java 代码
  1. public class ConfigBean implements Serializable{   
  2.     private String id;   
  3.   
  4.     private String name;   
  5.   
  6.     private String implement;   
  7.   
  8.     public String getId() {   
  9.         return id;   
  10.     }   
  11.   
  12.     public void setId(String id) {   
  13.         this.id = id;   
  14.     }   
  15.   
  16.     public String getImplement() {   
  17.         return implement;   
  18.     }   
  19.   
  20.     public void setImplement(String implement) {   
  21.         this.implement = implement;   
  22.     }   
  23.   
  24.     public String getName() {   
  25.         return name;   
  26.     }   
  27.   
  28.     public void setName(String name) {   
  29.         this.name = name;   
  30.     }   
  31. }   
  32.   
  33. public class Mybean {   
  34.   
  35.     private List<ConfigBean> mybeans;   
  36.   
  37.     public List<ConfigBean> getMybeans() {   
  38.         return mybeans;   
  39.     }   
  40.   
  41.     public void setMybeans(List<ConfigBean> mybeans) {   
  42.         this.mybeans = mybeans;   
  43.     }   
  44.   
  45. }   

 

3 在写我的bean工厂前,还是说下我的annotation吧。

  3.1 类的注释- 为了表明这个方法是否需要通过动态代理来处理

java 代码
  1. @Retention(RetentionPolicy.RUNTIME)   
  2. @Target(ElementType.TYPE)   
  3. public @interface MyClassAnnotation {   
  4.     String isInvoke() default "NO";   
  5. }  

3.2  方法注释-来标明这个方法是否执行特定的业务,还是比如说事务。。。-_-!(感觉就这个好说点)

java 代码
  1. @Retention(RetentionPolicy.RUNTIME)   
  2. public @interface MyMethodAnnotation {   
  3.     String isTransaction() default "NO";   
  4. }   

3.3 写一个简单的代理类

java 代码
  1. class MyTranstionHandler implements MyHandler,InvocationHandler{   
  2.     private Object o;   
  3.   
  4.     private MyJotmTranstion tra;   
  5.   
  6.     public MyTranstionHandler(Object delegate) {   
  7.         o = delegate;   
  8. //        tra = new MyJotmTranstion();   
  9.     }   
  10.   
  11.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {   
  12.         Object a = null;   
  13.         try {   
  14.   
  15.             if (method.isAnnotationPresent(MyMethodAnnotation.class)) {   
  16.                 MyMethodAnnotation an = method.getAnnotation(MyMethodAnnotation.class);   
  17.                 if (an.isTransaction().equals("yes") && an != null) {   
  18. //                    getTransactionManager().begin();   
  19.                     System.out.print("\n" + "start");   
  20.                     a = method.invoke(o, args);   
  21. //                    getTransactionManager().commit();   
  22.                     System.out.print("\n" + "end");   
  23.                 } else {   
  24.                     a = method.invoke(o, args);   
  25.                 }   
  26.             }   
  27.             return null;   
  28.         } catch (Exception e) {   
  29.             System.out.print("\n" + "invoke Exception");   
  30.         }   
  31.         return a;   
  32.     }   
  33.        
  34.     private TransactionManager getTransactionManager()   
  35.     {   
  36.         return tra.getTransactionManager();   
  37.     }   
  38. }   

4 现在给出一个具体的实现类

java 代码
  1. @MyClassAnnotation(isInvoke="yes")   
  2. public class MybeanOneImpl implements IMybeanOne {   
  3.     @MyMethodAnnotation(isTransaction = "yes")   
  4.     public void printString() {   
  5.         System.out.print("\n"+" don some thing");   
  6.     }   
  7.     @MyMethodAnnotation(isTransaction = "yes")   
  8.     public void printString1() {   
  9.         System.out.print("\n"+" good work");   
  10.     }   
  11. }  

 

5 然后给出我的bean工厂了

java 代码
  1. public class MyBeanFactory {   
  2.     private static MyBeanFactory instance = null;   
  3.   
  4.     private MyBeanFactory() {   
  5.         try {   
  6.             initBean();   
  7.         } catch (Exception e) {   
  8.             int b = 0;   
  9.         }   
  10.     }   
  11.   
  12.     public static MyBeanFactory getInstance() {   
  13.         return instance = new MyBeanFactory();   
  14.     }   
  15.   
  16.     private Map<String, Class> beanMap = new HashMap<String, Class>();   
  17.   
  18.     private Object getConfigBean() throws Exception {   
  19.         XmlToBean xml = new XmlToBean();   
  20.         return xml.getBean();   
  21.     }   
  22.   
  23.     private void initBean() throws Exception {   
  24.         Mybean beans = (Mybean) getConfigBean();   
  25.         List<ConfigBean> configList = beans.getMybeans();   
  26.         for (int i = 0; i < configList.size(); i++) {   
  27.             ConfigBean bean = configList.get(i);   
  28.             registerBean(bean.getName(), bean.getImplement());   
  29.   
  30.         }   
  31.         int i = 0;   
  32.     }   
  33.   
  34.     private void registerBean(String beanName, String className) throws Exception {   
  35.         Class bean = Class.forName(className);   
  36.         beanMap.put(beanName, bean);   
  37.   
  38.     }   
  39.   
  40.     public Object getRegistedBean(String beanName) throws Exception {   
  41.   
  42.         Class o = beanMap.get(beanName);   
  43.        if(o.isAnnotationPresent(MyClassAnnotation.class))   
  44.            return o.newInstance();   
  45.         MyClassAnnotation classAnn = (MyClassAnnotation) o.getAnnotation(MyClassAnnotation.class);   
  46.         if (classAnn.isInvoke().equals("yes")) {   
  47.             InvocationHandler handler = new MyTranstionHandler(o.newInstance());   
  48.             return   Proxy.newProxyInstance(o.getClassLoader(), o.getInterfaces(), handler);   
  49.         } else {   
  50.             return o.newInstance();   
  51.         }   
  52.     }   
  53. }  

 

6 测试代码

 

java 代码
  1. public static void main(String[] args) {   
  2.        MyBeanFactory f = MyBeanFactory.getInstance();   
  3.        try {   
  4.            IMybeanOne o =(IMybeanOne) f.getRegistedBean("first");   
  5.            o.printString();   
  6.        } catch (Exception e) {   
  7.            System.out.print("error "+e.getMessage());   
  8.        }   
  9.    }  

呵呵最后是结构输出:

start
 don some thing
end

这里我还是使用了xml来配置bean的信息。第一这种方式是我比较熟悉的 第二 我感觉这种方式还是比较灵活的。

然后,我把一些类似于横切面的业务放到了anntation中来处理,这个其实是我在开发中很希望能做到的。

比如事务,我就在方法上标上这个方法就是要执行事务就完了,或者要缓存。这样开发起来感觉简单快捷。(个人想法)

我通过配置信息把实现bean的class存放在一个map中在client调用的时候,判断是否通过代理实现在然后给出实例。

这些就是我的一个基本想法。(算是实现了)

这只是在学习,希望高人能给指点一二,然后我试着把这些想法完善。

 

分享到:
评论
8 楼 jomper 2008-01-21  
建议去看看 picocontainer ---ioc bible
7 楼 bxf12315 2008-01-21  
<div class='quote_title'>rEloaD_cn 写道</div><div class='quote_div'><div class='quote_title'>bxf12315 写道</div><div class='quote_div'><p>现在又有新问题了,如果使用了对象池。那么我怎么做对象的回收呢?</p><p>从client是不会做释放对象的动作的,这个该怎么做呢?</p><p>以前用对象池,一般都是要先借后还的,但是现在这种方式怎么还呢? 这样是不是就需要起一个后台线程通过lru什么的来进行回收? 这下不明白的就更多了。</p><p>能给例子来学习一下吗? 比如说数据库连接池的对象回收。(看过几次pico,但是没看懂他的实现机制)</p></div><br/>数据库连接池的对象回收好像是在close的时候将connection回收的吧,显示通知管理器该connection已经不再使用。 但一般的javabean这样才算不再使用了呢?难不成还要咱们还要去内存看它是不是死节点?不明白</div><p><br/>首先.一般的连接池中使用连接都是一中逻辑上的 创建和释放,并非实际的。</p><p>第二,在使用一些连接池的时候,开发者可以不去关心close。</p><p>这些工作会交给系统来做处理,-(我想可能是通过一些,机制或者原则-ex 时间 最近最多使用什么的 就像大家在使用一些缓存工具一样)。</p><p>也就是说,我们把对象的创建和释放工作交给容器来完成。 容器的一个特点不就是,可以是开发人员不关注对象的创建吗?</p><p> </p><p>呵呵,这些都是个人的一点理解。</p>
6 楼 rEloaD_cn 2008-01-11  
<div class='quote_title'>bxf12315 写道</div><div class='quote_div'><p>现在又有新问题了,如果使用了对象池。那么我怎么做对象的回收呢?</p>
<p>从client是不会做释放对象的动作的,这个该怎么做呢?</p>
<p>以前用对象池,一般都是要先借后还的,但是现在这种方式怎么还呢? 这样是不是就需要起一个后台线程通过lru什么的来进行回收? 这下不明白的就更多了。</p>
<p>能给例子来学习一下吗? 比如说数据库连接池的对象回收。(看过几次pico,但是没看懂他的实现机制)</p></div><br/>数据库连接池的对象回收好像是在close的时候将connection回收的吧,显示通知管理器该connection已经不再使用。

但一般的javabean这样才算不再使用了呢?难不成还要咱们还要去内存看它是不是死节点?不明白
5 楼 bxf12315 2007-12-13  
<p>现在又有新问题了,如果使用了对象池。那么我怎么做对象的回收呢?</p>
<p>从client是不会做释放对象的动作的,这个该怎么做呢?</p>
<p>以前用对象池,一般都是要先借后还的,但是现在这种方式怎么还呢? 这样是不是就需要起一个后台线程通过lru什么的来进行回收? 这下不明白的就更多了。</p>
<p>能给例子来学习一下吗? 比如说数据库连接池的对象回收。(看过几次pico,但是没看懂他的实现机制)</p>
4 楼 fight_bird 2007-12-11  
5年前就使用了所谓IOC的机制,只不过没上升到IOC的理论高度,OFBiz的实体容器本身就是包含IOC的机制,那比IOC的理论早出好几年。

鼓励造出超级“轮子”,如Spring,鄙视“锤子”,如EJB2。
3 楼 viqcel 2007-12-11  
做学习还可以,做实际项目风险太大了。
2 楼 bxf12315 2007-12-11  
<p>
leyen 写道
好轮子,呵呵! 我也写过一个类似的IOC,完全使用annotation,功能也支持事务,不过只支持JDBC.
</p>
<p>其实,ioc应该除了做反转控制外还应该有其他作用,比如说object的生命周期管理。其它的功能目前我还不知道,呵呵。</p>
<p>刚刚查了查,对于生命周期的管理可以分几个:单实例,每次请求产生一个新对象,对于每个线程一个单实例,对象池,另外可能有用户自定义。其实在上面做的只是实现了一个每次请求产生一个新对象。其他的完全没有实现,第一其它好多生命周期的管理的方式,我还太明白作用 第二 如何实现也不知道。</p>
<p>目前,对我来说还能进一步做的可能只有对象池了。</p>
<p>这方面的东西知识实在太有限了,希望大家给点意见,提供一些参考。(只是学习至于能否实现就不重要了呵呵)</p>
1 楼 leyen 2007-12-10  
好轮子,呵呵!
我也写过一个类似的IOC,完全使用annotation,功能也支持事务,不过只支持JDBC.

相关推荐

    Spring IOC容器实现分析.pdf 下载

    《Spring IOC容器实现分析》 在Java开发领域,Spring框架无疑是使用最为广泛的轻量级框架之一,其中的核心组件就是IOC(Inversion of Control)容器。本文将深入剖析Spring的IOC容器,理解其工作原理和重要功能,以...

    spring ioc模块手写demo

    spring ioc模块手写demospring ioc模块手写demospring ioc模块手写demospring ioc模块手写demospring ioc模块手写demospring ioc模块手写demospring ioc模块手写demospring ioc模块手写demospring ioc模块手写demo...

    自己的IoC框架实现

    在本项目中,我们将根据Spring的IoC原理,尝试实现自己的IoC框架。 首先,理解IoC的概念至关重要。IoC是指应用程序的控制权由传统的方式(如:对象直接创建和管理依赖关系)转移到框架或容器中,这样对象不再负责...

    springIOC手写框架分析

    springIOC手写框架分析springIOC手写框架分析springIOC手写框架分析springIOC手写框架分析springIOC手写框架分析springIOC手写框架分析springIOC手写框架分析springIOC手写框架分析springIOC手写框架分析springIOC...

    手写一个SpringIoc容器

    9. **单元测试与调试**:为了确保容器功能的正确性,需要编写单元测试用例。同时,良好的日志记录和调试信息可以方便开发者理解和调试容器。 通过实现这样一个自定义的Spring IOC容器,我们可以更深入地理解Spring...

    手写SpringIOC注解实现版本

    Spring IOC(Inversion of Control,控制反转)是Spring框架的核心组成部分,它负责管理应用程序中的对象。这个"手写Spring IOC注解实现版本"项目旨在帮助我们深入理解Spring框架的工作原理,通过实际动手实现来增强...

    手写IOC,DI,servlet

    在【标签】中,“IOC DI 手写”进一步强调了实现的核心特性,即这些核心组件都是开发者自行编写的,没有依赖额外的框架。 从【压缩包子文件的文件名称列表】"ShouXieMVC"来看,这可能是作者实现的一个简易的Model-...

    手写SpringIoc的XML实现方式

    Spring IOC(Inversion of Control,控制反转)是Spring框架的核心特性,它负责管理对象的生命周期和依赖关系。在本主题中,我们将深入探讨如何手写一个基于XML的Spring IOC实现,模仿Spring框架中的`...

    自己开发项目ioc

    在标题"自己开发项目ioc"中,我们可以推断出你在构建一个自定义的项目,并且在这个项目中应用了IoC的概念。这可能意味着你正在创建一个框架或者服务,其中包含了一个IoC容器来管理对象的生命周期和依赖关系。这样的...

    手写spring ioc(三) 资源org.zip

    在本资源"手写spring ioc(三) 资源org.zip"中,我们主要关注的是如何实现一个简易版的Spring IOC(Inversion of Control)容器,它涵盖了ioc的基本功能,包括解决循环依赖、使用构造器注入以及自动注入等核心特性。...

    springIoc实现原理

    在IoC中,不再由对象自己去创建或查找依赖的对象,而是将这种控制权交给一个专门的容器(即Spring Ioc容器)。这样,对象只需要声明自己需要哪些依赖,而具体的获取和管理过程则由容器负责,实现了对象间的低耦合。 ...

    IoC容器的设计(利用反射、注解和工厂模式实现)

    实验要求 1. 利用注解、反射和工厂模式设计一个简单的IoC容器 2. 该IoC容器包含3个...然后我们需要自己实现一个IoC容器类,处理自定义的注解的基本逻辑; 接下来在test类中实例化IoC容器,并从中取得bean,调用其方法

    用java写的一个简单的ioc实现,初学的朋友可以看看

    通过自己动手实现,初学者可以更好地理解Spring是如何在幕后管理对象和处理依赖的,这对于提升编程技能和设计模式的理解非常有益。同时,这也是软件开发中常用的一种学习方法——通过模仿和实践来深入理解复杂的概念...

    自己写了三个分别关于WEB,IOC,ORM的框架现将开源

    自己写了三个分别关于WEB,IOC,ORM的框架现将全部开源,内有说明文档,测试示例项目,框架源代码文件,sql语句等

    雷赛IOC0640.rar

    标题中的“雷赛IOC0640.rar”指的是雷赛智能公司的一款名为IOC0640...通过深入学习这些内容,无论是系统集成商、自动化工程师还是设备维护人员,都能提升自己在工业自动化领域的专业技能,更好地应对实际工作中的挑战。

    图片转IOC图标工具

    总的来说,"图片转IOC图标工具"是一款高效且实用的开发辅助工具,它解决了在iOS应用开发中创建和管理图标时可能出现的繁琐工作,使得开发者可以更专注于代码编写和功能实现,从而提高整体开发效率。对于任何涉及iOS...

    IOC练习事列

    1. **依赖注入(Dependency Injection, DI)**:这是IOC的核心概念,DI允许我们通过构造函数、属性或方法将依赖注入到对象中,而不是让对象自己去创建或查找依赖。这样可以避免硬编码,使代码更加灵活。 2. **接口...

    JavaEE Spring IoC入门

    总的来说,学习"JavaEE Spring IoC入门"意味着你需要理解Spring如何通过IoC管理对象,掌握XML配置文件的编写,以及如何在Web环境中使用Spring MVC进行开发。此外,还需要了解如何编写测试用例来验证Spring配置的有效...

    手写IOC项目,学习理解Spring IOC原理

    我们都知道,Spring框架的IOC是基于Java的反射机制实现,实现IOC,...IOC和DI是Spring里面最核心的东西,,资源中会写出这两个模块。资源内容包括Java反射机制的实践,使用反射机制实现IOC(包括依赖注入和对象创建)。

    IOC模式 c#经典例子

    IOC(Inversion of Control,控制反转)模式是一种软件设计原则,它在面向对象编程中用于解耦组件之间的依赖关系。C#中实现IOC的一种常见方式是通过依赖注入(Dependency Injection,DI)。在这个“IOC模式 c#经典...

Global site tag (gtag.js) - Google Analytics