Groovy语言学习

Groovy语言的学习：

Groovy 是用于Java虚拟机的一种敏捷的动态语言，它是一种成熟的面向对象编程语言，既可以用于面向对象编程，又可以用作纯粹的脚本语言。
       使用该种语言不必编写过多的代码，同时又具有闭包和动态语言中的其他特性。

Grails是一套用于快速Web应用开发的开源框架，它基于Groovy编程语言，并构建于Spring、Hibernate等开源框架之上，是一个高生产力一站式框架。
Grails是一个full-stack框架，它借助于核心技术与相关的插件（plug-in）来解决Web开发中方方面面的问题，其中包括：
Groovy语言基础知识讲解
易于使用的基于Hibernate的对象-关系映射(ORM)层
使用Groovy Server Pages (GSP)的表现层技术
基于Spring MVC的控制器层
利用内置的Spring 容器实现依赖注入
基于Spring的MessageSource核心概念，提供了对国际化（i18n）的支持
基于Spring事务抽象概念，实现事务服务层。同时借助于功能强大的Groovy动态语言和领域特定语言（Domain Specific Language，DSL），以上那些特性变得非常易用。

下载安装与环境配置：
Gralis下载：https:grails.org/   然后在path中配置 GRAILS_HOME环境变量;
      检查：在cmd中  输入:grails  回车，显示黄色字体并出现grails>; 说明配置成功
Groovy下载：http:www.groovy-lang.org/download.html  在path中配置 GROOVY_HOME 环境变量
      检查：在cmd中  输入：groovy 回车，出现跟输入java一样的显示。说民配置成功
            在cmd中，输入：groovyConsole 回车，等一会  出现了groovyConsole的开发工具，支持动态语言
eclipse中集成groovy的插件方式:
      1：检查自己的eclipse版本：在help->About Eclipse中查看
      2：进入 https://github.com/groovy/groovy-eclipse/wiki查找和自己eclipse对应版本的groovy
      3：拷贝下载地址
      4：打开eclipse，在eclipse中，选择help -> Install New Software…
      5：选择add，对话框中name随便写，地址将上面拷贝的地址粘贴进去
      6：等待会，会出现选项，全选后下一步
      7：安装完毕后重新启动eclipse，然后新建项目，选择Other，新建Groovy Project->groovy.class

1.hello world 演示
  println " ..hello wrold , hello groovy .."
  输出：..hello world , hello groovy..
  
2.基本类型与运算符
  ㈠groovy 是动态的弱类型语言，声明变量不需要制定类型。变量的类型是根据程序执行的上下文来决定的；
      def  :声明变量类型，类似与  javaScript中的"var"
      def a = 1;
      def b = "groovy"
      def c = true
      
      groovy中，单行不需要加";"。而多个语句写在同一行时，需要";"隔开
      def a = 1; def b=2
  
  ㈡groovy中的String 输出""与''的区别：
      在groovy ""和''都可以使用,用来输出字符串;
      "" :会输出 ""之内的值,变量转换成具体的值来输出;
      '' :如果在''中输出了，变量。它会把变量当做表达式来输出
      例如：
      def e = 10
      def f = "$e"   输出：10
      def h = '$e'   输出：$e
      
  ㈢groovy中"""的使用：可以用来输出一个字符段落;  与java中使用"+"拼接的功能类似  
    def str = """
        hello
        my name is zhangsan 
        my email is zhangsan@126.com
    """
    println str 
    输出：
        hello
        my name is zhangsan 
        my email is zhangsan@126.com
  
  ㈣groovy中String的方法
    str.size() 字符串的长度  //java.length()
    str[0..4]  字符串的截取  //java.subString()
  ㈤groovy中数字 采用精度更高的BigDecimal来进行计算
    def a = 1
    def b = 2
    println a + b        //3
    println a.plus(b)    //3
  ㈥groovy中的注释,与java中用法基本一致  
    单行  //
    多行  /** */
  ㈦groovy中的类 与java中基本没有什么区
    class 前没有限定符，作用域默认 public  缺省default修饰符
    构造器基于map初始化    
    
    示例：
    calss A {
       String name ; int age
    }
    def a = new A(name:"zhangsan",age:10)
    println a.name    //a.getName()
    println a.age     //a.getAge()
    注:在groovy中，不需要为成员变量添加get/set方法。在运行时，会自动创建   
  ㈧运算符：groovy中"=="与equals()的使用    
    在groovy中,  用"=="来比较两个对象的值/内容是否相等                 //Java中， "=="用来判断地址值
                 用".is()" 来比较地址值是否相等/基本类型是否相等       //Java中，".equals()"用来判断值/内容是否相等
  ㈨groovy中，assert断言的使用
    assert的使用是一种防御性编程;assert()就是一个debug断言
    assert(表达式) ：如果表达式为假,整个程序会退出,并将输出错误信息;
                     如果表达式为真,程序继续执行，断言后面的逻辑
    
3.groovy的控制结构：判断 循环  顺序
  ㈠与java的区别：
    在java中条件的表达式，只能为boolean值
    在groovy中 -->>
    传入boolean的使用与java一样
    传入数字时, 非0 -->> true;          0 -->> true
    传入字符串, null | "" -->> false ;  反之 -->> true
    传入集合,  .size()->0  -->> false ;  .size()>0 -->> true
    传入对象,   null -->> false ;      反之 -- >> true 
  ㈡for循环结构：
    for传统风格
    ①for( int index = 0; index < 10; index++){
         println index 
     }
    ②for-each风格
     for(index in 0..10 ){
        println index
     }    
    ③times风格
    10.times{println it}    //这里"it"  与java中的  this作用相同
       [1,2,3,4,].times{println it }   // 打印集合
  ㈢switch结构
    与java不同的是，case语句中可以进行多种复杂的判断
    实例说明：
    swith(10){
        case 0 : println "0" ;break;                         // 定值判断
        case 0..9 : println "range from 0 to 9 "; break;     // 范围判断
        case [8,9,11] : println "in 8,9,11";break;           // 集合判断
        case {it%3==0} ：println "multiple";break;           // Boolean值判断
        default : println "not found ";break;   
    }
    
4.groovy中的常用集合类型
  列表：list
  映射：map
  区间：range

  ㈠声明
    def list = []    //声明一个list集合
    def map = [:]    //声明一个map集合
    def range = 1..5 //声明一个区间 1-5
  
  ㈡list集合的方法及使用
    def list = [1,2,3,5,6,7,9,10]  
    list.max()      //最大值
    list.min()      //最小值
    list.sum()      //求和
    list.count(1)   //求"1" 出现的次数
    list.sort()     //从小到大排序
    list.size()     //求元素个数
    list.reverse()  //反转
    list<<5         //在集合末尾追加元素 5
    
    遍历：
    for(index in list) {
       print index + " "
    }
  ㈢map结合的方法及使用
    def map = [name:"zhangsan",age:21,sex:"male"]
    map.name       //map.get("name")  访问key为name的元素
    mep["name"]      //同上
    map.remove(key)//移除key元素
    
    遍历: --> 使用闭包遍历, 传入自定义参数 data 
    map.each(){
       data ->
       println data.key + ":" + date.value
    }
  ㈣range的方法及使用
    def range = 1..5     //区间：1-5
    def range1 = 1..<5   //区间：1-4
    
    range.size()         //元素个数
    range.contains(5)    //是否包含5元素
    
5.groovy中的闭包:
  闭包是java所不具备的语法结构。闭包就是一个代码块，使用{}括起来。程序代码也成为数据，可以被一个变量所引用。
  groovy中的API大量使用闭包，以实现对外开放。
  解释：以前程序代码是在编译的时候确定的，现在程序代码做为一种动态的数据。
  
  ㈠闭包的创建及使用
    {参数 ->   //如果多个参数用逗号隔开"," 如果省略，可以用"it"的变量访问参数
       代码
    }
    
    示例:
    def c = { println it }
    c.call("hello groovy")
    c("hello groovy 1")     //call可以省略
    
    def c2 = {data -> println data}
    c2("hello groovy 2")   //call可以省略
  ㈡闭包的Delegate属性
    指定了闭包的代理对，默认情况下delegate与this相同，但是可以手动修改delegate的值,使闭包可以访问其他对象的方法和属性
    
    示例：
    class Handler{
       def method(){
         println "handler method called.."
       }
    } 
    
    class Example{
        def method(){
           println "exmaple method called .."
        }
        def foo ( c ){
           c.delegate = new Handler()
           c()
        }
    }
    
    输出：
    new Exmaple().foo(){
       method()
    }
    //handler method called 
  ㈢采用闭包遍历集合
    def list = [1,2,4,5,6]
    list.each{
      print it + " "
    }    
    
    def map = [name:"zhangsan",age:10]
    map.each{
       data ->
       println data.key + ":" + data.value
    }
    
    map.each{
       key,value ->
       println key + ":" + value 
    }
    
6.groovy中的IO流：
  ㈠文件的读取
  new File("filepath文件存放路径").text()     //会自动读取所有的内容
  
  new File("filepath路径").eachLine(){        //采用闭包读取每一行
     line ->
     // 处理代码
  }
  ㈡文件的写入
  def out = new File("fielpath文件路径").newPrintWriter()
  out.write("content内容")                   //写入内容
  out.flush()                                //把内容数据  刷新到硬盘中
  out.close()                                //关闭流

  new File("fielpath文件路径").withPrintWriter(){
      out ->
      out.println("content内容")             //采用闭包不需要处理 flush和close
  }

7.groovy中对json数据的处理
  相同的数据内容json的数据占用大小要小于xml格式,特别适合网络传输数据使用;
  josn数据：{"person":{
                "naem":"zhangsan",
                "sex":"male",
                "age":10,
                "hobbies":
                ["running","baketball","tennis"]
                }
            }
  ㈠JSON读取
    import groovy.josn.*
    def root = new JsonSlurper().parseText(new File("person.json").text() //返回json中的所有内容)   //
    输出：println root.person.name
          println root.person.age
          proot.person.hobbies.each{
              print it 
          }    
  ㈡JSON生成
    def root = new JsonBuilder()                        //生成json,使用JsonBuilder这个类,json做为根处理的
    root.student{
       name "zhangsan"                                    //空格隔开就好   
       sex "male"
       age 1
       hobbies "runnign","see movie"
    }
    println  JsonOutput.prettyPrint(root.toString())   //JsonOutput.prettyPrint()  对json的输出进行格式化操作
    
8.groovy中对数据库的操作

  ㈠数据库连接
  这里使用的MySQL数据库
  def sql = groovy.sql.Sql.newInstance("jdbc:mysql://localhost:3306/student","root","root","com.mysql.jdbc.Driver")
  println sql.connection       //检查连接是成功 
  ㈡对数据的操作
  插入操作：
  sql.executeInsert("insert into student vlaues(default,?,?)",["zhangsan","male"])
  更新操作：
  sql.executeUpdate("update student set sex = ? where id = ?)",["femal",3])
  删除数据：
  sql.execute("delete from student where id = ?",[3])
  查询数据：
  sql.eachRow("select * from student"){        //使用eachRow的方法，采用闭包访问输出
      println it.name + " " + it.sex
      println "ID:${it.id}  Name:${it.name} sex:${it.sex}"  //在""里输出变量使用，${变量}来表示  it表示每一行的数据
  }

9.groovy中使用GORM操作数据库的CRUD
  GORM: Grails Object     Relational Mapping(对象关系映射)
  在底层,它使用hibernate5(流行和灵活的开源ORM解决方案)。但groovy天生动态，实际上对于动态和静态都支持;
  Grails约定大于配置。只要很少的配置;
  像操作对象一样去操作数据库中的数据;
  ㈠配置数据库各种数据
    过程略
  ㈡创建对象
  class Student{
    String name
    String sex
    int age
  }
  ㈢操作数据
  保存数据
  def student = new Student(name:"zhangsan",sex:"male",age:12)
  student.save(flush:true)         //把内存的数据刷新到数据库中
  ...
  
  读取数据
  def student = Student.get(1)     //直接读取 参数ID 会立即去数据库查询
  def student = Student.load(1)    //代理读取 不会立即返回，会返回代理。当去访问代理的字段的时候才去数据库查询
  ...
  
  更新数据:grails里没有更新方法   //先查询,然后在更新
  def student = Student.get(1)    //读取放入二级缓存中
  student.name = "KIM"
  student.save(flush:true)        //当去save()时，会去查询二级缓存，如果缓存中有对象，就是更新操作。如果没有数据，就是新增插入数据操作
  ...
  
  删除数据
  def student = Student.get(1)
  student.delete(flush:true)
  ...
  
  查询数据
  def list = student.list()
  list.each{
      s ->
      println s.name
  }
  
  根据条件查询
  def studnets = student.where{
     sex == "fale"
  }.find()
  students.each{
     s ->
     println s.sex
  }
  

10.参考资料
免费学习教程：http://icoolxue.com:1217/album/show/341  钱佳明讲
eclipse插件：http://blog.csdn.net/qq_27645299/article/details/72900801
grails:http://blog.csdn.net/bzray/article/details/5803927