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. >  
  3.   
  4. <beans>  
  5.       
  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="[email protected]" />  
  11.         <property name="password" value="111111" />  
  12.         <property name="javaMailProperties">  
  13.             <props>  
  14.                 <prop key="mail.smtp.auth">trueprop>  
  15.             props>  
  16.         property>  
  17.     bean>  
  18.   
  19.       
  20.     <bean id="mailMessage"  
  21.         class="org.springframework.mail.SimpleMailMessage">  
  22.         <property name="to" value="[email protected]" />  
  23.         <property name="from" value="[email protected]" />  
  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的思想——简单而且类型安全。


你可能感兴趣的:(java,框架)