DAO设计模式

梦里梦外; 2021-08-11 21:46 434阅读 0赞

# 【一】DAO简介 #

DAO（数据访问对象，Data Access Object）是指位于业务逻辑和持久化数据之间实现对持久化数据的访问。通俗来讲，就是将数据库操作都封装起来，包含了数据的增删改查操作。

DAO 模式提供了访问关系型数据库系统所需操作的接口，将数据访问和业务逻辑分离对上层提供面向对象的数据访问接口。

从以上 DAO 模式使用可以看出，DAO 模式的优势就在于它实现了两次隔离。

*  1、隔离了数据访问代码和业务逻辑代码。业务逻辑代码直接调用DAO方法即可，完全感觉不到数据库表的存在。分工明确，数据访问层代码变化不影响业务逻辑代码,这符合单一职能原则，降低了藕合性，提高了可复用性。
 *  2、隔离了不同数据库实现。采用面向接口编程，如果底层数据库变化，如由 MySQL 变成 Oracle 只要增加 DAO 接口的新实现类即可，原有 MySQ 实现不用修改。这符合 **"开-闭"** 原则。该原则降低了代码的藕合性，提高了代码扩展性和系统的可移植性。

> **一个典型的DAO 模式主要由以下几部分组成。**
> 
>  *  1、DAO接口： 把对数据库的所有操作定义成抽象方法，可以提供多种实现。
>  *  2、DAO 实现类： 针对不同数据库给出DAO接口定义方法的具体实现。
>  *  3、实体类：用于存放与传输对象数据。
>  *  4、数据库连接和关闭工具类： 避免了数据库连接和关闭代码的重复使用，方便修改。

# 【二】典型DAO模式示例 #

*  DAO接口
 *  DAO实现类
 *  DAO工厂类
 *  数据传递对象
 *  数据库连接

DAO接口：DAO接口中定义用户的增删改查操作。

package com.dao.test;
    
    import java.util.List;
    
    public interface StudentDAO {
    	public void update(String sql,Object...args);
    	public <T> T get(Class<T> clazz,String sql,Object...args);
    	public <T> List<T> getForList(Class<T> clazz,String sql,Object...args);
    	public <T> T getValue(String sql,Object...args);
    }

DAO实现类：DAO实现类通过数据库连接类操作数据库。

package com.dao.test;
    
    import java.lang.reflect.InvocationTargetException;
    import java.sql.Connection;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.sql.ResultSetMetaData;
    import java.sql.SQLException;
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    
    import org.apache.commons.beanutils.BeanUtils;
    
    import com.tool.JDBCUtils;
    
    public class StudentDAOImpl implements StudentDAO{
    
    	public void update(String sql, Object... args) {
    		Connection connection = null;
    		PreparedStatement pStatement = null;
    
    		try {
    			connection = JDBCUtils.getConnection();
    			pStatement = connection.prepareStatement(sql);
    			for (int i = 0; i < args.length; i++) {
    				pStatement.setObject(i + 1, args[i]);
    			}
    			pStatement.executeUpdate();
    		} catch (ClassNotFoundException e) {
    
    			e.printStackTrace();
    		} catch (SQLException e) {
    			e.printStackTrace();
    		} finally {
    			JDBCUtils.close(pStatement, connection);
    		}
    	}
    
    	// select:查询一条记录返回对应的对象
    	public <T> T get(Class<T> clazz, String sql, Object... args){
    		List<T> list = getForList(clazz, sql, args);
    		if (list.size() > 0) {
    			return list.get(0);
    		}
    		return null;
    	}
    	 
    
    	// 查询多条记录，返回对应的对象集合<T>
    	public <T> List<T> getForList(Class<T> clazz, String sql, Object... args){
    
    		Connection connection = null;
    		PreparedStatement pStatement = null;
    		ResultSet rSet = null;
    		List<T> list = new ArrayList<>();
    		try {
    			connection = JDBCUtils.getConnection();
    			pStatement = connection.prepareStatement(sql);
    			for (int i = 0; i < args.length; i++) {
    				pStatement.setObject(i + 1, args[i]);
    			}
    			rSet = pStatement.executeQuery();
    			List<Map<String, Object>> values = new ArrayList<>();
    			Map<String, Object> map = null;
    			ResultSetMetaData rsmData = rSet.getMetaData();
    			while (rSet.next()) {
    				map = new HashMap<>();
    				for (int i = 0; i < rsmData.getColumnCount(); i++) {
    					String columnLabel = rsmData.getColumnLabel(i + 1);
    					Object value = rSet.getObject(i + 1);
    					map.put(columnLabel, value);
    				}
    				values.add(map);
    			}
    
    			T entity = null;
    			if (values.size() > 0) {
    				for (Map<String, Object> m : values) {
    					entity = clazz.newInstance();
    					for (Map.Entry<String, Object> entry : m.entrySet()) {
    						String propertyName = entry.getKey();
    						Object value = entry.getValue();
    						BeanUtils.setProperty(entity, propertyName, value);
    					}
    					list.add(entity);
    				}
    			}
    		} catch (Exception e) {
    			e.printStackTrace();
    		} finally {
    			JDBCUtils.closeAll(rSet,pStatement, connection);
    		}
    		return list;
    	}
    
    	// 返回某一条记录的某一个字段值或一个统计的值
    	public <T> T getForValue(String sql,Object...args) {
    		Connection connection=null;
    		PreparedStatement pStatement=null;
    		ResultSet rSet=null;
    		try {
    			connection=JDBCUtils.getConnection();
    			pStatement=connection.prepareStatement(sql);
    			for(int i=0;i<args.length;i++) {
    				pStatement.setObject(i+1, args[i]);
    			}
    			rSet=pStatement.executeQuery();
    			if (rSet.next()) {
    				return (T) rSet.getObject(1);
    				
    			}		
    		}catch (Exception e) {
    			// TODO: handle exception
    			e.printStackTrace();
    		}finally {
    			JDBCUtils.closeAll(rSet, pStatement, connection);
    		}
    		return null;
    	}
    
    	@Override
    	public <T> T getValue(String sql, Object... args) {
    		return null;
    	}
    	
    }

DAO工厂类：通过自身的一个静态方法来获得实现类的示例，有了DAO工厂类，只需要修改DAO工厂中的方法代码。

好处：

用户不用知道底层的具体实现，只要操作接口；同时实现前台和后台的分离（当添加新的功能时只要在DAO接口中添加抽象方法，然后在DAOImpl中实现用户所增加的功能，就能完成用户功能的需求）

package com.dao.test;
    
    public class DAOFactory {
    	public static StudentDAO getUserDAOInstance() {
    		return new StudentDAOImpl();
    	}
    }

数据传递对象

package com.dao.test;
    
    public class Student {
    	private int id;
    	private String name;
    	private int age;
    	public Student() {
    		super();
    	}
    	public int getId() {
    		return id;
    	}
    	public void setId(int id) {
    		this.id = id;
    	}
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public int getAge() {
    		return age;
    	}
    	public void setAge(int age) {
    		this.age = age;
    	}
    	@Override
    	public String toString() {
    		return "Student [id=" + id + ", name=" + name + ", age=" + age + "]";
    	}
    }

数据库连接类

package com.tool;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    
    public class JDBCUtils {
    	/*
    	 * jdbc:mysql://localhost:3306/student?serverTimezone=GMT%2B8&useSSL=false
    	 */	
    	public final static String URL="jdbc:mysql://localhost:3306/plant";
    	public final static String USER="root";
    	public final static String PASSWORD="root";
    	//获取连接
    	public static Connection getConnection() throws SQLException, ClassNotFoundException {
    		Class.forName("com.mysql.jdbc.Driver");
    		Connection conn=DriverManager.getConnection(URL, USER, PASSWORD);
    		return conn;
    	}
    	
    	//关闭资源
    	public static void close(PreparedStatement stat,Connection conn) {
    		closeAll(null,stat,conn);
    	}
    	
    	//关闭所有资源
    	public static void closeAll(ResultSet rs,PreparedStatement stat,Connection conn) {
    		if(rs!=null) {
    			try {
    				rs.close();
    			} catch (SQLException e) {
    				e.printStackTrace();
    			}
    		}
    		if(stat!=null) {
    			try {
    				stat.close();
    			} catch (SQLException e) {
    				
    				e.printStackTrace();
    			}
    		}
    		
    		if(conn!=null) {
    			try {
    				conn.close();
    			} catch (SQLException e) {
    				
    				e.printStackTrace();
    			}
    		}
    	}
    }

【参考链接】：[https://www.jianshu.com/p/49fcfb34ee40][https_www.jianshu.com_p_49fcfb34ee40]

[https_www.jianshu.com_p_49fcfb34ee40]: https://www.jianshu.com/p/49fcfb34ee40