Groovy窥探-高级语法

719 阅读4分钟

本章主要讲解基础中高级部分,主要内容为代码,如若不感兴趣者,可以大致浏览标题即可

  • groovy json操作详解

    1. json转换为实体类对象(JsonSlurper)
      JsonSlurper slurper=new JsonSlurper()
      slurper.parse()
      
    2. 实体类对象转换为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的引用方式:

    首先在和src同级的文件夹上创建libs文件夹,然后将jar文件复制到libs文件夹中,
    然后在jar文件上右键选择add the library,到此就可以愉快的使用第三方lib了。
    
    1. 实战演练:使用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事件处理(较为节省内存,操作复杂)

    1. 解析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
      
      
      
    2. 创建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都可以使用
    实战演练:文本文件的读写和copy

        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中我们不需要自己手动关闭流的操作。

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