作者 | 杨洋
杏仁Java程序员,关注后端和底层技术
最近有同事反应,我们运营后台下载的 CSV 文件出现错乱的情况。问题的原因是原始数据中有 CSV 中非法的字符,比如说姓名字段,因为是用户填写的,内容有可能包含了 ,
、 "
等字符,会导致 CSV 文件内容错乱。
于是我就想用一个简单的方式来解决这个问题。一个简单粗暴的解决方案就是导出时对字符串进行处理,将一些特殊字符替换掉,或者前后用 "
包起来。但是这样的话,需要所有下载 CSV 的地方都要改写,会比较麻烦。如果我们可以简单的给 String 增加一个方法(如 String.csv()
)直接就把字符串处理成 CSV 兼容的格式,就会方便很多。我们的运营后台是使用 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 是一门静态语言,本身没有直接提供动态扩展的方法,但是我们可以通过 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 中可以通过关键词 extension
对已有的类进行扩展,可以扩展方法、属性、下标、构造器等等。
extension Int { func times(task: () -> Void) { for _ in 0..<self { task() } } }
比如说我给 Int 增加一个 times 方法。即执行任务的次数。就可以如下使用:
2.times({ print("Hello!") })
上面的代码会执行 2 次打印方法。
在 Go 中可以通过在方法名前面加上一个变量,这个附加的参数会将该函数附加到这种类型上。即给一个方法加上接收器。
func (s string) toUpper() string { return strings.ToUpper(s) } "aaaaa".toUpper //输出 AAAAA
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 中也可以很方便的给一个对象扩展函数。写法就是 对象
+ .
+ 函数名
。
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"
其实了解不同语言对于函数扩展的实现挺有意思的,本文只是粗略的介绍了一下。合理的使用这些语言的扩展,可以帮助我们提高代码质量和工作效率。我们还可以通过函数扩展来对第三方类库进行修改或者扩展,从而更灵活的调用第三方类库。
全文完
以下文章您可能也会感兴趣:
微服务环境下的集成测试探索(一) —— 服务 Stub & Mock
微服务环境下的集成测试探索(二)—— 契约式测试
乐高式微服务化改造(上)
乐高式微服务化改造(下)
一个创业公司的容器化之路(一) - 容器化之前
一个创业公司的容器化之路(二) - 容器化
一个创业公司的容器化之路(三) - 容器即未来
响应式编程(上):总览
响应式编程(下):Spring 5
复杂业务状态的处理:从状态模式到 FSM
后端的缓存系统浅谈
谈谈到底什么是抽象,以及软件设计的抽象原则
所谓 Serverless,你理解对了吗?
Linux 的 IO 通信 以及 Reactor 线程模型浅析
我们正在招聘 Java 工程师,欢迎有兴趣的同学投递简历到 rd-hr@xingren.com 。
长按左侧二维码关注我们,这里有一群热血青年期待着与您相会。