java 内嵌Groovy动态脚本操作

package com.webTest.dynamicGroovy.controller;

import groovy.lang.GroovyObject;

import java.io.File;

import java.io.IOException;

import java.util.HashMap;

import java.util.Map;

import javax.servlet.http.HttpServletRequest;

import org.apache.log4j.Logger;

import org.codehaus.groovy.control.CompilationFailedException;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Controller;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RequestMethod;

import org.springframework.web.bind.annotation.ResponseBody;

import com.base.common.GroovyUtils;

import com.webTest.dynamicGroovy.bean.GroovyBean;

import com.webTest.dynamicGroovy.groovyInterface.CallBackGroovyInvoke;

import com.webTest.dynamicGroovy.service.CallBackGroovy;

@Controller

@RequestMapping ( "/groovyTest" )

public class GroovyControl {   

     private Logger logger = Logger.getLogger(GroovyControl. class );     

     @Autowired

     private CallBackGroovy callBackGroovy;     

     @ResponseBody

     @RequestMapping (value= "/groovy1.do" ,method={RequestMethod.GET,RequestMethod.POST})

     public   Object testGroovy(HttpServletRequest request) throws CompilationFailedException, IOException, InstantiationException, IllegalAccessException, ClassNotFoundException{

         logger.info( "测试动态脚本语言Groovy Begin。。。" );

         String name= "崔春驰" ;

         String realPath = request.getSession().getServletContext().getRealPath( "groovyFile" );

         String groovyNameString = "\\hello.groovy" ;

         String path = realPath+groovyNameString;

         File file = new File(path);

         //获得class，并存放入堆缓存

         Class<?> groovyClass = GroovyUtils.CLASS_LOADER.parseClass( "myFirstGroovy" ,file, true );

         //获取groovyObject的实例

         GroovyObject  groovyObject = (GroovyObject) groovyClass.newInstance();

         //反射执行方法，得到返回信息   传多个参数 new Object[]{bean,request,new HashMap<>()}

         Object invokeResult = groovyObject.invokeMethod( "sayHello" , name);

         if (invokeResult != null ){

             System.out.println(invokeResult.toString());

         }

         //清楚缓存中的map  是为了grrovy脚本变化，清楚堆中缓存，重新类加载

         logger.info( "测试动态脚本语言Groovy End。。。" );

         return invokeResult;

     }

     @ResponseBody

     @RequestMapping (value= "/groovy2.do" ,method={RequestMethod.GET,RequestMethod.POST})

     public   Object testGroovy2(HttpServletRequest request) throws CompilationFailedException, IOException, InstantiationException, IllegalAccessException, ClassNotFoundException{

         logger.info( "测试动态脚本语言Groovy2 Begin。。。" );

         String realPath = request.getSession().getServletContext().getRealPath( "groovyFile" );

         String groovyNameString = "\\testGroovyBean.groovy" ;

         String path = realPath+groovyNameString;

         File file = new File(path);

         GroovyBean bean = new GroovyBean();

         bean.setNameString( "王小二" );bean.setAge( 12 );

         Map<String, Object> map = new HashMap<>();

         map.put( "address" , "江苏南京" );

         //获得class，并存放入堆缓存

         Class<?> groovyClass = GroovyUtils.CLASS_LOADER.parseClass( "mySecondGroovy" ,file, true );

         //获取groovyObject的实例

         CallBackGroovyInvoke  groovyObject = (CallBackGroovyInvoke) groovyClass.newInstance();

         //反射执行方法，得到返回信息

         Object doCallBackVal = groovyObject.doCallBack(bean, request, map);

         if (doCallBackVal instanceof GroovyBean){

             GroovyBean bean2  = (GroovyBean) doCallBackVal;

             System.out.println( "用户信息---》" +bean2.getNameString() + ":" +bean2.getAge()+ "岁" );

         }

         System.out.println( "统一groovy接口返回数据————————》" +doCallBackVal);

         //清楚缓存中的map  是为了grrovy脚本变化，清楚堆中缓存，重新类加载

         logger.info( "测试动态脚本语言Groovy2 End。。。" );

         return doCallBackVal;

     }

     @ResponseBody

     @RequestMapping (value= "/clearGroovyCache.do" ,method={RequestMethod.GET,RequestMethod.POST})

     public void clearCache(){

         //根据指定key来清楚

         GroovyUtils.CLASS_LOADER.clearCache( "myFirstGroovy" );

         //清楚所有

         GroovyUtils.CLASS_LOADER.clearCache();

     }

}

public class GroovyUtils {

  public static GroovyClassLoaderCommon CLASS_LOADER = null ;

  static {

   CompilerConfiguration configuration = CompilerConfiguration.DEFAULT;

   configuration.setSourceEncoding( "UTF-8" );

   CLASS_LOADER = new GroovyClassLoaderCommon(GroovyControl. class .getClassLoader(), configuration);

  }

}

package com.webTest.dynamicGroovy;

import groovy.lang.GroovyClassLoader;

import groovy.lang.GroovyCodeSource;

import java.io.File;

import java.io.FileNotFoundException;

import java.util.Map;

import java.util.concurrent.ConcurrentHashMap;

import org.codehaus.groovy.control.CompilationFailedException;

import org.codehaus.groovy.control.CompilerConfiguration;

public final class GroovyClassLoaderCommon extends GroovyClassLoader{

     //这一步可以放入分布式缓存中，如redis中，统一来管理，防止多次对groovy的变动，可以根据缓存开关来及时的更新到jvm中

     private static final Map<String, Object> CACHEMAP_MAP = new ConcurrentHashMap<>();

     public GroovyClassLoaderCommon() {

         super ();

     }

     public GroovyClassLoaderCommon(ClassLoader loader, CompilerConfiguration config){

         super (loader, config);

     }

     /**

      *

      * @param file  文件

      * @param shouldCacheSource   是否缓存

      * @return

      * @throws CompilationFailedException

      * @throws FileNotFoundException

      * Class<?>

      * @author 88397658

      * @since

      */

     public Class<?> parseClass(String key,File file,

             boolean shouldCacheSource) throws CompilationFailedException, FileNotFoundException {

         GroovyCodeSource codeSource = new GroovyCodeSource(file);

         codeSource.setCachable(shouldCacheSource);

         if (shouldCacheSource) CACHEMAP_MAP.put(key, codeSource.getName());

         return super .parseClass(codeSource);

     }

     /**

      * 清楚缓存

      */

     public void clearCache(){

         synchronized ( this ) {

             sourceCache.clear();

         }

     }

     /**

      * 清楚指定缓存

      * @param key

      * void

      * @author 88397658

      * @since

      */

     public void clearCache(String key){

         Object value = CACHEMAP_MAP.get(key);

         synchronized ( this ) {

             if (sourceCache.containsKey(value)) sourceCache.remove(value);

             if (CACHEMAP_MAP.containsKey(key)) CACHEMAP_MAP.remove(key);

         }

     }

}

import java.util.Date;

def sayHello(name){

     println name+ "向你说 [你好！！]" ;

     def date = new Date();

     return "success sayHello()+test  groovy" +date;

}

<!--可以直接调用 -->

sayHello( 'asda' );

import com.webTest.dynamicGroovy.groovyInterface.CallBackGroovyInvoke;

import javax.servlet.http.HttpServletRequest;

import java.util.Map;

import com.webTest.dynamicGroovy.bean.GroovyBean;

import org.slf4j.Logger

import org.slf4j.LoggerFactory

class testGroovyBean implements CallBackGroovyInvoke{

     public static final Logger LOGGER = LoggerFactory.getLogger(testGroovyBean. class ); 

     def doCallBack(GroovyBean bean ,HttpServletRequest request, Map<String, Object> map){

         LOGGER.info( "groovy 中记录日志。。。。" );

         println "测试接口groovy 获取用户信息：" +bean.getNameString() + " ；年龄:" +bean.getAge();

         println "设置用户信息：" ;

         bean.setNameString( "蛮王" );bean.setAge( 200 );

         def map1 = [ 'name' : '王大锤' , 'sex' : '男' ];

         map = map+map1+[ 'weight' : '160' ];

         def str =  otherMethod();

         LOGGER.info(str);

//      return map

         return bean;

     }

     def otherMethod(){

         println "在不重启应用的情况下，调用内部其他方法" ;

         return "我进入了，另一个方法！" ;

     }

}