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