groovygo语言 groovy language

现代编程语言那些让人激动的特性

有没有觉得，发展到现在，软件开发行业是越来越成熟了，无论是过程管理、架构方法、设计方法，还是语言、平台、框架、工具等，都发展到了一个前所未有的高度，相关思想和理念也日臻完善，我们真正进入了一个最好的时代。

创新互联是一家专注于成都网站建设、网站制作与策划设计,滨州网站建设哪家好?创新互联做网站,专注于网站建设十余年,网设计领域的专业建站公司;建站业务涵盖:滨州等地区。滨州做网站价格咨询:18980820575

单就编程语言来说，近些年包括Scala（2003）、Groovy（2003）、Go（2009）、Kotlin（2011）、Swift（2014）等新兴编程语言如雨后春笋版涌现出来，也给我们带来了很多让人眼前一亮的编程特性，甚至Java这等老牌编程语言也是不断推陈出新，编程再也不像过去那般枯燥。

本篇就带大家一起感受一下现代编程语言那些激动人心的特性。

这个特性其实有点早了，但是也是很早就让人感动的语言特性了，熟悉Javascript的同学应该对它很了解。Javascript语言具有动态性，我们可以随时为类的某个实例添加方法，也可以利用动态原型，为类的所有实例添加方法，有没有感觉扩展类的实现变得非常方便了呢？

扩展和原型很像，允许我们在不修改或继承类的情况下，将新的函数方法添加到原类中。这个特性较早见于C#这门语言，目前在Kotlin、Swift中均可以看到。这里顺便说一下C#，当时C#出来的时候，不得不说很多特性是非常棒的，包括扩展方法、泛型、分部类等等，比Java好不要太多。像Kotlin，不仅可以扩展类的方法，还可以扩展类的属性。

前两个都是关于扩展代码的，这里再来一个。我们知道Java 1.8以来，接口interface里的方法可以有自己的默认实现了，大大方便了实现类，减少了重复代码。相对于Java的这个实现是显示的，Go语言的接口实现可以是隐式的，添加隐式实现后，所有继承的结构（Go没有类，都是结构struct）都可以调用这个方法，和前面的两个特性有异曲同工之妙，下面我们对比看一下。

C语言就有宏的概念，通过 #define 定义，然后在代码中进行替换。宏作为Rust语言的高级特性，可以操作语法单元，是一种通过编写代码来生成代码的方式，被称作“元编程”（meta programming）。相对于函数，宏可以接受任意多个参数，可以减少重复代码，定义DSL。宏语法比较复杂，难以编写和调试，以至于在Rust文档中说，宏将是其最后的特性。

当你回想写代码枯燥的时候，应该会想到为字段编写getter、setter吧？较早的时候，C#就意识到了这个问题，贴心地推出了自动属性这个语法糖。而Java开发者则是通过Eclipse、IDEA这样的开发工具来自动生成getter、setter代码。当然，现在也可以依赖Lombook包，使用lombok的注解@Getter @Setter来编译时生成相关代码。

据说空指针异常是软件业最贵的异常，价值10亿美元。你有没有为处理调用链中的null值而烦恼过？又或者被伤害过？Kotlin会在编译期提示对可能为null变量的不安全使用，也提供了Elvis 操作符 ?: 来方便地处理null值。而有了可选链，就舒服多了。可选链语法应该较早出现在JavaScript语言中，新兴语言Swift也提供了这一省心的特性。Swift英明地决定变量是不允许直接存储NIL值，当然也提供了optionals的装箱功能允许将NIL或其它值包装起来，方便有时使用。

输入乃万恶之源，函数首要的事情就是检查不规范和不安全的输入，这也是卫语句的来历。Swift语言为此提供了专门的卫语句语法，有了它的贴身防护，整个代码都干爽多了，剧烈运动都不怕，不信往下瞧：

如果要评选最酷的语言特性，那么Lambda表达式必须获得提名。Lambda表达式很早就出现在Lisp语言中，python也有，在后来的C#语言大放异彩，又一次狠狠地羞辱了不长进的Java，而Java也终于在1.8版本后加入了这一特性，甚至C++ 11也光荣地上车了。

我们知道编程语言有静态和动态之分，静态语言如Java 、 C# 、 C 和 C++，动态语言如Perl，Python，JavaScript，Ruby 和 PHP等，多数为脚本语言。而融合了静态和动态特性的语音，就被称为渐进式语言，如TypeScript、Common LISP、Dylan、Cecil、Visual Basic.NET、Bigloo Scheme、Strongtalk等。静态类型检查可以尽早地发现 BUG，动态类型检查可以方便地处理依赖于运行时信息的值的类型。渐进式语言允许类型注释来控制程序的一部分使用静态类型检查，而另一部分为动态检查，更具灵活性。 Python从3.5开始引入了对静态类型检查的支持。

在面向对象的编程语言中，状态是计算的基础。由于可变状态的存在，在编写高并发，多线程代码时，无法知道并行进行的诸多状态读写中是否有顺序上的错误，而且这种错误又是难以察觉的，而不变性则规避了这个问题。不变性是函数式编程的基础，不变性意味着函数没有副作用，无论多少次执行，相同的输入就意味着相同的输出，所有线程都可以无所顾忌的执行同一个函数的代码，代码更像数学函数，更易理解和测试。

String就是构建在Java语言内核中的不可变类的一个典型例子。Java 的 CopyOnWrite系列容器类也是利用了不变性增强了并发安全性。Java可以通过final修饰符实现类和变量的不可变。而Scala、Swift、Groovy等语言也有各自的语法实现不可变的变量和类。

多重分派是一些编程语言的特性，其中的函数或者方法，可以在运行时间（动态的）使用一个或多个实际参数的组合特征，路由动态分派至实现函数或方法。多重分派主要区别于我们常见的重载方法，重载方法是在编译期就绑定了，而多重分派是在运行期分派的。Lisp、Julia、C#、Groovy等语言内建多分派特性，JavaScript、Python和C等语言通过扩展支持多分派。多重分派可以避免我们写很多分支条件，而是更直观地用对象类型表达，使代码变得可读性更好并且较少发生错误。

前面几个特性是不是略显沉闷，那么来看一下这个激动一下。解构这一语法特性用于从数组索引或对象属性创建变量，简直帅到飞起。

爱写单元测试的同学有福了，这个绝壁是重磅炸弹，在生产代码里夹着测试代码，你有想过这么写测试吗？谁想的？简直脑洞打开啊！该特性在Pyret语言中，Pyret旨在作为编程教育的杰出选择，同时探索脚本和函数式编程的融合。

如果内联测试没有让你震惊，D语言内联编译期的这个特性绝对会让你惊掉下巴，基于该特性，开发人员可以直接在D语言中嵌入汇编代码，彻底放飞自我了，俺滴亲娘啊！受不了！受不了！顺便说一下，D语言比较小众，是C++的一个改进型，它包括了按合约设计、垃圾回收、关联数组、数组切片和惰性求值等特性。

好吧，我们看点其它的来压压惊吧。尽管Kotlin语言也说自己实现了模式匹配，但是实际上只是一点点帅，真正帅的是 Elixir语言的模式匹配，Elixir作为一种在Erlang OTP上运行的动态类型语言，将模式匹配提升到了一个全新的水平。

在编程语法上，Python真是个神一样的存在，for循环都能写出花来。

Java 8 中提供了Stream API特性， Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式，来提供一种对 Java 集合运算和表达的高阶抽象。事实上这个特性C#早就有了（Java又躺枪一次）。不得不说，利用这个特性写出来的代码，看上去还真的是很流利的。

gRPC服务开发和接口测试初探「Go」

之前写过了Grpc服务开发和接口测试初探【Java】，中间耽搁了一些时间，Go版本的gRPC测试开发实践才有时间学习使用。其中也是由于自己Go语言不够熟悉导致的。之前有段时间想暂时放弃Go语言的学习，导致了Go的生疏，原因是从Groovy到Java性能。

回归正题，Go语言版本的gRPC实践相对Java来说是比较简单的，但是总体的工具链是比较复杂的，可能是因为Go生态目前相比Java还是比较匮乏吧。下面我先简述一下大致的步骤：

以上步骤亲自操作可能会遇到一些小问题，我本人搜到的教程什么的也是乱七八糟，踩了一些坑。我没有整理出一个亲自实践之后的可行的教程，原因有二：

Go语言的gRPC的 proto 编写跟Java大致一致，只有一个报名的参数不太一样。下面是我的 Hello.proto 内容：

这里主要 go_package 网上搜到的配置方式有些不一样，我没有全都尝试，大家在搜索的资料时候，尽量先看看 syntax 这个参数的值，以及文章教程写作的时间，如果距离现在太久了，我建议直接关掉。搜索引擎有过滤功能，可以过滤掉过时的教程。

这里Go语言gRPC的一点优势，就是在一个项目中即可实现，Java需要先弄一个SDK这样。Go语言的gRPC的代码可以通过生成代码命令中的参数实现指定路径。我是放在了和 proto 文件的同级目录。

服务端代码也是比较格式化的内容，如下：

其中 pb.RegisterHelloServiceServer(s, Ser{}) 如果报错，请检查自己安装的工具 protoc-gen-go 或者 protoc-gen-gofast 版本，一般提取报错 message 搜索也能得到解决办法。

下面是客户端的代码，由于学艺不精，其中大部分参数的含义目前我也不是很清楚，特别是基于 stream 的请求响应的方式使用。后面我先把Java的学完，再回过头来看Go的，按照这个顺序学习和分享。

服务端输出：

忘记打日志了。没有输出

客户端输出：

Go语言的gRPC测试开发实践已经完事儿，大概率上我不会在工作中使用Go作为主力gRPC测试语言，后面测试实践内容还是会以Java为主。

计算机有哪些编程语言？

参考tiobe编程语言统计网站, 有以下编程语言:

(Visual) FoxPro: FoxPro, Fox Pro, VFP

4th Dimension/4D: 4D, 4th Dimension

ABAP

ABC: ABC (exceptions: -tv -channel)

ActionScript: ActionScript, AS1, AS2, AS3

Ada

Agilent VEE

Algol

Alice: Alice (confidence: 90%)

Angelscript

Apex

APL

Applescript

Arc

AspectJ

Assembly

ATLAS

AutoIt

AutoLISP

Automator

Avenue

Awk: Awk, Mawk, Gawk, Nawk

Bash

Basic: Basic (confidence: 0%)

BCPL

BETA: BETA (confidence: 10%)

BlitzMax: BlitzMax, BlitzBasic, Blitz Basic

Boo

Bourne shell: Bourne shell, sh

C shell: Csh, C shell (confidence: 90%)

C#: C#, C-Sharp, C Sharp, CSharp, CSharp.NET, C#.NET

C++

C++/CLI

C-Omega

C: C (exceptions: -"Objective-C")

Caml

Ceylon

CFML: CFML, ColdFusion

cg: cg (confidence: 80%, exceptions: -"computer game" -"computer graphics")

Ch: Ch (exceptions: +ChScite)

CHILL

CIL

CL (OS/400): CL (exceptions: -Lisp), CLLE

Clarion

Clean: Clean (confidence: 43%)

Clipper

Clojure

CLU

COBOL

Cobra

CoffeeScript

COMAL

Common Lisp

Curl

D: D (confidence: 90%, exceptions: -"3-D programming" -"DTrace"), dlang

Dart

DCL

Delphi/Object Pascal: Delphi, Delphi.NET, DwScript, Object Pascal, Pascal (confidence: 11%)

DiBOL: DBL, Synergy/DE, DIBOL

Dylan

E: E (exceptions: +specman)

ECMAScript

EGL

Eiffel

Elixir

Emacs Lisp: Emacs Lisp, Elips

Erlang

Etoys

Euphoria

EXEC

F#: F#, F-Sharp, FSharp, F Sharp

Factor

Falcon

Fantom

Felix: Felix (confidence: 86%)

Forth

Fortran

Fortress

Gambas

GNU Octave

Go: Go (exceptions: +Google), Golang

Gosu

Groovy: Groovy, GPATH, GSQL, Groovy++

Hack

Haskell

Haxe

Heron

HPL

HyperTalk

Icon: Icon (confidence: 90%)

IDL: IDL (exceptions: -corba -interface)

Inform

Informix-4GL

INTERCAL

Ioke

J: J (confidence: 50%)

JADE

Java

JavaFX Script

JavaScript: JavaScript, JS, SSJS

JScript

JScript.NET

Julia

Korn shell: Korn shell, ksh

LabVIEW

Ladder Logic

Lasso

Limbo

Lingo

Lisp

LiveCode: Revolution, LiveCode

Logo: Logo (confidence: 90%, exceptions: -tv)

LotusScript

LPC

Lua

Lustre

MAD: MAD (confidence: 50%)

Magic: Magic (confidence: 50%)

Magik

Malbolge

MANTIS

Maple

Mathematica: Mathematica, Wolfram

MATLAB

Max/MSP

MAXScript

MDX

MEL

Mercury

Miva

Modula-2

Modula-3

Monkey

MOO

Moto

MQL4: MQL4, MQL5

MS-DOS batch

MUMPS

NATURAL

Nemerle

NQC

NSIS

NXT-G

Oberon

Object Rexx

Objective-C: Objective-C, objc, obj-c

OCaml: Objective Caml, OCaml

Occam

OpenCL

OpenEdge ABL: Progress, Progress 4GL, ABL, Advanced Business Language, OpenEdge

OPL

Oxygene

Paradox

Pascal: Pascal (confidence: 89%)

Perl

PHP

Pike

PILOT: PILOT (confidence: 50%, exceptions: -"Palm Pilot programming")

PL/I: PL/1, PL/I

PL/SQL

Pliant

PostScript: PostScript, PS

POV-Ray

PowerBasic

PowerScript

PowerShell

Processing: Processing (exceptions: +"sketchbook")

Programming Without Coding Technology: Programming Without Coding Technology, PWCT

Prolog

Pure Data: Pure Data, PD

Python

R: R (confidence: 90%, exceptions: +"statistical")

Racket

REBOL

REXX

RPG (OS/400): RPG (confidence: 80%, exceptions: -role), RPGLE, ILERPG, RPGIV, RPGIII, RPG400, RPGII, RPG4

Ruby

Rust

S-PLUS: S-PLUS (exceptions: +statistical)

S: S (exceptions: +statistical)

SAS

Sather

Scala

Scheme: Scheme (exceptions: -tv -channel)

Scratch

sed

Seed7

SIGNAL: SIGNAL (confidence: 10%)

Simula

Simulink

Slate: Slate (confidence: 57%)

Smalltalk

Smarty

SPARK

SPSS

SQR

Squeak

Squirrel

Standard ML: Standard ML, SML

Stata

Suneido

SuperCollider: SuperCollider (confidence: 80%)

Swift

TACL

Tcl: Tcl/Tk, Tcl

Tex

thinBasic

TOM: TOM (confidence: 50%)

Transact-SQL: T-SQL, Transact-SQL, TSQL

TypeScript

Vala/Genie: Vala, Genie

VBScript

Verilog

VHDL

Visual Basic .NET: Visual Basic .NET, VB.NET, Visual Basic.NET, Visual Basic (confidence: 50%), VB (confidence: 50%)

Visual Basic: Visual Basic (confidence: 50%), VB (confidence: 50%), VBA, VB6

WebDNA

Whitespace

X10

xBase

XBase++

Xen

Xojo: REALbasic, Xojo

XPL

XSLT

Xtend

yacc

Yorick

Z shell: Z shell, zsh

我们真的需要Go语言吗？

我们这个世界真的需要另外一种C语言风格的编程语言吗？很显然，谷歌很早就这么认为了，在 2009 年，它借用雷蒙斯乐队的歌“Hey!Ho!Let’s Go”，正式推出了 Go 语言。现在 Go 语言开发团队已经开发出了这种语言的第一个稳定版本，他们称之为 Go 1，他们将这种语言推向世界，希望人们用这种语言“开发出健壮的软件产品和作品。”那么，现在人们对这种语言的使用情况又是如何呢？让我们先回顾一下，什么是 Go 语言，是什么促使谷歌决定推出这样一种语言？按 Go 语言的“常见问题”里的说法，自从那个“重要的系统级编程语言”诞生距今已超过十几年了，这段时间计算机世界已经发生了很大的变化。谷歌的才人们对目前现有的各种语言深感失望，他们必须要在“快速的编译、快速的执行或简单编程”之间做出选择。“没有一种主流的编程语言，例如C，C++，Java，Python 等，能提供谷歌人想要的全部特征。于是，谷歌的工程师从 2007 年起开始开发 Go 语言。“常见问题”里这样说：Go 语言在基本语法上”基本上属于C语言家族“，但它从 Pascal 语系吸收了”大量的理念“，还有一些思想是来自其它的语言。但对于程序员来说，应该把它当成一种全新的语言，一种以”让程序员更有效率，让编程更有效率，至少是让我们更有效率并且使编程更有乐趣“的理念为设计目标的编程语言。Go 语言擅长做什么…？那么，Go 语言擅长做什么？根据谷歌著名的软件工程师——Go 语言的设计人之一——Rob Pike 的说法，它是用来开发”大型软件“的。Pike 说 Go 语言适合于”很多程序员一起开发的大型软件，并且开发周期较长，支持云计算的网络服务：简言之，就是服务端软件。Go 语言能够让程序员快速开发，并且在软件不断的增长过程中，它能让程序员更容易地进行维护和修改。它融合了传统编译型语言的高效性和脚本语言的易用性和富于表达性。“(作为原贝尔实验室 Unix 开发小组成员，Pike 对系统软件有相当的认识。)但对于其它类型的软件，Go 语言也一样的好用。例如，我在 Google+ 上询问了 Go 语言的使用者，得到了 Douglas Fils 的回复，他正在拿各种语言做实验。Fils 说他现在有时会开发一些 Web 应用程序，大多数都是在 Java 虚拟机(JVM)平台上。“所以 Java 自然是最常用的。我最近开始尝试更多的语言，例如 Scala 和 Groovy。我用 Groovy 语言已经开发了不少的东西，而且刚刚完成了一个 Groovy/Grails 语言上的大型项目。我还研究了一下 Ruby on Rails/Python (Python 框架)，并用它们做了一些东西。”他说他用早期版本的 Go 语言开发了一个 Web 界面来处理数据资源。但很不幸。“当时的 Go 的程序库和语法使得开发起来很困难。我还尝试了 node.js，而且，到了一月份，我的精力完全转向了 node.js.”Node.js，Fils 说，很流行，“虽然我很喜欢它，但它的单线程事件循环机制和非阻塞的编程模式让我不太满意。还有，所有的东西都要用 Javascript 的回调函数，我不喜欢这样。”很显然，他不是一个 JavaScript 的粉丝。Go 语言的语法和结构，从另一方面讲，“还是很简洁的。”当Go 语言的语法和结构趋于稳定，并发布了 Go 1 时，他觉得应该转回来，重写他的 Go 语言程序。这回，他想起来了当初为什么想用 Go 来开发。关于Go 语言的争论Fils 说，在 Java 里，很多东西都需要有一定的模板套路，这是很讨厌。他说 Scala 和 groovy 要好一些，但仍然是个问题。Go 语言给人的感觉像一个动态的类型化语言，Fils 说，但 Go 语言里静态类型特征并不像 Java 里那样明显。Go 语言的垃圾收集管理，比 JVM 要好的多。跟 Groovy 这样的动态语言比起来尤其能看出这点。Fils 在评论中说 Go 语言的速度比其它语言快很多倍。它运行速度快但不影响负载量。它编译所需的时间很短，他在开发时能边开发边编译，就像动态语言那样迅速。最后，他说使用 Go 语言要比使用 Node.js，Java 或以 Java 为基础的语言，Ruby on Rails 等语言要有趣的多。在开发 JVM 平台上的应用时，我总感觉自己是一个系统管理员，而不是一个开发者。我要修改堆空间，我要研究负载均衡或内存问题或其它的资源管理问题。而使用 Go 语言，我不需要考虑这些。我开发，编译，测试，运行，部署，非常的享受。请注意，并不是所有的人都喜欢 Go 语言。你可以看一看 Shaneal Manek 的关于 Go 语言的垃圾收集系统以及脚本语言和编译型语言之间比较的评论。Go 语言能走向主流吗？你的期望是什么？按照 RedMonk’s Stephen O’Grady 的说法，对于 Go 语言来说现在还非常年轻。通常，程序员会分成两个阵营：要么欢迎底层语言和脚本型/垃圾收集器型语言的融合，要么是反对这样做。对于后者，毫无意外的，他们是C语言的坚定拥护者。围绕着 Go 语言有很多的争论，这不令人吃惊，任何一种语言都是这样。而令人吃惊的是目前 Go 语言在程序员中获得了相当的吸引力。O’Grady 二月份在 RedMonk 编程语言分级中把 Go 语言放入了第二梯队。但是，他说，考虑一下 Go 语言是如此的年轻，“即使是目前这种成绩也是让人相当的印象深刻了。”谷歌已经发布了 Go 语言的稳定版本，并且在 Google App Engine 支持部署这种语言的应用，这将给 Go 语言带来更多的吸引力。Go 语言能否成为一种“主流”语言，这需要由时间来判定。不过，看起来除谷歌之外还有很多公司对这种语言也很感兴趣，比如 Engine Yard 等公司。那些对目前的现存的语言不太满意的程序员大概对 Go 语言都在拭目以待。如果你在使用 Go 语言或之前简单涉略过它，你需要注意，Go 1 版引入了不少的变化。然而从 Go 1 版开始，Go 语言的变化将会遵循它的规格说明书进行。根据 Go 语言的开发人员的透露，“也许在某个时间，我们会推出 Go 2 的规范，但在此之前，用 Go 语言编写的程序在今后的 Go 1 版本(Go 1.1, Go 1.2 等)上都能正确的运行。”你用Go 语言开发过什么项目吗？

在java中使用groovy怎么搞

一种基于Java虚拟机的动态语言，可以和java无缝集成，正是这个特性，很多时候把二者同时使用，把groovy作为java的有效补充。对于Java程序员来说，学习成本几乎为零。同时支持DSL和其他简介的语法（例如闭包），使代码便于阅读。可以用groovy的动态特性来做规则引擎，在DB中维护脚本，业务变化的时候让应用系统动态加载。

如果引入groovy在java工程中？

这个很简单，不需要做别的事情，仅仅把groovy的二方包加入到pom文件中即可。例如：

dependency

groupIdorg.codehaus.groovy/groupId

artifactIdgroovy-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+age;return 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 MapString /*class文件的描述*/ ,Class? GROOVY_SCRIPT_CLASS_CACHE = new HashMapString,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来启用。