用spring做领域对象的依赖注入

依赖注入是现在一个使用非常广泛的技术，极大的降低了编写程序的难度。对于领域层的代码，我们也想使用依赖注入。对于无状态的service repository factory等对象，我们可以用spring容器初始化它们，把它们作为普通的spring的bean，这样它们天生就能被注入依赖了。对于entity, value objects这些有状态的对象，依赖注入就有点麻烦了。

让spring帮我们注入依赖

如果手动注入依赖，会很麻烦，如下：

public class CFactory { 
	private A a; 
	private B b; 

	public C creaetC() { 
		C c = new C(); //手动注入依赖 
		c.setA(a); 
		c.setB(b); 
		return c; 
	} 

	@Autowired 
	public void setA(A a) { 
		this.a = a; 
	} 

	@Autowired 
	public void setB(B a) { 
		this.b = b; 
	} 
}

这样不仅代码量大，而且不灵活，如果以后C需要注入其它依赖，所有初始它的地方都要多写很多代码。因此，我们需要spring能够帮助我们自动注入依赖。通过下面的代码可以完成：

public class AutowireInjector implements ApplicationContextAware {
    private ApplicationContext applicationContext;

    public void autowire(Object bean) {
        this.applicationContext.getAutowireCapableBeanFactory().autowireBean(bean);
    }

    public void autowireBeanProperties(Object existingBean, int autowireMode, boolean dependencyCheck) {
        this.applicationContext.getAutowireCapableBeanFactory().autowireBeanProperties(existingBean, autowireMode, dependencyCheck);
    }

    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }
}

通过调用autowire方法，会自动根据对象里的@Autowired注入依赖，如下：

public class C {
    private A a;
    private B b;

    @Autowired
    public void setA(A a) {
        this.a = a;
    }

    @Autowired
    public void setB(B a) {
        this.b = b;
    }
}

public class CFactory {
    private AutowireInjector autowireInjector;

    public C creaetC() {
        C c = new C(); 
        //spring 会自动注入依赖 a b 
        this.autowireInjector.autowire(c); 
        return c; 
    } 
    
    @Autowired 
    public void setAutowireInjector(AutowireInjector autowireInjector) { 
        this.autowireInjector = autowireInjector; 
    } 
} 

这样不论C的依赖要求如何变化，CFactory里面都只要注入autowireInjector就行了。改了C不需要动CFactory。

利用AOP简化依赖注入

尽管有了AutowireInjector，但是还要注入很多AutowireInjector，手动调用autowire方法，还是不够方便。假如限定Entity只能通过Factory或Repository获取，我们就可以使用AOP，对Factory和Repository返回的领域对象注入依赖。用如下代码实现：

@Component
@Aspect
public class AutoWireAopConfig {
    private AutowireInjector autowireInjector;

    @Pointcut("execution(public * com.my..*Factory.create*(..))")
    public void factoryCreate() {
    }

    ;

    @Pointcut("execution(public * com.my..*Repository.find*(..))")
    public void repositoryFind() {
    }

    ;

    @AfterReturning(pointcut = "factoryCreate() || repositoryFind()", returning = "returnObject")
    public void injectAutowire(Object returnObject) {
        doInjection(returnObject);
    }

    public void doInjection(Object o) {
        if (o == null) {
            return;
        }
        if (o instanceof Collection) {
            Collection c = (Collection) o;
            for (Object subObject : c) {
                doInjection(subObject);
            }
            return;
        }
        if (o.getClass().isArray()) {
            int length = Array.getLength(o);
            for (int i = 0; i < length; i++) {
                doInjection(Array.get(o, i));
            }
            return;
        }
        if (o instanceof Map) {
            Collection c = ((Map) o).values();
            for (Object subObject : c) {
                doInjection(subObject);
            }
            return;
        }
        if (o.getClass().getCanonicalName().startsWith("com.my")) {
            this.autowireInjector.autowire(o);
        }
    }

    @Autowired
    public void setAutowireInjector(AutowireInjector autowireInjector) {
        this.autowireInjector = autowireInjector;
    }
} 

 这样，只要Factory和Repository以Factory和Repository作为类名的后缀，以create find作为方法的前缀，其返回值就会被注入依赖，而且支持返回领域对象集合。那此不通过Factory和Repository创建的对象，还是须要手动的注入依赖。

给hibernate载入的对象注入依赖

如果对象是通过hibernate从数据库载入的，那么可以通过hibernate的EntityListener注入依赖。首先得定义Listener类:

public class HibernateEntityDependencyInjector implements PostLoadEventListener, MergeEventListener {
    private AutowireInjector autowireInjector;

    @Override
    public void onPostLoad(PostLoadEvent event) {
        this.injectDependency(event.getEntity());
    }

    @Override
    public void onMerge(MergeEvent event) throws HibernateException {
        this.injectDependency(event.getEntity());
    }

    @Override
    public void onMerge(MergeEvent event, Map copiedAlready) throws HibernateException {
        this.injectDependency(event.getEntity());
    }

    protected void injectDependency(Object obj) {
        if (obj != null) {
            this.autowireInjector.autowire(obj);
        }
    }

    @Autowired
    public void setAutowireInjector(AutowireInjector autowireInjector) {
        this.autowireInjector = autowireInjector;
    }
} 

 然后通过spring，把它配置到SessionFactory里面:

<bean id="hibernateEntityDependencyInjector" class="com.my.HibernateEntityDependencyInjector"/> 
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
    <property name="dataSource" ref="dataSource"/>
    <property name="configLocation" value="classpath:/hibernate.cfg.xml"/>
    <property name="eventListeners">
        <map>
            <entry key="post-load" value-ref="hibernateEntityDependencyInjector"/>
            <entry key="merge" value-ref="hibernateEntityDependencyInjector"/>
        </map>
    </property>
</bean>

 这样，在post-load和merge的时候，会注入依赖。对于@Embedded的对象，这样是不管用的，还没有找到更好的办法。

转载于:https://my.oschina.net/komodo/blog/919176