自己动手写spring（一） 使用digester

前言

本来想熟悉下digester的使用，写着写着发现，可以搞一个类似spring的东西的来，将过程记录下来，与大家分享。

例子中很多代码没有优化，基本没有异常处理和判空操作，这是我的一个坏习惯，先奔着目的去，实现成功后再重构。但这样的代码，更易看懂，优化后的代码反而掩盖了很多思路和思想，尤其容易让人分不清重点（因为算是技巧的地方太多了）。

项目源码的git clone地址：git@code.csdn.net:lqk654321/lspring.git

使用digester读取一个配置文件

digester入门的例子通常是

<?xml version="1.0" encoding="UTF-8"?>
<books>
    <book>
        <author>Author 2</author>
        <title>His One Book</title>
    </book>
</books>

digester代码

public class BookMain {
    public static void main(String[] args) throws IOException, SAXException {
          Digester digester = new Digester();
          digester.setValidating(false);
          // 创建对象
          digester.addObjectCreate("books", Books.class);
          digester.addObjectCreate("books/book", Book.class);
          // 设置属性
          digester.addBeanPropertySetter("books/book/author", "author");
          digester.addBeanPropertySetter("books/book/title", "title");
          // 处理对象之间的关系
          digester.addSetNext("books/book", "addBook");
          InputStream in = ClassLoader.getSystemResourceAsStream("books.xml");
          Books bs = (Books) digester.parse(in);
          System.out.println(bs.getBooks().get(0));
    }
}

这个xml文件的配置跟我们常用的不太一样，很明显，常见的是下面这种：

<books>
    <book author="author" title="title" class="org.lqk.digester.book.Book"/>
</books>

对应的处理类

public class BookMain2 {
    public static void main(String[] args) throws IOException, SAXException {
          Digester digester = new Digester();
          digester.setValidating(false);
          digester.addObjectCreate("books", Books.class);
          digester.addObjectCreate("books/book", "org.lqk.digester.book.Book","class");
          digester.addSetProperties("books/book");
          digester.addSetNext("books/book", "addBook");
          InputStream in = ClassLoader.getSystemResourceAsStream("books2.xml");
          Books bs = (Books) digester.parse(in);
          System.out.println(bs.getBooks().get(0));
    }
}

这个跟常用的就像很多了。从这个例子中可以看到，根据配置文件，我们是可以搞出一些类来，并处理它们之间的关系。说的抽象点，我们可以将配置文件描述的信息，映射到jvm的类中。

spring样式的配置文件

那对于一个spring样式的配置文件，兴许也能搞出点东西来。

<beans>
    <!-- 目前的局限 
        1. 必须包括id和class两个属性
    -->
    <!-- <bean>标签中的name属性对Bean类有意义，但对beanA和beanB确没有意义 -->
    <bean id="beanA" name="test" class="org.lqk.container.bean.BeanA">
        <property name="beanB" ref="beanB"/>
        <property name="title" value="studentA"/>
    </bean>
    <bean id="beanB" class="org.lqk.container.bean.BeanB">
        <property name="title" value="studentB"/>
    </bean>
</beans>

我们先来尝试读取基本信息。首先是创建三个model，将标签信息对象化（你该不会想直接用digester生成beanA吧!）,model中省略set和get方法（但是必须要有的喔）。

public class Beans {
    private List<Bean> beans = new ArrayList<Bean>();
    public void addBean(Bean bean){
        this.beans.add(bean);
    }
}

public class Bean {
    private String className;
    private String id;
    private List<Property> props = new ArrayList<Property>();
    public void addProperty(Property property){
        this.props.add(property);
    }
}   

public class Property {
    private String name;
    private String value;
    private String ref;
}

public class Main {
    public static void main(String[] args) throws IOException, SAXException {
        Digester digester = new Digester();
        digester.setValidating(false);
        digester.addObjectCreate("beans", Beans.class);

        // 如果配置文件中有多个bean，add一次即可
        digester.addObjectCreate("beans/bean", Bean.class);

        // 设置bean的属性<bean name="",id="">中的id和name。默认属性名和类中的属性名一样，不同的要特殊配置
        digester.addSetProperties("beans/bean", "class", "className");
        digester.addSetProperties("beans/bean");

        digester.addObjectCreate("beans/bean/property", Property.class);
        // 将标签中的属性赋给对象
        digester.addSetProperties("beans/bean/property");

        // 设置对象间的关系
        digester.addSetNext("beans/bean/property", "addProperty");
        digester.addSetNext("beans/bean", "addBean");

        InputStream in = ClassLoader.getSystemResourceAsStream("beans.xml");
        Beans beans = (Beans) digester.parse(in);
        List<Bean> beanList = beans.getBeans();
        for (Bean bean : beanList) {
            System.out.println("bean =================================================>");
            System.out.println("    id ==> " + bean.getId());
            List<Property> props = bean.getProps();
            for (Property prop : props) {
                System.out.println("    property =================================================>");
                System.out.println("        name ==> " + prop.getName());
                System.out.println("        ref ==> " + prop.getRef());
                System.out.println("        value ==> " + prop.getValue());
            }
        }
    }
}

现在信息从配置文件转到了jvm中，以类的形式存在。我们可以通过Class.forName(className)加载真正的beanA进入jvm。柿子捡软的捏，我们先创建一个beanB出来。

public class Main2 {    
    public static void main(String[] args) throws Exception {
        // 省略上述代码
        for (Bean bean : beanList) {
            if("org.lqk.container.bean.BeanB".equals(bean.getClassName())){
                // 加载类并创建对象
                Class clazz = Class.forName("org.lqk.container.bean.BeanB");
                Object obj = clazz.newInstance();
                // 为对象属性赋值
                List<Property> props = bean.getProps();
                String methodName = "set" + bigCaseFirstChar(props.get(0).getName());
                Method m = clazz.getMethod(methodName, String.class);
                m.invoke(obj, props.get(0).getValue());
                // 使用对象
                BeanB beanB = (BeanB)obj;
                System.out.println(beanB.getTitle());
                break;
            }
        }
    }
    // 将该字符串的首字母大写
    public static String bigCaseFirstChar(String prop) {
        char ch = (char) (prop.charAt(0) - 32);
        return prop.replaceFirst(prop.charAt(0) + "", ch + "");
    }
}

我们真的弄了一个类出来，虽然对经常用spring的人来说有点大惊小怪，但亲身体验一把，还是很有意义的。