guice和spring的整合

Guice真的无法享受企业级组件吗，JavaEye里炮轰Guice的占绝大多数。但如果Guice能整合Spring，那么我们似乎可以做很多有意义的事了。那么开始Spring整合之旅吧。不过crazybob在整合方面极不配合，就给了我们一个单元测试类，然后让我们自力更生。好在Guice本身足够简单。

 

 

首先还是来一个最简单无聊的HelloWorld整合吧。

 

HelloWorld.java

Java代码  

1. package com.leo.domain;  
2.   
3. public class HelloWorld {  
4.   
5.     public String sayHello(String str) {  
6.         return str;  
7.     }  
8. }  

 

 

够简单了吧。

  

现在开始编写你的applicationContext.xml（如果不熟悉Spring的话，可能无法继续往下看）。

为保持简洁，去掉了那一段DTD。

 

 

Xml代码  

1. <beans>  
2.     <bean id="helloWorld" class="com.leo.domain.HelloWorld" />  
3. </beans>  

 

 

好了，开始与Guice整合吧。

 Guice的核心就是com.google.inject.Module，它类似于Spring的bean工厂。 HelloWorldMyModule.java

 

 

Java代码  

1. package com.leo.module;  
2.   
3. import static com.google.inject.spring.SpringIntegration.fromSpring;  
4.   
5. import org.springframework.beans.factory.BeanFactory;  
6. import org.springframework.context.support.ClassPathXmlApplicationContext;  
7.   
8. import com.google.inject.Binder;  
9. import com.google.inject.Module;  
10. import com.leo.domain.HelloWorld;  
11.   
12. public class HelloWorldMyModule implements Module {  
13.     public void configure(Binder binder) {  
14.         final BeanFactory beanFactory = new ClassPathXmlApplicationContext(  
15.                 new String[] { "applicationContext.xml", "daoContext.xml" });  
16.         binder.bind(BeanFactory.class).toInstance(beanFactory);  
17.         binder.bind(HelloWorld.class).toProvider(  
18.                 fromSpring(HelloWorld.class, "helloWorld"));  
19.     }  
20. }  

 

 

 

其中：

 

 

Java代码  

1. final BeanFactory beanFactory = new ClassPathXmlApplicationContext(  
2.                 new String[] { "applicationContext.xml", "daoContext.xml" });  
3.         binder.bind(BeanFactory.class).toInstance(beanFactory);  

 

 

 

定义了Guice与Spring整合后，将spring工厂也由Guice托管。我感觉crazybob在与Spring整合事件上非常低调，给了个吓死人的单元测试，而且没有任何文档，这个单元测试里的bean都是临时动态注入进去的，不知道是因为出自对Spring XML配置的不满，还是根本没想到用Guice的人会去整合Spring，我个人感觉他在这一点上非常吝啬。 注意这一句：

 

Java代码  

1. binder.bind(HelloWorld.class).toProvider(  
2.                 fromSpring(HelloWorld.class, "helloWorld"));  

 

 

这与普通Guice本身托管的Bean注入不一样，fromSpring很明显说明这个bean来自于spring,而且与helloWorld与applicationContext.xml中定义的那个是一致的。

 

好了，我们开始来个单元测试

 

HelloWorldTest.java

Java代码  

1. package com.leo.service;  
2.   
3. import junit.framework.TestCase;  
4.   
5. import com.google.inject.Guice;  
6. import com.google.inject.Inject;  
7. import com.google.inject.Injector;  
8. import com.leo.domain.HelloWorld;  
9. import com.leo.module.HelloWorldMyModule;  
10.   
11. /** 
12.  * @author superleo 
13.  */  
14. public class HelloWorldTest extends TestCase {  
15.   
16.     @Inject  
17.     private HelloWorld helloWorld;  
18.   
19.     public void testHelloWorld() {  
20.         HelloWorldMyModule module = new HelloWorldMyModule(); // 建HelloWorldModule，生成Guice的bean工厂  
21.         HelloWorldTest test = new HelloWorldTest();  
22.         Injector in = Guice.createInjector(module);  
23.         in.injectMembers(test); // 将HelloWorldTest所依赖的helloWorld注入进去  
24.         System.out.println(test.helloWorld.sayHello("hey, hello-world"));  
25.     }  
26. }  

 

 

代码还是非常简单。运行后，正常的结果会出来在控制台上。但是这段代码能说明什么，无非就是helloWorld不需要set,get方法，但还多加了一大堆什么Injector, Module之类的。实际上在Guice与Struts2整合后，这些硬编码是不会出现的，而且如果不是因为与Spring整合，连Module里面配置HelloWorld都不要。但不是有人说Guice无法使用企业级组件吗?就单纯一个DI，根本就是玩具，但大家想想Guice能通过Spring来应用这些企业级组件的话，Guice还是有优势的。因为它够简单，够快，够灵活，强类型，本身没有XML(与其它框架整合，不能保证别的框架没有),几乎没有学习曲线，文档就一个HTML。因此，我现在想给大家运用JavaMail，这个算企业级常用的组件了吧？

 继续编写Spring的applicationContext.xml applicationContext.xml

 

 

Xml代码  

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">  
3.   
4. <beans>  
5.     <!-- Java Mail -->  
6.     <bean id="mailSender"  
7.         class="org.springframework.mail.javamail.JavaMailSenderImpl">  
8.         <property name="host" value="smtp.163.com" />  
9.         <!-- 有些邮件服务器发送邮件需要认证，所以必须提供帐号  -->  
10.         <property name="username" value="kyo100900@163.com" />  
11.         <property name="password" value="111111" />  
12.         <property name="javaMailProperties">  
13.             <props>  
14.                 <prop key="mail.smtp.auth">true</prop>  
15.             </props>  
16.         </property>  
17.     </bean>  
18.   
19.     <!--一个邮件模板(测试时使用)-->  
20.     <bean id="mailMessage"  
21.         class="org.springframework.mail.SimpleMailMessage">  
22.         <property name="to" value="superleo_cn@hotmail.com" />  
23.         <property name="from" value="kyo100900@163.com" />  
24.         <property name="subject" value="fdsfdsfsdfsd" />  
25.     </bean>  
26.   
27. </beans>  

 

 

 

上面就是大家在Spring配置文件里写烂了的代码，别的什么整合代码同理，就不多说了。 这时候，我们写一个JavaMailModule 

JavaMailModule.java

 

Java代码  

1. package com.leo.module;  
2.   
3. import static com.google.inject.spring.SpringIntegration.fromSpring;  
4.   
5. import org.springframework.beans.factory.BeanFactory;  
6. import org.springframework.context.support.ClassPathXmlApplicationContext;  
7. import org.springframework.mail.MailSender;  
8. import org.springframework.mail.SimpleMailMessage;  
9. import org.springframework.mail.javamail.JavaMailSenderImpl;  
10.   
11. import com.google.inject.Binder;  
12. import com.google.inject.Module;  
13.   
14. public class JavaMailModule implements Module {  
15.   
16.     public void configure(Binder binder) {  
17.         final BeanFactory beanFactory = new ClassPathXmlApplicationContext(  
18.                 new String[] { "applicationContext.xml"});  
19.         binder.bind(BeanFactory.class).toInstance(beanFactory);  
20.         binder.bind(SimpleMailMessage.class).toProvider(  
21.                 fromSpring(SimpleMailMessage.class, "mailMessage"));  
22.   
23.         binder.bind(MailSender.class).toProvider(  
24.                 fromSpring(JavaMailSenderImpl.class, "mailSender"));  
25.     }  
26.   
27. }  

 

 

 

和HelloWorld一样，只是分别换成了mailMessage, mailSender。写到这里大家肯定明白了，Guice与Spring整合其实非常非常简单。

 

写个测试吧：

JavaMail.java

 

Java代码  

1. package com.leo.util;  
2.   
3. import org.springframework.mail.MailSender;  
4. import org.springframework.mail.SimpleMailMessage;  
5.   
6. import com.google.inject.Guice;  
7. import com.google.inject.Inject;  
8. import com.google.inject.Injector;  
9. import com.leo.module.MyModuleSpring;  
10.   
11. public class JavaMail {  
12.   
13.     @Inject  
14.     private MailSender mailSender;  
15.   
16.     @Inject  
17.     private SimpleMailMessage mailMessage;// 邮件模板  
18.   
19.     public void sendMail() {  
20.   
21.         System.out.println("-----------发送邮件!---------");  
22.         mailMessage.setText("send maiiiiiiiiiiiiiiiil~~~~~~~~~~~~~~~~~~");  
23.         try {  
24.             System.out.println(mailSender.toString());  
25.             mailSender.send(mailMessage);  
26.         } catch (Exception e) {  
27.             e.printStackTrace();  
28.         }  
29.         System.out.println("-----------发送成功!---------");  
30.     }  
31.   
32.     public static void main(String... strings) {  
33.         MyModuleSpring spring = new MyModuleSpring();  
34.         JavaMail mail = new JavaMail();  
35.         Injector in = Guice.createInjector(spring);  
36.         in.injectMembers(mail);  
37.         mail.sendMail();  
38.     }  
39. }  

 

 

 

只要用户名密码正确，没有设置什么代理，防火墙之类的，就能正常的运行，但大家如果测试的时候，请把电子邮件改改。至于说与Hibernate，事务等整合，已经出了wrap框架了，有兴趣可以看看robbin写的《Warp framework - 一个相当有前途的Java框架》。 因此Guice不是完全不可能使用所谓的企业级组件的，直接使用Spring就可很容易做到。那么在应用Guice的时候，我感觉可以单独建立一个SpringModule，将Guice无法做到的事通过Spring工厂来帮你组装，其它方面，比如说Struts2的Action或Service层之间的注入等，直接用@Inject就得了，不要那么多set,get，(Struts2需要放入到值栈的属性例外)我们项目大多数Action超过几千行了，光set,get就几百行。Spring配置文件估计拼在一起也有几千行，但所谓注入到的其它企业级组件还不到5个，剩下全是service,dao,action等等。就算Spring可以autowire,也不是解决问题的根本。 

 

 

Guice当然也有缺点——太过于简单。不少JavaEE开发人员感觉似乎没有什么实际价值，更像是一种玩具。但我看好Guice的思想——简单而且类型安全。