dao模式

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

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

DAO模式的作用

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

DAO模式的组成部分

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

方便修改。

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 表中的属性列表（键和元素对）写入输出流。

DAO 模式
原文链接https://www.runoob.com/note/27029

原文链接https://www.runoob.com/note/27029
DAO (DataAccessobjects 数据存取对象)是指位于业务逻辑和持久化数据之间实现对持久化数据的访问。通俗来讲，就是将数据库操作都封装起来。
对外提供相应的接口
在面向对象设计过程中，有一些"套路”用于解决特定问题称为模式。

DAO 模式提供了访问关系型数据库系统所需操作的接口，将数据访问和业务逻辑分离对上层提供面向对象的数据访问接口。
从以上 DAO 模式使用可以看出，DAO 模式的优势就在于它实现了两次隔离。
1、隔离了数据访问代码和业务逻辑代码。业务逻辑代码直接调用DAO方法即可，完全感觉不到数据库表的存在。分工明确，数据访问层代码变化不影响业务逻辑代码,这符合单一职能原则，降低了藕合性，提高了可复用性。

2、隔离了不同数据库实现。采用面向接口编程，如果底层数据库变化，如由 MySQL 变成 Oracle 只要增加 DAO 接口的新实现类即可，原有 MySQ 实现不用修改。这符合 “开-闭” 原则。该原则降低了代码的藕合性，提高了代码扩展性和系统的可移植性。

一个典型的DAO 模式主要由以下几部分组成。
1、DAO接口： 把对数据库的所有操作定义成抽象方法，可以提供多种实现。

2、DAO 实现类： 针对不同数据库给出DAO接口定义方法的具体实现。

3、实体类：用于存放与传输对象数据。

4、数据库连接和关闭工具类： 避免了数据库连接和关闭代码的重复使用，方便修改。
DAO 接口:

public interface PetDao {
    /**
     * 查询所有宠物
     */
    List<Pet> findAllPets() throws Exception;
}
DAO 实现类:

public class PetDaoImpl extends BaseDao implements PetDao {
    /**
     * 查询所有宠物
     */
    public List<Pet> findAllPets() throws Exception {
        Connection conn=BaseDao.getConnection();
        String sql="select * from pet";
        PreparedStatement stmt= conn.prepareStatement(sql);
        ResultSet rs=    stmt.executeQuery();
        List<Pet> petList=new ArrayList<Pet>();
        while(rs.next()) {
            Pet pet=new Pet(
                    rs.getInt("id"),
                    rs.getInt("owner_id"),
                    rs.getInt("store_id"),
                    rs.getString("name"),
                    rs.getString("type_name"),
                    rs.getInt("health"),
                    rs.getInt("love"),
                    rs.getDate("birthday")
                    );
                petList.add(pet);
        }
        BaseDao.closeAll(conn, stmt, rs);
        return petList;
    }
}

宠物实体类(里面get/set方法就不列出了)

public class Pet {
    private Integer id;    
    private Integer ownerId;    //主人ID
    private Integer storeId;    //商店ID
    private String name;    //姓名
    private String typeName;    //类型
    private int health;    //健康值
    private int love;    //爱心值
    private Date birthday;    //生日
}

连接数据库

public class BaseDao {
    private static String driver="com.mysql.jdbc.Driver";
    private static String url="jdbc:mysql://127.0.0.1:3306/epet";
    private static String user="root";
    private static String password="root";
        static {
            try {
                Class.forName(driver);
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
        
    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection(url, user, password);    
    }
    
    public static void closeAll(Connection conn,Statement stmt,ResultSet rs) throws SQLException {
        if(rs!=null) {
            rs.close();
        }
        if(stmt!=null) {
            stmt.close();
        }
        if(conn!=null) {
            conn.close();
        }
    }
    

    public int executeSQL(String preparedSql, Object[] param) throws ClassNotFoundException {
        Connection conn = null;
        PreparedStatement pstmt = null;
        /* 处理SQL,执行SQL */
        try {
            conn = getConnection(); // 得到数据库连接
            pstmt = conn.prepareStatement(preparedSql); // 得到PreparedStatement对象
            if (param != null) {
                for (int i = 0; i < param.length; i++) {
                    pstmt.setObject(i + 1, param[i]); // 为预编译sql设置参数
                }
            }
        ResultSet num = pstmt.executeQuery(); // 执行SQL语句
        } catch (SQLException e) {
            e.printStackTrace(); // 处理SQLException异常
        } finally {
            try {
                BaseDao.closeAll(conn, pstmt, null);
            } catch (SQLException e) {    
                e.printStackTrace();
            }
        }
        return 0;
    }
    }

Dao模式

Data Access Object 数据访问对象

步骤：

1.新建一个dao的接口， 里面声明数据库访问规则

2.新建一个dao的实现类，具体实现早前定义的规则

3.直接使用实现

 

实现代码：

1.新建一个dao的接口， 里面声明数据库访问规则

UserDao.java

package com.itheima.dao;	
   /**
	 * 定义操作数据库的方法
	 */
	public interface UserDao {
	
		/**
		 * 查询所有
		 */
		void findAll();
	}

2.新建一个dao的实现类，具体实现早前定义的规则

UserDaoImp.java

package com.itheima.implement;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.PreparedStatement;

import com.itheima.dao.UserDao;
import com.itheima.util.JDBCUtil;

public class UserDaoImpl implements UserDao{

	@Override
	public void findAll() {
		Connection conn = null;
		PreparedStatement st = null;
		ResultSet rs = null;
		try {
			//1. 获取连接对象
			conn = JDBCUtil.getConn();
			//2. 创建PreparedStatement对象
            String sql = "select * from t_user";
			ps =conn.prepareStatement(sql);
			
			rs = ps.executeQuery();
			
			while(rs.next()){
				String userName = rs.getString("username");
				String password = rs.getString("password");
				
				System.out.println(userName+"="+password);
			}
			
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			JDBCUtil.release(conn, ps, rs);
		}
	}

}

3.直接使用实现

TestUserDaoImp.java

package com.itheima.test;

import org.junit.Test;

import com.itheima.dao.UserDao;
import com.itheima.implement.UserDaoImp;

public class TestUserDaoImp {

	/*
	 * public static void main(String[] args) { UserDao dao = new UserDaoImp();
	 * dao.query(); }
	 */

//使用junit单元测试
	@Test
	public void testQuery() {
		UserDao dao = new UserDaoImp();
		dao.query();

	}

}

 JDBCUtil.java

package com.itheima.util;

import java.io.FileInputStream;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.PreparedStatement;

import java.sql.SQLException;
import java.util.Properties;

public class JDBCUtil {

	static String driverClass = null;
	static String url = null;
	static String name = null;
	static String password = null;

	static {
		try {
			// 1.创建一个属性配置对象
			Properties properties = new Properties();
			//将jdbc.properties
			InputStream is = new FileInputStream("jdbc.properties");
			
			/*将jdbc.properties文件放到src文件夹下用此方法
			 * 使用类加载器，去读取src底下的资源文件
			InputStream is = JDBCUtil.class.getClassLoader().getResourceAsStream("jdbc.properties");
			*/
			// 导入输入流
			properties.load(is);

			// 读取属性
			driverClass = properties.getProperty("driverClass");
			url = properties.getProperty("url");
			name = properties.getProperty("name");
			password = properties.getProperty("password");
		    

		} catch (Exception e) {
             e.printStackTrace();
		}
	}

	/**
	 * 获取连接对象
	 * 
	 * @return
	 */
	public static Connection getConn() {
		Connection conn = null;
		try {
			// 1.注册驱动
			Class.forName(driverClass);
			// 2.建立连接
			conn = DriverManager.getConnection(url, name, password);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return conn;

	}

	/**
	 * 释放资源
	 * 
	 * @param conn
	 * @param ps
	 * @param rs
	 */
	public static void release(Connection conn, PreparedStatement ps, ResultSet rs) {
		closeRs(rs);
		closePs(ps);
		closeConn(conn);
	}

	private static void closeRs(ResultSet rs) {
		try {
			if (rs != null) {
				rs.close();
			}
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			rs = null;
		}
	}

	private static void closePs(PreparedStatement ps) {
		try {
			if (ps != null) {
				ps.close();
			}
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			ps = null;
		}
	}

	private static void closeConn(Connection conn) {
		try {
			if (conn != null) {
				conn.close();
			}
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			conn = null;
		}
	}

}


 jdbc.properties

driverClass = com.mysql.jdbc.Driver
url = jdbc:mysql://localhost/user
name = root
password = 123456