场景描述：

我需要开发四个页面，每个页面都是只涉及增删改查的基本逻辑。

最简单的写法：

创建四个接口A,B,C,D，每个接口中都声明了增删改查四个方法,完全一致

public Map<String,Object> delete(HttpServletRequest request, User user);public Map<String,Object> query(HttpServletRequest request, User user, Map<String, Object> params);public Map<String,Object> insert(HttpServletRequest request, User user);public Map<String,Object> update(HttpServletRequest request, User user);

为上面四个接口分别创建四个实现类，复写接口中的增删改查方法

接口A的实现类

@Override
public Map<String, Object> delete(HttpServletRequest request, User user) {Map<String,Object> params = new HashMap<String,Object>();params.put("operation", "delete");return commandExecutor.execute(new DaoAImpl(request, params, user));
}
@Override
public Map<String, Object> query(HttpServletRequest request, User user,   Map<String, Object> params) {params = null == params ? new HashMap<String,Object>() : params;params.put("operation", "query");return commandExecutor.execute(new DaoAImpl(request, params, user));
}
@Override
public Map<String, Object> insert(HttpServletRequest request, User user) {Map<String,Object> params = new HashMap<String,Object>();params.put("operation", "insert");return commandExecutor.execute(new DaoAImpl(request, params, user));
}
@Override
public Map<String, Object> update(HttpServletRequest request, User user) {Map<String,Object> params = new HashMap<String,Object>();params.put("operation", "update");return commandExecutor.execute(new DaoAImpl(request, params, user));
}

接口B的实现类

@Override
public Map<String, Object> delete(HttpServletRequest request, User user) {Map<String,Object> params = new HashMap<String,Object>();params.put("operation", "delete");return commandExecutor.execute(new DaoBImpl(request, params, user));
}
@Override
public Map<String, Object> query(HttpServletRequest request, User user,   Map<String, Object> params) {params = null == params ? new HashMap<String,Object>() : params;params.put("operation", "query");return commandExecutor.execute(new DaoBImpl(request, params, user));
}
@Override
public Map<String, Object> insert(HttpServletRequest request, User user) {Map<String,Object> params = new HashMap<String,Object>();params.put("operation", "insert");return commandExecutor.execute(new DaoBImpl(request, params, user));
}
@Override
public Map<String, Object> update(HttpServletRequest request, User user) {Map<String,Object> params = new HashMap<String,Object>();params.put("operation", "update");return commandExecutor.execute(new DaoBImpl(request, params, user));
}

接口C，D 的实现类就不在展示了。其中主要区别就是：

ServiceAImpl调用DaoAImpl的对象

ServiceBImpl调用DaoBImpl的对象

ServiceCImpl调用DaoCImpl的对象

ServiceDImpl调用DaoDImpl的对象

看完上面的代码，你可以发现，重复的代码太多了，需要整理下

解决方案：

接口：可以将增删改查的方法声明放到一个基础接口中，然后继承这个基础接口就行。

基础service接口

package com.engine.odoc.service;import java.util.Map;import javax.servlet.http.HttpServletRequest;import weaver.hrm.User;public interface BaseService {public Map<String,Object> delete(HttpServletRequest request, User user);public Map<String,Object> query(HttpServletRequest request, User user, Map<String, Object> params);public Map<String,Object> insert(HttpServletRequest request, User user);public Map<String,Object> update(HttpServletRequest request, User user);
}

继承基础service接口的接口

package com.engine.odoc.service;public interface ServiceA extends BaseService {}

package com.engine.odoc.service;public interface ServiceB extends BaseService {}

package com.engine.odoc.service;public interface ServiceC extends BaseService {}

package com.engine.odoc.service;public interface ServiceD extends BaseService {}

接口的实现：同样是增删改查四个复写的方法，唯一不同的就是不同的实现类调用不同的持久层（DAO）对象。期初的想法与处理接口的想法一样，把复写的增删改查方法写到一个基础service实现类中，然后继承这个基础service实现类即可。

为了能实现这个功能，我们需要用到Java中的泛型和反射知识

新建一个基础service实现类

package com.engine.odoc.service.impl;public class BaseServiceImpl<T> implements BaseService {@Overridepublic Map<String, Object> delete(HttpServletRequest request, User user) {}@Overridepublic Map<String, Object> query(HttpServletRequest request, User user, Map<String, Object> params) {}@Overridepublic Map<String, Object> insert(HttpServletRequest request, User user) {}@Overridepublic Map<String, Object> update(HttpServletRequest request, User user) {}}

可以看到这个基础service实现类接受了一个类型参数T

那些继承了这个基础实现类的类，就可以通过这个类型参数，把需要调用的Dao层对象的类型传递到父类当中

package com.engine.odoc.service.impl;public class ServiceAImpl extends BaseServiceImpl<DaoAImpl> implements ServiceA {}

package com.engine.odoc.service.impl;public class ServiceBImpl extends BaseServiceImpl<DaoBImpl> implements ServiceB {}

package com.engine.odoc.service.impl;public class ServiceCImpl extends BaseServiceImpl<DaoCImpl> implements ServiceC {}

package com.engine.odoc.service.impl;public class ServiceDImpl extends BaseServiceImpl<DaoDImpl> implements ServiceD {}

接下来，我们需要思考的是，如何通过这个类型参数T，来得到T的一个实例。

我们先上菜

package com.engine.odoc.service.impl;import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.HashMap;
import java.util.Map;import javax.servlet.http.HttpServletRequest;import com.engine.odoc.service.BaseService;public class BaseServiceImpl<T> implements BaseService {public Class cusClass;public BaseServiceImpl() {// 获取T.classType genericSuperclass = this.getClass().getGenericSuperclass();if(genericSuperclass instanceof ParameterizedType) {ParameterizedType parameterizedType = (ParameterizedType) genericSuperclass;Type[] typeArray = parameterizedType.getActualTypeArguments();if(null != typeArray && typeArray.length>0) {cusClass = (Class) typeArray[0];}}}/*** 获取T类的实例* @param request* @param params* @param user* @return*/private T getTInstance(HttpServletRequest request, Map<String,Object> params, User user) {try {return (T) cusClass.getConstructor(new Class[]{HttpServletRequest.class, Map.class, User.class}).newInstance(request, params, user);} catch (Exception e) {e.printStackTrace();}return null;}@Overridepublic Map<String, Object> delete(HttpServletRequest request, User user) {}@Overridepublic Map<String, Object> query(HttpServletRequest request, User user,    Map<String, Object> params) {}@Overridepublic Map<String, Object> insert(HttpServletRequest request, User user) {}@Overridepublic Map<String, Object> update(HttpServletRequest request, User user) {}}

我们可以看到，我们在这个基础service实现类的默认构造函数中确认了类型参数T的类型，得到T.class。之后在getTInstance() 方法中通过反射的方式获取了T的实例。

Type genericSuperclass = this.getClass().getGenericSuperclass();

这行代码我们是写在父类（BaseServiceImpl）的默认构造函数中的。继承这个类的子类们，在执行默认构造函数的时候，会先执行super();调用父类的默认构造函数，这时候，以上这行代码中的this就代表了子类，调用getGenericSuperclass()来获得父类（BaseServiceImpl），而得到的父类（BaseServiceImpl）可能是BaseServiceImpl<DaoAImpl>,BaseServiceImpl<DaoBImpl>... ,也可能BaseServiceImpl<T>。

我们可以使用接口ParameterizedType，用来检验类型参数是否被参数化

Type genericSuperclass = this.getClass().getGenericSuperclass();
if(genericSuperclass instanceof ParameterizedType) {// 该泛型类的类型参数已经被参数化
}

如果类型参数已经被参数化，我们就可以通过调用下面的方法

package java.lang.reflect;public interface ParameterizedType extends Type {Type[] getActualTypeArguments();
}

返回的数组中就存储了类型参数T的具体类型，即T.class

获取到T.class之后,我们就可以通过反射来进一步获得T的实例

try {return (T) cusClass.getConstructor(new Class[]{HttpServletRequest.class, Map.class, User.class}).newInstance(request, params, user);
} catch (Exception e) {e.printStackTrace();
}