精华内容
下载资源
问答
  • Groovy实战分析

    2018-08-30 22:28:17
    本篇Groovy博文适合有Java+脚本语言(python or ruby)基础的同学快速入门。 本文不算是系统地学习groovy的教材,而是通过对比和对几个重点的介绍让大家直接上手groovy开发。 1 默认导入 java.io.* java.lang.* ...

    本篇Groovy博文适合有Java+脚本语言(python or ruby)基础的同学快速入门。
    本文不算是系统地学习groovy的教材,而是通过对比和对几个重点的介绍让大家直接上手groovy开发。

    1 默认导入

    java.io.* 
    java.lang.* 
    java.math.BigDecimal 
    java.math.BigInteger 
    java.net.* 
    java.util.* 
    groovy.lang.* 
    groovy.util.*

    就是说.groovy文件在起步阶段就等于.java文件再import进来以上这些常用包,可以省去大量import代码。

    2 两种元编程:运行时和编译时元编程。
    编译时元编程本质与java是一样的,提前将.groovy脚本编译成.class文件,然后丢给JVM去执行。
    运行时编程,通过groovy的类加载器在运行时直接加载*.groovy文件并且生成对象,在这种方式下,没有生成任何*.class,但是生成了一个java.lang.Class对象的实例,也就是说,当groovy代码中包括一个new MyClass()的表达式时,并且也有一个MyClass.groovy的文件,这个文件将被解释,一个MyClass的类型将被产生并且增加到类加载器中,在代码中将像从*.class一样获取到MyClass对象。


    3 有python功底的同学在玩groovy的集合时不会感到陌生。
    数组初始化
    int[] array = [1,2,3] 
    list初始化
    def list = [9, 4, 2, 10, 5]
    Map初始化
    def map = [name: 'Gromit', likes: 'cheese', id: 1234]
    空map:def emptyMap = [:]
    总之在groovy中不要随便用{}大括号,那个是闭包,剩下的关于集合的操作根python差不多。


    4 属性创建
    默认一个private属性加public的get set
    这样也是为了减少代码量


    5 GString与String
    groovy中双引号是GString,可以引用$的变量
    单引号是普通的java String,当字符串处理
    例如如下代码:
    log.error("Error occurred handling request for ${request.requestURL}", ex)
    如果是单引号当不会做$的转译,直接当纯字符串去处理
    如够长字符串跨多行,那就跟python一样使用三引号,例如:

    new File(baseDir,'haiku.txt') << '''Into the ancient pond
    A frog jumps
    Water’s sound!'''

    6 闭包代替lambda

    java代码:
    Runnable run = () -> System.out.println("Run");
    groovy代码:
    Runnable run = { println 'run' }

    闭包是groovy的核心,有点像java的statc静态代码块,用{}括起来的部分是一个闭包,代表某个逻辑运算。
    闭包比起lambda可读性更强,开发起来也更简单,闭包是groovy最重要的知识点,一定要掌握,特别是配合集合和map时的使用

    def subtemplates = (Map<String, String>) templates.findAll { it.key != "main"}.collectEntries {k, v -> [(k): objectMapper.writeValueAsString(v)]}

    这行代码用到了2个闭包,一个是过滤key值,一个是做value的json转换,设想这行代码用java来写大约要写多少行。


    7 判断相等
    java中的== 在groovy中要用is 这点与python一样。
    groovy中的==是值相等,不是引用相等。

    8 trait
    java中只有class和interface,groovy中新增了一个trait
    虽然对trait的引用也是implements这种方式,但是trait和interface的意义是不一样的。
    interface的意义是抽象以及共有部分的实现(jdk1.8的default),而trait的意义是能力的嵌入。implements进来某个trait,就说明当前类具备了这个能力,并不是实现、集成的意思。

    9 特殊符号

    range = 5..<8 半包括

    range = 5..8 全包括

    << 赋值或者添加到集合

    def list = []
    list << 5

    *展开运算符

    class Person{  
        String name  
        int age  
        String toString(){  
            return "${name}:${age}"  
        }  
    }  
      
    def people = [new Person(name:'阿大',age:24),new Person(name:'阿二',age:18)]  
    println people*.toString()  
      
    result:  
      
    ["阿大:24", "阿二:18"]  

    ?: 二元运算符

    groovy代码:
    description.check = description.check ?: oldDescription.check
    如果description.check为空那么用oldDescription.check的值代替。
    如果用java写:
    description.check = description.check!=null ? description.check: oldDescription.check
    java是三元运算,groovy是二元运算,因为groovy对boolean的判断与python是一样的“非空既真”,所以省去了非空的情况下是true还是false这层判断,减少了一元。

    ?. 非空占位符,简化空指针判断

    java代码:
    if (description!=null){
    	System.out.println(description.check)
    }
    等效的groovy代码:
    println description?.check

    & 闭包调用,有点像jdk1.8新特性方法的调用->

    //我定义了一个方法:
    AzureApplication translate(CacheData cacheData) {XXX}
    //我这里有个集合
    ollection<CacheData> applications = XXX;
    //我想遍历集合的元素调用上面的translate方法并拼装成一个新集合
    applications.collect this.&translate

    10 
    很多开发者往往会同时使用 def 和类型,但这里的 def 是多余的。因此,要么使用 def,要么使用类型。 
    所以不要这样写: 
    def String name = "Guillaume" 
    这样写就足够了: 
    String name = "Guillaume"
    在 Groovy 中使用 def 时,实际的类型持有者是 Object,所以可以将任何对象赋予利用 def 定义的变量,如果一个方法声明为返回 def 类型值,则它会返回任何类型的对象。 
    是用default还是用类型来修饰变量,这点也是灵活与可读性的博弈,按groovy的设计希望大家用default,但是如果你可以笃定你的类型,适当的用类型也是不错的选择。
     

     

    以上是groovy语法上的学习,实战中groovy还提供了很多便捷的annotation供开发者使用

    1
    @Memoized 作用在方法上
    groovy.transform.Memoized
    把方法的执行结果缓存起来,下次调用时,如果参数一样,那方法就不再计算而是直接返回结果了

    2
    @Slf4j 作用在类上
    groovy.util.logging.Slf4j
    相当于private  final Logger logger = LoggerFactory.getLogger(XXX.class)


    @ToString 作用在类上
    groovy.transform.ToString
    相当于自动重写了toString:格式是全类名(属性信息)
    com.xiaonanzhi.transform.model.Person(xiaoming, 网商路599号, 100)
    参数includeNames=true可以把属性显示出来
    com.xiaonanzhi.transform.model.Person(name:xiaoming, address:网商路599号, age:100)
    示例代码:

    @ToString(includeNames = true, includePackage = false)
      static class DeployServerGroup {
        String region
        String name
      }

    4 @EqualsAndHashCode 作用在类上
    groovy.transform.EqualsAndHashCode
    相当于重写了equals方法,它认为toString相等的对象就相等

    5 @TupleConstructor 作用在类上
    groovy.transform.TupleConstructor
    groovy默认可以给对象提供new object(key1:value1, key2:value2, key3:value3)这种方式的构造器,
    如果添加@TupleConstructor就会提供一个更简洁的构造方式:new object(value1,value2, value3)
    但是这种方式的缺点是可读性不好,需要与属性定义的位置一一对应。

    6 @Canonical 作用在类上
    groovy.transform.Canonical 
    相当于@ToString+@EqualsAndHashCode+@TupleConstructor

    7
    @Delegate作用在属性上

    groovy.lang.Delegate
    class A(){
        function a(){}
    }
    class B(){
        @Delegate
         A a = new A()
    
        funtion b(){}
    }

    通过B既可以调用b()方法,也可以调用a()方法,当自身找不到某个方法或属性时去delegate里去找。一个类可以设置N多个代理属性。
    但是这种对于习惯Java规范的人来说是一种很难理解的行为,可读性会变很差。

    8
    @Builder 作用在类上
    groovy.transform.builder.Builder
    被Builder修饰的类在创建时可以被builder了~ 语法如下:

    @Builder
    class OpenstackInstanceType implements InstanceType, Serializable {
      String account
      String region
      String id
      String name
      int ram
      int vcpus
      int disk
      int swap
      int ephemeral
      boolean available
      boolean disabled
    }
    
    OpenstackInstanceType.builder()
          .account(accountName)
          .region(region)
          .id(flavor.id)
          .name(flavor.name)
          .available(flavor.isPublic())
          .disabled(flavor.isDisabled())
          .disk(flavor.disk)
          .ephemeral(flavor.ephemeral)
          .ram(flavor.ram)
          .swap(flavor.swap)
          .vcpus(flavor.vcpus)
          .build()
      }

    9
    @Immutable 作用在类上
    groovy.transform.Immutable
    相当于声明class为final类型,不允许改变

    展开全文
  • Groovy实战

    2019-04-26 08:51:17
    一、闭包与基本类型结合使用(闭包实现循环): /** * 闭包与基本类型结合使用 * 举例:实现阶乘 10! */ //使用循环: 传统方法 int sum1 = 1 ...//使用循环: groovy用法 int sum2 = 1 for (i i...

    一、闭包与基本类型结合使用(闭包实现循环):

    /**
     * 闭包与基本类型结合使用
     * 举例:实现阶乘 10!
     */
    
    //使用循环: 传统方法
    int sum1 = 1
    for (i = 1; i < 6; i++) {
        sum1 *= i
    }
    println("sum1 = " + sum1)
    
    //使用循环: groovy用法
    int sum2 = 1
    for (i in 1..5) {
        sum2 *= i
    }
    println("sum2 = " + sum2)
    
    //使用循环: groovy闭包用法
    int sum3 = 1
    1.upto(5, { num -> sum3 *= num })
    println("sum3 = " + sum3)
    
    int sum4 = 1
    5.downto(1, { num -> sum4 *= num })
    println("sum4 = " + sum4)
    
    int sum5 = 1
    5.downto(1) { num -> sum5 *= num }
    println("sum5 = " + sum5)
    
    int sum6 = 0
    101.times { num -> sum6 += num }
    println("sum6 = " + sum6)

    二、闭包与String结合使用

    /**
     * 闭包与String结合使用
     */
    String str = "the 2 and 3 is 5"
    //each的遍历
    str.each {
        String temp -> print temp.multiply(2)
    }
    println()
    
    //find 查找符合条件的第一个
    String str2 = 'the 2 and 3 is 5'
    println str2.find {
        String s -> s.isNumber()
    }
    println str2.findAll() {
        String s -> s.isNumber()
    }
    
    // any
    def res = str2.any {
        String s -> s.isNumber()
    }
    println(res)
    
    println str2.every { String s -> s.isNumber() }
    
    println str2.collect { it.toUpperCase() }

    三、闭包的三个重要变量:this、owner、delegate

    /**
     * 闭包的三个重要变量:this、owner、delegate
     */
    def scriptClosure = {
        println "scriptClosure this: " + this //代表闭包定义处的类
        println "scriptClosure owner: " + owner //代表闭包定义处的类或者对象
        println "scriptClosure delegate: " + delegate //代表任意对象,默认与owner一致
    }
    scriptClosure.call()
    
    //定义了一个内部类
    class Person {
        def classClosure = {
            println "classClosure this: " + this //代表闭包定义处的类
            println "classClosure owner: " + owner //代表闭包定义处的类或者对象
            println "classClosure delegate: " + delegate //代表任意对象,默认与owner一致
        }
    
        def say() {
            def classClosure = {
                println "methodClassClosure this: " + this //代表闭包定义处的类
                println "methodClassClosure owner: " + owner //代表闭包定义处的类或者对象
                println "methodClassClosure delegate: " + delegate //代表任意对象,默认与owner一致
            }
            classClosure.call()
        }
    }
    
    Person person = new Person()
    person.classClosure.call()
    person.say()
    
    //定义了一个内部类
    class Animal {
        def static classClosure = {
            println "classClosure this: " + this //代表闭包定义处的类
            println "classClosure owner: " + owner //代表闭包定义处的类或者对象
            println "classClosure delegate: " + delegate //代表任意对象,默认与owner一致
        }
    
        def static say() {
            def classClosure = {
                println "methodClassClosure this: " + this //代表闭包定义处的类
                println "methodClassClosure owner: " + owner //代表闭包定义处的类或者对象
                println "methodClassClosure delegate: " + delegate //代表任意对象,默认与owner一致
            }
            classClosure.call()
        }
    }
    
    Animal.classClosure.call()
    Animal.say()
    
    //闭包中定义一个闭包
    def nestClosure = {
        def innerClosure = {
            println "innerClosure this: " + this //代表闭包定义处的类
            println "innerClosure owner: " + owner //代表闭包定义处的类或者对象
            println "innerClosure delegate: " + delegate //代表任意对象,默认与owner一致
        }
        innerClosure.call()
    }
    nestClosure.call()

    总结:
    大多数情况下,this、owner、delegate的值是一样的;
    当我们在闭包中定义一个闭包时,this就与owner、delegate的值不一样了;
    当我们认为修改了delegate的值之后,delegate与owner的值又会不一样了;
    this和owner是不能别修改的,delegate是可以被修改的。

    四、闭包的委托策略

    /**
     * 闭包的委托策略
     */
    class Student {
        String name
        def pretty = { "My name is ${name}" }
    
        String toString() {
            pretty.call()
        }
    }
    
    class Teacher {
        String name
    }
    
    def stu = new Student(name: "xiaoming")
    def tea = new Teacher(name: "zhanglaoshi")
    println(stu.toString())
    stu.pretty.delegate = tea
    //委托策略
    stu.pretty.resolveStrategy = Closure.DELEGATE_FIRST
    println(stu.toString())

    五、数据结构:列表

    /**
     * 列表的定义
     */
    //java 的定义方式
    def listJava = new ArrayList()
    //grovvy的定义方式
    def list = [1, 2, 3, 4, 5]
    println(list.class)
    println(list.size())
    
    //那么,怎么定义数组呢
    def array = [1, 2, 3, 4, 5] as int[]
    int[] array2 = [1, 2, 3, 4, 5]
    println(array.class)
    println(array.size())
    
    /**
     * list 添加元素
     */
    list.add(6)
    list.leftShift(7)
    list << 8
    println(list.toListString())
    def pluslist = list + 9
    println(pluslist)
    
    /**
     * list 删除元素
     */
    list.remove(7)
    list.remove((Object) 8)
    list.removeAt(2)
    list.removeElement(3)
    println list - [5, 7]
    println list.removeAll() { return it % 2 == 0 }
    
    /**
     * 列表的排序
     */
    //java方式
    def sortlist = [5, 8, -9, -54, 6, 4, 3]
    Collections.sort(sortlist)
    println(sortlist)
    
    //自定义排序规则 按照绝对值大小排列
    Comparator comparator = { a, b ->
        a == b ? 0 :
                Math.abs(a) < Math.abs(b) ? -1 : 1
    }
    Collections.sort(sortlist, comparator)
    println(sortlist)
    
    //groovy方式
    println sortlist.sort()
    
    sortlist.sort {
        a, b ->
            a == b ? 0 :
                    Math.abs(a) < Math.abs(b) ? 1 : -1
    }
    println(sortlist)
    
    //字符串排序
    def stringList = ['abc', 'bb', 'java', 'groovy', 'gradle', 'android']
    //按照字符串的长度排序
    stringList.sort { it -> return it.size() }
    println(stringList)
    
    /**
     * 列表的查找
     */
    def findlist = [-3, 9, 6, 2, -7, 1, 5]
    //查找第一个偶数
    int res2 = findlist.find { return it % 2 == 0 }
    println(res2)
    //查找所有偶数
    def res3 = findlist.findAll { return it % 2 == 0 }
    println(res3)
    def res4 = findlist.any { return it % 2 == 0 }
    println(res4)
    def res5 = findlist.every { return it % 2 == 0 }
    println(res5)
    //最小值 最大值
    println findlist.min()
    println findlist.max()
    //绝对值的最小值 最大值
    println findlist.min { return Math.abs(it) }
    println findlist.max { return Math.abs(it) }
    //统计
    def res6 = findlist.count { return it >= 5 }
    println(res6)

    六、数据结构:映射(Map)

    /**
     * map的定义
     */
    //java的方式
    def hashMap = new HashMap()
    //groovy的方式
    def colors = [red  : 'ff0000',
                  green: '00ff00',
                  blue : '0000ff']
    //索引方式
    println colors['red']
    println colors.red
    //添加元素
    colors.yellow = 'ffff00'
    colors.complex = [a: 1, b: 2]
    
    println colors.toMapString()
    println colors.getClass()
    
    /**
     * Map的遍历
     */
    def students = [
            1: [number: '0001', name: 'Bob',
                score : 55, sex: 'male'],
            2: [number: '0002', name: 'Johnny',
                score : 62, sex: 'female'],
            3: [number: '0003', name: 'Claire',
                score : 73, sex: 'female'],
            4: [number: '0004', name: 'Amy',
                score : 66, sex: 'male']
    ]
    
    //遍历
    students.each { def student ->
        println "the key is ${student.key}  " +
                "the value is ${student.value}"
    }
    students.each { key, value ->
        println "the key is ${key}  " +
                "the value is ${value}"
    }
    
    
    //带索引的遍历
    students.eachWithIndex { def student, int index ->
        println "the index is ${index}  " +
                "the key is ${student.key}  " +
                "the value is ${student.value}"
    }
    students.eachWithIndex { key, value, index ->
        println "the index is ${index}  " +
                "the key is ${key}  " +
                "the value is ${value}"
    }
    
    /**
     * Map的查找
     */
    println()
    println("===================== Map的查找 =========================")
    
    def entry = students.find { def student ->
        return student.value.score >= 60
    }
    println(entry)
    
    def entries = students.findAll { def student ->
        return student.value.score >= 60
    }
    println(entries)
    
    //统计
    def count = students.count { def student ->
        return student.value.score >= 60 &&
                student.value.sex == 'male'
    }
    println count
    
    //查找所有及格学生的名字
    def names = students.findAll { def student ->
        return student.value.score >= 60
    }.collect {
        return it.value.name
    }
    println(names)
    
    //分组 根据学生成绩
    def group = students.groupBy { def student ->
        return student.value.score >= 60 ? '及格' : '不及格'
    }
    println(group)
    
    //排序 根据学生成绩
    def sort = students.sort { def student1, def student2 ->
        Number score1 = student1.value.score
        Number score2 = student2.value.score
        return score1 == score2 ? 0 : score1 < score2 ? -1 : 1
    }
    println(sort)

    七、数据结构:范围(Range)

    /**
     * Range的定义
     */
    def range = 1..10
    println(range[8])
    println(range.contains(6))
    println(range.from)
    println(range.to)
    
    //遍历 推荐
    range.each { println(it) }
    
    for (i in range) {
        println(i)
    }
    
    def getGrade(Number number) {
        def result
        switch (number) {
            case 0..<60:
                result = '不及格'
                break
            case 60..<70:
                result = '及格'
                break
            case 70..<80:
                result = '良好'
                break
            case 80..100:
                result = '优秀'
                break
        }
        return result
    }
    println getGrade(100)

    八、面向对象

    groovy中类,接口等的定义和使用

    interface Action {
        void eat()
        void drink()
        void play()
    }
    
    /**
     * groovy中的类、方法、参数默认都是public类型的
     */
    class Person {
    
        String name
        int age
    
        def increaseAge(int years) {
            this.name += years
        }
    
        /**
         * 一个方法找不到时,调用它代替
         * @param name
         * @param args
         * @return
         */
        def invokeMethod(String name,Object args){
            return "the method is ${name}, the params is ${args}"
        }
    
    
        def methodMissing(String name,Object args){
            return "the method ${name} is missing"
        }
    
    }

     groovy中的元编程

    
    def person = new Person(name: "Song", age: 27)
    println person.cry()
    
    //将以下注入的属性设置为全局可用
    ExpandoMetaClass.enableGlobally()
    //为类动态添加一个属性
    Person.metaClass.sex = 'male'
    def person2 = new Person(name: "Song2", age: 29)
    println person2.sex
    person2.sex = 'female'
    println person2.sex
    
    //为类动态添加一个方法
    Person.metaClass.setUpperCase = { -> sex.toUpperCase() }
    def person3 = new Person(name: "Song3", age: 35)
    println person3.setUpperCase()
    
    //为类动态添加一个静态方法
    Person.metaClass.static.createPerson = { String name, int age ->
        new Person(name: name, age: age)
    }
    def person4 = Person.createPerson('song4', 40)
    println person4.name
    println person4.age

    、闭包与数据结构结合使用

    、闭包与文件等结合使用

    展开全文
  • Groovy实战

    2019-04-28 09:34:54
    def file = new File('D:\\idea_ws\\test\\GroovyTest\\GroovyTest1\\GroovyTest1.iml') file.eachLine { line -> // println line } //读取文件内容 String def text = file.getText() //println text //读取文件...

    一、json操作详解

    def list = [new Person(name: "John", age: 22),
                new Person(name: 'Major', age: 33)]
    def json = JsonOutput.toJson(list)
    println json
    println JsonOutput.prettyPrint(json)
    
    
    def response = getNetworkData('https://restapi.amap.com/v3/weather/weatherInfo?city=%E9%95%BF%E6%B2%99&' +
            'key=13cb58f5884f9749287abbead9c658f2')
    
    def json2 = JsonOutput.toJson(response)
    println json2
    println JsonOutput.prettyPrint(json2)
    
    println response
    println response.lives
    
    def getNetworkData(String url) {
        //发送http请求
        def connection = new URL(url).openConnection()
        connection.setRequestMethod('GET')
        connection.connect()
        def response = connection.content.text
    
        //将json转化为实体对象
        def jsonSlurper = new JsonSlurper()
        return jsonSlurper.parseText(response)
    }

    二、xml文件解析

    final String xml = '''
        <response version-api="2.0">
            <value>
                <books id="1" classification="android">
                    <book available="20" id="1">
                        <title>疯狂Android讲义</title>
                        <author id="1">李刚</author>
                    </book>
                    <book available="14" id="2">
                       <title>第一行代码</title>
                       <author id="2">郭林</author>
                   </book>
                   <book available="13" id="3">
                       <title>Android开发艺术探索</title>
                       <author id="3">任玉刚</author>
                   </book>
                   <book available="5" id="4">
                       <title>Android源码设计模式</title>
                       <author id="4">何红辉</author>
                   </book>
               </books>
               <books id="2" classification="web">
                   <book available="10" id="1">
                       <title>Vue从入门到精通</title>
                       <author id="4">李刚</author>
                   </book>
               </books>
           </value>
        </response>
    '''
    
    //开始解析xml数据
    def xmlSlurper = new XmlSlurper()
    def response = xmlSlurper.parseText(xml)
    println response
    println response.value.books[0].book[0].title.text()
    println response.value.books[1].book[0].@available
    
    //查询作者为李刚的书名
    def list = []
    response.value.books.each { books ->
        //对书名进行遍历
        books.book.each { book ->
            def author = book.author.text()
            if (author.equals('李刚')) {
                list.add(book.title.text())
            }
        }
    }
    println list
    
    //深度遍历xml数据  depthFirst()等同于 '**'
    def titles = response.depthFirst().findAll {
        book -> return book.author.text() == '李刚'
    }
    println titles
    
    //广度遍历xml数据  children()等同于 '*'
    def names = response.value.books.children().findAll { node ->
        node.name() == 'book' && node.@id == '1'
    }.collect {node ->
        return node.title.text()
    }
    println names

    三、xml文件生成

    /**
     * 生成xml格式数据
     * <langs type='current' count='3' mainstream='true'>
     <language flavor='static' version='1.5'>Java</language>
     <language flavor='dynamic' version='1.6.0'>Groovy</language>
     <language flavor='dynamic' version='1.9'>JavaScript</language>
     </langs>
     */
    def sw = new StringWriter()
    def xmlBuilder = new MarkupBuilder(sw)//用来生成xml的核心类
    //根节点langs创建
    xmlBuilder.langs(type: 'current', count: 3, mainstream: 'true') {
        //第一个language节点
        language(flavor: 'static', version: '1.5', 'Java')
        language(flavor: 'dynamic', version: '1.6.0', 'Groovy')
        language(flavor: 'dynamic', version: '1.9', 'JavaScript')
        language(flavor: 'static', version: '1.5') {
            age('16')
        }
    }
    println sw
    
    //对应xml中的langs节点
    class Langs {
        String type = 'current'
        int count = 3
        boolean mainstream = true
        def languages = [new Language(flavor: 'static', version: '1.5', value: 'Java'),
                         new Language(flavor: 'static', version: '1.6.0', value: 'Groovy'),
                         new Language(flavor: 'static', version: '1.9', value: 'JavaScript')]
    }
    
    //对应xml中的language节点
    class Language {
        String flavor
        String version
        String value
    }
    
    def sw2 = new StringWriter()
    def xmlBuilder2 = new MarkupBuilder(sw2)
    
    def langs = new Langs()
    xmlBuilder2.langs(type: langs.type, count: langs.count,
            mainstream: langs.mainstream) {
        //遍历所有的子结点
        langs.languages.each { lang ->
            language(flavor: lang.flavor,
                    version: lang.version, lang.value)
        }
    }
    println sw2

    四、groovy文件处理详解

    def file = new File('D:\\idea_ws\\test\\GroovyTest\\GroovyTest1\\GroovyTest1.iml')
    file.eachLine { line ->
    //    println line
    }
    
    //读取文件内容 String
    def text = file.getText()
    //println text
    
    //读取文件内容 返回List<String>
    def res = file.readLines()
    
    //读取文件部分内容
    def reader = file.withReader { reader ->
        char[] buffer = new char[100]
        reader.read(buffer)
        return buffer
    }
    //println reader
    
    //拷贝文件
    def copy(String sourcePath, String targetPath) {
        try {
    //首先创建目标文件
            def tarFile = new File(targetPath)
            if (!tarFile.exists()) {
                tarFile.createNewFile()
            }
    
            //开始copy
            def sourFile = new File(sourcePath)
            if (sourFile.exists()) {
                sourFile.withReader { reader ->
                    def lines = reader.readLines()
                    tarFile.withWriter { writer ->
                        lines.each { line ->
                            writer.append(line + "\r\n")
                        }
                    }
                }
            }
            return true
        } catch (Exception e) {
            e.printStackTrace()
        }
        return false
    }
    
    def res2 = copy('D:\\idea_ws\\test\\GroovyTest\\GroovyTest1\\GroovyTest1.iml',
            '../../../GroovyTest2.iml')
    //println res2
    
    def saveObject(Object object, String targetPath) {
        try {
            //首先创建目标文件
            def tarFile = new File(targetPath)
            if (!tarFile.exists()) {
                tarFile.createNewFile()
            }
            tarFile.withObjectOutputStream { out ->
                out.writeObject(object)
            }
            return true
        } catch (Exception e) {
            e.printStackTrace()
        }
        return false
    }
    
    def readObject(String path) {
        def obj = null
        try {
            def file = new File(path)
            if (file == null || !file.exists()) return null
            //从文件中读取对象
            file.withObjectInputStream { input ->
                obj = input.readObject()
            }
        } catch (Exception e) {
            e.printStackTrace()
        }
        return obj
    }
    
    def person = new Person(name: 'song', age: 27)
    //saveObject(person, '../../../Person.bin')
    
    def res3 = (Person) readObject('../../../Person.bin')
    println res3.name + ',' + res3.age

     

    展开全文
  • groovy in action电子书 中文版和英文原版-------下载不扣分,回帖加1分,欢迎下载,童叟无欺 groovy 实战指南
  • Groovy是一种替代语言。替代什么?替代Java。与Java相比,Groovy大的优势就在于“如果实现相同的功能,使用Groovy的话,代码量更少”。
    Groovy实战入门教程—214人已学习 
    
    课程介绍    
    201804280938262291.jpg
        Groovy是一种替代语言。替代什么?替代Java。与Java相比,Groovy大的优势就在于“如果实现相同的功能,使用Groovy的话,代码量更少”。
    课程收益
        深入认识到 Groovy 就是 Java,是丢掉了许多包袱的 Java。
    讲师介绍
        吕常龙 更多讲师课程
        《Grails实战教程》系列视频作者,从事网站开发工作近6年,对网站开发相关技术及工作有着一定的了解~
    课程大纲
        1. Groovy实战入门教程01Groovy的配置与验证  6:28
        2. Groovy实战入门教程02Java的替代者Groovy  11:39
        3. Groovy实战入门教程03在集成开发环境中运行Groovy  11:08
        4. Groovy实战入门教程04Groovy与Java的基础操作对比  19:08
        5. Groovy实战入门教程05Groovy的进阶技能  15:56
    大家可以点击【 查看详情】查看我的课程
    展开全文
  • groovy 闭包实战教程

    千次阅读 2017-02-19 10:37:19
    groovy 闭包实战教程 闭包本质是一段匿名的代码块,如是:{ -&gt; } ; 闭包是groovy.lang.Closure类型,因此可以作为参数传入方法,甚至闭包。 同时闭包也是一个方法,没有与之关联的类;因此,其可以有...
  • 实战groovy.rar

    2012-03-19 16:15:53
    实战groovy.rar
  • java调用groovy脚本实战

    2020-03-03 16:04:22
    Groovy就是用Java写的 , Groovy语法与Java语法类似, Groovy 代码能够与 Java 代码很好地结合,也能用于扩展现有代码, 相对于Java, 它在编写代码的灵活性上有非常明显的提升 需求: 当java逻辑需要调用某段groovy脚本...
  • IBM 实战 Groovy

    2009-11-02 11:22:35
    相当不错的groovy实践之作,IBM大师亲自为您讲述groovy的魅力之处
  • https://www.ibm.com/developerworks/cn/java/j-pg04149.html?ca=drs-cn-0605 转载于:https://www.cnblogs.com/MasterMonkInTemple/p/7015981.html
  • Gradle从入门到实战 - Groovy基础

    万次阅读 多人点赞 2017-07-25 17:29:04
    Android方向的第一期文章,会专注于Gradle系列,名字叫做『 Gradle从入门到实战』,计划有如下几个课程: Groovy基础 全面理解Gradle 如何创建Gradle插件 分析Android的build tools插件 实战,从0到1完成一款...
  • 随着 Groovy JSR-1(及其后续...这个月,Groovy 的常驻实践者 Andrew Glover 将介绍 Groovy 语法最重要的变化,以及在经典 Groovy 中找不到的一个方便特性。 从我在 alt.lang.jre 的系列文章“Feeling Groo...
  • Groovy in Action Groovy实战 英文第2版 Groovy in Action Groovy实战 英文第2版
  • 实战 Groovy: 用 Groovy 进行 JDBC 编程 用 GroovySql 构建下一个报告应用程序 ...
  • Groovy 专家 Scott Davis 将重新开始撰写 实战 Groovy 系列文章,该系列文章于 2006 年停止编写。作为开篇文章,本文将介绍 Groovy 最近的发展以及 Groovy 当前的状态。然后了解大约 从 2009 年开始,使用 Groovy...
  • 实战 Groovy 系列的这一复兴篇中,Groovy 开发人员兼特约专栏作家 J. Scott Hickey 带您进行一系列对常规 Java 代码和 Groovy 代码的比较,展示这门令人兴奋的语言如何将您解放出来,让您能够专注于编码的重要...
  • 通过项目实战,带大家了解Groovy在脚本引擎方面的应用。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,987
精华内容 1,994
关键字:

groovy实战