第9章、编译期元编程和AST转换

最新推荐文章于 2024-03-09 21:17:41 发布
最新推荐文章于 2024-03-09 21:17:41 发布
阅读量473 收藏 1
点赞数
分类专栏： Groovy 文章标签： groovy AST 编译期 AstBuilder 注解
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37355951/article/details/110621713
版权

文章目录

AST- abstract syntax tree ( 抽象的语法树)

1、一个简短故事

1.1、生成字节码而不是源码

  • groovy自动生成getter，setter方法，变成字节码文件

1.2、开发者发挥生成代码的能力

2、使得Groovy更简洁

2.1、代码生成转换

  • @groovy.transform.ToString, 有点类似Lombok

    • /**
 * 使用groovy 的@ToString注解
 * @author liangchen* @date 2020/11/12
 */
class ToString91_92 extends GroovyTestCase{

    void testToStringToGenerating(){
        def sherLock = new Detective(firtName: "Sherlock", lastName: "Holmes")
        assert sherLock.toString() == 'com.jack.groovy.ch9.Detective(Sherlock, Holmes)'
    }

    void testToStringParameters(){
        def nancy = new Sleuth(firstName: 'Nancy',lastName: 'Drew')
        assert nancy.toString() == 'com.jack.groovy.ch9.Sleuth(firstName:Nancy, lastName:Drew)'
        // 忽略null值
        nancy.lastName=null
        assert nancy.toString() == 'com.jack.groovy.ch9.Sleuth(firstName:Nancy)'
    }
}
@ToString
class Detective{
    String firtName, lastName
}

//包括字段名且忽略null的字段
@ToString(includeNames = true, ignoreNulls =true)
class Sleuth{
    String firstName, lastName
}

  • @EqualsAndHashCode

    • /**
 * @EqualAndHashCode
 * @author liangchen* @date 2020/11/12
 */
class EqualsAndHashCode93 extends GroovyTestCase {

    void testGeneratesEqualAndHashCodeMethods(){

        def magneto = new Actor(firstName: "Ian", lastName: "McKellen")
        def gandalf = new Actor(firstName: "Ian", lastName: "McKellen")
        assert  magneto == gandalf
    }
}

@EqualsAndHashCode
class Actor{
    String firstName, lastName
}

  • @TupleConstructor 构造方法(各种参数的构造方法)

    • /**
 * @TupleConstructor 生成各种参数的构造方法
 * @author liangchen* @date 2020/11/12
 */
class TupleConstructor94  extends GroovyTestCase{
    void testTupleConstructorToGenerateJava(){

        def al = new Athlete('Michael', 'Jordan')
        def a2 = new Athlete('Michael')
        assert al.firstName == a2.firstName
    }
}

@TupleConstructor
class Athlete{

    String firstName, lastName
}

  • @Lazy 延迟加载

    • /**
 * 延迟加载 @Lazy 并没有立即实例化，在使用时候才实例化
 * @author liangchen* @date 2020/11/12
 */
class Lazy95  extends  GroovyTestCase{

    void testLazyDelayProperty(){
        new ResourceMain().with {
            assert Resource.stats() == '1 alive, 0 used'
            res2.use()
            res3.use()
            res4.use()
            assert Resource.stats() == '4 alive, 3 used'
            assert res4 instanceof Resource
            def expected = 'res4=java.lang.ref.SoftReference'
            assert  it.dump().contains(expected)
        }
    }
}

class  Resource{
    private  static alive = 0
    private static used =0
    Resource(){
        alive++
    }
    def use(){
        used++
    }
    static stats(){
        "$alive alive, $used used"
    }
}


class ResourceMain{
    def rea1 = new Resource()
    @Lazy res2 = new Resource()
    @Lazy static res3 = {new Resource()}()
    @Lazy (soft = true) volatile  Resource res4
}

  • @IndexedProperty List生成数组下标

    • /**
 * 类似生成数组的下标
 * @author liangchen* @date 2020/11/12
 */
class IndexedProperty96 extends GroovyTestCase{

    void testUsingIndexedProperty(){
        def books = ['The Mysterious Affair at Styles','The Murder at the Vicarage']
        new Author(name:'Agatha Christie', books:books).with {
            books[0] = 'Murder on the Orient Express'
            setBooks(0,'Death on the Nile')
            assert getBooks(0) == 'Death on the Nile'
            assert getBooks(1) =='The Murder at the Vicarage'
        }
    }
}

class Author{
    String name
    @IndexedProperty List<String> books
}

  • @InheritConstructors 自动生成继承父类的构造方法

    • import groovy.test.GroovyTestCase

/**
 *
 * @author liangchen* @date 2020/11/12
 */
class InheritConstructors extends GroovyTestCase{

    void testInheritConstructors(){
        def pw1 = new MyPrintWriter(new File('out1.txt'))
        def pw2 = new MyPrintWriter('out2.txt', 'US-ASCII')
        [pw1, pw2].each {
            //将foo 字符写到 out1.txt和out2.txt文件中
            it << 'foo'
            //关闭流
            it.close()
        }
        //获取文本
        assert new File('out1.txt').text == new File('out2.txt').text
        // 删除文件
        ['out1.txt','out2.txt'].each{new File(it).delete()}
    }

}
/**
 * 继承父类构造方法
 */
@groovy.transform.InheritConstructors
class MyPrintWriter extends PrintWriter{}

  • @Sortable (排序)

    • import groovy.test.GroovyTestCase
import groovy.transform.Sortable

/**
 * @Sortable 注解，有序
 * @author liangchen* @date 2020/11/12
 */
class Sortable98  extends GroovyTestCase{

    void testSortableGenerateComparableMethod() {
        def politicians = [
                new Politician(first: 'Margaret', initial: 'H', last: 'Thatcher'),
                new Politician(first: 'George', initial: 'W', last: 'Bush'),
                new Politician(first: 'Jack', initial: 'O', last: 'Bush')
        ]
        // 执行排序
        def sorted = politicians.toSorted()
        //执行排序之后调用initials
        assert  sorted*.initials() == ['JOB','GWB',"MHT"]
        def byInitial = Politician.comparatorByInitial()
        sorted = politicians.toSorted(byInitial)
        assert sorted*.initials() == ['MHT','JOB', 'GWB']
    }
}

/**
 * 排序，首先根据last排序，然后按照initial 排序
 */
@Sortable(includes = 'last,initial')
class Politician {
    String first
    Character initial
    String last
    String initials(){
        first[0] + initial + last[0]
    }
}

  • @Builder注解 ，建造模式创建对象

    • /**
 * 建造模式创建对象, 链式调用
 * @author liangchen* @date 2020/11/12
 */
class Builder99  extends GroovyTestCase{

    void testNormalInstance(){
       def c = new Chemist(first: "jack", last: "mar", born: 1822)
    }
    void testUseBuilderInstance(){
        def builder = Chemist.builder()
        def c = builder.first('jack').last('mar').born(1867).build()
        assert c.first == 'jack'
    }
}

@Builder
class Chemist{
    String first, last
    int born
}

2.2、Class设计和设计模式注解

  • @Canonical = @ToString, @EqualsAndHashCode, @TupleConstructor

    • import groovy.test.GroovyTestCase
import groovy.transform.Canonical

/**
 * 集合注解 @Canonical = @ToString, @EqualsAndHashCode, @TupleConstructor
 * @author liangchen* @date 2020/11/12
 */
class Canonical910 extends GroovyTestCase{
    void testCanonical(){
        def i1 = new Inventor('Thomas', 'Edison')
        def i2 = new Inventor('Thomas')
        assert i1 != i2
        assert i1.firstName == i2.firstName
        assert i1.toString()=='com.jack.groovy.ch9.Inventor(Thomas, Edison)'
    }
}
@Canonical
class Inventor{
    String firstName, lastName
}

  • @Immutable (实例化后属性不能变更)

    • /**
 * 一旦实例化属性就不能修改
 * @author liangchen* @date 2020/11/12
 */
class Immutable911  extends GroovyTestCase{

    void testImmutable(){
        def g1 = new Genius(firstName: 'Albert',lastName: 'Einstein')
        assert g1.toString() == 'com.jack.groovy.ch9.Genius(Albert, Einstein)'

        def g2 = new Genius('Leonardo', 'da Vinci')
        assert g2.firstName == 'Leonardo'
        assert g1 != g2
        shouldFail (ReadOnlyPropertyException) {
            g2.lastName = 'DiCaprio'
        }
    }
}

@Immutable
class Genius{
   String firstName, lastName
}

  • @Delegate 委托能力

    • import groovy.test.GroovyTestCase

/**
 * @Delegate 代理、委托
 * @author liangchen* @date 2020/11/12
 */
class NoisySet912 extends GroovyTestCase {

    void testDelegate(){
        Set ns = new NoisySet();
        ns.add(1)
        ns.addAll([2,3])
        assert ns.size() == 3
    }
}

/**
 * 如果某个类加了@Delegate,具有委托类能力
 */
class NoisySet {

    @Delegate
    Set delegate = new HashSet()
    
    @Delegate
    Map mapDelegate = new HashMap()

    @Override
    boolean add(item) {
        println "adding $item"
        delegate.add(item)
    }

    boolean addAll(Collection items) {
        items.each {println "adding $it"}
        delegate.addAll(items)
    }

     put(key,value) {
       mapDelegate.put(key, value) 
    }

}

  • @Singleton 单例

    • package com.jack.groovy.ch9

import groovy.test.GroovyTestCase

/**
 * @author liangchen* @date 2020/11/12
 */
class Single913 extends GroovyTestCase {

    void testSingletonInstance(){
        assert Zeus.instance
        def ex = shouldFail (RuntimeException){
            new Zeus()
        }
        assert ex.toString()== "Can't instantiate singleton com.jack.groovy.ch9.Zeus. Use com.jack.groovy.ch9.Zeus.instance"
    }
}

@Singleton
class Zeus{}

  • @Memoized 缓存方法结果

    • import groovy.test.GroovyTestCase
import groovy.transform.Memoized

/**
 * 缓存数据
 * @author liangchen* @date 2020/11/12
 */
class Memoized914 extends GroovyTestCase {

    void testMemoized(){
        new Calc().with {
            assert  sum(3,4) == 7
            assert sum(4,4) == 8
            //查询缓存
            assert  sum(3,4) == 7
            assert sum(4,4) == 8
            assert logs.join(" ") == "3+4 4+4"
        }
    }

}

class Calc {
    def logs = []

    @Memoized
    int sum(int a, int b) {
        logs << "$a+$b"
        a + b
    }
}

  • @TailRecursive 尾部递归，避免stack异常

    • import groovy.test.GroovyTestCase
import groovy.transform.TailRecursive

/**
 * @author liangchen* @date 2020/11/12
 */
class TailRecursive915 extends GroovyTestCase{

    void testTailRecursive(){
        assert ListUtil.reverse(['1','2','3']) == ['3','2','1']
    }

}

class ListUtil{
    static reverse(List list) {
        doReverse(list,[])
    }

    @TailRecursive
    private static doReverse(List todo, List done) {
        if(todo.isEmpty()) done
        else doReverse(todo.tail(), [todo.head()] + done)
    }
}

2.3、日志提高

  • 日志注解

    • /**
 * @Log注解
 * @author liangchen* @date 2020/11/12
 */

class Log916  extends GroovyTestCase{

   
    void testLog(){
        new Logs().search()
    }
}
@Log
class Logs{
    def search(){
        log.fine(runLongDatabaseQuery())
    }

    def runLongDatabaseQuery() {
        println 'Calling database'
        return 'query result'
    }
}

  • 其他注解

    • @Log @Commons @ Log4j @Log4j2 @Slf4j

2.4、声明并发

  • @Synchronized 同步 @WithReadLock 和@WithWriteLock (读锁和写锁)

    • package com.jack.groovy.ch9

import com.beust.jcommander.IValueValidator
import groovy.test.GroovyTestCase
import groovy.transform.Synchronized
import groovy.transform.WithReadLock
import groovy.transform.WithWriteLock
import groovy.util.logging.Log

/**
 * @author liangchen* @date 2020/11/12
 */
class Synchronized917  extends GroovyTestCase{

    void testSynchronized(){
        def p1 = new PhoneBook1()
        (0..99).collect{num ->
            //开启一个线程
            Thread.start {
                p1.addNumber('Number' + num, '98765' + num)
            }
            //主函数等待
        }*.join()
        assert p1.getNumber('Number43') == '9876543'
    }

    void testCustomsSynchronized(){
        def p2 = new PhoneBook2()
        (0..99).collect{num ->
            Thread.start {
                p2.addNumber('Number' +num, '98765' + num)
            }
        }*.join()
        assert p2.getNumber('Number43') == '9876543'
    }

    void testReadAndWriteLock(){
        def p3 = new PhoneBook3()
        (3..4).collect{num ->
            Thread.start {
                sleep 100*num
                p3.addNumber('Number' +num, '98765' + num)
            }
        }
        (2..7).collect{count ->
            Thread.start {
                sleep 100 * count
                p3.getNumber('Number'+ count)
            }
        }*.join()
    }
}

class PhoneBook1{
    private final phoneNumbers = [:]

    @Synchronized
    def getNumber(key) {
        phoneNumbers[key]
    }

    @Synchronized
    void addNumber(key, value) {
        phoneNumbers[key] = value
    }
}

/**
 * 自定义锁块
 */
@Log
class PhoneBook2 {
    private final phoneNumbers = [:]
    private final lock = new Object[0]

    @Synchronized('lock')
    def getNumber(key) {
        phoneNumbers[key]
    }

    void addNumber(key, value) {
        log.info("Adding phone number $value")
        synchronized (lock) {
            phoneNumbers[key] = value
        }
    }
}


/**
 * 读写锁
 */
class PhoneBook3 {
    private final phoneNumbers = dummyNums()

    private dummyNums() {
        (1..8).collectEntries{
            ['Number'+it, '765432' + it]
        }
    }

    @WithReadLock
    def getNumber(key) {
        println "Reading started for $key"
        phoneNumbers[key]
        sleep 80
        println "Reading done for $key"
    }

    @WithWriteLock
    def addNumber(key,value){
        println "Writing started for $key"
        phoneNumbers[key] = value
        sleep 100
        println "Writing done for $key"
    }
}

2.5、容易克隆和扩展

  • @AutoClone

    • import groovy.test.GroovyTestCase
import groovy.transform.AutoClone
import groovy.transform.AutoCloneStyle
import groovy.transform.TupleConstructor

/**
 * @AutoClone 克隆注解
 *
 * @author liangchen* @date 2020/11/13
 */
class AutoClone720  extends GroovyTestCase{

    void testAutoClone(){
        def name = "Heston Blumenthal"

        def recipes =["Snail porridge","Bacon & egg ice cream"]
        def born = Date.parse("yyyy-MM-dd", '1999-01-01')

        def c1 = new Chef1( name,  recipes,  born)
        def c2 = c1.clone()
        assert  c2.recipes == recipes
        assert c1.name == c2.name
    }

    void testAutoCopyConstructor() {
        def name = 'Jamie Oliver'

        def recipes = ['Lentil Soup', 'Crispy Duck']

        def born = Date.parse('yyyy-MM-dd', '1975-05-27')

        def c1 = new Chef2(name, born, recipes)

        def c2 = c1.clone()

        assert c2.name == name

        assert c2.born == born

        assert c2.recipes == recipes
    }
}

/**
 * 提供四种类型， CLONE：不提供深度拷贝，不适合final修饰属性
 * SIMPLE : 只会调用无参构造方法，不支持深度拷贝
 * COPY_CONSTRUCTOR 不支持深度拷贝，支持final修饰属性
 * SERIALIZATION ： 支持深度拷贝，不适合final修饰属性拷贝
 */
@AutoClone
class Chef1{

    String  name

    List<String> recipes

    Date born
}

@TupleConstructor
@AutoClone(style=AutoCloneStyle.COPY_CONSTRUCTOR)

class Person {

    final String name

    final Date born

}



@TupleConstructor(includeSuperProperties=true, callSuper=true)
@AutoClone(style=AutoCloneStyle.COPY_CONSTRUCTOR)

class Chef2 extends Person {

    final List<String> recipes

}

  • @AutoExternalize

    • import groovy.test.GroovyTestCase
import groovy.transform.ToString

/**
 * @AutoExternal 序列化
 * @author liangchen* @date 2020/11/13
 */
class AutoExternalize922 extends GroovyTestCase{

    void testAutoExternalize() {
        def c = new Composer(name: 'Wolfgang Amadeus Mozart', born: 1756, married: true)
        //创建输出数组流
        def baos = new ByteArrayOutputStream()
        //写出流到baos中
        baos.withObjectOutputStream {
            os -> os.writeObject(c)
        }
        // 创建一个输入流
        def bais = new ByteArrayInputStream(baos.toByteArray())
        def loader = getClass().classLoader
        def result
        bais.withObjectInputStream(loader) {
            result = it.readObject().toString()
        }
        assert result == 'com.jack.groovy.ch9.Composer(Wolfgang Amadeus Mozart, 1756, true)'

    }

}

@groovy.transform.AutoExternalize
@ToString
class Composer{
    String name

    int born

    boolean married
}

2.6、脚本支持

  • @TimedInterrupt ( 超过时间打断)

    • /**
 * @author liangchen* @date 2020/11/13
 */
class TimedInterrupt923 extends GroovyTestCase{


    void testBlastOff1(){
        def b = new BlastOff1()
        Thread.start {
            try {
                b.countdown(10)
            } catch (TimeoutException ignore) {
                b.logs << 'aborted'
            }
        }.join()
        assert b.logs.join(' ') == '10 9 8 7 6 aborted'
    }
}

/**
 * 超过480毫米自动打断方法，触发timeInterrupt
 */
@TimedInterrupt(value = 480L,unit = TimeUnit.MILLISECONDS)
class BlastOff1 {
    def logs = []

    def countdown(n) {
        sleep 100
        logs << n
        if (n == 0) {
            logs << 'ignition'
        }else countdown(n -1)
    }
}

  • @ThreadInterrupt 线程打断

    • import groovy.test.GroovyTestCase
import groovy.transform.ThreadInterrupt

/**
 * 线程打断, 这里例子有问题
 * @author liangchen* @date 2020/11/13
 */
class ThreadInterrupt924 extends GroovyTestCase{

    void testThreadInterrupt(){
        def b = new BlastOff2()
        def t1 = Thread.start {
            try {
                println 1
                b.countdown(10)
                println 2
            } catch (InterruptedException ignore) {
                b.logs << 'aborted'
            }
        }
        sleep 300
        println 3
        t1.interrupt()
        t1.join()
        assert  b.logs.join(' ')=='10 9 8 7 6 5 4 3 2 1 0 ignition'
    }
}

@ThreadInterrupt()
class BlastOff2 {
    def logs = []

    def countdown(n) {
        sleep 100
        logs << n
        if (n == 0) {
            logs << 'ignition'
        }else countdown(n -1)
    }
}

  • @Field注解 脚本使用

    • import groovy.transform.Field

/**
 * 不需要创建类似class文件结构只要是groovy就行
 */
@Field
List awe = [1,2,3]
def awesum(){
    awe.sum()
}
assert awesum() == 6

  • @BaseScript

2.7、更多转换

3、探索AST

  • 一般groovy编译和运行过程
    • image-20201113111330225

4、创建ASTs

4.1、亲手创建Ast

  • 利用groovy已有AST的node创建新节点

    • import groovy.test.GroovyTestCase
import org.codehaus.groovy.ast.ClassHelper
import org.codehaus.groovy.ast.expr.ArgumentListExpression
import org.codehaus.groovy.ast.expr.ConstructorCallExpression

import org.codehaus.groovy.ast.stmt.ReturnStatement

import static org.codehaus.groovy.ast.ClassHelper.make

import static org.codehaus.groovy.ast.tools.GeneralUtils.*
/**
 * @author liangchen* @date 2020/11/13
 */
class Ast928 extends GroovyTestCase{

    void testCreateAst(){

       def ast = new ReturnStatement(
                new ConstructorCallExpression(
                        ClassHelper.make(Date), ArgumentListExpression.EMPTY_ARGUMENTS
                )
        )
        assert ast instanceof ReturnStatement

        //创建语法树返回再抽象
        def asts = returnS(ctorX(make(Date)))

        assert asts instanceof ReturnStatement
    }

}

4.2、AstBuilder.buildFromSpec

  • 利用规范快速构架AST结构

    • /**
 * 利用AstBuilder 快速构建
 * @author liangchen* @date 2020/11/13
 */
class AstBuilder930  extends GroovyTestCase{

    void testAstBuilder(){
        def ast = new AstBuilder().buildFromSpec {
            returnStatement {
                constructorCall(Date){
                    argumentList {}
                }
            }
        }
        assert ast[0] instanceof  ReturnStatement
    }
}

4.3、AstBuilder.buildFromString

  • 利用字符串构建ast node

    • /**
 * 利用字符串直接创建Ast node
 * @author liangchen* @date 2020/11/13
 */
class AstBuildFromString931 extends GroovyTestCase{

    void testAstBuilderFromString(){
        def ast = new AstBuilder().buildFromString('new Date()')
        assert  ast[0] instanceof  BlockStatement
        assert ast[0].statements[0] instanceof  ReturnStatement
    }

    void testAstDynamicCode() {
        def approxPI = 3.14G
       // 直接添加方法，采用字符串
        def ast = new AstBuilder().buildFromString(
                CompilePhase.CLASS_GENERATION, false,
                'static double getTwoPI() { def pi = ' + approxPI + '; pi * 2 }'

        )

        assert ast[1] instanceof  ClassNode
        def method =ast[1].methods.find{
            it.name == 'getTwoPI'
        }
        assert method instanceof MethodNode
        
    }
}

4.4、AstBuilder.buildFromCode

  • 利用code构建

    • /**
 * 利用code构建ast node
 * @author liangchen* @date 2020/11/13
 */
class AstBuildFromCode944  extends GroovyTestCase{

    void testAstBuildFromCode(){
        def ast = new AstBuilder().buildFromCode {
            //直接使用代码
            new Date()
        }
        assert  ast[0].statements[0]  instanceof  ReturnStatement
    }
}

5、本地转换

  • 自定义main注解，自动生成main方法

    • package com.jack.groovy.ch9


import org.codehaus.groovy.ast.*
import org.codehaus.groovy.control.CompilePhase
import org.codehaus.groovy.control.SourceUnit
import org.codehaus.groovy.transform.ASTTransformation
import org.codehaus.groovy.transform.GroovyASTTransformation
import org.codehaus.groovy.transform.GroovyASTTransformationClass

import java.lang.annotation.ElementType
import java.lang.annotation.Retention
import java.lang.annotation.RetentionPolicy
import java.lang.annotation.Target

/**
 * 定义一下注解Main注解， 增加@GroovyASTransformationClass 表示这个注解处理的类
 * 是MainTransformation
 * RetentionPolicy 注解保持到源码阶段
 */
@Retention(RetentionPolicy.SOURCE)
@Target([ElementType.METHOD])
@GroovyASTTransformationClass(classes = [MainTransformation])
@interface Main{}


import static groovyjarjarasm.asm.Opcodes.ACC_PUBLIC
import static groovyjarjarasm.asm.Opcodes.ACC_STATIC
import static org.codehaus.groovy.ast.ClassHelper.VOID_TYPE
import static org.codehaus.groovy.ast.tools.GeneralUtils.*

// 确定那个时期处理，在指令选择处理
@GroovyASTTransformation(phase = CompilePhase.INSTRUCTION_SELECTION)
class MainTransformation implements ASTTransformation{
    // 定义默认节点
    private NO_EXCEPTIONS = ClassNode.EMPTY_ARRAY
    private STRING_ARRAY = ClassHelper.STRING_TYPE.makeArray()
    @Override
    void visit(ASTNode[] astNodes, SourceUnit sourceUnit) {
        // 判断注解是否正确
        if(astNodes?.size() != 2) return
        if(!(astNodes[0] instanceof  AnnotationNode)) return
        if(astNodes[0].classNode.name != Main.name) return
        if(!(astNodes[1] instanceof MethodNode)) return

        // 获取目标方法、目标类，目标实例
        def targetMethod = astNodes[1]
        def targetClass = targetMethod.declaringClass
        def targetInstance = ctorX(targetClass)
        def callTarget = callX(targetInstance, targetMethod.name)
        def mainBody = block(stmt(callTarget))
        def visibility = ACC_STATIC | ACC_PUBLIC
        def parameters = params(param(STRING_ARRAY,'args'))
        //目标类增加main方法
        targetClass.addMethod('main', visibility, VOID_TYPE, parameters,NO_EXCEPTIONS, mainBody)
    }

}
new GroovyShell(getClass().classLoader).evaluate  """
class Greeter{
        @com.jack.groovy.ch9.Main
        def greet(){
        println "Hello from the greet() method!"
        }
} 
"""

6、全局转换

  • 这个暂时不懂, 有点类似dubbo services， spi

7、测试AST转换

  • GroovyClassLoader 和 GroovyShell

    • package com.jack.groovy.ch9

import groovy.test.GroovyTestCase
import groovy.transform.WithReadLock

import java.lang.reflect.Modifier
import java.util.concurrent.locks.ReentrantReadWriteLock

/**
 * ast 测试
 * @author liangchen* @date 2020/11/13
 */
class WithReadLockTestAst938 extends  GroovyTestCase{

    static class MyClass{
        @WithReadLock
        void readerMethod1(){}
    }
    void testLockFieldDefaultsForReadLock(){
        def dee =  MyClass.getDeclaredFields();
        def field = MyClass.getDeclaredField('$reentrantlock')
        assert Modifier.isPrivate(field.modifiers)

        assert !Modifier.isTransient(field.modifiers)

        assert Modifier.isFinal(field.modifiers)
        assert !Modifier.isStatic(field.modifiers)
        assert field.type == ReentrantReadWriteLock
    }

    /**
     * 这是类，不是实例
     */
    void testLockFieldDefaultsForReadLocks(){
        //字符串 直接解析类
        def tester = new GroovyClassLoader().parseClass("""
    class MyClass{
    @groovy.transform.WithReadLock
    public void readerMethod1(){}
    } 
""")
        def field = tester.getDeclaredField('$reentrantlock')
        assert Modifier.isPrivate(field.modifiers)

        assert !Modifier.isTransient(field.modifiers)

        assert Modifier.isFinal(field.modifiers)
        assert !Modifier.isStatic(field.modifiers)
        assert field.type == ReentrantReadWriteLock
    }

    /**
     * groovyShell evaluate 是一个实例，而不是类
     */
    void testLockFieldDefaultsForReadLockGroovyShell() {
        def tester = new GroovyShell().evaluate("""
        import groovy.transform.WithReadLock
        class MyClass{
            @WithReadLock
            public void readerMethod1(){}
        }
        new MyClass()
""")
        // 这里是getClass()
        def field = tester.getClass().getDeclaredField('$reentrantlock')
        assert Modifier.isPrivate(field.modifiers)

        assert !Modifier.isTransient(field.modifiers)

        assert Modifier.isFinal(field.modifiers)
        assert !Modifier.isStatic(field.modifiers)
        assert field.type == ReentrantReadWriteLock
    }

}

  • @ASTTest

    • /**
 * @author liangchen* @date 2020/11/13
 */

@ASTTest(phase = CompilePhase.SEMANTIC_ANALYSIS, value={
    lookup('anchor').each{
        n-> assert n instanceof ForStatement
    }
})
void doSomenthing(){
    println "Hello, Groovy"
    anchor:for(int i=0; i<10; i++){println "Iteration $i"}
}

8、限制

10、总结

  • 这一章有蒙圈，后面有需要再更新
往前的
关注
专栏目录
【Groovy】编译时元编程 ( ASTTransformation#visit 方法简介 | org.codehaus.groovy.ast.ModuleNode 脚本节点 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
02-07 1032
一、ASTTransformation#visit 方法简介、 二、org.codehaus.groovy.ast.ModuleNode 脚本节点
【Groovy】编译时元编程 ( 编译时处理 ASTTransformation 接口实现 | 配置 ASTTransformation )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
02-07 1202
一、编译时处理 ASTTransformation 接口实现、 二、配置 ASTTransformation
【Groovy】编译时元编程 ( ASTTransformation#visit 方法获取 Groovy 源文件 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
02-07 1128
一、ASTTransformation#visit 方法获取 Groovy 源文件、 二、完整代码示例、 1、Groovy 脚本 Groovy.groovy、 2、ASTTransformation 接口实现 MyASTTransformation.groovy、 3、配置 ASTTransformation、 3、使用命令行进行编译时处理、
【Groovy】编译时元编程 ( 利用注解进行 AST 语法树转换 | 定义注解并使用 GroovyASTTransformationClass 注明 AST 转换接口 | AST 转换接口实现 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
02-08 1188
一、利用注解进行 AST 语法树转换、 1、定义注解并使用 GroovyASTTransformationClass 注明 AST 转换接口、 2、AST 转换接口实现、 3、定义 Groovy 类并使用 @Compile 注解修饰需要拦截的方法、 4、执行结果、
gradle_使用Gradle构建和应用AST转换
cunfeng7797的博客
12-16 130
gradle 最近，我想在Gradle项目中构建并应用本地ast转换。 虽然我可以找到几个有关如何编写转换的示例，但找不到完整的示例来显示完整的构建过程。 转换必须单独编译，然后放在类路径中，因此其源代码不能简单地放在Groovy源代码树的其余部分中。 这是使我绊倒了一段时间的细节。 我最初设置了一个单独的GroovyCompile任务来处理其余注释，然后再处理其余注释(摘自Gradle论坛上...
html转换成抽象语法树,五分钟了解抽象语法树（AST）babel是如何转换的？
weixin_29027285的博客
05-31 790
抽象语法树什么是抽象语法树？It is a hierarchical program representation that presents source code structure according to the grammar of a programming language, each AST node corresponds to an item of a source code....
元编程技术综述
pl_lab_001的博客
08-12 1276
# 作者简介 # Yannis Lilis 博士是欧洲最大的汽车租赁公司的高级程序员，兼职在克里特大学的计算机科学系任客座讲师，在数学及应用数学系任兼职教师，同时兼任计算机科学研究所（ICS）FORTH 实验室的研究员。他的研究兴趣包括软件工程、机器学习、计算机视觉、人工智能、分布式系统等等。他总计发表了 20 篇会议 / 期刊等出版物，其中超过半数为元编程相关技术文章。 Anthony Savidis 教授是克里特大学计算机科学系的正教授和计算机科学研究所（ICS）FORTH 和 HCI 实验室的研究
第10章 前端编译与优化
lyw4631的博客
08-31 202
文章目录10.1 概述10.2 Javac编译器10.3 Java语法糖的味道10.4 实战：插入式注解处理器10.5 本章小结 第10章 前端编译与优化    从计算机程序出现的第一天起，对效率的追逐就是程序员天生的坚定信仰，这个过程犹如一场没有终点、永不停歇的F1方程式竞赛，程序员是车手，技术平台则是在赛道上飞驰的赛车。 10.1 概述             10.2 Javac编译器 10.3 Java语法糖的味道 10.4 实战：插入式注解处理器 10.5 本章小结 ...
【梳理】编译原理与实践 第三章 上下文无关语法与语法分析（docx）
COFACTOR
04-02 951
编译原理 知 识 梳 理 （第一版）   建议先修课程：离散数学、C / C++、数据结构、汇编语言、计算机组成原理。 配套教材： Kenneth C. Louden Compiler Construction: Principles and Practice 链接：https://pan.baidu.com/s/1SG8BRZnMM56NjSPR4cLcgQ 提取码：0000 三 上下文无关语法与语法分析 编程语言的语法，通常是由上下文无关语法（context-free grammar，上下文
智能化软件开发微访谈·第十九期暨2022新年特辑：软件智能化开发：进展与挑战...
pengxin_ce的博客
01-08 2031
CodeWisdom智能化软件开发沙龙是复旦大学CodeWisdom团队参与组织的专注于代码大数据与智能化软件开发的学术和技术沙龙，面向相关领域的学术界研究者和工业界实践者，通过各种线上和...
ast四则运算
weixin_39057744的博客
07-05 252
```cpp #include <iostream> #include <cstring> #include <algorithm> using namespace std; char arr[100040]; int pos; int NumVal; class Expr { public: virtual int calc() = 0; }; class ExprNum :public Expr { public: int val; Exp.
JDT随记-ASTNode分类生成
鱼香稀饭
12-05 395
现把一些 Java代码生成对应的ASTNode方式列出来，供参考： List 1 生成Package // package astexplorer;java 代码 PackageDeclaration packageDeclaration = ast.newPackageDeclaration();  unit.setPackage(packageDeclaration);  packageD...
抽象语法树（AST）：理解JavaScript代码的抽象语法树
最新发布
你若盛开，清风自来
03-09 1365
抽象语法树（AST）是JavaScript编译器处理代码时创建的一种树形结构，它代表了代码的逻辑结构。本文将介绍AST的概念、作用以及如何在开发中利用它来提升代码质量和安全性。AST是一种树形结构，它以一种抽象的方式表示源代码的语法结构。在JavaScript中，AST用于编译器解析代码，它将代码的逻辑结构从文本形式转换为树状结构，这样更容易进行分析和处理。AST（Abstract Syntax Tree）即抽象语法树，是源代码的抽象语法结构的树状表示。
Python 编译阶段 -- 从 AST 到 字节码
zpoint's blog
07-23 698
AST 到 字节码 以后都在 github 更新，请戳 AST 到 字节码 目录 related file optimize symtable CodeObject read more 相关位置文件 Python/compile.c Python/pythonrun.c Python/symtable.c Include/symtable.h Python/ast_opt.c 我们来尝试从之前的 语法树 中生成对应的字节码 前面提到过的 pythonrun 的调用栈如下 这次
Demllie【5】＞由AST抽象语法树到生成字节码
痛苦的时候装出幸福相，这不是那么难做到的事
01-05 552
前言 在没有AST抽象语法树的时候，直接迭代返回值就计算完了，有了AST抽象语法树后，值放在树节点里，在遍历的时候返回运算结果。再抽象一下，遍历的时候也不计算，而是生成字节码放入文件里，等后面用虚拟机处理字节码时运算！！！ 前面的文章 Demllie＞做一个Toy语言编译器，随便玩玩 Demllie＞小型词法分析器，其实就是循环判断 Demllie＞编译语言实现的核心问题，就是这里不明白让我白白写6000行垃圾 Demllie＞由迭代法next_term_factor_expr来构造AST抽象语法树 修改v
Groovy简介——编译时方法注入
thunder_sz的博客
11-26 783
一般只用于编写一些插件或者模板方法的时候使用，编译后的代码还是会合成为静态代码，会比运行时的处理方式效率更高。需要根据AST来添加对应的语法树。Groovy编译器允许我们进入其变异截断，一窥其所处理的AST（Abstract Syntax Tree 抽象语法树）。 AST： 这就是生成的语法树： Groovy支持开发者在任何阶段介入：初始化、解析、转换、语义分析、规范化、...
字节码插桩(四): AST
Kibaco的博客
11-16 686
我们通过 AndroidStudio 生成Bean对象一般是通过注解来实现自动生成getter/setter方法、equals()和hashCode()方法,其中类（或接口）要符合驼式命名法，首字母大写。方法要符合驼式命名法，首字母小写,类或实例变量要符合驼式命名法，首字母小写。常量要求全部由大写字母或下划线构成，且第一个字符不能是下划线,否则编译器会报警告 那么: 编译器是怎么解析到这些不规范的命名方式呢?这里不得不提到一个很重要的字节码插桩技术AST,什么是AST? 一. AST概念 AST 是 Abs
调试Groovy ASTTransformation的方法
weixin_33853794的博客
04-30 744
2019独角兽企业重金招聘Python工程师标准>>> ...
Groovy语法学习(十)AST的使用
JabamiYu的博客
04-20 3328
在开发Android项目中，经常会用到AbstractProcessor来构建注解处理器。在编译的时候生成代码，从而减少工作量。使用非常广泛的butterknife就是如此，但是最新版的github貌似是使用gradle插件来尽心生成，不过原理应该都类似，编译的时候通过对应的注解生成一些辅助类，或者主动注入一些方法。Groovy的AST就是类似的用法，由于Groovy的动态性，在AST中能做的事情...
编译原理：AST特点与文法转换解析
"AST的特点-编译原理第三章上" 在编译原理中，抽象语法树（Abstract Syntax Tree，简称AST）是程序源代码的一种中间表示形式，它在语法分析阶段被构建，用于帮助编译器理解代码的结构和含义。AST的特点包括： 1. *...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值