本文介绍了如何设计一套简洁的DAO接口，包括findById、findList、create、update等常见操作，支持JavaBean和Map数据格式。接口实现利用Java动态代理，无需编写具体实现。测试用例展示了接口的使用方式，适用于JavaBean和Map类型的数据库访问。
数据访问对象 DAO（Data Access Object）本质是个名词，但我们更多语境中不是作名词用，需要的是一套通用的接口去使用，至于返回的对象是什么，可以是 Java Bean 或者 Map 键对值。
假设我们背后有一套数据访问机制，是 MyBatis、原生 JDBC 无所谓，只要能提供数据就可以了，那么目前需要设计一套标准的 DAO 接口，会是这样的。
我们的目的是尽量可能简单衔接底层的据访问机制，提供常见的 findById、findList、create、update 等的操作，而且还允许扩展。于是只要求用户继承 Java Interface 接口就好，不用写实现。
数据格式
这里说的数据格式，就是数据实体，至于是 PO/VO/BO/DTO/POJO 什么鬼的先别管——我们刻下讨论的是 Java Bean 还是 Map。
为简单起见，假设背后的数据访问机制返回的通通都是 Map。——为什么要用 Map 呢？一个是简单，另外一个在跨表查询的时候，Map 是比较适合的，因为一般一个 Bean 对应一张表，如果跨表，那跨表的字段该放哪里好呢？
DAO 基类接口 IDataServiceBase
提供常见的数据操作方法，统一返回 Map/List<Map> 数据格式。
import java.io.Serializable;
import java.util.List;
import java.util.Map;
import com.ajaxjs.framework.PageResult;
/**
* DAO 基类接口
* <p>
* 子接口继承该接口后，不需要写实现
*
* @author Frank Cheung<sp42@qq.com>
*/
public interface IDataServiceBase {
/**
* 查询单个记录。如果找不到则返回 null
*
* @param id 记录 id
* @return 单个记录的 Bean
*/
Map<String, Object> findByIdAsMap(Serializable id);
/**
* 查询列表数据
*
* @return Map 格式的列表结果
*/
List<Map<String, Object>> findListAsListMap();
/**
* 查询分页数据
*
* @param start 开始行数
* @param limit 读取行数
* @return 分页结果对象
*/
PageResult<Map<String, Object>> findPagedListAsMap(int start, int limit);
/**
* 新建记录
*
* @param map Map 实体
* @return 新建记录之 id 序号
*/
Serializable create(Map<String, Object> map);
/**
* 修改记录
*
* @param map Map 实，应包含 id 字段
* @return 影响的行数，理应 = 1
*/
Integer update(Map<String, Object> map);
/**
* 单个删除
*
* @param beanOrMapOrId
* @return 是否删除成功
*/
Boolean delete(Object beanOrMapOrId);
/**
* 设置 SQL WHERE 的查询条件参数
*
* @param queryParams
* @return
*/
IDataServiceBase setQuery(Map<String, Object> queryParams);
/**
* 设置 SQL WHERE 的查询条件参数。 不用设置 Map，固定 where 参数
*
* @param where
* @return
*/
IDataServiceBase setWhereQuery(String where);
}
IDataService
IDataService 这个是可以指定泛型的，即 Java Bean 类型。用起来因为要指定泛型比较繁琐，所以单独这个接口，跟 IDataServiceBase 区分开来。只用 Map 的用户可以直接继承 IDataServiceBase ，不用使用 IDataService。
import java.io.Serializable;
import java.util.List;
import java.util.Map;
import com.ajaxjs.framework.PageResult;
/**
* DAO 基类接口。可指定泛型
* <p>
* 子接口继承该接口后，不需要写实现
*
* @author Frank Cheung<sp42@qq.com>
*
* @param <T> 记录的实体类型
*/
public interface IDataService<T> extends IDataServiceBase {
/**
* 查询单个记录。如果找不到则返回 null
*
* @param <T> 记录的实体类型
* @param id 记录 id
* @return 单个记录的 Bean
*/
T findById(Serializable id);
/**
* 查询列表数据
*
* @param <T> 记录的实体类型
* @param clz Bean 的类型
* @return Bean 格式的列表结果
*/
List<T> findList();
/**
* 查询分页数据
*
* @param <T> 记录的实体类型
* @param start 开始行数
* @param limit 读取行数
* @param clz Bean 的类型
* @return 分页结果对象
*/
PageResult<T> findPagedList(int start, int limit);
/**
* 新建记录
*
* @param bean Bean 对象
* @return 新建记录之 id 序号
*/
Serializable create(T bean);
/**
* 修改记录
*
* @param bean Bean 对象，应包含 id 字段
* @return 影响的行数，理应 = 1
*/
Integer update(T bean);
@Override
IDataService<T> setQuery(Map<String, Object> queryParams);
@Override
IDataService<T> setWhereQuery(String where);
}
用法，下面是图文 Article 的 Java Bean：
import java.io.Serializable;
import java.util.Date;
public class Article implements Serializable {
private static final long serialVersionUID = -4302949595025705444L;
private Long id;
private String name;
private String title;
private String content;
private Date createDate;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
public Date getCreateDate() {
return createDate;
}
public void setCreateDate(Date createDate) {
this.createDate = createDate;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
图文 ArticleDAO
import com.ajaxjs.data_service.sdk.IDataService;
public interface ArticleDAO extends IDataService<Article> {
}
若有其他 DAO 方法，可在 ArticleDAO 中给出方法签名。
测试用例
下面的单测也说明了用法如何，都是围绕 CRUD 的。适合 Java Bean/Map 两种类型。
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import java.io.Serializable;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import com.ajaxjs.data_service.api.ApiController;
import com.ajaxjs.data_service.sdk.Caller;
import com.ajaxjs.framework.PageResult;
@ContextConfiguration(locations = { "classpath*:application-test.xml" })
@RunWith(SpringJUnit4ClassRunner.class)
public class TestSdk {
@Autowired
private ApiController c;
ArticleDAO dao;
@Before
public void init() {
c.init();
dao = new Caller("cms", "cms_article").bind(ArticleDAO.class, Article.class);
}
@Test
public void testFindById() {
Map<String, Object> map = dao.findByIdAsMap(1L);
assertNotNull(map.get("name"));
Article info = dao.findById(1L);
assertNotNull(info.getName());
}
@Test
public void testFindListAsListMap() {
List<Map<String, Object>> list;
Map<String, Object> queryParams = new HashMap<>();
queryParams.put("where", "stat = 1");
list = dao.setQuery(queryParams).findListAsListMap();
System.out.println(list.get(0));
assertNotNull(list.get(0));
list = dao.setWhereQuery("stat = 1").findListAsListMap();
System.out.println(list.get(0));
assertNotNull(list.get(0));
}
@Test
public void testFindList() {
List<Article> list;
list = dao.setWhereQuery("stat = 1").findList();
System.out.println(list.get(0).getName());
assertNotNull(list.get(0));
}
@Test
public void testFindPageList() {
PageResult<Map<String, Object>> list = dao.findPagedListAsMap(0, 10);
System.out.println(list.get(0).get("name"));
System.out.println(list.getTotalCount());
assertNotNull(list.get(0));
PageResult<Article> _list = dao.findPagedList(0, 10);
System.out.println(_list.get(0).getName());
assertNotNull(_list.get(0));
}
@Test
public void writeMap() {
Map<String, Object> article = new HashMap<>();
article.put("name", "TEST");
Serializable id = dao.create(article);
System.out.println(id);
assertNotNull(id);
Map<String, Object> article2 = new HashMap<>();
article2.put("id", id);
article2.put("name", "TEST22");
assertTrue(dao.update(article2));
assertTrue(dao.delete(article2));
}
@Test
public void writeBean() {
Article article = new Article();
article.setName("TEST2");
long id = (long) dao.create(article);
System.out.println(id);
assertNotNull(id);
Article article2 = new Article();
article2.setId(id);
article2.setName("TEST2222");
assertTrue(dao.update(article2));
assertTrue(dao.delete(article2));
}
}
DAO 底层实现如何？
本文着重介绍 DAO 接口层面如何——至于底层如何实现，不是本文的重点。这里简单介绍一下，主要是通过 Java 动态代理（Java Proxy，InvocationHandler）去实现的。不需要写实现，下面一句创建 DAO 实例。
new Caller("cms", "cms_article").bind(ArticleDAO.class, Article.class);
下面 bind() 方法完成了从 Java 接口到普通实例对象的过程。
/**
* 绑定接口（使用 Java Bean）
*
* @param <T> DAO 类型
* @param daoClz DAO 接口其引用
* @param beanClz Java Bean 类引用
* @return DAO 实现
*/
@SuppressWarnings("unchecked")
public <T extends IDataServiceBase, K> T bind(Class<T> daoClz, Class<K> beanClz) {
if (beanClz != null)
this.setBeanClz(beanClz);
setClz(daoClz);
Object obj = Proxy.newProxyInstance(daoClz.getClassLoader(), new Class[] { daoClz }, this);
return (T) obj;
}
/**
* 绑定接口（使用 Map 类型）
*
* @param <T> DAO 类型
* @param daoClz DAO 接口其引用
* @return DAO 实现
*/
public <T extends IDataServiceBase> T bind(Class<T> daoClz) {
return bind(daoClz, null);
}
下面是覆盖 InvocationHandler 接口的实现方法，核心的实现处理都在这里执行、分发。
@SuppressWarnings("unchecked")
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
String methodName = method.getName();
if (methodName.equals("setQuery")) {
setQueryParams((Map<String, Object>) args[0]);
return proxy;
} else if (methodName.equals("setWhereQuery")) {
if (queryParams == null)
queryParams = new HashMap<>();
queryParams.put("where", args[0]);
return proxy;
} else if (methodName.startsWith("find") || methodName.startsWith("get")) {
LOGGER.info("相当于 HTTP GET");
return get(methodName, args);
} else if (methodName.equals("create")) {
LOGGER.info("相当于 HTTP POST");
return create(methodName, args);
} else if (methodName.equals("update")) {
LOGGER.info("相当于 HTTP PUT");
return update(methodName, args);
} else if (methodName.equals("delete")) {
LOGGER.info("相当于 HTTP DELETE");
return delete(methodName, args);
} else {
LOGGER.info("其他自定义命令");
}
return null;
}
小结
最后，一个清爽、简易的 DAO 接口层就完成了！如有不足，敬请斧正。
扫一扫
771
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
