Groovy窥探-高级语法

时间 2019-11-05

原文原文链接

本章主要讲解基础中高级部分，主要内容为代码，如若不感兴趣者，能够大体浏览标题便可java

groovy json操做详解node

json转换为实体类对象(JsonSlurper)

JsonSlurper slurper=new JsonSlurper()
slurper.parse()
复制代码

实体类对象转换为json(JsonOutput)

//普通格式输出
def list=[new Person(name: 'john',age: 20),new Person(name: 'Jane',age: 18)]
println JsonOutput.toJson(list)

//按照json格式输出的结果
def json=JsonOutput.toJson(list)
println JsonOutput.prettyPrint(json)
复制代码

大致介绍下第三方json的引用方式:json

首先在和src同级的文件夹上建立libs文件夹，而后将jar文件复制到libs文件夹中，
而后在jar文件上右键选择add the library，到此就能够愉快的使用第三方lib了。
复制代码

实战演练：使用jsonSluper进行网络数据解析

def getNetworkData(String url){
    //发送http请求 java 
    def connection=new  URL(url).openConnection()
    connection.setRequestMethod('GET')
    connection.connect()
    def response=connection.content.text
    //将json转化为实体对象 groovy
    def  jsonSluper=new JsonSlurper()
    return jsonSluper.parseText(response)

}

def  reponse=getNetworkData('请求地址')
//输出你想要的结果
println (reponse.data.head.name)
复制代码

xml文件操做详解
在Java中咱们对xml进行处理一般有两种方式：
①DOM文档驱动处理
②SAX事件处理（较为节省内存，操做复杂）api

解析xml格式数据(XmlSlurper)

final String xml = ''' <response version-api="2.0"> <value> <books id="1" > <book id="1" avaliable="10"> <title>Android开发艺术探索</title> <author id="1">任玉刚</author> </book> <book id="2" avaliable="100"> <title>第一行代码</title> <author id="2">郭霖</author> </book> <book id="3" avaliable="100"> <title>疯狂Android讲义</title> <author id="3">李刚</author> </book> <book id="4" avaliable="100"> <title>Vue从入门到精通</title> <author id="3">李刚</author> </book> </books> </value> </response> '''

//开始解析xml数据
def xmlSpluper=new XmlSlurper()
def response=xmlSpluper.parseText(xml)

//打印title
println( response.value.books.book[0].title.text())
//打印出属性节点的信息使用@
println  response.value.books.book[1].@avaliable

//开始解析xml数据
def xmlSpluper = new XmlSlurper()
def response = xmlSpluper.parseText(xml)
//普通遍历
def list1 = []
response.value.books.book.each{books->
    //对书进行遍历
    def author=books.author.text()
    if (author.equals('李刚')){
        list1.add(books.title.text())
    }
}
println list1.toListString()


//深度遍历depthFirst()等价于"**"
def title = response.depthFirst().findAll { book -> return book.author.text() == '李刚' ? true : false }
println title.toListString()

//广度遍历children()等价于"*"
def resName=response.value.books.children().findAll{
    node->
        node.name()=='book' && node.@id=='2'
}.collect{
    node->return  node.title.text()
}
println resName


复制代码

建立xml格式数据(MarkupBuilder)

//静态生成
def sw= new StringWriter()
//MarkupBuilder生成xml格式的数据核心类
def xmlBuilder=new MarkupBuilder(sw)
//建立根节点langs
xmlBuilder.langs(type:'current',count:'3',
 mainstream:'true'){
    language(flavor:'static',version:'1.5','java'){age('16')}
    language(flavor:'dynamic',version:'1.6','Groovy')
    language(flavor:'dynamic',version:'1.9','JavaScript')
}
println sw


//实体类动态生成
class Langs{
    String type='current'
    int count=3
    boolean  mainstream=true
    def language=[
            new Language(flavor:'static',version:'1.5',value:'java'),
            new Language(flavor:'dynamic',version:'1.6',value:'Groovy'),
            new Language(flavor:'dynamic',version:'1.9',value:'JavaScript')
    ]
}

class Language{
    String flavor
    String version
    String value
}

def sw1= new StringWriter()
////MarkupBuilder生成xml格式的数据核心类
def xmlBuilder=new MarkupBuilder(sw)
def langs=new Langs()
xmlBuilder.langs(type:langs.type,count:langs.count,mainstream:langs.mainstream){
    langs.language.each {
        //遍历全部的子节点
        lang->language(
 flavor:lang.flavor,version:lang.version,lang.value
        )

    }
}

println sw1
复制代码

每日一练:

经过上面的json和xml的操做，有兴趣的小伙伴能够尝试将json数据转换成xml的数据格式     
复制代码

*** groovy 文件操做**
java中处理文件的方式最多见的就是流处理(inputstream、outputstream等）。
全部Java对文件的处理类，groovy均可以使用
实战演练:文本文件的读写和copybash

def file1 ='/Users/用户名/IDEProjects/MyGroovy/MyGroovy.iml'
    def file2 = '/Users/用户名/IDEProjects/MyGroovy/MyGroovy2.iml'
    def result=copy(file1,file2)
    println result
    def copy(String sourcePath, String destationPath) {
        try {
            //建立目标文件
            def desFile = new File(destationPath)
            if (!desFile.exists()) {
                desFile.createNewFile()
            }
            //开始拷贝
            new File(sourcePath).withReader { reader ->
                def lines = reader.readLines()
                desFile.withWriter {
                    write ->
                        lines.each {
                            line ->
                                write.append(line+"\r\n")
                        }
                }
            }
            return true
        }
        catch (Exception e) {
            e.printStackTrace()
        }
        return false
    
    }
复制代码

实战演练：对象的读写和copy网络

def person=new Person(name:'Haha',age:25)
    saveObject(person,'../../person.bin')
    readObject(''../../person.bin'')
    //对象保存
    def saveObject(Object object, String path) {
        try {
            //建立目标文件
            def desFile = new File(path)
            if (!desFile.exists()) {
                desFile.createNewFile()
            }
            //开始拷贝
            desFile.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){
    
        }
        return  obj
    }
复制代码

在Groovy中咱们不须要本身手动关闭流的操做。app

好了，到此为此，咱们就已经将groovy的基础部分讲述完毕，基础很重要，但愿你们能多练习下前面的基础内容部分。
从下一章节开始，咱们开始学习进阶Gradle,下期再见学习