• Save
Groovy简介
Upcoming SlideShare
Loading in...5
×
 

Groovy简介

on

  • 777 views

 

Statistics

Views

Total Views
777
Views on SlideShare
777
Embed Views
0

Actions

Likes
1
Downloads
0
Comments
0

0 Embeds 0

No embeds

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment
  • 工欲善其事,必先利其器 Groovy 并没有取代 Java ,而是作为 Java 的补充,它提供了更简单、更灵活的语法,可以在运行时动态地进行类型检查。您可以使用 Groovy 随意编写 Java 应用程序,连接 Java 模块,甚至扩展现有的 Java 应用程序 — 甚至可以用 Groovy 对 Java 代码进行单元测试。 Groovy 的美妙之处还在于,它能够比编写纯粹的 Java 代码更快地完成所有工作 — 有时候会快许多。
  • Groovy 代码还能在运行时轻松地改变自己。这实际上意味着,能够在运行时轻松地为对象指定新方法和属性。这一编程领域称为元编程 。
  • Java 的 HelloWorld 同样在 groovy 中运行自如。
  • 事实上 Groovy 只是规则少一些
  • assert 命令用来证明范围是 java.util.List 的实例
  • assert 命令用来证明范围是 java.util.List 的实例
  • assert 命令用来证明范围是 java.util.List 的实例
  • 实际上在 for 循环中并不需要类型声明,因为 Groovy 已经将迭代转变为任何集合的直接成员。在这个示例中,不必获取 Iterator 实例并直接操纵它,可以直接在集合上迭代。而且,通常放在循环构造内的行为(例如 for 循环体中 println )接下来要放在闭包内。
  • 实际上在 for 循环中并不需要类型声明,因为 Groovy 已经将迭代转变为任何集合的直接成员。在这个示例中,不必获取 Iterator 实例并直接操纵它,可以直接在集合上迭代。而且,通常放在循环构造内的行为(例如 for 循环体中 println )接下来要放在闭包内。
  • 实际上在 for 循环中并不需要类型声明,因为 Groovy 已经将迭代转变为任何集合的直接成员。在这个示例中,不必获取 Iterator 实例并直接操纵它,可以直接在集合上迭代。而且,通常放在循环构造内的行为(例如 for 循环体中 println )接下来要放在闭包内。
  • 实际上在 for 循环中并不需要类型声明,因为 Groovy 已经将迭代转变为任何集合的直接成员。在这个示例中,不必获取 Iterator 实例并直接操纵它,可以直接在集合上迭代。而且,通常放在循环构造内的行为(例如 for 循环体中 println )接下来要放在闭包内。
  • 实际上在 for 循环中并不需要类型声明,因为 Groovy 已经将迭代转变为任何集合的直接成员。在这个示例中,不必获取 Iterator 实例并直接操纵它,可以直接在集合上迭代。而且,通常放在循环构造内的行为(例如 for 循环体中 println )接下来要放在闭包内。
  • delegate 委托在是一种常用设计模式,但在 java 中实现相对比较繁琐, groovy 直接在 GroovyObject 中已经实现了 delegate 模式,所以在 groovy 中应用 delegate 很方便。
  • 目前实现的业务系统是 java 编写的,但是一些业务频繁变化又要求立刻生效,而且业务也比较复杂,一时不好抽象成规整的可复用 java 代码。于是考虑修改当前业务系统。基础业务和 web 界面还是用 java 相关技术实现,将比较动态和逻辑模糊的业务抽取出来,用 groovy 实现。 如果在应用程序正在运行时对 GroovyPdfGenerator.groovy 脚本做出更改, Spring 将检测到这一更改,并在运行时重新装载 pdfGenerator bean ,而不必重新启动。注意,只有达到规定的延迟时间, 并且 可刷新 bean 上发生方法调用,才会发生刷新检查。例如,假设 pdfGenerator bean 的刷新检查延时为 10 秒,但是连续 50 秒内没有发生方法调用。在这种情况下, Spring 会在 50 秒之后(而不是每过 10 秒)检查是否需要刷新。换句话说, Spring 不会积极地轮询脚本的更改;相反,它判断自上次方法调用后经过的时间,然后计算这段时间是否超过刷新检查延时。只有当经过的时间超过刷新检查延时, Spring 才检查脚本是否被更改,进而确定是否需要刷新。另一方面,假设 pdfGenerator bean 处于较重的负载下,每一秒钟它的方法被多次调用。如果 refresh-check-delay 为 10 秒,无论这个 bean 被使用多少次,它最快只能每 10 秒重新装载一次。所以,不需要担心 Spring 是否会因为积极地轮询 Groovy 脚本而消耗系统资源,它并没有这样做。

Groovy简介 Groovy简介 Presentation Transcript

  • Groovy 简介 CRM_TPD sunhao
  • 什么是 Groovy?
    • Groovy 是一种具有 Python 、 Ruby 等动态语言特性的与 Java 平台紧密结合的 敏捷 开发语言 , 是 JVM 的一个替代语言 — 替代 是指可以用 Groovy 在 Java 平台上进行 Java 编程,使用方式基本与使用 Java 代码的方式相同。在编写新应用程序时, Groovy 代码能够与 Java 代码很好地结合,也能用于扩展现有代码。
  • 什么是 Groovy?
    • Groovy 是 松散的 Java 语法 , 允许省略分号和修改符。
    • 除非另行指定, Groovy 的所有内容都为 public 。
    • Groovy 允许定义简单脚本,同时无需定义正规的 class 对象。
    • Groovy 在普通的常用 Java 对象上增加了一些独特的方法和快捷方式,使得它们更容易使用。
    • Groovy 语法还允许省略变量类型。
    • Groovy 允许省略 Java 语法中的一些元素,但也增加了一些新特性,例如本地集合、内置的正则表达式和闭包。
    一体两面
  • HelloWorld 用 Java 编写的典型的 Hello World 示例如下所示: public class HelloWorld { public static void main(String[] args) { System.out.println("Hello World!"); } } 用 Groovy 编写的 Hello World : println "Hello World!" 在这段代码周围没有类结构,而且也没有方法结构!我还使用 println 代替了 System.out.println 。
  • 没有类型的 Java 代码
    • 为什么要有类型定义
    在 Java 中,如果要声明一个 String 变量,则必须输入: String value = "Hello World"; Groovy 允许省略 value 前面的 String 类型变量,并用 def 代替。 def value = "Hello World“ def message = 123 println value.class 实际上, Groovy 会根据对象的值来判断它的类型。 在 Groovy 中 “一切都是对象”
  • 无类型有什么意义 ?
    • Groovy 缺少类型能够带来更高的灵活性 — 不需要接口或抽象类。
    • 只需要使用 def 关键字就能在方法中声明一个独立变量 , 不需要将 def 关键字作为方法声明中的参数。
    • 在 for 循环声明中也不需要它,这意味着不用编写 (int x = 0; x < 5; x++) , 甚至 可以省略 int ,保留空白。
    开始体验循环
  • 更好、更短的循环
    • 感受 Groovy 缺乏类型的好处
    • def repeat(val){
    • for(i = 0; i < 5; i++){
    • println val
    • }
    • }
    • repeat(“hello world&quot;)
    实际上,它很像 JavaScript 但它就是 Java 代码,只不过是用 Groovy 的样式编写的。
  • Groovy 中的范围
    • 范围 是一系列的值。
    • 例如 “ 0..4 ” 表明包含 整数 0 、 1 、 2 、 3 、 4 。
    • Groovy 还支持排除范围,“ 0..<4 ” 表示 0 、 1 、 2 、 3 。
    • 还可以创建字符范围:“ a..e ” 相当于 a 、 b 、 c 、 d 、 e 。
    • “ a..<e ” 包括小于 e 的所有值。
    • for(i = 0; i < 5; i++)
    • def repeat(val){ def repeat(val){
    • for(i in 0..5){ for(I in 0..<5){
    • println val println val
    • } }
    • } }
  • 默认参数值
    • Groovy 支持默认参数值,可以在函数或方法的正式定义中指定参数的默认值 , 调用函数的程序可以选择省略参数,使用默认值。
    • 使用前面的 repeat 函数时,如果希望调用程序能够指定重复值,可以像下面这样编码:
    • def repeat(val, repeat=5){
    • for(i in 0..<repeat){
    • println val
    • }
    • }
    • 像下面这样调用该函数:
    • repeat(&quot;Hello World&quot;, 2)
    • repeat(&quot;Goodbye sunshine&quot;, 4)
    • repeat(&quot;foo&quot;)
  • Groovy boolean 值
    • Groovy 与 Java 的 boolean 值有着本质的区别 . 根据不同的情况 , Groovy 会自动将表达式的值作为 boolean 看待 .
    • str = 'hello'
    • if (str) { println 'hello' }
    • Groovy 会检查集合是否为空来判断,因此 , 像 if (obj) 为 true 的条件只在 obj 不为 null 且集
    • 合必须拥有至少一个元素 :
    • lst0 = null
    • println lst0 ? 'lst0 true' : 'lst0 false'
    • lst1 = [1, 2, 3]
    • println lst1 ? 'lst1 true' : 'lst1 false'
    • lst2 = []
    • println lst2 ? 'lst2 true' : 'lst2 false'
  • Groovy 集合
    • 回想 JAVA 编程中是如何使用集合的 。
    • > 导入 java.util 类 ;
    • > 初始化集合 ;
    • > 将项加入集合。
    • def range = 0..4
    • println range.class
    • assert range instanceof List
    而 Groovy 可以直接在语言内使用集合。在 Groovy 中,不需要导入专门的类,也不需要初始化对象。
  • Groovy 集合
    • 丰富的支持
    • 每个 Groovy 集合都是 java.util.Collection 或 java.util.Map 的实例 。
    • def coll = [&quot;Groovy&quot;, &quot;Java&quot;, &quot;Ruby&quot;]
    • assert coll instanceof Collection
    • assert coll instanceof ArrayList
    • Java 代码中得到集合 :
    • Collection<String> coll = new ArrayList<String>();
    • coll.add(&quot;Groovy&quot;);
    • coll.add(&quot;Java&quot;);
    • coll.add(&quot;Ruby&quot;);
    coll.add(&quot;Python&quot;) coll << &quot;Smalltalk&quot; coll[5] = &quot;Perl&quot;
  • Groovy 集合
    • 检索非常轻松
    • 得到第二个项 “ Java ”
    • assert coll[1] == &quot;Java“
    • Groovy 还允许在集合中增加或去掉集合,如下所示:
    • def numbers = [1,2,3,4]
    • assert numbers + 5 == [1,2,3,4,5]
    • assert numbers - [2,3] == [1,4]
    魔法方法 def numbers = [1,2,3,4] assert numbers.join(&quot;,&quot;) == &quot;1,2,3,4&quot; assert [1,2,3,4,3].count(3) == 2 assert [&quot;JAVA&quot;, &quot;GROOVY&quot;] == [&quot;Java&quot;,&quot;Groovy&quot;]*.toUpperCase()
  • Groovy 映射
    • 除了丰富的列表处理功能, Groovy 还提供了坚固的映射机制。同列表一样,映射也是本地数据结构。而且 Groovy 中的任何映射机制在幕后都是 java.util.Map 的实例。
    • JAVA :
    • Map<String, String>map = new HashMap<String, String>();
    • map.put(&quot;name&quot;, &quot;Andy&quot;);
    • map.put(&quot;VPN-#&quot;,&quot;45&quot;);
    • Groovy:
    • def hash = [name:&quot;Andy&quot;, &quot;VPN-#&quot;:45]
    Groovy 映射中的键不必是 String 。在这个示例中, name 看起来像一个变量,但是在幕后, Groovy 会将它变成 String 。 传统取键值方法: hash.put(&quot;id&quot;, 23) assert hash.get(&quot;name&quot;) == &quot;Andy&quot;
  • 有 Groovy 特色的 映射
    • Groovy 给任何语句都施加了魔法, 还 可以用 . 符号将项放入映射中。
    • 如果想将新的名称 - 值对加入映射(例如 dob 和 “ 01/29/76 ” ),可以像下面这样操作:
    • hash.dob = &quot;01/29/76“
    • . 符号还可以用来获取项。例如,使用以下方法可以获取 dob 的值:
    • assert hash.dob == &quot;01/29/76&quot;
  • 位置映射
    • 还可以使用假的位置语法将项放入映射,或者从映射获取项目,如下所示:
    • assert hash[&quot;name&quot;] == &quot;Andy&quot;
    • hash[&quot;gender&quot;] = &quot;male&quot;
    • assert hash.gender == &quot;male&quot;
    • assert hash[&quot;gender&quot;] == &quot;male&quot;
    • 请注意,在使用 [] 语法从映射获取项时,必须将项作为 String 引用。
  • Groovy 中的闭包
    • 闭包是 Java 世界的一个重大主题,对于是否会在 Java 7 中包含闭包仍然存在热烈的争论 。
    • Groovy 就是 Java ,所以如果愿意,那么总是能够得到 Java 的 Iterator 实例,用它在集合上迭代,就像下面这样:
    • def acoll = [&quot;Groovy&quot;, &quot;Java&quot;, &quot;Ruby&quot;]
    • for(Iterator iter = acoll.iterator(); iter.hasNext();){
    • println iter.next()
    • }
    acoll.each{ println it } 请注意, each 直接在 acoll 实例内调用,而 acoll 实例的类型是 ArrayList 。在 each 调用之后,引入了一种新的语法 , 由 {} 包围起来可以用作函数参数和方法参数的代码块。
  • Groovy 中的闭包
    • 闭包中的 it 变量是一个关键字,指向被调用的外部集合的每个值 --- 它是默认值,可以用传递给闭包的参数覆盖它。下面的代码执行同样的操作,但使用自己的项变量:
    • def acoll = [&quot;Groovy&quot;, &quot;Java&quot;, &quot;Ruby&quot;]
    • acoll.each{ value ->
    • println value
    • }
    如果想在前面一节 “ Groovy 中的映射” 中的 hash 对象上迭代,可以编写以下代码: def hash = [name:&quot;Andy&quot;, &quot;VPN-#&quot;:45] hash.each{ key, value -> println &quot;${key} : ${value}&quot; }
  • Groovy 中的闭包
    • 闭包类似 Java 的内类,区别是闭包只有单一的方法可以调用,但可以有任意的参数,闭包用 “ {}” 括起, “ ->” 前面是参数,后面是处理语句,可以直接调用,也可以使用 call 调用。
    • def square = {it * it} // 定义一个叫 square 的闭包。 assert 4 == square(2) // 使用闭包
    • def closure = { param -> println(&quot;hello ${param}&quot;) } closure.call(&quot;world!&quot;)
    • def closure = { greeting, name -> println(greeting + name) } closure.call(&quot;hello &quot;, &quot;world!&quot;)
    • closure = { println &quot;hello &quot; + it } closure.call(&quot;world!&quot;)
  • Groovy 中的闭包
    • 把闭包当作变量返回的例子:
    • def localMethod() {   def localVariable = new java.util.Date()   return {println localVariable} } def clos = localMethod() println &quot;Executing the closure:&quot; clos()
    • Groovy 闭包中几个隐含变量 it :默认的参数名,调用是如果没有传参数, it 为 null this : 跟 Java 一样,是定义闭包所在类的一个引用,不管有多少层闭包嵌套, this 指向的都是最上层的类。 owner : 封闭闭包的对象 ( 如果只有一层闭包就是 this ,如果有多层闭包嵌套就是含有此闭包的上层闭包 ) delegate : 缺省值是 owner ,但是可以改变。
  • Groovy 中的闭包
    • class Class1 {
    • def closure = {
    • println &quot; ============================== &quot;
    • println &quot;this = &quot;+ this.class.name
    • println &quot;owner = &quot; + owner.class.name
    • println &quot;delegate = &quot; + delegate.class.name
    • def nestedClos = {
    • println &quot; ============================== &quot;
    • println &quot;this = &quot;+ this.class.name
    • println &quot;owner = &quot; + owner.class.name
    • println &quot;delegate = &quot; + delegate.class.name
    • def thirdClos = {
    • println &quot; ============================== &quot;
    • println &quot;this = &quot;+ this.class.name
    • println &quot;owner = &quot; + owner.class.name
    • println &quot;delegate = &quot; + delegate.class.name
    • }
    • thirdClos()
    • }
    • nestedClos()
    • }
    • }
    • def clos = new Class1().closure
    • //clos.delegate = this
    • clos()
    • 闭包实现接口
    • interface Test { def test() } def test = { println'ok' } as Test
    •     test.test()
    • 如果接口只有一个方法需要实现,比如 Comparator , Runnable 等接口就可以直接实现方法后加上 as Runnable 接口名就可以。 多方法接口, groovy 用 Map 的方法实现。
    Groovy 中的闭包 interface MultiFuncTest {     def test1()     def test2(str) } def impl = [test1:{println'test'},         test2:{str -> println str}] as MultiFuncTest impl.test1() impl.test2('ok')
    • delegate 委托的用法
    • class Dog{
    • def play = {
    • &quot;wang wang!&quot;
    • }
    • def childmind = {
    • println delegate.play();
    • }
    • }
    • class Cat {
    • def play = {&quot;miao miao !&quot;}
    • }
    • def dog = new Dog()
    • def cat = new Cat()
    • dog.childmind()
    • dog.childmind.delegate = cat;
    • dog.childmind()
    Groovy 中的闭包 这个 例子 就 是狗爸爸让老猫帮忙照看他的狗儿子玩游戏。
    • 动态语言和静态语言结合,各自发挥自己的优势。动态语言易于维护,生产效率较高。静态语言性能更好,语法检查等更严格。
    Groovy 与 spring 集成 groovy 修改后可在 java 系统运行期间立即生效。
    • <lang:groovy id=&quot;protoBusiness&quot; refresh-check-delay=&quot;10000&quot; script-source=&quot;classpath:proto/ProtoBusinessGroovyImpl.groovy&quot;> </lang:groovy>
    设置默认刷新检查延时 <lang:defaults   refresh-check-delay=&quot;2000&quot;/>     <lang:groovy   id=&quot;pdfGenerator&quot;           script-source=&quot;classpath:groovierspring/GroovyPdfGenerator.groovy&quot;           refresh-check-delay=&quot;6000&quot;>      <lang:property   name=&quot;companyName&quot;   value=&quot;Refreshable   Groovy   Bookstore&quot;/>   </lang:groovy>     <lang:groovy   id=&quot;invoiceEmailer&quot;           script-source=&quot;classpath:groovierspring/GroovyInvoiceEmailer.groovy&quot;           refresh-check-delay=&quot;-1&quot;/>
  • 谢谢!