使用模板模式将连接mysql的相关代码封装

项目结构：

 

思路：对于数据库的增删改查，要经常改动的代码其实就是sql语句和对查询结果集的处理。所以我们以下做的事情就是将不经常改动的代码写好封装，使用的时候由调用者自己定义sql语句和处理结果集，而且这两个我们也没法提前做好。需要注意的是模板中传入对结果集处理部分的代码要做一个规范，用接口实现。

1、获取链接与关闭连接

package MySQL.Tool.util;

import java.io.IOException;
import java.io.InputStream;
import java.sql.*;
import java.util.Properties;

public class ConnectionUtil {
    private static String driverClass;
    private static String url;
    private static String name;
    private static String pwd;
    private static Properties pro = new Properties();

    static{
        //java.lang.Class类的getResourceAsStream()方法用于获取具有此类指定资源的资源，也就是用相对流获取文件
        InputStream in = ConnectionUtil.class.getResourceAsStream("jdbc.properties");
        try {
            pro.load(in);
            driverClass = pro.getProperty("driverClass");
            url = pro.getProperty("url");
            name = pro.getProperty("name");
            pwd = pro.getProperty("pwd");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
    * @return java.sql.Connection
    * @Description 描述： 获取数据库连接
    * @Author 李闪闪
    * @Date 2021/10/4 13:34
    */
    public static Connection getConnection(){
        try {
            Class.forName(driverClass);
            Connection con = DriverManager.getConnection(url, name, pwd);
            return con;
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
        return null;
    }

    /**
    * @paramType [java.sql.Connection, java.sql.Statement, java.sql.ResultSet]
    * @param //[con, statement, rs]
    * @return void
    * @Description 描述： 关闭Connection，Statement，ResultSet
    * @Author 李闪闪
    * @Date 2021/10/4 13:35
    */
    public static void close(Connection con, Statement statement, ResultSet rs){
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        if (statement != null) {
            try {
                statement.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        if (con != null) {
            try {
                con.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
    }

    public static void close(Connection con, Statement statement){
        close(con,statement,null);
    }

}

配置文件

driverClass=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3309/test
name=root
pwd=123456

2、处理结果集的接口

package MySQL.Tool.mapper;

import java.sql.ResultSet;
import java.sql.Statement;
import java.util.List;

public interface Mapper {
    /**
    * @paramType [java.sql.ResultSet]
    * @param //[rs] 查询结果集
    * @return java.util.List<?>
    * @Description 描述： 对结果集的处理由调用人员自定义，此接口定义规范
    * @Author 李闪闪
    * @Date 2021/10/4 13:36
    */
    List<?> resultRs(ResultSet rs);
}

3、DML与DQL语句的模板（增删改查）

package MySQL.Tool.util;

import MySQL.Tool.mapper.Mapper;
import MySQL.affair.util.ConnectionUtil;

import java.sql.*;
import java.util.List;

public class Template {
    /**
    * @paramType [java.lang.String, java.lang.Object[], MySQL.Tool.mapper.Mapper]
    * @param //[sql：调用者自定义sql语句, param：prepareStatement预处理对象所需的参数, mapper：自定义的结果集处理]
    * @return java.util.List<?>
    * @Description 描述：查询模板
    * @Author 李闪闪
    * @Date 2021/10/4 13:41
    */
    public static List<?> query(String sql, Object[] param, Mapper mapper) throws SQLException, ClassNotFoundException {
        Connection con = ConnectionUtil.getConnection();
        PreparedStatement statement = null;
        ResultSet rs = null;
        try {
            statement = con.prepareStatement(sql);
            //判断参数数组是否为空
            if (param != null){
                for (int i = 0; i < param.length; i++) {
                    statement.setObject(i+1,param[i]);
                }
            }
            rs = statement.executeQuery();
            //这里使用回调函数，将查询结果作为参数传入实现Mapper接口类的resultRs函数处理
            List<?> list = mapper.resultRs(rs);
            return list;
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }finally {
            ConnectionUtil.close(con,statement,rs);
        }
        return null;
    }

    /**
    * @paramType [java.lang.String, MySQL.Tool.mapper.Mapper]
    * @param //[sql, mapper]
    * @return java.util.List<?>
    * @Description 描述： 用Statement形式的sql语句，不传入参数
    * @Author 李闪闪
    * @Date 2021/10/4 13:47
    */
    public static List<?> query(String sql, Mapper mapper) throws SQLException, ClassNotFoundException {
        List<?> list = query(sql, null, mapper);
        return list;
    }

    /**
    * @paramType [java.lang.String, java.lang.Object[]]
    * @param //[sql, param]
    * @return void
    * @Description 描述： 执行update,delete,insert语句的函数，不需要处理结果集
    * @Author 李闪闪
    * @Date 2021/10/4 13:58
    */
    public static void update(String sql, Object[] param) throws SQLException, ClassNotFoundException {
        Connection con = ConnectionUtil.getConnection();
        PreparedStatement statement = null;
        try {
            statement = con.prepareStatement(sql);
            if (param != null){
                for (int i = 0; i < param.length; i++) {
                    statement.setObject(i+1,param[i]);
                }
            }
            int i = statement.executeUpdate();
            if (i > 0){
                System.out.println("成功更新"+i+"行");
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }

    public static void update(String sql) throws SQLException, ClassNotFoundException {
        update(sql,null);
    }
}

使用模板：

1、定义实体类

package MySQL.Tool.netity;

import java.io.Serializable;
import java.util.Objects;

public class User implements Serializable {
    private int uid;
    private String uname;
    private int uage;

    public User() {
    }

    public User(int uid, String uname, int uage) {
        this.uid = uid;
        this.uname = uname;
        this.uage = uage;
    }

    public int getUid() {
        return uid;
    }

    public void setUid(int uid) {
        this.uid = uid;
    }

    public String getUname() {
        return uname;
    }

    public void setUname(String uname) {
        this.uname = uname;
    }

    public int getUage() {
        return uage;
    }

    public void setUage(int uage) {
        this.uage = uage;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return uid == user.uid && uage == user.uage && Objects.equals(uname, user.uname);
    }

    @Override
    public int hashCode() {
        return Objects.hash(uid, uname, uage);
    }

    @Override
    public String toString() {
        return "User{" +
                "uid=" + uid +
                ", uname='" + uname + '\'' +
                ", uage=" + uage +
                '}';
    }
}

2、查询数据（懒得写标准测试类了，直接main）

package MySQL.Tool.dao;

import MySQL.Tool.mapper.Mapper;
import MySQL.Tool.netity.User;
import MySQL.Tool.util.Template;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

//查询
public class Query implements Mapper {
    public static void main(String[] args) throws SQLException, ClassNotFoundException {
        Query query = new Query();
        String sql = "SELECT UID,UNAME,UAGE FROM USER WHERE UID=123";
        //String sql = "SELECT UID,UNAME,UAGE FROM USER";
        int id = 123;
        Object[] obj = {id};
        //List<User> list = (List<User>) Template.query(sql, obj, query);
        List<User> list = (List<User>) Template.query(sql, query);
        for (User o : list) {
            System.out.println(o.toString());
        }
    }

    /**
    * @paramType [java.sql.ResultSet]
    * @param //[rs]
    * @return java.util.List<?>
    * @Description 描述： 实现Mapper的resultRs()
    * @Author 李闪闪
    * @Date 2021/10/4 14:19
    */
    @Override
    public List<?> resultRs(ResultSet rs) {
        try{
            List<User> users = new ArrayList<>();
            while (rs.next()){
                int uid = rs.getInt("uid");
                String uname = rs.getString("uname");
                int uage = rs.getInt("uage");
                users.add(new User(uid,uname,uage));
            }
            return users;
        }catch (SQLException throwables) {
            throwables.printStackTrace();
        }
        return null;
    }
}

3、增加、删除、修改数据

package MySQL.Tool.dao;

import MySQL.Tool.util.Template;

import java.sql.SQLException;

//增删改
public class Update {
    public static void main(String[] args) throws SQLException, ClassNotFoundException {
        //Template.update("UPDATE USER SET UNAME='张三' WHERE UID=123");
        //Template.update("INSERT INTO USER(UID,UNAME,UAGE) VALUES (10,'赵六',20)");
        Template.update("DELETE FROM USER WHERE UID=?",new Object[]{10});
    }
}

结束！

2021-11-5，再加点东西，记录一下

后来又需要用纯java做个小电商项目，我写了两个处理结果集的类，可以像mybatis那样只关心sql语句，当然比它low多了，但是也减少了很多工作量。

处理结果集的实现类

package com.mapper.conimpl;

import com.alibaba.fastjson.JSON;
import com.mapper.ConUtilMapper;

import java.lang.reflect.Field;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

//这里跟上面的接口名不一样了，不过用法都是一样的
public class ResultImpl implements ConUtilMapper {

    /**
    * @paramType [java.sql.ResultSet]
    * @param //[rs]     查询结果集
    * @return java.util.List<?>
    * @Description 描述： 根据查询出来的结果集每列别名和值存入map,map存入list返回
    * @Author 李闪闪
    * @Date 2021/10/29 0:48
    */
    @Override
    public List<?> resultRs(ResultSet rs) {
        ArrayList<HashMap<String,Object>> list = new ArrayList<>();
        try{
            //获取结果集元数据
            ResultSetMetaData metaData = rs.getMetaData();
            //获取结果集的列数
            int count = metaData.getColumnCount();
            while (rs.next()){
                HashMap<String, Object> map = new HashMap<>();
                for (int i = 1; i <= count; i++) {
                    //String key = metaData.getColumnName(i);  //获取字段名
                    String key = metaData.getColumnLabel(i);  //获取别名，作为map的key，如果没有别名则会获取到字段名
                    Object value;
                    //System.out.println(value);
                    //这是一个时间类型的字段，我要把它用字符串2021-11-5 01:23:22形式拿出来
                    if ("DATETIME".equals(metaData.getColumnTypeName(i))){
                        value = rs.getString(i);
                    }else {
                    //直接用Object方式取，不然判断字段类型太麻烦，取出来后面用到再转换
                        value = rs.getObject(i);
                    }
                    map.put(key,value);
                }
                list.add(map);
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
        //System.out.println(JSON.toJSONString(list));
        return list;
    }


    /**
    * @paramType [java.sql.ResultSet, java.lang.Class<?>]
    * @param //[rs, obj]  数据库查询返回结果集，实体类类型
    * @return java.util.List<?>
    * @Description 描述： 通过反射创建实体类对象，并注入属性值，返回对象列表
    * @Author 李闪闪
    * @Date 2021/10/30 10:58
    */
    @Override
    public List<?> resultRs(ResultSet rs, Class<?> obj) {
        ArrayList<Object> list = new ArrayList<>();
        try{
            ResultSetMetaData metaData = rs.getMetaData();
            int count = metaData.getColumnCount();
            System.out.println("列数："+count);
            Field[] fields = obj.getDeclaredFields();
            while (rs.next()){
                //先创建对象
                Object o = obj.newInstance();
                for (Field field : fields) {
                    //允许通过反射访问类的成员，默认是不允许访问的，也就无法注入值了
                    field.setAccessible(true);
                    String name = field.getName();
                    //要大量判断成员属性的类型，不然类型不对会报错，这里根据需要去改，可以看出是根据属性名取的数据，所以要sql语句中起别名或者字段名跟属性名一样才能映射成功
                    if(int.class == field.getType()){
                        field.set(o,rs.getInt(name));
                    }else if(double.class == field.getType()){
                        field.set(o,rs.getDouble(name));
                    }else if(long.class == field.getType()){
                        field.set(o,rs.getLong(name));
                    }else if(short.class == field.getType()){
                        field.set(o,rs.getShort(name));
                    }else if(float.class == field.getType()){
                        field.set(o,rs.getFloat(name));
                    }else{
                        field.set(o,rs.getString(name));
                    }
                }
                list.add(o);
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return list;
    }
}

用Map是很方便的，但是也要看情况，需要用对象的，那肯定不适合，我这里最后会转换为json字符串返回给前端的，跟用对象的最后结果一样，所以我就使用了。

像一些对象里面嵌套对象的情况，可以在service层的时候根据外层Map某一个值去查询内层对象，再放进去，就像下面这样，这是用map的方式可以做的。这种情况就不能用类对象自动注入的办法做了，因为没写这么复杂哈哈。

public List<Map<String, Object>> showOrderNoPayById(long uid) throws SQLException {
        List<Map<String, Object>> list = orderDao.queryById(uid);
        for (Map<String, Object> map : list) {
            long id = TypeCaseUtil.objToLong(map.get("id"));
            List<OrderItem> items = orderItemDao.queryById(id);
            map.put("children",items);
        }
        return list;
    }

虽然跟框架比很low，但抛开实际环境谈就是耍流氓，这个东西放在我们的纯java项目里面，确确实实给我们小组减少了很多代码量。