DAO模式

最新推荐文章于 2024-03-25 14:09:30 发布
最新推荐文章于 2024-03-25 14:09:30 发布
阅读量1.7k 收藏 14
点赞数 1
分类专栏： 数据库技术 文章标签： java-ee java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56161893/article/details/125115528
版权

DAO数据访问对象data access object的缩写，用于进行数据操作的封装，在Java程序开发中属于标准开 发架构中的持久层的设计模式。DAO模式是标准JavaEE设计模式之一，用途在于将底层的数据访问操作和高层的业务逻辑分离开。 典型的DAO模式的组成 一个DAO工厂类，一个DAO接口 实现了DAO接口的多种实现类 数据传输对象DTO，有时简称为VO。

运用JAVA反射机制，获取实体类定义的字段和方法实现一个万能的DAO模式，IBaseDao接口和BaseDaoImpl类定义类通用的增删改查方法，只需用具体的实现类去继承通用方法，泛型传入具体的类型即可。

结构：

dao类：

IBaseDao：一个接口（定义通用的增删改查方法），通过接口暴漏当前层中允许调用的方法

public interface IBaseDao<T extends Serializable> {

    public int save(T t);//增

    public int delete(T t);//删

    public int update(T t);//改

    public List<T> query(T t);//按id查询

    public List<T> findByExample(T t);//整表查询

}

BaseDaoImpl：实现IBaseDao接口定义的方法：

public abstract class BaseDaoImpl<T extends Serializable> implements IBaseDao<T> {
      
	private Class<T> clazz;
	
	@SuppressWarnings({ "unchecked", "rawtypes" })
	public BaseDaoImpl() {
		Class<? extends IBaseDao> clz=this.getClass();
		ParameterizedType pt =(ParameterizedType)clz.getGenericSuperclass();
	    clazz = (Class) pt.getActualTypeArguments()[0];
	}

	@Override
	//insert into tb_user() values();
	public int save(T obj) {
		StringBuilder sb1 = new StringBuilder("insert into tb_");
		sb1.append(clazz.getSimpleName().toLowerCase()).append("(");
		StringBuilder sb2=new StringBuilder(") values (");
		Field[] fs = clazz.getDeclaredFields();//获取当前类的所有字段
		List<Object> params = new ArrayList<>();
		try {
			for (int i = 0; i < fs.length; i++) {
				Field f = fs[i];
				f.setAccessible(true);
				Object val = f.get(obj);
				if (val!=null) {
					sb1.append(f.getName()).append(",");
					sb2.append("?,");
					params.add(val);
				}
			}
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
		if (sb1.toString().endsWith(",")) {
			sb1.deleteCharAt(sb1.length()-1);
		}
		if (sb2.toString().endsWith(",")) {
			sb2.deleteCharAt(sb2.length()-1);
		}
		String sql = sb1.toString()+sb2.toString()+")";
		return update(sql, params.toArray());
	}
	
	public int update(String sql,Object...params) {
		int res=0;
		try {
			res = JdbcUtils.executeUpdate(sql, params);
		} catch (Exception e) {
			JdbcUtils.releaseConnention();
		}
		return res;
	}

	@Override
	//delete from tb_user where id=?
	public int delete(T obj) {
		StringBuilder sb1 = new StringBuilder("delete from tb_");
		sb1.append(clazz.getSimpleName().toLowerCase()).append(" where 1=1 ");
		Field [] fs = clazz.getDeclaredFields();
		List<Object> params = new ArrayList<>();
		try {
			for (int i = 0; i < fs.length; i++) {
				Field f = fs[i];
				f.setAccessible(true);
				Object val = f.get(obj);
				if (f!=null && val!=null) {
					sb1.append(" and ").append(f.getName()).append(" =? ");
					params.add(val);
				}
			}
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
		
		String sql = sb1.toString();
		return update(sql, params.toArray());
	}

	@Override
	//update tb_user set name=?,password=?  where id=?;
	public int update(T obj) {
		StringBuilder sb1 = new StringBuilder("update tb_");
		sb1.append(clazz.getSimpleName().toLowerCase()).append(" set ");
		StringBuilder sb2 = new StringBuilder(" where ");
		Field [] fs = clazz.getDeclaredFields();
		List<Object> params = new ArrayList<>();
		try {
			for (int i = 1; i < fs.length; i++) {
				Field f = fs[i];
				f.setAccessible(true);
				Object val = f.get(obj);
				if (f!=null && val!=null) {
					sb1.append(f.getName()).append(" =?,");
					params.add(val);
				}
			}
			Field f = fs[0];
			f.setAccessible(true);
			sb2.append(f.getName()).append(" =? ");
			Object val = f.get(obj);
			params.add(val);
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
		if (sb1.toString().endsWith(",")) {
			sb1.deleteCharAt(sb1.length()-1);
		}
		String sql = sb1.toString()+sb2.toString();
		return update(sql, params.toArray());
	}

	@Override
	public List<T> query(T obj) {
		List<T> res = new ArrayList<>();
		try {
			StringBuilder sb = new StringBuilder("select * from tb_");
			sb.append(clazz.getSimpleName().toLowerCase()).append(" where 1=1 ");
			Field[] fs = clazz.getDeclaredFields();
			List<Object> params = new ArrayList<>();
			for (int i = 0; i < fs.length; i++) {
				Field f = fs[i];
				f.setAccessible(true);
				Object val = f.get(obj);
				if (val!=null) {
					sb.append(" and ").append(f.getName()).append(" =? ");
					params.add(val);
				}
			}
			ResultSet rs = JdbcUtils.executeQuery(sb.toString(),params.toArray());
			while (rs.next()) {
				ResultSetMetaData rsemd = rs.getMetaData();
				T t = clazz.newInstance();
				for (int i = 1; i <=rsemd.getColumnCount(); i++) {
					String fieldName = rsemd.getColumnLabel(i);
					Field f = clazz.getDeclaredField(fieldName);
					f.setAccessible(true);
					f.set(t, rs.getObject(i));
				}
				res.add(t);
			}
			rs.close();
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			JdbcUtils.releaseConnention();
		}
		return res;
	}

	@Override
	public List<T> findByExample(T obj){
		List<T> res = new ArrayList<>();
		List<Object> params = new ArrayList<>();
		StringBuilder sql = new StringBuilder("select * from tb_user;");
		try{
			ResultSet rs = JdbcUtils.executeQuery(sql.toString(),params.toArray());
			while (rs.next()) {
				ResultSetMetaData rsemd = rs.getMetaData();
				T t = clazz.newInstance();
				for (int i = 1; i <=rsemd.getColumnCount(); i++) {
					String fieldName = rsemd.getColumnLabel(i);
					Field f = clazz.getDeclaredField(fieldName);
					f.setAccessible(true);
					f.set(t, rs.getObject(i));
				}
				res.add(t);
			}
			rs.close();
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			JdbcUtils.releaseConnention();
		}
		return res;
	}
}

IUserDao和UserDaoImpl：

public interface IUserDao extends IBaseDao<User> {
   //如果需要增加方法，可以在这里声明

}
public class UserDaoImpl extends BaseDaoImpl<User> implements IUserDao {
如果有特殊方法，则在这里实现，实际上通用的增删改查方法已经从BaseDao中继承

}

实体类entity：

user：根据对应的表结构定义实体类类名称和表名称对应，属性名称和字段名称对应 类中的属性不要使用简单类型，判断的需要 setObject

public class User implements Serializable {
    private Integer id;
    private String username;
    private String password;

    public User() {

    }

    public User(Integer id, String username, String password) {
        this.id = id;
        this.username = username;
        this.password = password;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

工厂类Factory：

Factory：

public class User implements Serializable {
    private Long id;
    private String username;
    private String password;

    public User() {

    }

    public User(Long id, String username, String password) {
        this.id = id;
        this.username = username;
        this.password = password;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

工具类Util类：

public class JdbcUtils {
    private JdbcUtils() {

    }

    private static DataSource ds;
    private static final ThreadLocal<Connection> ts = new ThreadLocal<>();
    static {
        try {
            InputStream is = JdbcUtils.class.getClassLoader().getResourceAsStream("src/jdbc.properties");
            Properties ps = new Properties();
            ps.load(is);
            ds = DruidDataSourceFactory.createDataSource(ps);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    //获取链接
    public static Connection getConnection() {
        Connection res = ts.get();
        if (res == null) {
            try {
                res = ds.getConnection();
                ts.set(res);
            } catch (Exception e) {
                throw new RuntimeException(e.getMessage());
            }
        }
        return res;
    }

    //释放连接
    public static void releaseConnention() {
        Connection conn = ts.get();
        if (conn != null) {
            try {
                conn.close();
                ts.remove();
            } catch (Exception e) {
                throw new RuntimeException(e.getMessage());
            }
        }
    }
    //执行增删改的方法
    public static int executeUpdate(String sql, Object... params) {
        try {
            System.out.println(sql);
            return createPreparedStatement(sql, params).executeUpdate();
        } catch (Exception e) {
            throw new RuntimeException(e.getMessage());
        }
    }
    //执行查询的方法
    public static ResultSet executeQuery(String sql, Object... params) {
        try {
            return createPreparedStatement(sql, params).executeQuery();
        } catch (Exception e) {
            throw new RuntimeException(e.getMessage());
        }
    }
    //为sql语句赋值，并返回PreparedStatement对象
    public static PreparedStatement createPreparedStatement(String sql, Object... params) {
        try {
            Connection conn = getConnection();
            PreparedStatement ps = conn.prepareStatement(sql);
            if (params != null && params.length > 0)
                for (int i = 0; i < params.length; i++)
                    ps.setObject(i + 1, params[i]);
            System.out.println(ps);
            return ps;
        } catch (Exception e) {
            throw new RuntimeException(e.getMessage());
        }
    }
}

测试方法：

具体的数据表tb_user

​
mysql> desc tb_user;
+----------+-------------+------+-----+---------+----------------+
| Field    | Type        | Null | Key | Default | Extra          |
+----------+-------------+------+-----+---------+----------------+
| id       | int(11)     | NO   | PRI | NULL    | auto_increment |
| username | varchar(32) | NO   |     | NULL    |                |
| password | varchar(32) | NO   |     | NULL    |                |
+----------+-------------+------+-----+---------+----------------+
3 rows in set (0.02 sec)

mysql> select * from tb_user;
+----+----------+----------+
| id | username | password |
+----+----------+----------+
|  1 | 张三     | ZS123456 |
|  2 | 李四     | LS123456 |
|  3 | 王五     | WW123456 |
+----+----------+----------+
3 rows in set (0.00 sec)

​

1.测试增加数据的方法：save（T obj）

IUserDao dao =DaoFactory.getUserDao();
        User user1=new User(4L,"赵六","ZL123456");
        int num=dao.save(user1);
        if (num >0) {
            System.out.println("插入成功！");
        }else {
            System.out.println("插入失败！");
        }

mysql> select * from tb_user;
+----+----------+----------+
| id | username | password |
+----+----------+----------+
|  1 | 张三     | ZS123456 |
|  2 | 李四     | LS123456 |
|  3 | 王五     | WW123456 |
|  4 | 赵六     | ZL123456 |
+----+----------+----------+
4 rows in set (0.00 sec)

mysql>

 2.测试删除方法delet（T obj）

IUserDao dao =DaoFactory.getUserDao();
        User user1=new User();
        user1.setId(4L);
        int num=dao.delete(user1);
        if (num >0) {
            System.out.println("删除成功！");
        }else {
            System.out.println("删除失败！");
        }

 

mysql> select * from tb_user;
+----+----------+----------+
| id | username | password |
+----+----------+----------+
|  1 | 张三     | ZS123456 |
|  2 | 李四     | LS123456 |
|  3 | 王五     | WW123456 |
+----+----------+----------+
3 rows in set (0.00 sec)

3.测试修改方法delet（T obj）

IUserDao dao =DaoFactory.getUserDao();
        User user1=new User();
        user1.setId(1L);
        user1.setUsername("张小三");
        int num=dao.update(user1);
        if (num >0) {
            System.out.println("修改成功！");
        }else {
            System.out.println("修改失败！");
        }

 

mysql> select * from tb_user;
+----+----------+----------+
| id | username | password |
+----+----------+----------+
|  1 | 张小三   | ZS123456 |
|  2 | 李四     | LS123456 |
|  3 | 王五     | WW123456 |
+----+----------+----------+
3 rows in set (0.00 sec)

4.测试查询方法：

1.测试整表查询

mysql> select * from tb_user;
+----+----------+----------+
| id | username | password |
+----+----------+----------+
|  1 | 张小三   | ZS123456 |
|  2 | 李四     | LS123456 |
|  3 | 王五     | WW123456 |
+----+----------+----------+
3 rows in set (0.00 sec)

 2.测试按id查询：

 IUserDao dao =DaoFactory.getUserDao();
        User user1=new User();
        user1.setId(1);
        List<User> list = dao.query(user1);
        for (User temp:list) {
            System.out.println(temp);
        }

 

子夜夏歌
关注
  • 1
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
dao模式开发
12-05
dao模式的实现 及数据库介绍
DAO模式详细讲解，简单易懂
weixin_59755109的博客
04-11 7418
一，分层模式 显示层：jsp,显示数据，和用户交互。 控制层：用来控制前端的请求，交给后端的业务层去处理。 管家。承上启下。 业务层：具体的业务逻辑(Bussiness) ，服务层(Service);将一系列数据层的数据操作组合起来。 数据层：原子级别的数据操作（增、删、改、查 CRUD）操作。 二，dao模式简介: DAO:Data Access Object :数据存取对象；数据访问层。封装了jdbc操作，实现数据的CRUD，套路。 BaseDao:封装过了通用的数据操作 dao接口：提供
数据库-DAO模式
m0_48081612的博客
06-29 1417
DAO模式是指数据访问对象模式，它是一种用于封装和抽象数据库操作的设计模式，它将数据访问逻辑和业务逻辑分离，提高了代码的可维护性和可重用性。DAO模式可以用于开发各种基于数据库的Java应用程序，例如Web应用、桌面应用、移动应用等。DAO模式中包括了DAO接口、DAO实现类、实体类、数据库连接工具类等组件，它们协同工作，实现对数据库的增删改查操作。DAO模式可以支持多种类型的数据库，例如MySQL、Oracle、SQL Server等，只需更换相应的DAO实现类即可。
dao模式简介
最新发布
m0_59716343的博客
03-25 374
通过使用DAO模式，应用程序可以将数据访问逻辑封装在DAO实现类中，使得业务逻辑层只需要调用DAO的方法，而不需要关心具体的数据访问实现细节。这样，当需要更换数据访问技术时，只需要修改DAO实现类而不影响业务逻辑层的代码。它的主要目的是将数据访问逻辑从业务逻辑中分离出来，使得数据访问操作更加灵活、可复用和可维护。在DAO模式中，数据访问对象（DAO）是一个接口或类，用于定义可以被应用程序使用的各种数据访问操作。它隐藏了数据访问细节，提供了对数据的增删改查等基本操作的统一接口。
JavaWeb(DaO模式开发）
Xiaowenhencaid的博客
12-19 2286
JavaWeb(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 模式 详解
热门推荐
编程大白菜
10-25 1万+
DAO模式 DAO（Data Access Object）数据访问对象。主要的功能就是用于进行数据操作的，在程序的标准开发架构中属于数据层的操作 先来看基本的架构分层 企业分层架构： 客户层：B/S结构都使用浏览器，C/S结构则是一个客户端 显示层：使用JSP/Servlet进行页面效果的显示 业务层：（Business Object，业务对象）：会将多个原子性的DAO操作进行组合，组合成一个完整的业务逻辑。 数据层（DAO）：提供多个原子性的DAO操作（数据持久化操作），例如：增加、修改、删除等，都属于
一篇带你走进程序设计的准则——DAO和MVC设计模式
H215919719的博客
10-21 3404
DAO（Data Access Object，数据访问对象）的主要功能就是操作数据库，也就是数据的增删改查。接下来分别介绍每一层的功能。（1）客户层：目前采用B/S开发架构居多，客户使用浏览器访问，当然也可以使用别的工具访问。（2）显示层：使用JSP/Servlet进行页面显示。（3）业务层：负责将DAO层的操作进行组合，形成一个完整的业务逻辑。（4）数据层：提供原子性操作，比如增加、删除、修改、查询。那么Model、View、Controller分别在应用程序中代表什么呢？
DAO设计模式
qq_45440786的博客
03-01 748
DAO模式将这些操作封装在数据访问对象中，而不是将其直接写在业务逻辑中，从而使得业务逻辑和数据访问逻辑之间的耦合度更低。总之，DAO模式的存在使得软件开发更具可维护性、可测试性、可重用性和安全性，它已经成为了一种常见的设计模式，在很多软件开发项目中被广泛应用。在软件开发中，DAO是指数据访问对象（Data Access Object），是一种设计模式，用于将应用程序的业务逻辑和数据存储操作分离。可维护性：通过DAO模式，数据访问逻辑和业务逻辑被分离，使得代码组织更为清晰，易于维护和修改。
JavaWeb-DAO设计模式
Alphamilk的博客
08-17 1553
DAO设计模式、1.认识DAO、2.DAO各部分的详解、3.DAO设计模式流程、4.具体案例
Dao模式
One of thre_tigers的博客
07-02 511
DAO设计模式 DAO（Data Access Object，数据访问对象），主要的功能就是用 于进行数据操作的，在程序的标准开发架构中属于数据层的操作。 DAO的组成部分 DAO由几下几个部分组成： （1）VO：封装数据信息，主要属性和getXXX() setXXX()方法组成，VO 类中的属性和表中的字段相对应，每个VO类的对象相当于数据库表中的一行记录。***.vo.***,vo的命名要与表的命名一致。 （2）DatabaseConnection：专门负责数据库打开和关闭操作的类。***.dbc.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值