Groovy 方法扩展

￡神魔★判官ぃ 2023-03-13 13:01 2阅读 0赞

在`Groovy`允许对一个类的进行添加额外的静态方法或者实例方法。  
步骤：

1.  编写一个静态方法。
2.  在`META-INF/service/org.codehaus.groovy.runtime.ExtensionModule`文件声明扩展函数位置。
3.  打成`jar` 。

Demo：  
我们首先实现对`String`实例方法进行扩展，判断这个字符和另一个字符串是否包含字符`*`。  
扩展函数语法要求：

1.  必须有至少一个参数，且第一个参数类型是扩展的类
2.  函数必须为静态

package org.fmy
    
    class StringExt {
    	//扩展实例方法第一个参数就是扩展的实例（固定要第一个参数）。
        static containStar(String self, String other) {
            return self.contains("*") && other.contains("*")
        }
    }

然后我们在为`String`添加一个静态扩展方法，判断另一个字符串是否包含字符`x`。

package org.fmy
    
    class StringStaticExt {
    
        static containX(String self, String other) {
        	//静态扩展self必为null
            println("self = " +self)
            return other.contains("x")
        }
    }

接下来就是在`META-INF/service/org.codehaus.groovy.runtime.ExtensionModule`文件声明扩展函数位置。

moduleName = MyStringExt //你的模块名
    moduleVersion = 1.0  //版本
    extensionClasses = org.fmy.StringExt //实例扩展函数
    staticExtensionClasses =org.fmy.StringStaticExt //静态扩展函数

最后达成`Jar`放入另一个工程中运行即可。  
如下代码：

println "asd*sad".containStar("asdsd*")
    println String.containX("2x")

输出：

true
    self = null
    true

#### `use`函数扩展 ####

在`groovy`中存在一个特殊的函数`use`接受两个参数，第一个`扩展类`，第二个`Closure`.

/**
         * Scoped use method
         *
         * @param self          any Object
         * @param categoryClass a category class to use
         * @param closure       the closure to invoke with the category in place
         * @return the value returned from the closure
         * @since 1.0
         */
        public static <T> T use(Object self, Class categoryClass, Closure<T> closure) {
            return GroovyCategorySupport.use(categoryClass, closure);
        }

扩展类语法糖或者说规则：  
存在0到N个静态函数，其中第一个参数为扩展某个对象类，后续参数为开发扩展函数的传入参数。

举个例子：  
假设存在一个类`Person`,我们需要对其扩展一个函数`cry`，传入一个参数，然后打印。

class Person {
    }
    
    def person = new Person()
    
    
    class PersonExt {
        /**
         * @param p 第一个参数 是扩展类
         * @param msg 扩展函数的参数
         * @return
         */
        static def cry(Person p, String msg) {
            println("Person invoke cry $msg")
        }
    }
    
    use(PersonExt) {
        person.cry("hello world")
    }

输出：

Person invoke cry hello world

*  `Category` 注解的使用  
    `Category` 配合`use`可以使扩展更加可读。语法注解规则，第一 `Category` 注解在一个实现扩展类上（这里不是指被扩展类），第二 声明一个函数，参数全部为扩展函数的参数。

class Person {
    }
    
    def person = new Person()
    
    
    class PersonExt {
        /**
         * @param p 第一个参数 是扩展类
         * @param msg 扩展函数的参数
         * @return
         */
        static def cry(Person p, String msg) {
            println("Person invoke cry $msg")
        }
    }
    
    @Category(Person)
    class PersonExt2 {
        def cry(String msg) {
            println("${this} PersonExt2 invoke cry $msg")
        }
    }
    
    use(PersonExt2) {
        person.cry("hello world")
    }

输出：

Person@587d1d39 PersonExt2 invoke cry hello world

当`use`存在多个扩展实现参数时，后者优先

//由于PersonExt2在后面，所以只会调用PersonExt2
    use(PersonExt, PersonExt2) {
        person.cry("hello world")
    }

#### Mixin ####

Mixin是一个groovy注解，用于标注某个类注入到被标注的类上。

@Mixin(Student)
    class Person {
    }
    
    
    class Student {
        def goSchool() {
            println("I'm go school")
        }
    }
    def person = new Person()
    person.goSchool()

当然需要注意的是Mixin所传入的类必须存在无参构造。

换个形式

class Person {
    }
    
    
    class Student {
        def goSchool() {
            println("I'm go school")
        }
    }
    Person.mixin(Student)
    def person = new Person()
    person.goSchool()

#### trait ####

Mixin已经被启用了，取而代之的是trait机制。trait是一个关键字,标注某个类是一个专门用于混合使用的。其他类想混合trait类方法时主需要实现接口。

class Person implements Student {
    }
    
    
    trait Student {
        
        def goSchool() {
            println("I'm go school")
        }
    }
    
    def person = new Person()
    
    
    person.goSchool()

需要注意trait类不能实例化，且存在无参构造