简单，易于Mock，仅依赖Spring的Domain Model

声明：该贴并不讨论Domain Model对于企业应用是否有意义，JE已经讨论过很多了，有很多优秀的帖供参考，这里仅谈实现。

马丁大叔在《企业应用架构模式中》提出Domain Model（领域模型，领域对象，Domain Object）的概念后，我们发现这才是开发企业应用更OO的模式，以前的Transaction Script简直太土了。。。按照领域模型组织起来的面向对象语言代码，简直美极了，而ROR中的ActiveRecord就是一种Domain Model的实现，其威力大家也都见识过了。但是因为Java语言的特性的原因（例如静态类型），一直没有一种好的，优美的，简单的方式去实现，主要的难题就是领域对象和数据库逻辑的依赖关系（例如和Dao的依赖），大家关于这方面的尝试从来就没有断过，目前有以下几种主流的实现方式：

1 放弃IOC，在DomainObject里直接去获得Dao的Instance，例如在Domain Object里拿到Spring上下文，直接get所需要的Bean，这样的优势就是简单，缺点就是DomainObject与Dao的实现以及上下文的耦合，领域逻辑的执行依赖数据库，无法单元测试。有的观点认为利用内存数据库，这样比真正的访问数据库要快，要方便，认为mock dao没有意义，这个观点还持保留意见 ：）

2 利用一些框架的特性去实现Dao或者数据库访问能力的注入，例如利用Hibernate Interceptor，在Domain Object持久化的时候注入，这个方式有个明显的缺点就是Domain Object的生命周期依赖特定环境，也就是说这个Domain Object必须是由Hibernate构造的，其才会被注入Dao。这点其实很郁闷，我们以前有个项目就是用这种方式，自己写了Hibernate Interceptor去注入Domain Object，初看很爽很EASY，但是表现层这边，DWR将用户提交的表单数据转换成DomainObject后，那个Dao当然就是NULL了，于是自己又写了个DWR的 Convertor，去实现注入，而这个Domain Object真的是很Rich，随后又要通过web serivce传输，又要在webservice框架里加拦截器实现注入，真的是很郁闷。

3 将Dao通过方法参数传入，优点就是简单，POJOS In Action里就提到了这种方式，缺点就是会影响方法以及接口的设计，经常会出现一个方法会有6个参数之多，而5个都是Dao，真是很丑陋。

4 利用AspectJ等工具实现编译期注入，Spring 2.0刚出的时候，引入了AspectJ，其Reference中就提到了这个方式，我也尝试过，非常的麻烦，而且性能很慢，没记错的话当时大概是06年10月份，用的JDK5，现在不知道有没有改善，我当时还在JE发过新手帖询问过，某大牛说是BEA的虚拟机对其有优化，我也没条件尝试，而且编译期的手脚动太多了，感觉不是很好。

上述几种方式都有明显的缺点，我们追求的好的领域模型的实现就是，领域模型不依赖实现，例如可以注入，易于单元测试，而且其生命周期不依赖特定的环境，还要够简单！难道真是Robbin所说的JAVA不适合Rich Domain Model吗？不见得：

首先，不依赖实现，可以注入，那么要在领域模型中提供接口dao的set方法，允许被注入，这个很明确。

其次，领域模型的生命周期不依赖环境， 不依赖hibernate的构造，不被spring管理等。一般的情况，dao都是无状态的，单例的，那么把领域模型中的依赖的dao设置为static，static是class级别的，和具体的instance没关系，只要在应用初始化的时候给所有的领域模型的class注入一次，整个应用运行的时间周期，领域模型随意怎么new，在哪new，new出来的Domain Object的都可以访问一开始被注入的static的dao，实现了领域模型的生命周期不依赖环境，这样也易于测试，易于MOCK，和目前传统编程方式差别很小，仅仅把dao改为static的。

 

但是spring可以实现对一个class的静态peroperty注入吗？答案是不能（经bottom同学修正，spring是可以静态property注入，但是还是要在所有bean初始化之前注入才行，所以还是要扩展，我在3楼已经回复说明），但是spring是个优美扩展性强的框架，我们只要稍微扩展一下，就可以达到我们的目的。

就拿一个典型的web应用为例，普遍的方式的是在web.xml配置spring的context loader listener和spring的配置文件，这个listener会在应用启动时，创建并初始化spring的上下文，我们需要在所有bean初始化之前注入domain class，那么就在这里找切入点，通过spring的源代码可以发现类AbstractApplicationContext的refresh方法内的finishBeanFactoryInitialization有些重要的东东。

/**
 * Finish the initialization of this context's bean factory,
 * initializing all remaining singleton beans.
*/
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
       // 省略
       // Instantiate all remaining (non-lazy-init) singletons.
        // 这里，会初始化所有的单例
       beanFactory.preInstantiateSingletons();
}

通过观察代码发现，初始化单例其实就是将Spring配置文件中定义的所有不是lazy init的单例初始化了，对一个Bean的初始化就是调用getBean来完成，Spring在调用getBean的时候，会判断如果已经初始化了就直接返回给你Bean的引用，否则就初始化这个Bean再返回给你，很典型的实现LAZY的方式。

我们只需要在这个初始化方法之前，主动去扫描所有的领域模型class，并且知道他们需要注入的Dao，直接getBean获得dao的实例，并且注入进Domain Model的class就完成了，那么我们只需要自己实现一个ConfigurableListableBeanFactory接口，也就是继承DefaultListableBeanFactory（其是ConfigurableListableBeanFactory接口的默认实现）， 并且在preInstantiateSingletons方法的时候先注入领域模型，巨简单

private class StaticPropertyInjectSupportListableBeanFactory extends DefaultListableBeanFactory {
       @Override//覆盖父类的方法
       public void preInstantiateSingletons() throws BeansException {
              //先注入所有的领域模型的class
              injectStaticPropertyForBasePackage();
              //再调用父类的该方法去初始化所有的非LAZY单例
              super.preInstantiateSingletons();
       }
}

继续观察代码，finishBeanFactoryInitialization的方法的参数ConfigurableListableBeanFactory，是通过调用的createBeanFactory方法获得的，默认的实现在AbstractRefreshableApplicationContext中有这样一个方法，去创建DefaultListableBeanFactory，而这个方法是protected的，摆明着让我们去复盖扩展其功能，这也是spring易于扩展的体现，我们只要实现一个自己的ApplicaitonContext，覆盖createBeanFactory方法创建我们刚才自己实现的StaticPropertyInjectSupportListableBeanFactory就OK了，代码也巨简单

public class StaticPropertyInjectSupportXmlWebApplicationContext extends XmlWebApplicationContext {
       @Override
       protected DefaultListableBeanFactory createBeanFactory() {
              return new StaticPropertyInjectSupportListableBeanFactory(getInternalParentBeanFactory());
       }
}

实现了自己的ApplicationContext，怎么让Spring启动的时候初始化你的上下文呢？当然可以了，spring提供了扩展的后门，只要在web.xml配置context parameter "contextClass"告诉spring，他就会用你自己的ApplicationContext去初始化了，不配置该参数默认的ApplicationContext实现是XmlWebApplicationContext。

关于自己实现静态property的注入就很简单了，在context parameter里加入个参数configurableBeanBasePackage，获得所有要注入的领域模型的父包，就可以了，如下

<!--加入这两个参数，其余不变 -->
<!--告诉spring用我们自己实现的支持静态bean注入的context -->
<context-param>
        <param-name>contextClass</param-name>
	<param-value>com.norther.sps.StaticPropertyInjectSupportXmlWebApplicationContext</param-value>
</context-param>
<!--注入com.norther包下（包含子包）所有的领域模型的class-->
<context-param>  
	<param-name>configurableBeanBasePackage</param-name>
	<param-value>com.norther</param-value>
</context-param>

这样就OK了，有人会想到这样还是有一点点点点麻烦，用PostProcessorBean或者Spring的容器初始化完毕的事件去实现注入static property不是更爽吗？这也是我最先想到的方式，但是这两种方式的注入的时间太靠后了，那个preInstantiateSingletons方法 已经被调用过了，有些bean已经被初始化了，例如quartz的SchedulerFactoryBean，就有可能你部署的quartz或者其他的 job已经开始跑了，但是领域模型还没有被注入，在那些job里调用领域模型都会空指针，所以一定要在preInstantiateSingletons方法调用前去注入。

 

那么如何辨别哪些是领域模型呢？就利用了spring的Configurable这个annotation去标识这个是需要静态注入的领域模型，然后自己实现了两种自动装配，BY_TYPE和BY_NAME，以及JSR-250的Resource annotation，例子如下

@Configurable
public class Student {
       private Long id;

       @Resource //注入field的名字所代表的bean,
       private static StudentDao studentDao;

       public static void setStudentDao(StudentDao studentDao) {
              Student.studentDao = studentDao;
       }

 

@Configurable
public class Assistant {
       private static StudentDao studentDao;

       @Resource(name = "studentDao") //注入name为studentDao的bean 
       public static void setDao(StudentDao studentDao) {
              Assistant.studentDao = studentDao;
       }

@Configurable(autowire = Autowire.BY_TYPE)//自动装配
public class SchoolMaster {
       private static StudentDao studentDao;

       // by type
       public static void setDao(StudentDao studentDao) {
              SchoolMaster.studentDao = studentDao;
       }

单元测试以及Mock

@Configurable(autowire = Autowire.BY_NAME)//自动装配
public class Teacher {
       private static StudentDao studentDao;

       public static void setStudentDao(StudentDao studentDao) {
              Teacher.studentDao = studentDao;
       }

       public List<Students> getStudents() {
              return studentDao.getByClassId(this.getClassId());
       }

 

 

 StudentDao studentDao = EasyMock.createMock(StudentDao.class);
 EasyMock.expected(studentDao.getByClassId(998877)).andReturn(students);

 Teacher.setStudentDao(studentDao);
 Teacher zhang3 = new Teacher();
 zhang3.setClassId(998877);//设置班级ID
 List<Student> actual = zhang3.getStudents();
 .......

后半部分说了这么多其实都是实现static property的注入，原理很简单，代码也很简单，就4个类，但是我认为这么简单的东西spring之类的框架可以更容易并且实现的更好，也就是说目前的java可以简单的解决领域对象和dao依赖的问题从而实现rich domain model。

 

当然这个代码只是demo性质的，实现的比较简单，只有web方式的实现方法，希望和大家共同讨论。

 

评论

7 楼 jianfeng008cn 2008-05-16  

Norther 写道

谢谢楼上同学的纠正，这个当然算静态property注入，但是，在bean的初始化的时候，每个bean初始化的时间是不确定的，仅spring管理的bean有依赖初始化的关系，而我们的domain model是class级别的注入，这个依赖关系，spring无法知道，而只有在这个MethodInvokingFactoryBean被spring初始化的时候才去注入，有可能这个时候，其他调用Domain Object的quartz的job已经再开始跑了，但是他们去执行一些domain object的方法时，他们都还没有被注入，所以必须要要在所有的bean初始化之前去注入，才能保证所有的spring管理的bean去调用domain object时，他们都是被注入过的。

既然你的调用是有依赖的 用spring配置了这些有依赖关系的bean 那么初始化的时候也肯定会根据这个关系生成实例，怎么会和你说的这样呢？ 比方说 a 依赖于b 在实例化a的时候 发现b还没有实例化 那肯定会先去实例化b啊，即使lazy了 哪么用的时候肯定要实例化了吧

6 楼 Norther 2008-05-16  

moonranger 写道

你这个思路个人感觉的确不错，值得一试。但是仍有一个非常关键的问题没有解决，那就是事务问题。按照你这种方式实现的Rich Domain Object怎么配置事务呢？事务放在哪一层？

方式很多，粒度粗的直接在action的execute声明事务，粒度细的可以用facade去包装一下，在facade方法上声明事务，粒度再细的直接上spring transaction template，

5 楼 Norther 2008-05-16  

taowen 写道

利用static的缺陷就是在一个JVM中，它是一直在那的。如果有多个测试用一个JVM跑的话，容易产生上下文依赖。而且static隐含的要求了所有的依赖都必须是singleton的。
同时，个人认为mock DAO实在太麻烦，而且没法测试到行为，只能defend你的实现。

1 这个缺陷很好克服，在tearDown时给他set成Null就行了，static也不是在一个jvm，是classloader级别的，另外产生下文依赖不是很明白什么意思？

2 static要求所有的依赖都是单例的，这个要求大家都已经实现了，普遍情况下，被spring管理的dao和service也都是无状态的，单例的，IOC就是被注入，是被动的，bean是无法控制注入进来的对象的生命周期，至少不是他构造的，

3 mock dao的麻烦在哪？能否请taowen同学说明，我不是很理解。mock是不能测试行为，他仅仅测试接口之间的约定，那用stub就可以了，易于mock的意义不在于mock本身，而在于弱耦合可以随意替换实现，不管mock还是什么其他的方式， set进去就好了。

4 楼 moonranger 2008-05-16  

你这个思路个人感觉的确不错，值得一试。但是仍有一个非常关键的问题没有解决，那就是事务问题。按照你这种方式实现的Rich Domain Object怎么配置事务呢？事务放在哪一层？

3 楼 taowen 2008-05-16  

利用static的缺陷就是在一个JVM中，它是一直在那的。如果有多个测试用一个JVM跑的话，容易产生上下文依赖。而且static隐含的要求了所有的依赖都必须是singleton的。
同时，个人认为mock DAO实在太麻烦，而且没法测试到行为，只能defend你的实现。

2 楼 Norther 2008-05-16  

谢谢楼上同学的纠正，这个当然算静态property注入，但是，在bean的初始化的时候，每个bean初始化的时间是不确定的，仅spring管理的bean有依赖初始化的关系，而我们的domain model是class级别的注入，这个依赖关系，spring无法知道，而只有在这个MethodInvokingFactoryBean被spring初始化的时候才去注入，有可能这个时候，其他调用Domain Object的quartz的job已经再开始跑了，但是他们去执行一些domain object的方法时，他们都还没有被注入，所以必须要要在所有的bean初始化之前去注入，才能保证所有的spring管理的bean去调用domain object时，他们都是被注入过的。

1 楼 bottom 2008-05-16  

但是spring可以实现对一个class的静态peroperty注入吗？答案是不能。

这个算不算是静态peroperty注入？

<bean id="teacher"  class="org.springframework.beans.factory.config.MethodInvokingFactoryBean">
<property name="staticMethod">
<value>com...Teacher.setStudentDao</value>
</property>
<property name="arguments">
<list>
<ref bean="studentDao" />
</list>
</property>
</bean>