概述
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
最后
以上就是典雅黑裤为你收集整理的Groovy语言学习的全部内容，希望文章能够帮你解决Groovy语言学习所遇到的程序开发问题。
如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。
本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
发表评论 取消回复