KK: []
DJ: []
a.
1. 【俚】绝妙的时髦的
2. 墨守成规的
以上结果由 Dr.eye译典通字典 提供
groove
KK: []
DJ: []
n.[C]
1. 沟槽(车)辙(唱片)纹(道)
Wheels leave grooves in a dirt road.
轮子在泥路上会留下车辙。
2. 常规习惯老一套
A nun's life runs in a groove.
修女过着刻板的生活。
3. 【印】字沟
4. 【俚】顶呱呱的东西称心的东西
The flower show was a groove.
那个花展棒极了。
5. 【俚】快活(或令人兴奋)的经历
vt.
1. 在...上开出沟(或槽等)用沟(或槽等)连接
The carpenter grooved the board.
木匠在木板上开槽。
2. 使陷入常规[(+into/in/down)][H]
He was grooved in running errands for his neighbors.
他已习惯于为邻居跑腿。
3. 【俚】使极快活尽情享受
vi.
1. 被槽连接被配上槽形成沟槽
2. 陷入常规[(+into/in/down)]
3. 【俚】过得快活使人快活[(+on)]
These young girls really groove on his music.
这些小姑娘迷上了他的音乐。
以上结果由 Dr.eye译典通字典 提供
一种基于Java虚拟机的动态语言，可以和java无缝集成，正是这个特性，很多时候把二者同时使用，把groovy作为java的有效补充。对于Java程序员来说，学习成本几乎为零。同时支持DSL和其他简介的语法（例如闭包），使代码便于阅读。可以用groovy的动态特性来做规则引擎，在DB中维护脚本，业务变化的时候让应用系统动态加载。如果引入groovy在java工程中？
这个很简单，不需要做别的事情，仅仅把groovy的二方包加入到pom文件中即可。例如：
<dependency>
<groupId>org.codehaus.groovy</groupId>
<artifactId>groovy-all</artifactId>
<version>1.8 . 3 </version>
</dependency>
java和groovy混合使用的方法有几种？
1、 静态编译 ，在java工程中直接写groovy的文件，然后可以在groovy的文件中引用java工程的类，这种方式能够有效的利用groovy自身的语言特性，例如闭包；
2、通过 groovyShell 类直接执行脚本，例如：
package groovy_dsl.shell
import groovy.lang.Binding
import groovy.lang.GroovyShell
public class GroovyShellEx {
public static void main(String[] args) {
Binding bind = new Binding()
bind.setVariable( "name" , "iamzhongyong" )
bind.setVariable( "age" , "25" )
GroovyShell shell = new GroovyShell(bind)
Object obj = shell.evaluate( "str = name+agereturn str" )
System.out.println(obj)
}
}
3、通过 groovyScriptEngine 执行文件或者脚本，例如：
package groovy_dsl.script
import groovy.util.GroovyScriptEngine
public class ScriptEngine {
public static void main(String[] args) throws Exception {
GroovyScriptEngine engine = new GroovyScriptEngine( "" )
Object obj = engine.run( "src/main/java/groovy_dsl/script/script_test.groovy" , "iamzhongyong" )
System.out.println(obj)
}
}
4、通过 GroovyClassLoader 来执行，例如：
package groovy_dsl.classloader
import groovy.lang.GroovyClassLoader
import groovy.lang.GroovyObject
import java.io.File
import java.io.IOException
public class GroovyClassLoaderEx {
public static void main(String[] args) throws Exception, IOException {
GroovyClassLoader loader = new GroovyClassLoader()
for ( int i= 0 i<100 i++){
Class<?>clazz = loader.parseClass( new File( "src/main/java/groovy_dsl/classloader/UserDO.groovy" ))
GroovyObject clazzObj = (GroovyObject)clazz.newInstance()
clazzObj.invokeMethod( "setName" , "iamzhongyong" )
clazzObj.invokeMethod( "setSex" , "Boy" )
clazzObj.invokeMethod( "setAge" , "26" )
System.out.println(clazzObj.invokeMethod( "getAllInfo" , null ))
}
}
}
使用groovy尤其需要主要的问题？
通过看groovy的创建类的地方，就能发现，每次执行的时候，都会新生成一个class文件，这样就会导致JVM的perm区持续增长，进而导致FullGCc问题，解决办法很简单，就是脚本文件变化了之后才去创建文件，之前从缓存中获取即可。
groovy中的源码如下：
return parseClass(text, "script" + System.currentTimeMillis() + Math.abs(text.hashCode()) + ".groovy" )
这个是增加缓存的代码：
GroovyClassLoader groovyClassLoader = new GroovyClassLoader(GroovyScriptExecute. class .getClassLoader())
Class<?>groovyClass = null
String classKey = String.valueOf(scriptClass.hashCode())
//先从缓存里面去Class文件
if (GroovyScriptClassCache.newInstance().containsKey(classKey)){
groovyClass = GroovyScriptClassCache.newInstance().getClassByKey(classKey)
} else {
groovyClass = groovyClassLoader.parseClass(scriptClass)
GroovyScriptClassCache.newInstance().putClass(classKey, groovyClass)
}
GroovyObject go = (GroovyObject)groovyClass.newInstance()
下面这个是缓存的单例类，贴一下：
public class GroovyScriptClassCache {
private static final Map<String /*class文件的描述*/ ,Class<?>>GROOVY_SCRIPT_CLASS_CACHE = new HashMap<String,Class<?>>()
private GroovyScriptClassCache(){}
private static GroovyScriptClassCache instance = new GroovyScriptClassCache()
public static GroovyScriptClassCache newInstance(){
return instance
}
public Class<?>getClassByKey(String key){
return GROOVY_SCRIPT_CLASS_CACHE.get(key)
}
public void putClass(String key,Class<?>clazz){
GROOVY_SCRIPT_CLASS_CACHE.put(key, clazz)
}
public boolean containsKey(String key){
return GROOVY_SCRIPT_CLASS_CACHE.containsKey(key)
}
}
为啥要每次new一个GroovyClassLoader，而不是所有的脚本持有一个？
因为如果脚本重新加载了，这时候就会有新老两个class文件，如果通过一个classloader持有的话，这样在GC扫描的时候，会认为老的类还在存活，导致回收不掉，所以每次new一个就能解决这个问题了。
注意CodeCache的设置大小
对于大量使用Groovy的应用，尤其是Groovy脚本还会经常更新的应用，由于这些Groovy脚本在执行了很多次后都会被JVM编译为native进行优化，会占据一些CodeCache空间，而如果这样的脚本很多的话，可能会导致CodeCache被用满，而CodeCache一旦被用满，JVM的Compiler就会被禁用，那性能下降的就不是一点点了。
Code Cache用满一方面是因为空间可能不够用，另一方面是Code Cache是不会回收的，所以会累积的越来越多（其实在不采用groovy这种动态更新/装载class的情况下的话，是不会太多的），所以解法一可以是增大code cache的size，可通过在启动参数上增加-XX:ReservedCodeCacheSize=256m（Oracle JVM Team那边也是推荐把code cache调大的），二是启用code cache的回收机制（关于Code Cache flushing的具体策略请参见此文），可通过在启动参数上增加：-XX:+UseCodeCacheFlushing来启用。
Groovy字符串及其常用方法字符串方法
与java不同，在GString中提供了多种表示字符串的方法，分别是单引号字符串、双引号字符串、三单引号字符串、三双引号字符串、斜杠字符串和$修饰的斜杠字符串。
单引号字符串
单引号字符串是一系列被单引号包围的字符，是普通的java.lang.String。不支持插值。
def str = 'groovy'
assert str.class == java.lang.String
三单引号字符串
三单引号字符串是一列被三个单引号包围的字符，是普通的java.lang.String。不支持插值。
def str = '''groovy'''
assert str.class == java.lang.String
三单引号字符串是多行的。你可以使字符串内容跨越行边界，不需要将字符串分割为一些片段，不需要连接，或换行转义符：
def str = '''
one
two
three'''
//需要注意的是，这个字符串每一次换行都包含了一个换行转义符：
assert str.contains("\n") == true
assert str.size() == 14
//可以通过使用反斜杠换行符剥离该字符
def str = '''\
one\
two\
three'''
assert str.contains("\n") == false
assert str.size() == 11
