自己编写ioc

java 代码

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

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

1 bean配置：

xml 代码

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

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

2  配置读取

 2.1 使用castor读取xml的代码

java 代码

public class XmlToBean {

    public Mybean getBean() throws Exception {
        Mapping map = new Mapping();
        URL u = this.getClass().getClassLoader().getResource("com/my/ioc/config/config-mapping.xml");
        map.loadMapping(u);
        Unmarshaller un = new Unmarshaller(Mybean.class);
        File file = new File("myconfig.xml");
        file.getAbsoluteFile();
        Reader reader = new FileReader(file);
        // Unmarshaller unmarshaller = new Unmarshaller(map);
        un.setMapping(map);
        Mybean read = (Mybean) un.unmarshal(reader);

        return read;
    }
}

 

2.2 castor 的配置文件

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

xml 代码

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapping PUBLIC "-//EXOLAB/Castor Mapping DTD Version 1.0//EN"
    "http://castor.org/mapping.dtd">
<mapping>
    <class name="com.my.ioc.config.Mybean" auto-complete="true">
        <map-to xml="my_beans" />
        <field name="mybeans" type="com.my.ioc.config.ConfigBean" collection="arraylist">
            <bind-xml name="bean" node="element" />
        </field>
    </class>
    <class name="com.my.ioc.config.ConfigBean" auto-complete="true">
        <field name="id">
            <bind-xml name="id"  node="attribute"/>
        </field>
        <field name="name">
            <bind-xml name="name" node="attribute"/>
        </field>
        <field name="implement">
            <bind-xml name="implement"  node="attribute"/>
        </field>
    </class>
</mapping>

 

2.3 然后就是配置的bean了

 好像介绍的顺序不太对。

 

java 代码

public class ConfigBean implements Serializable{
    private String id;

    private String name;

    private String implement;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getImplement() {
        return implement;
    }

    public void setImplement(String implement) {
        this.implement = implement;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

public class Mybean {

    private List<ConfigBean> mybeans;

    public List<ConfigBean> getMybeans() {
        return mybeans;
    }

    public void setMybeans(List<ConfigBean> mybeans) {
        this.mybeans = mybeans;
    }

}

 

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

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

java 代码

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface MyClassAnnotation {
    String isInvoke() default "NO";
}

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

java 代码

@Retention(RetentionPolicy.RUNTIME)
public @interface MyMethodAnnotation {
    String isTransaction() default "NO";
}

3.3 写一个简单的代理类

java 代码

class MyTranstionHandler implements MyHandler,InvocationHandler{
    private Object o;

    private MyJotmTranstion tra;

    public MyTranstionHandler(Object delegate) {
        o = delegate;
//        tra = new MyJotmTranstion();
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object a = null;
        try {

            if (method.isAnnotationPresent(MyMethodAnnotation.class)) {
                MyMethodAnnotation an = method.getAnnotation(MyMethodAnnotation.class);
                if (an.isTransaction().equals("yes") && an != null) {
//                    getTransactionManager().begin();
                    System.out.print("\n" + "start");
                    a = method.invoke(o, args);
//                    getTransactionManager().commit();
                    System.out.print("\n" + "end");
                } else {
                    a = method.invoke(o, args);
                }
            }
            return null;
        } catch (Exception e) {
            System.out.print("\n" + "invoke Exception");
        }
        return a;
    }

    private TransactionManager getTransactionManager()
    {
        return tra.getTransactionManager();
    }
}

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

java 代码

@MyClassAnnotation(isInvoke="yes")
public class MybeanOneImpl implements IMybeanOne {
    @MyMethodAnnotation(isTransaction = "yes")
    public void printString() {
        System.out.print("\n"+" don some thing");
    }
    @MyMethodAnnotation(isTransaction = "yes")
    public void printString1() {
        System.out.print("\n"+" good work");
    }
}

 

5 然后给出我的bean工厂了

java 代码

public class MyBeanFactory {
    private static MyBeanFactory instance = null;

    private MyBeanFactory() {
        try {
            initBean();
        } catch (Exception e) {
            int b = 0;
        }
    }

    public static MyBeanFactory getInstance() {
        return instance = new MyBeanFactory();
    }

    private Map<String, Class> beanMap = new HashMap<String, Class>();

    private Object getConfigBean() throws Exception {
        XmlToBean xml = new XmlToBean();
        return xml.getBean();
    }

    private void initBean() throws Exception {
        Mybean beans = (Mybean) getConfigBean();
        List<ConfigBean> configList = beans.getMybeans();
        for (int i = 0; i < configList.size(); i++) {
            ConfigBean bean = configList.get(i);
            registerBean(bean.getName(), bean.getImplement());

        }
        int i = 0;
    }

    private void registerBean(String beanName, String className) throws Exception {
        Class bean = Class.forName(className);
        beanMap.put(beanName, bean);

    }

    public Object getRegistedBean(String beanName) throws Exception {

        Class o = beanMap.get(beanName);
       if(o.isAnnotationPresent(MyClassAnnotation.class))
           return o.newInstance();
        MyClassAnnotation classAnn = (MyClassAnnotation) o.getAnnotation(MyClassAnnotation.class);
        if (classAnn.isInvoke().equals("yes")) {
            InvocationHandler handler = new MyTranstionHandler(o.newInstance());
            return   Proxy.newProxyInstance(o.getClassLoader(), o.getInterfaces(), handler);
        } else {
            return o.newInstance();
        }
    }
}

 

6 测试代码

 

java 代码

public static void main(String[] args) {
       MyBeanFactory f = MyBeanFactory.getInstance();
       try {
           IMybeanOne o =(IMybeanOne) f.getRegistedBean("first");
           o.printString();
       } catch (Exception e) {
           System.out.print("error "+e.getMessage());
       }
   }

呵呵最后是结构输出：

start
 don some thing
end

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

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

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

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

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

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