背景：在JAVA中执行groovy有多种方式，个人觉得最舒服的莫过于使用IDE插件创建groovy工程，这样可以直接在java代码中引用groovy的类。因groovy的IDE插件会自动对groovy脚本编译，并生成相应的class放于工程的output目录下，这样在编译时就不会报错，直接使用groovy类了。这种方式在协作开发时就有了不便，这要求团队中其它人也要使用groovy插件，否则别人的环境中就会编译报错，且个人觉得目前eclipse对groovy的支持不是很好，如果没有创建groovy工程，那么脚本默认不会自动编译（可能是我个人没有找到好的方式），所以如果要在老的项目中使用一些groovy实现，那么可能还是需要使用脚本引擎或者groovy的GroovyShell或GroovyClassLoader。

       本文是JAVA与groovy交互的例子，通过简单的解析xml配置的例子，涉及了JAVA与groovy中互相调用、使用groovy解析xml的方法。

1、环境

       需下载groovy的发布包,解压后将其lib下如下jar加入工程的classpath,本文使用的是groovy1.8.6版本。

2、代码

   代码结构：

 

    先给出解析的xml配置文件，一个简单的用户管理配置users.xml，主要包含两个elements，分别是users、roles,即用户和角色：

 
  
  1. <?xml version="1.0" encoding="UTF-8"?> 
  2. <userMgr> 
  3.     <users role="administrator"> 
  4.         <user name="root"> 
  5.             <authType>local</authType> 
  6.             <type>admin</type> 
  7.         </user> 
  8.         <user name="domain"> 
  9.             <authType>LDAP</authType> 
  10.             <type>admin</type> 
  11.         </user> 
  12.     </users> 
  13.  
  14.     <roles> 
  15.         <role name="administrator"> 
  16.             <auth>user</auth> 
  17.             <auth>res</auth> 
  18.         </role> 
  19.     </roles> 
  20. </userMgr> 
 
  
    再给出解析该xml的groovy脚本parseUserXml.groovy，该脚本通过JAVA client传递的输入流解析xml并打印输出各节点，并且将xml转为java模型存储到JAVA的缓存中,代码有些冗长但多数代码是在做打印输出和模型转换，而具体的xml的解析实际是很简单的:    
 
  
 
  
  1. import groovy.CacheXml; 
  2. import model.*; 
  3.  
  4. def doParse(InputStream ins){ 
  5.  
  6.     // 使用输入流构造XmlParser 
  7.     def userMgr = new XmlParser().parse(ins) 
  8.  
  9.     println "---------- users ----------" 
  10.     println "role:" + userMgr.users[0].attribute("role") 
  11.  
  12.     // 对于非遍历的情况类似数据的操作，可直接用下标引用 
  13.     userMgr.users[0].user.each { 
  14.         println "\nuser name: " + it.attribute("name") 
  15.         println "user authType: " + it.authType.text() 
  16.         println "user type: " + it.type.text() 
  17.  
  18.         // 转换为java模型并加入缓存 
  19.         User user = new User(); 
  20.         user.setAuthType(it.authType.text()) 
  21.         user.setName(it.attribute("name")) 
  22.         user.setType(it.type.text()) 
  23.         CacheXml.getInstance().put(user.getName(), user); 
  24.     } 
  25.  
  26.     println "\n---------- roles ----------" 
  27.  
  28.     // 闭包嵌套 
  29.     userMgr.roles[0].role.each {role -> 
  30.         println "role type" + role.attribute("name") 
  31.          
  32.         // 转换为java模型并加入缓存 
  33.         Role rol = new Role() 
  34.         rol.setName(role.attribute("name")) 
  35.         Set authSet = new HashSet(); 
  36.          
  37.         role.each { 
  38.             println "auth: " + it.text() 
  39.             authSet.add(it.text()); 
  40.         } 
  41.          
  42.         rol.setAuths(authSet); 
  43.         CacheXml.getInstance().put(rol.getName(), rol) 
  44.     } 
  45. } 
 
  
 User.java和Role.java只是两个JavaBean，其属性对应着xml中相关配置，实现时只是重写了toString方法（使用eclipse的缺省实现），这里省略其代码。CacheXml是一个map缓存用来缓存配置转换后的模型对象：
 
  
 
  
  1. import java.util.HashMap; 
  2. import java.util.Map; 
  3. import java.util.Map.Entry; 
  4. import java.util.Set; 
  5.  
  6. public class CacheXml 
  7. { 
  8.     private static CacheXml cx = null; 
  9.  
  10.     private static Map<String, Object> map1 = new HashMap<String, Object>(); 
  11.  
  12.     public static synchronized CacheXml getInstance() 
  13.     { 
  14.         if (cx == null) 
  15.         { 
  16.             return new CacheXml(); 
  17.         } 
  18.         return cx; 
  19.     } 
  20.  
  21.     public static void put(String key, Object value) 
  22.     { 
  23.         map1.put(key, value); 
  24.     } 
  25.  
  26.     public String toString() 
  27.     { 
  28.         StringBuilder sb = new StringBuilder(); 
  29.  
  30.         Set<Entry<String, Object>> set = map1.entrySet(); 
  31.  
  32.         for (Entry<String, Object> entry : set) 
  33.         { 
  34.             sb.append("key:" + entry.getKey() + ",value:" + entry.getValue() 
  35.                     + "\n"); 
  36.         } 
  37.  
  38.         return sb.toString(); 
  39.     } 
  40. } 
 
  
        最后给出调用groovy的JAVA client
 
  
 
  
  1. package groovy; 
  2.  
  3. import java.io.IOException; 
  4. import java.io.InputStream; 
  5. import java.io.InputStreamReader; 
  6.  
  7. import javax.script.Invocable; 
  8. import javax.script.ScriptEngine; 
  9. import javax.script.ScriptEngineManager; 
  10. import javax.script.SimpleBindings; 
  11.  
  12. public class XmlParserWithEngineManager 
  13. { 
  14.  
  15.     public static void main(String[] args) 
  16.     { 
  17.         // 使用java script API获取脚本引擎 
  18.         ScriptEngineManager sem = new ScriptEngineManager(); 
  19.         ScriptEngine engine = sem.getEngineByName("groovy"); 
  20.  
  21.         // 绑定入参 
  22.         SimpleBindings bindings = new SimpleBindings(); 
  23.         InputStream inXml = XmlParserWithEngineManager.class 
  24.                 .getResourceAsStream("/users.xml"); 
  25.         bindings.put("ins", inXml); 
  26.  
  27.         InputStream in = null; 
  28.         try 
  29.         { 
  30.             in = XmlParserWithEngineManager.class 
  31.                     .getResourceAsStream("/groovy/parseUserXml.groovy"); 
  32.              
  33.             Invocable inv = (Invocable) engine; 
  34.              
  35.             engine.eval(new InputStreamReader(in), bindings); 
  36.             inv.invokeFunction("doParse", new Object[] { inXml }); 
  37.              
  38.             System.out.println("---------- IN JAVA ----------\n" 
  39.  + CacheXml.getInstance().toString()); 
  40.              
  41.         } 
  42.         catch (Exception ex) 
  43.         { 
  44.  // TODO
  45.             ex.printStackTrace(); 
  46.         } 
  47.         finally 
  48.         { 
  49.             if (in != null) 
  50.             { 
  51.                 try 
  52.                 { 
  53.                     in.close(); 
  54.                 } 
  55.                 catch (IOException e) 
  56.                 { 
  57.                     // TODO 
  58.                     e.printStackTrace(); 
  59.                 } 
  60.             } 
  61.             if (inXml != null) 
  62.             { 
  63.                 try 
  64.                 { 
  65.                     inXml.close(); 
  66.                 } 
  67.                 catch (IOException e) 
  68.                 { 
  69.                     // TODO 
  70.                     e.printStackTrace(); 
  71.                 } 
  72.             } 
  73.         } 
  74.     } 
  75. } 
 
  
3、运行
 
  
        运行XmlParserWithEngineManager类，有如下控制台输出：
 
  
 
  
  1. ---------- users ---------- 
  2. role:administrator 
  3.  
  4. user name: root 
  5. user authType: local 
  6. user type: admin 
  7.  
  8. user name: domain 
  9. user authType: LDAP 
  10. user type: admin 
  11.  
  12. ---------- roles ---------- 
  13. role typeadministrator 
  14. auth: user 
  15. auth: res 
  16. ---------- IN JAVA ---------- 
  17. key:root,value:User [name=root, authType=local, type=admin] 
  18. key:administrator,value:Role [name=administrator, auths=[res, user]] 
  19. key:domain,value:User [name=domain, authType=LDAP, type=admin]