背景：最近项目组同事希望大家一起写一个泛型DAO，然后大家可以一起使用。
作为项目组中拥有审核代码权限的人，我认为，至少在使用Hibernate这个对象关系映射框架中，是不必要的。而我之所以反对的原因是
-
业务模型是复杂多变的，我们很难从其中抽取出共同的抽象类（有的业务模型十分复杂，有的业务模型简单，这些情况将会导致对于业务简单DAO层类需要继承很多不必要的方法）。
-
Hibernate对于对象关系映射已经封装的很好，没必要再写一个类似Hibernate关系对象映射的封装了。
-
抽象出来的DAO类很难复用，将会导致各个模块有着相同的业务逻辑。（举例来说，成员A写了一个用户模块（该用户模块只处理自己的业务逻辑：如用户权限控制，用户状态），成员B在完成订单模块的同时，需要用户模块的时候，是可以调用用户模块A，但是会面临着成员A会对用户模块进行重写的风险，往往为了规避这种风险存在，成员B就会对这个用户模块进行再次复写。这种大量重复的开发的确存在着）。
也正是因为以上的观点，我想出了一种基于抽象工厂、适配器的混合设计模式 。
Talk is cheap,show me the code
// DAO的工厂接口
public interface DaoFactory<T,P> {
// 取消注册
public void unrgistered(T type);
// 注册
public void register(T type,P provider);
// 更新
public void update(T type, P provider);
// 获取
public P valueOf(T type);
}
// DAO的适配器
@FunctionalInterface
public interface DaoProvider<T> {
public T of();
}
// DAO的类型
public interface DaoType {}
// DAO的抽象工厂
public abstract class AbstractDaoFactory<T extends DaoType,P extends DaoProvider<?>> implements DaoFactory<T,P>{
protected static final Map<DaoType, DaoProvider<?>> map = new ConcurrentHashMap<>(4);
@Override
public void register(T type,P provider){
Objects.requireNonNull(type);
Objects.requireNonNull(provider);
if (map.containsKey(type))
throw new DaoRegisteredException();
map.putIfAbsent(type, provider);
}
@Override
public void unrgistered(T type){
Objects.requireNonNull(type);
if (!map.containsKey(type))
throw new DaoUnregisteredException();
map.remove(type);
}
@Override
public void update(T type, P provider){
Objects.requireNonNull(type);
Objects.requireNonNull(provider);
if (!map.containsKey(type))
throw new DaoUpdatedException();
map.replace(type, provider);
}
@SuppressWarnings("unchecked")
@Override
public P valueOf(T type){
Objects.requireNonNull(type);
if (!map.containsKey(type))
throw new DaoUnregisteredException();
return (P) map.get(type);
}
}
public class DaoRegisteredException extends RuntimeException {
private static final long serialVersionUID = -3794217705148674984L;
public DaoRegisteredException() {
super("Dao has registered,using update method please...");
}
public DaoRegisteredException(String message, Throwable cause, boolean enableSuppression,
boolean writableStackTrace) {
super(message, cause, enableSuppression, writableStackTrace);
}
public DaoRegisteredException(String message, Throwable cause) {
super(message, cause);
}
public DaoRegisteredException(String message) {
super(message);
}
public DaoRegisteredException(Throwable cause) {
super(cause);
}
}
public class DaoUnregisteredException extends RuntimeException {
private static final long serialVersionUID = 5997668949853885283L;
public DaoUnregisteredException() {
super("Dao still unregistered,using register method please...");
}
public DaoUnregisteredException(String message, Throwable cause, boolean enableSuppression,
boolean writableStackTrace) {
super(message, cause, enableSuppression, writableStackTrace);
}
public DaoUnregisteredException(String message, Throwable cause) {
super(message, cause);
}
public DaoUnregisteredException(String message) {
super(message);
}
public DaoUnregisteredException(Throwable cause) {
super(cause);
}
}
public class DaoUpdatedException extends RuntimeException {
private static final long serialVersionUID = -1424730522134154582L;
public DaoUpdatedException() {
super("Dao still unregisted,using register method please...");
}
public DaoUpdatedException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
super(message, cause, enableSuppression, writableStackTrace);
}
public DaoUpdatedException(String message, Throwable cause) {
super(message, cause);
}
public DaoUpdatedException(String message) {
super(message);
}
public DaoUpdatedException(Throwable cause) {
super(cause);
}
}
这里，我提供了DaoFactory的接口(注册，取消注册，更新Dao适配器与获取适配器等方法)，并且同时提供了DAO的适配器、DAO的类型。
同时在AbstractDaoFactory中，我对其进行了简单的实现。到了这里，其实大家可以看出，我就是对于一个抽象模型的增删查改的DAO进行拆分。因为我现在设计的这些类要解决的就是上面的三个问题。
-
任何一个业务模型CURD必须细分出来，不需要继承不必要的抽象类，必须注册到DaoFactory中去。
-
不需要你去写适应项目组成员的泛型Dao。
-
你所实现的方法是可以给别人调用，因为当你需要进行重构你的代码的时候，你只能新增方法，不能修改你原先的业务逻辑。其他成员将会将会根据你的DaoType进行索引你的方法。
简单应用案例：
@SuppressWarnings("rawtypes")
public interface HotelOrderDetailDaoProvider extends DaoProvider<HotelOrderDetailQueryDao>{}
@FunctionalInterface
public interface HotelOrderDetailQueryDao<T> {
public T queryHotelOrderDetail(int id);
}
public final class HotelOrderDetailDaoFactory extends AbstractDaoFactory<HotelOrderDetailType,HotelOrderDetailDaoProvider> implements DaoFactory<HotelOrderDetailType,HotelOrderDetailDaoProvider>{
private static final Logger log=LoggerFactory.getLogger(HotelOrderDetailDaoFactory.class);
private static final HotelOrderDetailDaoFactory factory=new HotelOrderDetailDaoFactory();
private HotelOrderDetailDaoFactory(){
log.info("HotelOrderDaoFactory start accepting registration...");
}
/**
* @return
*/
public static HotelOrderDetailDaoFactory getInstance() {
return factory;
}
}
Thanks for reading,have a good night :)
网友评论