简单聊聊各种语言的函数扩展

背景

最近有同事反应,我们运营后台下载的 CSV 文件出现错乱的情况。问题的原因是原始数据中有 CSV 中非法的字符,比如说姓名字段,因为是用户填写的,内容有可能包含了 ," 等字符,会导致 CSV 文件内容错乱。

于是我就想用一个简单的方式来解决这个问题。一个简单粗暴的解决方案就是导出时对字符串进行处理,将一些特殊字符替换掉,或者前后用"包起来。但是这样的话,需要所有下载 CSV 的地方都要改写,会比较麻烦。如果我们可以简单的给 String 增加一个方法(如 String.csv())直接就把字符串处理成 CSV 兼容的格式,就会方便很多。我们的运营后台是使用 Scala 语言开发的,所幸的是,Scala 里提供了一个非常强大的功能,可以满足我们的需求,那就是隐式转换。

Scala 的隐式转换

在 Scala 里可以通过 implicit 隐式转换来实现函数扩展。

编译器在碰到类型不匹配或是调用一个不存在的方法的时候,会去搜索符合条件的隐式类型转换,如果找不到合适的隐式转换方法则会报错。

下面是处理 CSV 下载字符串的代码:

trait CsvHelper {
  implicit def stringToCsvString(s: String) = new CsvString(s)
}
class CsvString(val s: String){
  def csv = s"""${s.replaceAll(",", " ").replaceAll("\"", "'")}"""
}

class Controller extends CsvHelper {
    def dowload(){
        ...
        ",foo,".csv //foo
    }
}

Controller 中我调用 String.csv 方法,但是 String 没有 csv 方法。这时候编译器就会去找 Controller 中有没有隐式转换的方法,发现在其父类 CsvHelper 中有方法把 String 转换成 CsvString,而 CsvString 中实现了 csv 方法。所以编译器最终会调用到 CsvString.csv 这个方法。

隐式转换是一个很强大,但是也很容易误用的功能。Scala 里隐式转换有一些基本规则:

  • 优先规则:如果存在两个或者多个符合条件的隐式转换,如果编译器不能选择一条最优的隐式转换,则提示错误。具体的规则是:当前类中的隐式转换优先级大于父类中的隐式转换;多个隐式转换返回的类型有父子关系的时候,子类优先级大于父类。
  • 隐式转换只会隐式的调用一次,编译器不会调用多个隐式方法,不会产生调用链。
  • 如果当期代码已经是合法的,不需要隐式转换则不会使用隐式转换。

Java 的动态扩展

我们再来看看我们熟悉的 Java 语言。Java 是一门静态语言,本身没有直接提供动态扩展的方法,但是我们可以通过 AOP 动态代理的方式来修改一个方法,从而间接的实现方法的动态扩展。

下面就是一个我们就用 AspectJ 来实现一个动态扩展,用于分页查询后获取数据的总条数。

@Aspect
@Component
public class PaginationAspect {
    @AfterReturning(
        pointcut = "execution(* com.xingren..*.*ByPage(..))",
        returning = "result"
    )
    public void afterByPage(JoinPoint joinPoint, Object result) {
        //根据result获取sql信息,再查询总条数封装到result中。
    }
}

其中 AfterReturning 注解表明在被注解方法返回后的一些后续动作。pointcut 定义切点的表达式,可以用通配符 * 表示;returning 指定返回的参数名。然后就可以对返回的结果进行处理。这样就可以达到动态的修改原始函数功能。

当然除了 AspectJ 也可以使用 CGLib 来代理来实现简单的 AOP。

public class FooService {
    public Page findByPage(){
        return new Page();
    }
    public Page findPage(){
        return new Page();
    }
}
@Data
public class Page {
    private String sql = "";
    private List<Object> content = new ArrayList();
    private Integer size = 0;
    private Integer page = 0;
    private Integer total = 0;
}

创建一个对象 FooService 用来模拟查询分页方法。

public class CGLibProxyFactory implements MethodInterceptor {

    private Object object;

    public CGLibProxyFactory(Object object){
        this.object = object;
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("before method! do something...");

        Object result = methodProxy.invoke(object, objects);
        //进行方法判断,是否需要处理
        if (method.getName().contains("ByPage")) {
            if (result instanceof Page) {
                System.out.println("after method! do something...");
                ((Page) result).setTotal(100);
            }
        }
        return result;
    }
}

创建一个代理类实现 MethodInterceptor 接口,手动调用 invoke 方法,用来动态的修改被代理的实现方法。可以在执行之前做一些参数校验,或者一些参数的预处理。也可以获取修改执行的结果,或者干脆不调用 invoke 方法,自定义实现。也可以在调用后做一些后续动作。

public class ObjectFactoryUtils {
    public static <T> Optional<T> getProxyObject(Class<T> clazz) {
        try {
            T obj = clazz.newInstance();
            CGLibProxyFactory factory = new CGLibProxyFactory(obj);
            Enhancer enhancer=new Enhancer();//利用`Enhancer`来创建被代理类的代理实例
            enhancer.setSuperclass(clazz);//设置目标class
            enhancer.setCallback(factory);//设置回调代理类
            return Optional.of((T)enhancer.create());
        } catch (InstantiationException | IllegalAccessException e) {
            e.printStackTrace();
        }
        return Optional.empty();
    }
}

public static void main(String[] args) {
        Optional<FooService> proxyObject = ObjectFactoryUtils.getProxyObject(FooService.class);
        if(proxyObject.isPresent()) {
            FooService foo = proxyObject.get();
            System.out.println("findByPage:");
            System.out.println(foo.findByPage().getTotal());
            System.out.println("findPage:");
            System.out.println(foo.findPage().getTotal());
        }
}

最后打印的输出是:

findByPage:
before method! do something...
after method! do something...
100
findPage:
before method! do something...
0

当然除了 CGLIB 代理也可以使用 Proxy 动态代理,同样的逻辑也可以达到动态的修改原始方法的目的,从而间接的实现函数扩展。不过 Proxy 动态代理是基于接口的代理。

其它语言的函数扩展

其实除了 Scala 的隐式转换和 Java 的动态代理,其他很多语言也能支持各种不同的函数扩展。

Swift

在 Swift 中可以通过关键词 extension 对已有的类进行扩展,可以扩展方法、属性、下标、构造器等等。

extension Int {
    func times(task: () -> Void) {
        for _ in 0..<self {
            task()
        } 
    }
}

比如说我给 Int 增加一个 times 方法。即执行任务的次数。就可以如下使用:

2.times({
    print("Hello!")
})

上面的代码会执行 2 次打印方法。

Go

在 Go 中可以通过在方法名前面加上一个变量,这个附加的参数会将该函数附加到这种类型上。即给一个方法加上接收器。

func (s string) toUpper() string {
    return strings.ToUpper(s)
}

"aaaaa".toUpper //输出 AAAAA

Kotlin

Kotlin 的函数扩展非常简单,就是定义的时候,函数名写成 接收器 + . + 方法名 就行了。

class C {

}
fun C.foo() { println("extension") }

C().foo() //输出extension

注意当给一个类扩展已有的方法的时候,默认使用的是类自带的成员函数。如下:

class C {
    fun foo() { println("member") }
}

fun C.foo() { println("extension") }

C().foo() //输出member

可以通过函数重载的方式区分成员函数(fun C.foo(i:Int) { println("extension") }),在调用的地方显示的区分。

JavaScript

在 JavaScript 中也可以很方便的给一个对象扩展函数。写法就是 对象 + . + 函数名

var date = new Date();
date.format = function() {
    return this.toISOString().slice(0, 10);
}
date.format(); //"2017-11-29"

也可以给一个 Object 进行扩展:

Date.prototype.format = function() {
     return this.toISOString().slice(0, 10);
}
new Date().format(); //"2017-11-29"

总结

其实了解不同语言对于函数扩展的实现挺有意思的,本文只是粗略的介绍了一下。合理的使用这些语言的扩展,可以帮助我们提高代码质量和工作效率。我们还可以通过函数扩展来对第三方类库进行修改或者扩展,从而更灵活的调用第三方类库。

0