论坛首页 → Java企业应用论坛 →

自己编写ioc

浏览 5619 次
锁定老帖子 主题：自己编写ioc
精华帖 (0) :: 良好帖 (0) :: 新手帖 (0) :: 隐藏帖 (0)
作者 正文
  • bxf12315
  • 等级: 初级会员
  • 性别:
  • 文章: 33
  • 积分: 62
  • 来自: 北京
   发表时间：2007-12-10  
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调用的时候，判断是否通过代理实现在然后给出实例。

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

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

 
返回顶楼
         
  • leyen
  • 等级: 一星会员
  • 性别:
  • 文章: 47
  • 积分: 102
   发表时间：2007-12-10  
好轮子，呵呵!
我也写过一个类似的IOC，完全使用annotation,功能也支持事务，不过只支持JDBC.
返回顶楼
          回帖地址
0 请登录后投票
  • bxf12315
  • 等级: 初级会员
  • 性别:
  • 文章: 33
  • 积分: 62
  • 来自: 北京
   发表时间：2007-12-11  

[quote="leyen"]好轮子，呵呵! 我也写过一个类似的IOC，完全使用annotation,功能也支持事务，不过只支持JDBC.[/quote]

其实，ioc应该除了做反转控制外还应该有其他作用，比如说object的生命周期管理。其它的功能目前我还不知道，呵呵。

刚刚查了查，对于生命周期的管理可以分几个：单实例，每次请求产生一个新对象，对于每个线程一个单实例，对象池，另外可能有用户自定义。其实在上面做的只是实现了一个每次请求产生一个新对象。其他的完全没有实现，第一其它好多生命周期的管理的方式，我还太明白作用 第二 如何实现也不知道。

目前，对我来说还能进一步做的可能只有对象池了。

这方面的东西知识实在太有限了，希望大家给点意见，提供一些参考。（只是学习至于能否实现就不重要了呵呵）
返回顶楼
          回帖地址
0 请登录后投票
  • viqcel
  • 等级: 初级会员
  • 性别:
  • 文章: 1
  • 积分: 30
  • 来自: 深圳
   发表时间：2007-12-11  
做学习还可以，做实际项目风险太大了。
返回顶楼
          回帖地址
0 请登录后投票
  • fight_bird
  • 等级: 二星会员
  • 性别:
  • 文章: 386
  • 积分: 234
   发表时间：2007-12-11  
5年前就使用了所谓IOC的机制，只不过没上升到IOC的理论高度，OFBiz的实体容器本身就是包含IOC的机制，那比IOC的理论早出好几年。

鼓励造出超级“轮子”，如Spring，鄙视“锤子”，如EJB2。
返回顶楼
          回帖地址
0 请登录后投票
  • bxf12315
  • 等级: 初级会员
  • 性别:
  • 文章: 33
  • 积分: 62
  • 来自: 北京
   发表时间：2007-12-13  

现在又有新问题了，如果使用了对象池。那么我怎么做对象的回收呢？

从client是不会做释放对象的动作的，这个该怎么做呢？

以前用对象池，一般都是要先借后还的，但是现在这种方式怎么还呢？ 这样是不是就需要起一个后台线程通过lru什么的来进行回收？ 这下不明白的就更多了。

能给例子来学习一下吗？ 比如说数据库连接池的对象回收。（看过几次pico，但是没看懂他的实现机制）
返回顶楼
          回帖地址
0 请登录后投票
  • rEloaD_cn
  • 等级: 初级会员
  • 性别:
  • 文章: 27
  • 积分: 79
   发表时间：2008-01-11  
bxf12315 写道

现在又有新问题了，如果使用了对象池。那么我怎么做对象的回收呢？

从client是不会做释放对象的动作的，这个该怎么做呢？

以前用对象池，一般都是要先借后还的，但是现在这种方式怎么还呢？ 这样是不是就需要起一个后台线程通过lru什么的来进行回收？ 这下不明白的就更多了。

能给例子来学习一下吗？ 比如说数据库连接池的对象回收。（看过几次pico，但是没看懂他的实现机制）


数据库连接池的对象回收好像是在close的时候将connection回收的吧，显示通知管理器该connection已经不再使用。 但一般的javabean这样才算不再使用了呢？难不成还要咱们还要去内存看它是不是死节点？不明白
返回顶楼
          回帖地址
0 请登录后投票
  • bxf12315
  • 等级: 初级会员
  • 性别:
  • 文章: 33
  • 积分: 62
  • 来自: 北京
   发表时间：2008-01-21  
rEloaD_cn 写道
bxf12315 写道

现在又有新问题了，如果使用了对象池。那么我怎么做对象的回收呢？

从client是不会做释放对象的动作的，这个该怎么做呢？

以前用对象池，一般都是要先借后还的，但是现在这种方式怎么还呢？ 这样是不是就需要起一个后台线程通过lru什么的来进行回收？ 这下不明白的就更多了。

能给例子来学习一下吗？ 比如说数据库连接池的对象回收。（看过几次pico，但是没看懂他的实现机制）


数据库连接池的对象回收好像是在close的时候将connection回收的吧，显示通知管理器该connection已经不再使用。 但一般的javabean这样才算不再使用了呢？难不成还要咱们还要去内存看它是不是死节点？不明白


首先.一般的连接池中使用连接都是一中逻辑上的 创建和释放，并非实际的。

第二，在使用一些连接池的时候，开发者可以不去关心close。

这些工作会交给系统来做处理，-（我想可能是通过一些，机制或者原则-ex 时间 最近最多使用什么的 就像大家在使用一些缓存工具一样）。

也就是说，我们把对象的创建和释放工作交给容器来完成。 容器的一个特点不就是，可以是开发人员不关注对象的创建吗？

 

呵呵，这些都是个人的一点理解。
返回顶楼
          回帖地址
0 请登录后投票
  • jomper
  • 等级: 一星会员
  • 性别:
  • 文章: 109
  • 积分: 119
  • 来自: 湖北-武汉
   发表时间：2008-01-21  
建议去看看 picocontainer ---ioc bible
返回顶楼
          回帖地址
0 请登录后投票
论坛首页 → Java企业应用版

跳转论坛:
Global site tag (gtag.js) - Google Analytics