Hello Groovy

def str = "Hello Groovy"
println "${str}"

字符串操作

单引号表示静态的字符串
双引号表示动态的字符串
连续三个双引号表示字符串段落

例

def str = "Hello Groovy";
def str2 = """
    hello!
    my name is zhangsan!
    my email is [email protected]
"""
println "${str}";
println '${str}';
println str2;

输出：

Hello Groovy
${str}

    hello!
    my name is zhangsan!
    my email is zhangsan@qq.com

/*************************/
println str.size() // java.length()
println str[0..4] // java.substring()
println str.reverse() // 字符串反转
/*************************/

数字操作

def x = 1;
def y = 2;
println x+y;
println x.plus(y) // 等同于x+y

类

与java类似
但是class前面没有限定符，构造器基于Map初始化
不需要写get，set方法

class A{
    String p1;
    String p2;
}
def a = new A(p1:"a",p2:"b") // 实例化对象
println a.p1 // 相当于get方法
println a.p2

运算符

大部分与java相同
特别注意
== 比较值是否相等
.is() 比较对象引用的地址是否相等

java
== 比较对象引用的地址是否相等
.equals() 比较值是否相等
例

def str = 'hello';
def str2 = str;
def str3 = new String('hello');
def str4 = 'Hello';

println str == str2 // true
println str == str3 // true
println str == str4 // false

println str.is(str2) // true
println str.is(str3) // false
println str.is(str4) // false

if结构

在java中条件的表达式计算结果只能是布尔值
在Groovy中
传入boolean或Boolean时，与Java相同
传入数字时，非0为真，0为假
传入字符串时，空字符串尾假，反之为真
传入集合时，元素个数等于0为假，元素个数大于0为真
传入对象时，null为假，反之为真

for结构

for传统风格

for(int index=0;index<10;index++){
    println index;
}

for-each风格

for(int index in 0...10){
    println index
}

times风格

10.times{
    println it
}

switch结构

与java不同的是，case子句内可以进行多种复杂的判断

switch(10){
    case 0:println "0";
           break;
    case 0..9:println "range from 0 to 9";
            break;
    case [8,9,11]:printl "in 8,9,11";
            break;
    case {it % 3 == 0}:println "multiple of 3";
            break;
    ...
    default: println "not found";
            break;
}

例：

switch(78){
    case 0..59: println "不及格";break;
    case 60..68: println "及格"; break;
    case 70..79: println "良好"; break;
}

groovy集合

列表List(java.util.List)

def datas = [10,8,4,1,3,7,6,2,5,9]
datas.max() // 最大值
datas.min() // 最小值
datas.sum() // 求和
datas.count(1) // 统计1 的个数
datas.sort() // 从小到大排序
datas.size() // 元素个数
datas.reverse() // 元素反转
datas<<5 // 在列表末尾添加元素5

映射Map(java.util.Map)

def datas = [name:"ZhangSan",age:"21",sex:"male"]
datas.name // 访问key为name的元素值
datas[name] // 访问key为name的元素值 （datas["name"]要加引号）
datas.remove(key) // 删除key元素
// 闭包
datas.each{
    data ->
    println data.key +","+data.value
}

区间Range
闭区间：起始..结束
右开区间：起始..<结束

def range1 = 1..5
def range2 = 1..<5
range1.size() // 元素个数
range2.contains(5) // 是否包含5元素

闭包

闭包是Java所不具备的语法结构
闭包就是一个代码块，用{}括起来。
程序代码也成为数据，可以被一个变量所引用
Groovy的API大量使用闭包，以实现对外开放
例：

// 不带参数的闭包
def closure1 = {
    println it
};
closure1.call("Hello Groovy");
// 带一个参数的闭包
def closure2 = {
    text ->
    println text
}
closure2("Hello Groovy2");
// 带两个参数的闭包
def closure3 = {
    name,age ->
    println "my name is ${name},I am ${age} year old";
    println name+age;
}
closure3("zhangsan",12)

Delegate属性

指定了闭包的代理对象，默认情况下delegate与this是相同的，
但可以手动修改delegate的值，使闭包可以访问其他对象的方法和属性。

class Handler{
    def method(){
        println "handler method called..."
    }
}
class Example{
    def method(){
        println "example method called...";
    }

    def foo(closure){
        // 指向Handler对象
        closure.delegate = new Handler()
        closure();
    }
}
// 创建实例化对象
new Example().foo{
    method();
}

文件的读取

new File("filepath").text

// 闭包方式读取文件
new File("C:/Users/caizh/Desktop/groovy笔记.txt").eachLine{
    line ->
    println line;
}
文件的写入
def out = new File("filepath").newPrintWriter()
out.write("content")
out.flush()
out.close()

new File("filepath").withPrintWriter{
    out ->
    out.println("content")
}

groovy的XML处理

xml文档

<languages type="current">
<language author="James Gosling">java</language>
<language author="Anders Hejlsbeng">C#</language>
</languages>

解析xml

def languages = new XmlParser().parse(new File("languages.xml"))
println "type=${languages.attribute("type")}"

languages.language.each{
    println "language:${it.text()},author:${it.attribute("author")}"
}

创建xml

import groovy.xml.*;// 注意导包
def out = new StringWriter()
def xml = new MarkupBuilder(out)
// 根节点（属性值）
xml.langs(type:"current"){
    // 前面如果没有属性名称，则为节点的文本信息
    language("java",author:"James Gosling")
    language("C#",author:"Anders Hejlsberg")
    language("SQL",name:"mysql")
}
def file = new File("C:/Users/caizh/Desktop/languages.xml")
file.write(out.toString())

创建HTML

import groovy.xml.*;
def out = new StringWriter()
def html = new MarkupBuilder(out)
html.html{
    head{
        title("Hello HTML")
    }
    body{
        h1("Here are my HTML bookmarks");
        a(href:"http://www.baidu.com","百度一下");
    }
}
def file = new File("C:/Users/caizh/Desktop/index.html");
file.write(out.toString());

Groovy的JSON处理

解析JSON

import groovy.json.*
// 实例化JsonSlurper对象
def root = new JsonSlurper().parseText(new File("C:/Users/caizh/Desktop/index.txt").text);
// 访问person。name
println root.person.name
println root.person.sex
println root.person.age
root.person.hobbies.each{
    print it + ","
}

生成JSON

import groovy.json.*
def json = new JsonBuilder()
json.person{
    name "Zhangsan1"
    sex "male"
    age 21
    hobbies "running","basketball","tennis"
}
println JsonOutput.prettyPrint(json.toString())

groovy连接数据库

def sql = groovy.sql.Sql.newInstance("jdbc:mysql://localhost:3306/groovy","root","root","com.mysql.jdbc.Driver");
println sql.connection

// 插入数据操作
//sql.executeInsert("insert into student value(default,?,?)",["zhangsan",'male']);
//sql.executeInsert("insert into student value(default,?,?)",["li si",'female']);
//sql.executeInsert("insert into student value(default,'wang wu','male')");

// 更新数据操作
//sql.executeUpdate("update student set sex = ? where id = ?",['female',3]);

// 删除数据操作
//sql.execute("delete from student where id=?",[3]);

// 查询数据操作
sql.eachRow("select * from student"){

    println "Id:${it.id}    Name:${it.name}     Sex:${it.sex}";
}

GORM

Grails Object Relational Mapping(对象关系映射)
在底层，它使用Hibernate5（一个非常流行和灵活的开源ORM解决方案），
但是因为Groovy天生的动态性，实际上，对动态类型和静态类型两者都支持，
由于Grails的规约，只需要很少的配置涉及Grails domain类的创建。
（操作对象一样来操作数据库中的数据，不再写繁琐的SQL语句）

import grailsorm.Student
// 插入数据操作
/*def stu1 = new Student(name:"zhangsan",sex:"male",age:21)
def stu2 = new Student(name:"lisi",sex:"female",age:12)
def stu3 = new Student(name:"wangwu",sex:"male",age:23)

stu1.save(flush: true)
stu2.save(flush: true)
stu3.save(flush: true)*/

// 读取数据
/*def student = Student.get(1)
println student.name;
println student.age;
println student.sex;*/

// 更新数据操作
/*def student = Student.get(1)
student.name = "Mike";
student.save(flush: true);*/

// 删除数据操作
/*def student = Student.get(3)
student.delete(flush: true)*/

// 查询列表
/*def students = Student.list()
students.each{
    s->
    println s.name
}*/

// 查询数据带条件
def students = Student.where{
    sex == 'male'
}.find()
students.each{
    s ->
    println s.name
}

Groovy笔记