DAO模式

最新推荐文章于 2024-03-25 14:09:30 发布
最新推荐文章于 2024-03-25 14:09:30 发布
阅读量535 收藏 2
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45649283/article/details/106552772
版权

DAO模式

DAO 是指位于业务逻辑和持久化数据之间实现对持久化数据的访问。通俗来讲，就是将数据库操作都封装起来。

  1. 位于业务逻辑和持久化数据之间
  2. 实现对持久化数据的访问

DAO模式的作用

  1. 隔离业务逻辑代码和数据访问代码
  2. 隔离不同数据库的实现

DAO模式的组成部分

  1. DAO接口： 把对数据库的所有操作定义成抽象方法，可以提供多种实现。
  2. DAO 实现类： 针对不同数据库给出DAO接口定义方法的具体实现。
  3. 实体类：用于存放与传输对象数据。
  4. 数据库连接和关闭工具类： 避免了数据库连接和关闭代码的重复使用，
    方便修改。

DAO模式的实际应用

package dbqn.dao.impl;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.apache.log4j.Logger;
public class BaseDao {
 private String driver = "com.mysql.jdbc.Driver";
 private String url = "jdbc:mysql://localhost:3306/mybook?useUnicode=true&characterEncoding=utf8";
 private String user="root";
 private String password="123456";
 private static Logger logger = Logger.getLogger(BaseDao.class.getName());
 /**
  * 连接数据库
  * 
  * @return
  */
 public Connection getConnection() {
  try {
   Class.forName(driver);
   Connection conn = DriverManager.getConnection(url, user, password);
   return conn;
  } catch (ClassNotFoundException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
   logger.error(e);
  } catch (SQLException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
   logger.error(e);
  }
  return null;
 }
 /**
  * 关闭数据库
  * 
  * @param conn
  * @param stmt
  * @param rs
  * @param stat
  */
 public void closeAll(Connection conn, Statement stmt, ResultSet rs, PreparedStatement stat) {
  if (conn != null)
   try {
    conn.close();
   } catch (SQLException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
    logger.error(e);
   }
  if (stmt != null)
   try {
    stmt.close();
   } catch (SQLException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
    logger.error(e);
   }
  if (rs != null)
   try {
    rs.close();
   } catch (SQLException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
    logger.error(e);
   }
  if (stat != null)
   try {
    stat.close();
   } catch (SQLException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
    logger.error(e);
   }
 }
 /**
  * 增删改
  * 
  * @param sql
  * @param objects
  * @return
  */
 public int executeUpdate(String sql, Object... objects) {
  Connection conn = this.getConnection();
  PreparedStatement pstmts = null;
  try {
   pstmts = conn.prepareStatement(sql);
   for (int i = 0; i < objects.length; i++) {
    pstmts.setObject(i + 1, objects[i]);
   }
   return pstmts.executeUpdate();
  } catch (SQLException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
   logger.error(e);
  } finally {
   this.closeAll(conn, null, null, pstmts);
  }
  return 0;
 }
 public List<Map<Object,Object>> executeselect(String sql){
  Connection conn = this.getConnection();
  PreparedStatement pstmts = null;
  ResultSet rs=null;
  List<Map<Object,Object>> list = new ArrayList<Map<Object,Object>>();
  try {
   pstmts=conn.prepareStatement(sql);
   rs=pstmts.executeQuery();
   ResultSetMetaData md = rs.getMetaData();
      int columnCount = md.getColumnCount();
   while (rs.next()) {
    Map<Object,Object> rowData = new HashMap<Object,Object>();
             for (int i = 1; i <= columnCount; i++) {
                 rowData.put(md.getColumnName(i), rs.getObject(i));
             }
             list.add(rowData);
   }
   return list;
  } catch (SQLException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
   logger.error(e);
  }finally {
   this.closeAll(conn, null, rs, pstmts);
  }
  return null;
 }
}
package dbqn.dao.impl;
import java.sql.Connection;
import java.sql.Date;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import org.apache.log4j.Logger;
import dbqu.dao.BookDao;
import dbqu.entity.Book;
import dbqu.urltrafm.transformation;
public class BookDaoImpl extends BaseDao implements BookDao{
 transformation  trforma=new transformation();
 private static Logger logger = Logger.getLogger(BaseDao.class.getName());
 @Override
 public int addBook(Book book) {
  // TODO Auto-generated method stub
  String sql ="insert into book values(?,?,?,?,?,?,?)";
  return super.executeUpdate(sql, book.getBib(),book.getbName(),book.getAuthor(),book.getPubComp(),book.getPubDate(),book.getInCount(),book.getPrice());
 }
 @Override
 public int delBook(int id) {
  // TODO Auto-generated method stub
  String sql="delete from book where bid=?";
  return super.executeUpdate(sql, id);
 }
 @Override
 public int updateBook(Book book) {
  // TODO Auto-generated method stub
  String sql="update book set bName=?,author=?,pubComp=?,pubDate=?,inCount=?,price=? where bib=?";
  return super.executeUpdate(sql,book.getbName(),book.getAuthor(),book.getPubComp(),book.getPubDate(),book.getInCount(),book.getPrice(),book.getBib());
 }
 @Override
 public List<Book> getAll() {
  // TODO Auto-generated method stub
  List<Book> list=new ArrayList<Book>();
  String sql="select * from book";
  Book book;
  List<Map<Object,Object>> alist=super.executeselect(sql);
  for(Map<Object, Object> str : alist) {
    book=new Book();
    book.setBib((int)str.get("bid"));
    book.setbName((String)str.get("bname"));
    book.setAuthor((String)str.get("author"));
    book.setPubComp((String)str.get("pubcomp"));
    Date date=null;
    try {
     date = trforma.dateChange((str.get("pubDate")));
    } catch (ParseException e) {
     // TODO Auto-generated catch block
     e.printStackTrace();
     logger.error(e);
    }
    book.setPubDate(date);
    book.setInCount((int)str.get("inCount"));
    Double price= trforma.douNumber(str.get("price"));
    book.setPrice(price);
    list.add(book);
  }
  return list;
//  Connection conn = super.getConnection();
//  PreparedStatement pstmts = null;
//  ResultSet rs=null;
//  try {
//   pstmts=conn.prepareStatement(sql);
//   rs=pstmts.executeQuery();
//   while (rs.next()) {
//    book=new Book();
//    book.setBib(rs.getInt ("bid"));
//    book.setbName (rs.getString ("bname"));
//    book.setAuthor (rs.getString ("author"));
//    book.setPubComp (rs.getString ("pubcomp"));
//    book.setPubDate(rs.getDate("pubDate"));
//    book.setInCount (rs.getInt ("inCount"));
//    book.setPrice (rs.getDouble ("price"));
//    list.add(book);
//   }
//   return list;
//  } catch (SQLException e) {
//   // TODO Auto-generated catch block
//   e.printStackTrace();
//  }finally {
//   super.closeAll(conn,null,rs,pstmts);
//  }
//  return null;
 }
 }
package dbqu.dao;
import java.util.List;
import dbqu.entity.Book;
public interface BookDao {
 /**
  * 增加
  * @param book
  * @return
  */
 public int addBook(Book book);
 /**
  * 删除
  * @param id
  * @return
  */
 public int delBook(int id);
 /**
  * 更新
  * @param book
  * @return
  */
 public int updateBook(Book book);
 /**
  * 查询
  * @return
  */
 public List<Book> getAll();
}

package  dbqu.entity;
import java.sql.Date;
public class Book {
 private int bib;
 private String bName;
 private String author;
 private String pubComp;
 private Date pubDate;
 private int inCount;
 private double price;
 public Book() { 
 }
 public Book(int bib, String bName, String author, String pubComp, Date pubDate, int inCount, double price) {
  this.bib = bib;
  this.bName = bName;
  this.author = author;
  this.pubComp = pubComp;
  this.pubDate = pubDate;
  this.inCount = inCount;
  this.price = price;
 }
 public int getBib() {
  return bib;
 }
 public void setBib(int bib) {
  this.bib = bib;
 }
 public String getbName() {
  return bName;
 }
 public void setbName(String bName) {
  this.bName = bName;
 }
public String getAuthor() {
  return author;
 }
 public void setAuthor(String author) {
  this.author = author;
 }
  public String getPubComp() {
  return pubComp;
 }
public void setPubComp(String pubComp) {
  this.pubComp = pubComp;
 }
 public Date getPubDate() {
  return pubDate;
 }
 public void setPubDate(Date pubDate) {
  this.pubDate = pubDate;
 }
 public int getInCount() {
  return inCount;
 }
 public void setInCount(int inCount) {
  this.inCount = inCount;
 }
 public double getPrice() {
  return price;
 }
 public void setPrice(double price) {
  this.price = price;
 }
 @Override
 public String toString() {
  return "Book [bib=" + bib + ", bName=" + bName + ", author=" + author + ", pubComp=" + pubComp + ", pubDate="
    + pubDate + ", inCount=" + inCount + ", price=" + price + "]";
 }
 }
package dbqu.urltrafm;
import java.sql.Date;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import org.apache.log4j.Logger;
public class transformation {
 private static Logger logger = Logger.getLogger(transformation.class.getName());
 public Date dateChange(Object object) throws ParseException {
  String ostr=object.toString();
 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
 java.util.Date ACDate;
 Date dd = null;
 try {
  ACDate = sdf.parse(ostr);
  dd = new Date(ACDate.getTime());
 } catch (ParseException e) {
  // TODO Auto-generated catch block
  e.printStackTrace();
  logger.error(e);
 }
 return dd;
 }
 public Double douNumber(Object object) { 
  return Double.parseDouble(object.toString());
 }
}
package bdqu.test;
import java.util.List;
import org.junit.jupiter.api.Test;
import dbqn.dao.impl.BookDaoImpl;
import dbqu.dao.BookDao;
import dbqu.entity.Book;
class TestBook {
@Test
 void testQuery() {
  BookDao bookdao=new BookDaoImpl();
  List<Book> list=bookdao.getAll();
  for(Book book:list) {
   System.out.println(book);
  }
 }
 }

运行结果如下：
Book [bib=1001, bName=null, author=韩国欧巴, pubComp=null, pubDate=2020-04-23, inCount=306, price=100.0]
Book [bib=1002, bName=null, author=日本花姑娘, pubComp=null, pubDate=2020-04-23, inCount=200, price=50.0]
Book [bib=1003, bName=null, author=嘿嘿, pubComp=null, pubDate=2020-01-02, inCount=99, price=60.0]
Book [bib=1004, bName=null, author=wi, pubComp=null, pubDate=2020-04-24, inCount=101, price=30.0]

Properties 类

Properties 继承于 Hashtable.表示一个持久的属性集.属性列表中每个键及其对应值都是一个字符串。
Properties 类被许多Java类使用。

String getProperty(String key)用指定的键在此属性列表中搜索属性。
String getProperty(String key, String defaultProperty)用指定的键在属性列表中搜索属性。
void list(PrintStream streamOut)将属性列表输出到指定的输出流。
void list(PrintWriter streamOut)属性列表输出到指定的输出流。
void load(InputStream streamIn) throws IOException从输入流中读取属性列表（键和元素对）。
Enumeration propertyNames( )按简单的面向行的格式从输入字符流中读取属性列表（键和元素对）。
Object setProperty(String key, String value)调用 Hashtable 的方法 put。
void store(OutputStream streamOut, String description)以适合使用 load(InputStream)方法加载到 Properties 表中的格式，将此 Properties 表中的属性列表（键和元素对）写入输出流。
~plus～
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
数据库-DAO模式
m0_48081612的博客
06-29 1363
DAO模式是指数据访问对象模式，它是一种用于封装和抽象数据库操作的设计模式，它将数据访问逻辑和业务逻辑分离，提高了代码的可维护性和可重用性。DAO模式可以用于开发各种基于数据库的Java应用程序，例如Web应用、桌面应用、移动应用等。DAO模式中包括了DAO接口、DAO实现类、实体类、数据库连接工具类等组件，它们协同工作，实现对数据库的增删改查操作。DAO模式可以支持多种类型的数据库，例如MySQL、Oracle、SQL Server等，只需更换相应的DAO实现类即可。
什么是DAO模式？
weixin_34414196的博客
07-25 1909
DAO（Data Access Object）顾名思义是一个为数据库或其他持久化机制提供了抽象接口的对象，在不暴露底层持久化方案实现细节的前提下提供了各种数据访问操作。在实际的开发中，应该将所有对数据源的访问操作进行抽象化后封装在一个公共API中。用程序设计语言来说，就是建立一个接口，接口中定义了此应用程序中...
DAO 模式 详解
编程大白菜
10-25 1万+
DAO模式 DAO（Data Access Object）数据访问对象。主要的功能就是用于进行数据操作的，在程序的标准开发架构中属于数据层的操作 先来看基本的架构分层 企业分层架构： 客户层：B/S结构都使用浏览器，C/S结构则是一个客户端 显示层：使用JSP/Servlet进行页面效果的显示 业务层：（Business Object，业务对象）：会将多个原子性的DAO操作进行组合，组合成一个完整的业务逻辑。 数据层（DAO）：提供多个原子性的DAO操作（数据持久化操作），例如：增加、修改、删除等，都属于
dao模式简介
最新发布
m0_59716343的博客
03-25 301
通过使用DAO模式，应用程序可以将数据访问逻辑封装在DAO实现类中，使得业务逻辑层只需要调用DAO的方法，而不需要关心具体的数据访问实现细节。这样，当需要更换数据访问技术时，只需要修改DAO实现类而不影响业务逻辑层的代码。它的主要目的是将数据访问逻辑从业务逻辑中分离出来，使得数据访问操作更加灵活、可复用和可维护。在DAO模式中，数据访问对象（DAO）是一个接口或类，用于定义可以被应用程序使用的各种数据访问操作。它隐藏了数据访问细节，提供了对数据的增删改查等基本操作的统一接口。
dao模式开发
12-05
dao模式的实现 及数据库介绍
使用DAO模式实现宠物数据更新
03-26
在本例中，我们将探讨如何使用DAO模式来实现宠物数据的更新功能。 首先，DAO模式的基本结构包括以下几个部分： 1. **实体类（Entity）**：在这里，我们可以创建一个`Pet`类，它代表宠物对象，包含宠物的相关属性如...
DAO模式设计
03-01
DAO模式的核心思想是通过创建一个独立于具体数据库操作的对象（即DAO），来封装对数据库的访问细节，这样可以使得业务代码不直接依赖于具体的数据库API，提高了代码的可测试性和可维护性。 在现代Java应用中，尤其...
DAO.rar_dao模式怎么写
09-14
本文将深入探讨DAO模式的原理、实现步骤以及注意事项。 一、DAO模式的概念 DAO模式的主要目的是提供一个独立于应用程序的数据访问接口。它创建了一个数据访问的对象，该对象负责处理所有与数据库相关的操作，如...
Java Web实验六 采用 DAO 模式实现对数据库的访问方法， 利用 Servlet 实现 MVC 模式
12-15
首先，DAO模式是一种用于分离业务逻辑层与数据访问层的模式。在该模式中，DAO类作为数据存取的接口，负责处理与数据库的所有交互。这样做的好处在于，业务逻辑层不必直接与数据库进行通信，而是通过调用DAO的方法，...
DAO模式实现增加删除修改操作
07-17
DAO模式实现增加删除修改操作.rar
什么是持久化？持久化的主要操作？DAO模式由哪几部分组成？
wly212638的博客
09-23 1873
持久化：讲数据存入数据库中，将数据库中的数据读取出来的过程，称之为持久 持久化是将程序中的数据在瞬时状态和持久状态间转换的机制 持久化的主要操作：读取，删除，修改，查找等 DAO模式 DAO层：数据访问层实现数据库数据操作，实现对持久化数据的访问 DAO层的作用：隔离业务逻辑代码和数据访问代码，隔离不同数据库的实现 DAO层的组成：接口，接口实现类，实体类，数据库连接工具（BaseDao：jdbc封装类） DAO层实际应用 编写实体类对象 ...
数据持久化层和DAO层的关系
热门推荐
woshiliulei0的专栏
02-18 1万+
DAO =Data Access Objects，也就是所谓的数据访问对象，这个对象是和数据打交道的，当然是持久化层的。目前通用的是dao是数据层，也可以说为持久化层，service是逻辑层，也可以叫服务层。 首先这是现在最基本的分层方式，结合了SSH架构。modle层就是对应的数据库表的实体类。Dao层是使用了Hibernate连接数据库、操作数据库（增删改查）。Service层：引用对应的D
DAO的作用
weixin_66109724的博客
12-05 1245
一个典型的DAO 模式主要由以下几部分组成。
浅谈什么是DAO模式
wind513的专栏
01-24 2355
什么是DAODAO是Data Access Object数据访问接口，数据访问：故名思义就是与数据库打交道。夹在业务逻辑与数据库资源中间。DAO的功能:1. DAO用来封装Data Source的，就比如,Connection conn = DAOFacotry.createConnection()就可以把Driver，URL，username，passpword这一些放在DAO中。
dao模式中的service
07-14
DAO模式中的Service是用来封装对DAO（Data Access Object）的操作，提供更高层次的业务逻辑处理。Service层通常包含了一系列对DAO的操作，例如数据的增删改查，以及其他的业务逻辑处理。Service层可以对DAO的操作进行组合、封装和扩展，同时也可以处理事务、异常等。 Service层的设计可以使得业务逻辑更加清晰，同时也可以提高代码的可维护性和可测试性。在多层架构中，Service层通常位于业务逻辑层和数据访问层之间，起到了协调和调度的作用。 通过Service层，我们可以将业务逻辑的处理与数据访问操作解耦，使得系统更加灵活和可扩展。此外，Service层还可以对数据进行验证和转换，保证数据的一致性和准确性。 总结来说，DAO模式中的Service层是用来封装对DAO的操作，并提供更高层次的业务逻辑处理，以提高系统的可维护性和可测试性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

~plus～

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值