JDBC简单封装以及策略模式的利用

最新推荐文章于 2019-12-13 22:11:40 发布
最新推荐文章于 2019-12-13 22:11:40 发布
阅读量297 收藏
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZHJUNJUN93/article/details/80549961
版权

结果集封装为Map

    @Test
    public void warp2Map() throws SQLException {
        Map<String, Object> map = warp2Map("select * from user_test where id = 2011");
        System.out.println(map);
    }

    static Map<String, Object> warp2Map(String sql) throws SQLException {
        Map<String, Object> map = null;
        Connection conn = null;
        PreparedStatement stmt = null;
        ResultSet rs = null;
        try {
            conn = ConnCreate.getConnection();
            stmt = conn.prepareStatement(sql);
            rs = stmt.executeQuery();
            ResultSetMetaData rsmd = rs.getMetaData();
            // 取得行数
            int count = rsmd.getColumnCount();
            if (rs.next()) {
                if (!rs.isLast())
                    throw new SQLException("查询记录超过一行，不能使用Map结果集");
                map = new HashMap<String, Object>();
                for (int i = 1; i <= count; ++i) {
                    map.put(rsmd.getColumnLabel(i), rs.getObject(i));
                }
            }
        } finally {
            ConnCreate.close(conn, stmt, rs);
        }
        return map;
    }

封装为对象 注重利用反射

    @Test
    public void warp2Object() throws SecurityException, IllegalArgumentException, SQLException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException{
        User user =(User) warp2Class("select * from user_test where id=2011",User.class);
        System.out.println(user.getName());
        System.out.println(user.getBirthday());
        System.out.println(user.getId());
        System.out.println(user.getMoney());
    }

    static Object warp2Class(String sql,Class<?> clazz) throws SQLException, SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException, InstantiationException{
        Connection conn = null;
        PreparedStatement stmt = null;
        ResultSet rs = null;
        Object destObject = clazz.newInstance();
        try {
            conn = ConnCreate.getConnection();
            stmt = conn.prepareStatement(sql);
            rs = stmt.executeQuery();
            ResultSetMetaData rsmd = rs.getMetaData();
            if(rs.next()){
                if(!rs.isLast())
                    throw new SQLException("查询记录超过一行，不能使用Map结果集");
                Method method = null;
                for(int i=1;i<=rsmd.getColumnCount();i++){
                    method = clazz.getMethod(parseMethodName(rsmd.getColumnLabel(i)),new Class[]{rs.getObject(i).getClass()});
                    method.invoke(destObject, new Object[]{rs.getObject(i)});
                }
            }
        } finally{
            ConnCreate.close(conn, stmt, rs);
        }
        return destObject;
    }

    static String parseMethodName(String columnName){
        String temp = "set";
        temp+=columnName.substring(0, 1).toUpperCase();
        temp+=columnName.substring(1);
        return temp;
    }

封装为List

@Test
    public void warp2Object() throws SecurityException, IllegalArgumentException, SQLException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException{
        List<Object> userList =warp2Class("select * from user",User.class);
        for(Iterator<Object> it = userList.iterator();it.hasNext();){
            User user  = (User) it.next();
            System.out.println(user.getName()+"|"+user.getBirthday()+"|"+user.getMoney()+"|"+user.getId());
        }
    }

    static List<Object> warp2Class(String sql,Class<?> clazz) throws SQLException, SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException, InstantiationException{
        Connection conn = null;
        PreparedStatement stmt = null;
        ResultSet rs = null;
        List<Object> lists = new ArrayList<Object>();
        try {
            conn = ConnFactory.getConnection();
            stmt = conn.prepareStatement(sql);
            rs = stmt.executeQuery();
            ResultSetMetaData rsmd = rs.getMetaData();
            while(rs.next()){
                Object destObject = clazz.newInstance();
                Method method = null;
                for(int i=1;i<=rsmd.getColumnCount();i++){
                    method = clazz.getMethod(parseMethodName(rsmd.getColumnLabel(i)),new Class[]{rs.getObject(i).getClass()});
                    method.invoke(destObject, new Object[]{rs.getObject(i)});
                }
                lists.add(destObject);
            }
        } finally{
            ConnFactory.close(conn, stmt, rs);
        }
        return lists;
    }

    static String parseMethodName(String columnName){
        String temp = "set";
        temp+=columnName.substring(0, 1).toUpperCase();
        temp+=columnName.substring(1);
        return temp;
    }

策略模式的应用

前面的三个小节中，我们通过将结果集封装成三种不同的结构体演示了如何通过反射，结果集的元数据将数据库对象转换成Java对象，基本功能均已实现，但是存在一个问题，就是我们大多时候使用了强类型转换，并且没有使用统一的接口去管理三个不同的封装形式，如果要我们自己编写API供别人使用，这将是一个很不太好的方式。

在本节中我们通过一个统一的接口来作为抽象，三种不同的实现作为继承，这样使用者只需要通过接口进行编程即可。

  • ResultHandler
public interface ResultHandler<T> {
    public T handler(String sql,Class<T> clazz) throws SQLException, IllegalAccessException, InstantiationException, NoSuchMethodException;
}
  • ResultMap
import java.sql.*;
import java.util.HashMap;
import java.util.Map;

public class ResultMap implements ResultHandler<Map<String,Object>> {

    @Override
    public Map<String, Object> handler(String sql, Class<Map<String, Object>> clazz) throws SQLException {
        Map<String, Object> map = null;
        Connection conn = null;
        PreparedStatement stmt = null;
        ResultSet rs = null;
        try {
            conn = ConnCreate.getConnection();
            stmt = conn.prepareStatement(sql);
            rs = stmt.executeQuery();
            ResultSetMetaData rsmd = rs.getMetaData();
            int count = rsmd.getColumnCount();
            if (rs.next()) {
                if (!rs.isLast())
                    throw new SQLException("查询记录超过一行，不能使用Map结果集");
                map = new HashMap<String, Object>();
                for (int i = 1; i <= count; ++i) {
                    map.put(rsmd.getColumnLabel(i), rs.getObject(i));
                }
            }
        } finally {
            ConnCreate.close(conn, stmt, rs);
        }

        return map;
    }

}
  • ResultBean
import java.lang.reflect.Method;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;

public class ResultBean<T> implements ResultHandler<T>{

    private String parseMethodName(String columnName){
        String temp = "set";
        temp+=columnName.substring(0, 1).toUpperCase();
        temp+=columnName.substring(1);
        return temp;
    }

    @SuppressWarnings("unchecked")
    public T handler(String sql, Class<?> clazz) throws Exception {
        Connection conn = null;
        PreparedStatement stmt = null;
        ResultSet rs = null;
        T t = (T) clazz.newInstance();
        try {
            conn = ConnFactory.getConnection();
            stmt = conn.prepareStatement(sql);
            rs = stmt.executeQuery();
            ResultSetMetaData rsmd = rs.getMetaData();
            if(rs.next()){
                if(!rs.isLast())
                    throw new SQLException("查询记录超过一行，不能使用Map结果集");
                Method method = null;
                for(int i=1;i<=rsmd.getColumnCount();i++){
                    method = clazz.getMethod(parseMethodName(rsmd.getColumnLabel(i)),new Class[]{rs.getObject(i).getClass()});
                    method.invoke(t, new Object[]{rs.getObject(i)});
                }
            }
        } finally{
            ConnFactory.close(conn, stmt, rs);
        }
        return t;
    }
}
  • ResultList
import java.lang.reflect.Method;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.util.ArrayList;
import java.util.List;

public class ResultList<T> implements ResultHandler<List<T>>{

    private String parseMethodName(String columnName){
        String temp = "set";
        temp+=columnName.substring(0, 1).toUpperCase();
        temp+=columnName.substring(1);
        return temp;
    }

    @SuppressWarnings("unchecked")
    public List<T> handler(String sql, Class<?> clazz) throws Exception {
        Connection conn = null;
        PreparedStatement stmt = null;
        ResultSet rs = null;
        List<T> lists = new ArrayList<T>();
        try {
            conn = ConnFactory.getConnection();
            stmt = conn.prepareStatement(sql);
            rs = stmt.executeQuery();
            ResultSetMetaData rsmd = rs.getMetaData();
            while(rs.next()){
                T destObject = (T) clazz.newInstance();
                Method method = null;
                for(int i=1;i<=rsmd.getColumnCount();i++){
                    method = clazz.getMethod(parseMethodName(rsmd.getColumnLabel(i)),new Class[]{rs.getObject(i).getClass()});
                    method.invoke(destObject, new Object[]{rs.getObject(i)});
                }
                lists.add(destObject);
            }
        } finally{
            ConnFactory.close(conn, stmt, rs);
        }
        return lists;
    }
}
  • Test
@Test
    public void mapWarp() throws Exception{
        ResultHandler<Map<String, Object>> handler = new ResultMap();
        Map<String,Object> maps=handler.handler("select * from user where id=1", null);
        System.out.println(maps);
    }

    @Test
    public void beanWarp() throws Exception{
        ResultHandler<User> handler = new ResultBean<User>();
        User user = handler.handler("select * from user where id=1", User.class);
        Assert.assertEquals("test", user.getName());
    }

    @Test
    public void ListWarp() throws Exception{
        ResultList<User> handler = new ResultList<User>();
        List<User> lists = handler.handler("select * from user", User.class);
        Assert.assertEquals(2, lists.size());
    }
WX码小菜
关注
专栏目录
springboot整合sharding-jdbc实现分库分表详解
congge
05-21 6801
springboot整合sharding-jdbc实现分库分表详解
经典设计模式之策略模式【重构聚合支付平台，对接 (支付宝、微信、银联支付) 】
小尾寒羊的博客
05-14 3334
1、为什么要使用设计模式 使用设计模式可以重构整体架构代码、提交代码复用性、扩展性、减少代码冗余问题。Java高级工程师必备的技能！ 2、什么是策略模式 策略模式是对算法的包装，是把使用算法的责任和算法本身分割开来，委派给不同的对象管理，最终可以实现解决多重if判断问题。 1、环境(Context)角色：持有一个Strategy的引用。 2、抽象策略(Strateg...
JDBC之使用策略模式和模板方法模式优化代码
BruceLeeNumberOne的博客
07-29 660
在处理ResultSet时，不同的方法处理的方式是不一样的，但在继承的时候，rowMapper方法只能以一种方式实现，因此可以将对ResultSet处理的部分单独提取成一个抽象的部分，在不同的方法需要处理的时候，各自以自己的方式进行定义。 1、定义一个策略接口RowMapper package cn.itcast.jdbc.dao.refactor; import java.sql.Re
jdbc封装
weixin_44038327的博客
08-09 195
jdbc封装导入连接数据库包步骤MVC框架包结构异常处理方式 导入连接数据库包步骤 1.新建lib包 2.copy jar包 3.右击add as lib MVC框架 MVC全名是Model View Controller，是模型(model)－视图(view)－控制器(controller)的缩写，一种软件设计典范，用一种业务逻辑、数据、界面显示分离的方法组织代码，将业务逻辑聚集到一个部...
JDBC封装
qq_33150537的博客
03-14 223
简单数据库数据及路径： 流程思路： 查询页 user.jsp   实体类 com.bingo.entity包下：User.java  实现类 com.bingo.DAO下，BaseDao.java  UserDao.java 代码如下： User.java package com.bingo.entity; /* * 实体类 */ public class User {
Java策略模式实践：操作JDBC数据库
"Java策略模式在JDBC数据库操作中的应用" 在Java开发中，策略模式是一种行为设计模式，它使你能在运行时改变对象的行为。在这个场景中，我们将策略模式应用于JDBC（Java Database Connectivity）数据库操作，以提高...
Spring整合JDBC实现转账业务-动态代理模式
06-01
在本示例中，我们将深入探讨如何利用Spring框架与JDBC的整合来实现转账业务，并通过动态代理模式来优化事务管理。动态代理模式是Java中一种强大的设计模式，它允许我们在运行时创建对象的代理，以拦截方法调用并执行...
JDBC、封装JDBC连接池、第三方连接池工具
程序小白的成长
12-13 640
主要内容：JDBC简介JDBC来源通过代码实现JDBCJDBC的改进需求JDBC改进的代码实现JDBC使用的设计模式封装连接池封装JDBC连接池ThreadLoacl的使用ThreadLocal常见方法第三方连接池工具（数据源）策略模式 JDBC简介 全称：Java DataBase Connection 译名：Java数据库连接 JDBC来源 JDBC的来源： 最早在Java提出连接数据库需求的...
JDBC的封装
12-05
JDBC的封装，（含预编译，结果集等），执行DML有参、执行DML无参、执行DQL无参及有参
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值