Spark小课堂Week7
从Spark中一个例子看面向对象设计
今天我们讨论了个问题，来设计一个Spark中的常用功能。
功能描述：数据源是一切处理的源头，这次要实现下加载数据源的方法load()
初始需求
需求：支持Json数据源加载
具体：输入一个path，需要返回一个Relation，
Relation中提供scan()和write()两个方法
示意代码：
class Context{
public Relation json(String path){
return new Relation(path);
}
}
class Relation{
public Relation(path);
public scan();
public write();
}
第一次需求变化
现在需要添加jdbc数据源，输入的是url和tableName，需要有自己的Relation实现
简单实现：
class Context{
public JsonRelation json(String path){
return new JsonRelation(path);
}
public JdbcRelation jdbc(String url,String tableName){
return new JdbcRelation(url,tableName);
}
}
class JsonRelation{
public JsonRelation(String path);
public scan();
public write();
}
class JdbcRelation{
public JdbcRelation(String url,String tableName);
public scan();
public write();
}
这个实现明显违反了开放封闭原则，增加一种文件格式，需要对核心类Context进行修改！！！
方法整合
所以首先，需要对json和jdbc方法进行合并为format，参数也进行合并，
source参数表示数据源，是一个字符串，比如:"json"、"jdbc"
逻辑整合起来
class Context{
public Relation format(String source,Map param){
if(source == "json") return new JsonRelation(param.get("path"));
if(source == "jdbc") return new JdbcRelation(param.get("url"),param.get("tableName"));
...
}
}
class JsonRelation extends Relation{
public JsonRelation(String path);
public scan();
public write();
}
class JdbcRelation extends Relation{
public JdbcRelation(String url,String tableName);
public scan();
public write();
}
方法通用化。
format方法还是违反了开放封闭原则。我们可以使用反射对其进行通用化。
class Context{
public Relation format(String source,Map param){
Class c = Class.forName(source + "Relation");
Constructor constructor= c.getDeclaredConstructor(Map.class);
return constructor.newInstance(param);
...
}
}
class JsonRelation extends Relation{
public JsonRelation(Map param){
this.path = param.get("path");
};
public scan();
public write();
}
class JdbcRelation extends Relation{
public JdbcRelation(Map param){
this.url = param.get("url");
this.tableName = param.get("tableName");
}
public scan();
public write();
}
第二次需求变化
需求：再增加一种文件类型csv，同样是输入path
按照之前的思路，我们可以增加一个Relation类
class CsvRelation extends Relation{
public CsvRelation(Map param){
this.path = param.get("path");
};
public scan();
public write();
}
这里有一个问题，我们其发现构造方法和JsonRelation是完全重复的，有没有办法消除这种重复
消除重复，第一点是需要把重复的部分拆离出来。我们把Relation类拆分为Relation类和Provider类。其中Provider是一个工厂方法，通过反射来调用。
class Context{
public Relation format(String source,Map param){
Class c = Class.forName(source + "Provider");
Method method= c.getMethod("getRelation",Map.class);
return method.invoke(null,param);
...
}
}
class JsonProvider{
public static createRelation(Param param){
return new JSonRelation(param.get("path"));
};
}
class JsonRelation extends Relation{
public JsonRelation(String path);
public scan();
public write();
}
class CsvProvider{
public static createRelation(Param param){
return new CsvRelation(param.get("path"));
};
}
class CsvRelation extends Relation{
public CsvRelation(String path);
public scan();
public write();
}
class JdbcProvider{
public static Relation createRelation(Param param){
return new JdbcRelation(param.get("url"),param.get("tableName"));
};
}
class JdbcRelation extends Relation{
public JdbcRelation(String path,String tableName);
public scan();
public write();
}
Json和csv采用path构造，而jdbc使用url+table，这个可以认为是一个固有的规则，我们可以把构造中间重复的逻辑再单独抽取出来
class Context{
public Relation format(String source,Map param){
Class c = Class.forName(source + "Provider");
if(hasIntereface(c,PathProvider.class)){
Method method= c.getMethod("getRelation",String.class);
return method.invoke(null,param.get("path"));
}
if(hasIntereface(c,UrlProvider.class)){
Method method= c.getMethod("getRelation",String.class,String.class);
return method.invoke(null,param.get("url"),param.get("tableName"));
}
...
}
}
class JsonProvider implements PathProvider{
public static createRelation(String path){
return new JSonRelation(path);
};
}
class CsvProvider implements PathProvider{
public static createRelation(String path){
return new CsvRelation(path);
};
}
class JdbcProvider implements UrlProvider{
public static Relation createRelation(String url,String tableName){
return new JdbcRelation(url,tableName);
};
}
然后，我们发现format方法中的实现有些太复杂，所以单独抽取出来
class Context{
public Relation format(String source,Map param){
return Provider.getRelation(source,param);
}
}
class Provider{
public Relation getRelation(String source,Param,param){
Class c = Class.forName(source + "Provider");
if(hasIntereface(c,PathProvider.class)){
Method method= c.getMethod("getRelation",String.class);
return method.invoke(null,param.get("path"));
}
if(hasIntereface(c,UrlProvider.class)){
Method method= c.getMethod("getRelation",String.class,String.class);
return method.invoke(null,param.get("url"),param.get("tableName"));
}
...
}
}
小结
未完待续。
这个例子主要是进行对象的构造，是比较有通用性的。
我们可以看到，面向对象设计中，主要是靠不同对象的特性来实现变化。
而对于对象的构造会需要一些规则来驱动，这种规则我们一般抽象为接口来标识，
处理这些规则的往往都是工厂方法，也是工厂的一个非常重要的作用。