持久层之DAO

最新推荐文章于 2024-04-17 21:50:13 发布
最新推荐文章于 2024-04-17 21:50:13 发布
阅读量314 收藏 1
点赞数
CC 4.0 BY-SA版权
文章标签： java 数据库 设计模式
原文链接：https://my.oschina.net/diedai/blog/533085
本文详细介绍了DAO（数据访问对象）的设计理念与实现细节，包括其核心功能——增删查改及连接管理，并提供了具体的接口定义与实现类示例。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

为什么80%的码农都做不了架构师？>>>   hot3.png

前言

DAO的意思是数据访问对象，就是用该类来访问数据库，具体来说是执行增删查改的。

另外，还需要负责获取连接对象和关闭连接对象。


UML

153208_fcXh_1027544.png



代码示例

1、接口

1）增删查改。

2）获取连接对象和关闭连接对象。

package com.bigning.db;

import java.io.*;
import java.util.*;
import java.util.Date;
import java.sql.*;

import com.bigning.Important;
import com.bigning.ImportantLevel;

/**
 * DAO接口
 * 
 * @author gzh
 * @see AbstractDal
 * 
 */
@Important(ImportantLevel.Top)
public interface ComDal extends Serializable {
	/**
	 * 增、删、改
	 * 
	 * @param sql
	 *            sql语句
	 * @return 记录数量
	 * @throws DalException
	 */
	public int execCommand(String sql) throws DalException;

	/**
	 * 增、删、改
	 * 
	 * @param sql
	 *            sql语句
	 * @param date
	 *            日期
	 * @return 记录数量
	 * @throws DalException
	 */
	public int execCommand(String sql, java.util.Date date) throws DalException;

	/**
	 * 增、删、改
	 * 
	 * @param sql
	 *            sql语句
	 * @param dates
	 *            日期数组
	 * @return 记录数量
	 * @throws DalException
	 */
	public int execCommand(String sql, java.util.Date[] dates)
			throws DalException;

	/**
	 * 增、删、改
	 * 
	 * @param sql
	 *            sql语句
	 * @param dates
	 *            日期列表
	 * @return 记录数量
	 * @throws DalException
	 */
	public int execCommand(String sql, List<Date> dates) throws DalException;

	/**
	 * 查询
	 * 
	 * @param sql语句
	 * @return 结果集
	 * @throws DalException
	 */
	public ResultSet doSelect(String sql) throws DalException;

	/**
	 * 查询
	 * 
	 * @param sql
	 *            sql语句
	 * @param date
	 *            日期
	 * @return 结果集
	 * @throws DalException
	 */
	public ResultSet doSelect(String sql, java.util.Date date)
			throws DalException;

	/**
	 * 查询
	 * 
	 * @param sql
	 *            sql语句
	 * @param dates
	 *            日期数组
	 * @return 结果集
	 * @throws DalException
	 */
	public ResultSet doSelect(String sql, java.util.Date[] dates)
			throws DalException;

	/**
	 * 查询
	 * 
	 * @param sql
	 *            sql语句
	 * @param dates
	 *            日期列表
	 * @return 记录集
	 * @throws DalException
	 */
	public ResultSet doSelect(String sql, List<Date> dates) throws DalException;

	/**
	 * 执行一批命令
	 * 
	 * @param arrSqls
	 *            命令数组
	 */
	public void execBatch(String[] arrSqls) throws DalException;

	/**
	 * 执行一组命令
	 */
	public void execBatch(List<String> vSqls) throws DalException;

	/**
	 * 执行存储过程（对 SQL Server而言）
	 * 
	 * @param spName
	 *            存储过程名称
	 * @param spParams
	 *            存储过程的参数
	 */
	public void execStoreCommand(String spName, String spParams)
			throws DalException;

	/**
	 * 取得连接对象
	 * 
	 * @return 连接对象
	 */
	public Connection getConnection() throws DalException;

	/**
	 * 清除历史的 statment
	 */
	public void clearHistory();

	/**
	 * 关闭结果集对象、语句对象和连接对象
	 */
	public void closeConnection();

	/**
	 * 取得最后执行的一条 SQL 语句
	 */
	public String getLastSql();

	/**
	 * 取得连接生成器
	 */
	public ConnectionGenerator getConnectionGenerator();

	/**
	 * 设置数据的 Filter，插入到数据库之前， 将数据进行 convert 一下 -- updated on 20030117
	 */
	// public void setFilter(DataFilter df);
	/**
	 * 移除过滤器 -- updated on 20030117
	 */
	// public DataFilter removeFilter() ;
	
	/**
	 * 设置要获取的记录数量
	 * @param fetchSize 记录数量
	 */
	public void setFetchSize(int fetchSize);
};



2、实现类（非连接池）

注：该类是DAO接口的实现类，并不是抽象类，这里命名错误！

package com.bigning.db;

import java.util.*;
import java.util.Date;
import java.sql.*;
import org.apache.log4j.*;

import com.bigning.Important;
import com.bigning.ImportantLevel;

/**
 * DAO的实现类： 作为一个基本的 DAL 类存在， 而并不是一个Abstract 类， 可作为 ComDal 的一个参考实现
 * 
 * @author Administrator
 * 
 */
@Important(ImportantLevel.Top)
public class AbstractDal implements ComDal, Cloneable {
	/**
	 * Comment for <code>serialVersionUID</code>
	 */
	private static final long serialVersionUID = 3257001055735658040L;

	static PreProcesser SPP = new PreProcesser();
	// 字段定义
	private ConnectionGenerator cg; // 连接生成器
	private String lastSql; // 最后执行的 SQL 语句
	protected Connection conn; // 数据库连接
	private LinkedList<Statement> historyStatements;
	private LinkedList<ResultSet> historyResultSets;
	private static final Logger logger = Logger.getLogger(AbstractDal.class);
	// private DataFilter filter;
	int fetchSize = 20;

	// 构造方法说明：
	/**
	 * @param cg
	 *            连接生成器
	 */
	public AbstractDal(ConnectionGenerator cg) {
		this.cg = cg;
		historyStatements = new LinkedList<Statement>();
		historyResultSets = new LinkedList<ResultSet>();
	}

	// 其他方法说明：
	/**
	 * 执行 SQL 命令， 如 Insert， Delete等
	 * 
	 * @param sql
	 *            SQL命令
	 * @throws DalException
	 *             封装SQL语句出错的命令
	 */
	public int execCommand(String sql) throws DalException {
		return execCommand(sql, SPP);
	}

	/**
	 * 执行 SQL 命令， 如 Insert， Delete等
	 * 
	 * @param sql
	 *            SQL命令
	 * @param aDate
	 *            一个日期
	 */
	public int execCommand(String sql, java.util.Date aDate)
			throws DalException {
		return execCommand(sql, new DatePreProcesser(aDate));
	}

	/**
	 * 执行 SQL 命令，如 Insert, Delete等， 但这条命令中包括有 Date 类型需要设置
	 * 
	 * @param sql
	 *            SQL 命令
	 * @param dates
	 *            一组日期
	 */
	public int execCommand(String sql, java.util.Date[] dates)
			throws DalException {
		return execCommand(sql, new DatePreProcesser(dates));

	}

	/**
	 * 执行 SQL 命令，如 Insert, Delete等， 但这条命令中包括有 Date 类型需要设置
	 * 
	 * @param sql
	 *            SQL 命令
	 * @param dates
	 *            一组日期
	 */
	public int execCommand(String sql, List<Date> dates) throws DalException {
		return execCommand(sql, new DatePreProcesser(dates));
	}

	private int execCommand(String sql, PreProcesser dpp) throws DalException {
		ensureConnected();
		lastSql = sql;
		int r = 0;
		try {
			PreparedStatement ps = conn.prepareStatement(sql);
			try {
				dpp.process(ps);
				r = ps.executeUpdate();
			} finally {
				ps.close();
			}
			logSucc(sql);
		} catch (SQLException ex) {
			logFail(ex, sql + dpp.getDates());
			throw new DalException(this, ex, sql + dpp.getDates());
		}
		return r;
	}

	/**
	 * 执行 SQL 查询命令
	 * 
	 * @param sql
	 *            SQL查询语句
	 * @return 记录集
	 */
	/**
	 * 执行一批命令
	 * 
	 * @param arrSqls
	 *            命令数组
	 */
	public void execBatch(String[] arrSqls) throws DalException {
		ensureConnected();
		try {
			Statement s = conn.createStatement();
			try {
				for (int i = 0; i < arrSqls.length; i++) {
					lastSql = arrSqls[i];
					s.executeUpdate(lastSql);
					logSucc(lastSql);
				}
			} finally {
				s.close();
			}
		} catch (SQLException ex) {
			logFail(ex, lastSql);
			throw new DalException(this, ex, lastSql);
		} // end of catch
	}

	/**
	 * 执行一组命令
	 */
	public void execBatch(List<String> vSqls) throws DalException {
		String[] s = new String[vSqls.size()];
		vSqls.toArray(s);
		execBatch(s);
	}

	/**
	 * 执行 SQL 查询命令
	 * 
	 * @param sql
	 *            SQL查询语句
	 * @return 结果集
	 */
	public ResultSet doSelect(String sql) throws DalException {
		return doSelect(sql, SPP);
	}

	/**
	 * 执行查询语句
	 * 
	 * @param sql
	 *            sql语句
	 * @param spp
	 *            预处理
	 * @return 结果集
	 * @throws DalException
	 */
	private ResultSet doSelect(String sql, PreProcesser spp)
			throws DalException {
		ensureConnected();
		lastSql = sql;
		try {
			PreparedStatement s = conn.prepareStatement(sql,
					ResultSet.TYPE_SCROLL_INSENSITIVE,
					ResultSet.CONCUR_READ_ONLY);
			try {
				s.setFetchSize(fetchSize);
			} catch (Exception ex) {
			}
			spp.process(s);
			ResultSet r = s.executeQuery();
			try {
				r.setFetchSize(fetchSize);
			} catch (Exception ex) {
			}
			synchronized (historyStatements) {
				historyStatements.addLast(s);
				historyResultSets.addLast(r);
			}
			logSucc(sql);
			return r;
		} catch (SQLException ex) {
			logFail(ex, sql + spp.getDates());
			throw new DalException(this, ex, sql + spp.getDates());
		} // end of catch
	}

	/**
	 * 执行 SQL 查询命令
	 * 
	 * @param sql
	 *            SQL查询语句
	 * @return 结果集
	 */
	public ResultSet doSelect(String sql, Date aDate) throws DalException {
		return doSelect(sql, new DatePreProcesser(aDate));
	}

	/**
	 * 执行 SQL 查询命令
	 * 
	 * @param sql
	 *            SQL查询语句
	 * @param dates
	 *            一组日期
	 * @return 记录集
	 */
	public ResultSet doSelect(String sql, Date[] dates) throws DalException {
		return doSelect(sql, new DatePreProcesser(dates));
	}

	/**
	 * 执行 SQL 查询命令
	 * 
	 * @param sql
	 *            SQL查询语句
	 * @param dates
	 *            一组日期
	 * @return 记录集
	 */
	public ResultSet doSelect(String sql, List<Date> dates) throws DalException {
		return doSelect(sql, new DatePreProcesser(dates));
	}

	/**
	 * 执行一批命令
	 * 
	 * @param arrSqls
	 *            命令数组
	 */
	/**
	 * 清除历史记录的Statement
	 */
	public void clearHistory() {
		synchronized (historyStatements) {
			for (ResultSet rs : historyResultSets) {
				try {
					rs.close();
				} catch (Exception ex) {
				}
			}
			historyResultSets.clear();

			for (Statement s : historyStatements) {
				try {
					s.close();
				} catch (Exception ex) {
				}
			}
			historyStatements.clear();
		}
	}

	/**
	 * 执行存储过程（对 SQL Server而言）(未实现)
	 * 
	 * @param spName
	 *            存储过程名称
	 * @param spParams
	 *            存储过程的参数
	 */
	public void execStoreCommand(String spName, String spParams)
			throws DalException {
		throw new DalException(" store Command is not supported by "
				+ getClass().getName());
	}

	/**
	 * 取得连接对象
	 * 
	 * @return 连接对象
	 */
	public Connection getConnection() throws DalException {
		ensureConnected();
		return conn;
	}

	/**
	 * 关闭连接串
	 */
	public void closeConnection() {
		clearHistory();
		try { // an exception would be shrown here, I try to catch it!
			if (conn != null) { // start of if
				doCloseConnection(conn);
			} // end of if
		} catch (Exception ex) { //
			// ex.printStackTrace(); // Print Stack Trace
		} // end of catch
		finally {
			conn = null;
		}
	}

	protected void doCloseConnection(Connection c) throws SQLException {
		c.close();
	}

	/**
	 * 取得最后执行的一条 SQL 语句
	 * 
	 * @return 通过 DAL 执行的最后一条 SQL 语句
	 */
	public String getLastSql() {
		return lastSql;
	}

	/**
	 * 确保当前有连接对象：如果没有的话，创建一个连接对象
	 * 
	 * @throws DalException
	 */
	private void ensureConnected() throws DalException {
		try {
			if (conn == null || conn.isClosed()) { // 如果当前没有连接对象，那么创建连接对象
				conn = openConnection();
			} // end of if
		} catch (SQLException ex) {
			throw new DalException(this, ex, "Fail to Connect To Database");
		} // end of catch
	}

	/**
	 * 获取连接对象
	 * 
	 * @return
	 * @throws ConnectFailException
	 */
	protected Connection openConnection() throws ConnectFailException {
		return cg.getConnection();
	}

	public void finalize() {
		closeConnection();
	}

	/**
	 * 取得连接生成器
	 */
	public ConnectionGenerator getConnectionGenerator() {
		return cg;
	}

	private void doLog(Throwable t, String msg) {
		logger.error(msg, t);

	}

	private void logSucc(String sql) {
		logger.info(sql + "? SUCCESS");
	}

	private void logFail(Throwable t, String sql) {
		doLog(t, sql + "? FAILUER");
	}

	public String toString() {
		return "AbstractDal\r\nConnectionString: " + cg.getConnString()
				+ "\r\nLast SQL: " + lastSql;
	}

	public Object clone() {
		try {
			AbstractDal dal = (AbstractDal) super.clone();
			dal.conn = null;
			dal.historyResultSets = new LinkedList<ResultSet>();
			dal.historyStatements = new LinkedList<Statement>();
			return dal;
		} catch (Exception ex) {
			// ex.printStackTrace();
			logger.error("Cannot Clone the Dal", ex);
		}
		return new AbstractDal(this.cg);
	}

	public void setFetchSize(int fetchSize) {
		if (fetchSize < 1) {
			fetchSize = 20; //如果要获取的记录数量小于1，那么默认设置为20
		}
		
		this.fetchSize = fetchSize;
	}
}


3、DAO实现类（连接池）

/*
 * @(#)
 *
 * Copyright bigNing(javaning@sina.com, 2003.06.01
 */
package com.bigning.db.pool;

import java.sql.Connection;
import java.sql.SQLException;


import com.bigning.db.*;

/**
* 可缓冲的数据访问层
*/
public class  PoolableComDal extends AbstractDal implements ComDal {
	/**
	 * Comment for <code>serialVersionUID</code>
	 */
	private static final long serialVersionUID = 3546923576121899056L;

	/**
	 * 默认的连接关闭监听器
	 * 关闭连接 -- 非缓冲 
	 * @author fantasy
	 *
	 */
	private static class CloseConnReleaseListener implements ConnReleaseListener{

		/* (non-Javadoc)
		 * @see bigning.db.pool.ConnReleaseListener#connReleased(bigning.db.pool.ConnReleaseEvent)
		 */
		public void connReleased(ConnReleaseEvent cre) {
			Connection c=cre.getConnection();
			try{
				c.close();
			}
			catch (Throwable e ){}
		}
		
	}
	//默认的连接关闭监听器
	private static final ConnReleaseListener DEFAULT_LISTENER=new CloseConnReleaseListener();
	// 连接关闭监听器
	private ConnReleaseListener listener;
	/**
	 * 构造缓冲的数据访问层
	 * @param cg 连接生成器
	 * @param lsnr 连接关闭监听器
	 */
	public PoolableComDal(PoolableConnectionGenerator cg,ConnReleaseListener lsnr) {
		super(cg);
		if(lsnr==null){
			lsnr=DEFAULT_LISTENER;
		}
		listener=lsnr;
	}
	/**
	 * 构造普通的数据访问层
	 * @param cg 连接生成器
	 */
	public PoolableComDal(PoolableConnectionGenerator cg) {
		this(cg,DEFAULT_LISTENER);
	}
	public void setConnReleaseListener(ConnReleaseListener listener) {
		if(listener==null){
			listener=DEFAULT_LISTENER;
		}
		this.listener=listener;
	}
	/**
	 * 移除连接关闭监听器, 并使用默认监听器
	 * @return 当前使用的监听器
	 */
	public ConnReleaseListener removeConnReleaseListener() {
		ConnReleaseListener l=listener;
		listener=DEFAULT_LISTENER;
		return l;
	}

	/**
	 * 关闭连接串
	 * @throws SQLException
	 */
	protected  void doCloseConnection(Connection c) throws SQLException{
		listener.connReleased(new ConnReleaseEvent(this,c));
	}

}


总结

所有的关于持久层的实现或者说思想原理什么的，都是围绕着DAO的2大功能（即增删查改功能和获取/关闭连接对象）来实现的。


以DAO为核心，其他的无非是连接池的运用，各种工厂类的运用（即设计模式的运用）…………等等。

转载于:https://my.oschina.net/diedai/blog/533085

数据持久层DAO的建立和使用，实现数据库的连接
桑安琪的成长之路
02-03 1万+
//DAO接口 package ex3; import java.sql.Connection; public interface DAO { public Connection getConnection();//声明连接方法 }//StudentDAO接口 package ex3; import java.util.List; public interface StudentDAO{
Mybatis-03：实现DAO持久层
ZhaoGX_156的博客
02-08 398
Mybatis实现DAO持久层的基本介绍，实现流程，动态SQL语句的实现方法简介。
持久层Dao
qq_42264638的博客
09-15 2875
一、系统的开发架构 客户层-------显示层-------业务层---------数据层---------数据库 1.客户层：客户层就是客户端，简单的来说就是浏览器。 2.显示层：JSP/Servlet，用于给浏览器显示。 3.业务层：对于数据层的原子操作进行整合。 4.数据层：对于数据库进行的原子操作，增加、删除等； 二、DAO(Data Access Object)介绍 DAO应用在数据层那...
自定义持久层(dao)框架
sc6231565的专栏
05-29 1056
2. 自定义持久层(dao)框架 更新案例：(insert/update/delete) 1.       加载驱动 2.       获取连接 3.       创建pstmt对象 4.      执行sql：  pstmt.executeUpdate(); 5.      关闭   查询：(select) 1.       加载驱动 2.       获取连接 3.   
三层:控制层（Controller） 服务层（Service） 持久层（Repository 或 DAO）的理解
m0_59281987的博客
04-17 6103
持久层的主要作用是执行数据的持久化和检索，以及管理数据的事务。控制器负责接收和处理用户请求，服务层负责实现业务逻辑，持久层负责与数据存储交互，三者共同协作完成应用程序的功能。`@Controller`、`@Service` 和持久层（通常使用 `@Repository` 或者 `@DAO`）就是这种划分的一部分。在这个例子中，`UserRepository` 是一个持久层接口，它继承了 Spring Data 提供的 `CrudRepository` 接口，用于对用户数据进行 CRUD 操作。
Java持久层之DAO开发模式
MOOG007的博客
08-08 259
文章目录 DAO开发模式
自动生成mysql持久层dao，实体类及映射文件mapper
08-23
本压缩包"mysql_generator"正是提供了这样一个功能，它能帮助我们自动生成MySQL的持久层DAO（Data Access Object）、实体类以及映射文件Mapper。 首先，我们需要了解DAO模式。DAO模式是一种常用的设计模式，它的...
Hibernate 基于持久层框架的DAO模式应用
04-20
在基于持久层框架的DAO（Data Access Object）模式应用中，Hibernate扮演着核心角色，使得业务逻辑和数据访问逻辑分离，提高了代码的可复用性和可维护性。 1. **DAO模式的理解** DAO模式是一种设计模式，它创建了...
DAO层为什么叫持久层
最新发布
05-11
好的，用户想知道DAO层为什么被称为持久层。首先，我需要回顾一下DAO的定义和它在分层架构中的位置。根据引用[1]和[2]，DAO层是数据访问对象，负责与数据库交互，属于持久化层。那“持久化”具体指什么呢？持久化...
action层，dao层 ，service层，entity层1
08-08
在Java中，这些类通常被标记为`@Entity`，并使用JPA或Hibernate等ORM框架进行映射，以便于在Service层与DAO层之间传输和持久化数据。 5. **Util层（工具层）**： 这一层包含了一些通用的工具类和静态方法，比如...
自动生成持久层代码工具
06-06
"自动生成持久层代码工具"正是这样一个解决方案，旨在帮助开发者快速地生成实体类、DAO层以及对应的XML配置文件，从而避免繁琐的手动编写过程。这个工具基于Java语言，利用其强大的面向对象特性和丰富的库资源，可以...
持久层dao设计模式
xiaocai9999的专栏
09-03 1767
开发中持久层帮助我们与数据库打交道，尤为重要。那么今天我们就简单设计一个dao模式。 准备工作：我们选用hibernate作为持久层，关于hibernate环境搭建应该都会在这里不多说。比如我们创建一个student类，关于配置如下： 我们定义一个通用的dao接口，满足一般的增删改查如下： 然后我们创建一个basedao供我们业务层调用，并且实现我们dao接口，因为based
SSH--------持久层(dao)、Service和表现层(web)的设计---抽取避免重复代码
qq_32659773的博客
04-28 348
持久层接口设计（Dao） 持久层设计图解和原理 这里以User表的数据库设计为例 每一张表都有共同的数据库操作，如增删改查，所以IBaseDao, BaseDaoImpl中可以放置公有的方法或者属性 每 一张表都有自己的特有的业务，所以IUserDao里的方法是属于特有的 这样做代码的扩展性，健壮性比较好 代码：IBaseDao ...
数据持久化层和DAO层的关系
woshiliulei0的专栏
02-18 1万+
DAO =Data Access Objects，也就是所谓的数据访问对象，这个对象是和数据打交道的，当然是持久化层的。目前通用的是dao是数据层，也可以说为持久化层，service是逻辑层，也可以叫服务层。 首先这是现在最基本的分层方式，结合了SSH架构。modle层就是对应的数据库表的实体类。Dao层是使用了Hibernate连接数据库、操作数据库（增删改查）。Service层：引用对应的D
表现层 业务层 持久层 web层 service层 dao层的相关概念描述
dslluoye的博客
03-11 5658
我们的架构一般分为两种， 一种是C/S（客户端/服务器），另一种是B/S（浏览器/服务器）。 在我接下来学习的SpringMVC种，几乎都是B/S架构开发的。 其标准的三层架构中，一般分为：表现层，业务层和持久层。 表现层： 表现层又被称为web层，主要负责接受客户端的请求，向客户端发送请求结果。 而表现层又包括展示层和控制层，展示层负责结果的展示，控制层负责接受请求。 表现层依赖业务层，接受到客户端请求一般会调用业务层进行业务信息处理，然后再把结果相应给客户端，。 MVC模...
一、数据持久层Dao层代码的演变
weixin_45602227的博客
03-31 434
一、开发回顾 Struts：基于mvc模式的web层的框架。 Hibernate:基于持久层的框架（数据持久层） 二、Dao层代码的演变 1.操作XML,使用XML作为数据库。 2.使用JDBC技术 a.使用JDBC1.0的API(最原始的jdbc操作。Connectiin/ResultSet/Statement) 数据连接...
Dao层和Mapper层
double222222的博客
12-17 4127
层和 （Data Access Object）层是在持久层中用于处理数据访问的两个概念。虽然这两者的目的都是用于访问数据库，但它们之间有一些区别。在Java开发中，这两个概念通常与MyBatis（或其他ORM框架）结合使用。目录Mapper层：DAO层：对比 其实用起来二者一样 定义：职责：注解：示例： 定义：职责：注解：示例： 对比 技术栈：灵活性：命名规范：在实际项目中， 层和 层有时会交替使用或者同时存在，具体的选择会根据项目的需求、技术栈和团队的开发习惯而定。在使用 MyB
DAO层、ENTITY层、SERVICE层、CONTROLLER层个人的理解分析
热门推荐
Wpan的博客
03-28 3万+
DAO层、ENTITY层、SERVICE层、CONTROLLER层 1、DAO层： 持久层  主要与数据库进行交互    DAO层主要是做数据持久层的工作，主要与数据库进行交互。DAO层首先会创建DAO接口，然后会在配置文件中定义该接口的实现类，    接着就可以在模块中就可以调用DAO 的接口进行数据业务的而处理，并且不用关注此接口的具体实现类是哪一个类。DAO 层的数据源
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值