优化JDBC封装

可重用性较强的JDBC封装

以下为代码，注释中写了主要思想

主类

com.util.JDBCUtil.java

package com.util;

import java.lang.reflect.Field;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class JDBCUtil {
    private final static String driver="com.mysql.jdbc.Driver";
    private final static String url="jdbc:mysql://192.168.137.11:3306/db_test?useUnicode=true&characterEncoding=utf8";
    private final static String user="root";
    private final static String password="123456";
    //获取JDBC连接
    public static Connection getConnection(){
        Connection conn=null;
        try {
            Class.forName(driver);
            conn=DriverManager.getConnection(url,user,password);
            
        } catch (ClassNotFoundException e) {
            // TODO 自动生成的 catch 块
            e.printStackTrace();
        } catch (SQLException e) {
            // TODO 自动生成的 catch 块
            e.printStackTrace();
        }
        return conn;
    }
    //关闭连接
    public static void close(Connection conn,PreparedStatement pstmt,ResultSet rs){
        if(rs!=null){
            try {
                rs.close();
            } catch (SQLException e) {
                // TODO 自动生成的 catch 块
                e.printStackTrace();
            }
        }
        if(pstmt!=null){
            try {
                pstmt.close();
            } catch (SQLException e) {
                // TODO 自动生成的 catch 块
                e.printStackTrace();
            }
        }
        if(conn!=null){
            try {
                conn.close();
            } catch (SQLException e) {
                // TODO 自动生成的 catch 块
                e.printStackTrace();
            }
        }
    }
    //增、删、改
    /*
     * sql语句参数部分应改为？替代，代码中使用PreparedStatement类来注入参数，防止sql注入
     * 因不确定sql语句参数个数，类型，所以使用动态参数Object... objects 
     * 将objects使用PreparedStatement中setObject方法注入
     * 调用时可以这样调用
     * update("insert into user values(?,?)","ads","asdsa");
     * 这样封装使得此方法可重用性强
     */
    public static int update(String sql,Object... objects ){
        Connection conn=getConnection();
        PreparedStatement pstmt=null;
        int result =0;
        
        try {
            pstmt=conn.prepareStatement(sql);
            if(objects!=null){
                for(int i=0;i<objects.length;i++){
                    pstmt.setObject(i+1, objects[i]);
                }
            }
            result=pstmt.executeUpdate();
        } catch (SQLException e) {
            // TODO 自动生成的 catch 块
            e.printStackTrace();
        }finally {
            close(conn, pstmt, null);
        }
        
        
        return result;
    }
    
    //添加对象
    /*
     * 不确定未来编程时向数据库中添加对象是什么，固使用泛型T    
     * 可以使用自定义注解的方式实现javabean与相应数据表的映射
     * 此方法封装时代码晦涩难懂，使用时不用自己去写sql语句较为方便且复用性强
     * 类似于hibernate
     */
    public static <T> int insert(T t){
        //列名数组，即javabean的属性，用于拼接sql语句
        List<String> columns=new ArrayList<>();
        //用于拼接sql语句，存放‘？’，若javabean有4个属性，则此数组为[?,?,？,？]
        List<String> values=new ArrayList<>();
        //存放javabean各个属性的值，最后使用PreparedStatement注入
        List<Object> params=new ArrayList<>();
        
        Class clz=t.getClass();
        //TableUtil自定义注解，用于javabean与表名的映射
        TableUtil ann=(TableUtil)clz.getAnnotation(TableUtil.class);
        //获取该javabean的属性
        Field[] fields=clz.getDeclaredFields();
        //for循环对columns values数组赋值
        /*
         * ColumnUtil自定义注解，用于javabean属性与表的列名映射
         * IDUtil自定义注解，用于表的自增长主键与相应javabean属性映射
         */
        for (Field field : fields) {
            //若数据表中设置了自增长主键，使用insert语句时须跳过相应的主属性，所以应执行此if语句判断
            if(!field.isAnnotationPresent(IDUtil.class)){
                //判断是使用ColumnUtil将此属性映射
                if(field.isAnnotationPresent(ColumnUtil.class)){
                    //获取列名
                    ColumnUtil column= field.getAnnotation(ColumnUtil.class);
                    //columns数组添加相应列名
                    columns.add(column.value());
                    //获取一列，便向values数组中添加一个‘？’，即有多少列就有多少个‘？’
                    values.add("?");
                    //一般javabean属性为private，使用此方法可访问private属性
                    field.setAccessible(true);
                    try {
                        //列相应的值，存放入params数组
                        params.add(field.get(t));
                    } catch (IllegalArgumentException | IllegalAccessException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            }
        }
        /*
         * 拼接sql语句
         * ann.value()即注解的表名
         * list数组转化为String，结果为[...]，为拼接sql语句需将"[]"变"()"
         */
        String sql="insert into "+ann.value()+Arrays.toString(columns.toArray()).replaceAll("\[", "(").replaceAll("\]", ")")+" values"+Arrays.toString(values.toArray()).replaceAll("\[", "(").replaceAll("\]", ")");
        //System.out.println(Arrays.toString(params.toArray()) );
        //System.out.println(sql);
        
        //以下为执行sql语句过程
        //思想同上面的update方法
        Connection connection=getConnection();
        PreparedStatement preparedStatement=null;
        int result=0;
        try {
            preparedStatement=connection.prepareStatement(sql);
            for (int i=0;i<params.size();i++) {
                preparedStatement.setObject(i+1,params.get(i));
            }
            result=preparedStatement.executeUpdate();
            
        } catch (SQLException e) {
            // TODO 自动生成的 catch 块
            e.printStackTrace();
        }finally {
            close(connection, preparedStatement, null);
        }
        
        return result;
        
    }
    
    //查询，获取对象列表
    /*
     * 此方法调用时，使用匿名内部类，程序员可以自己写ResultSet结果集，具有好的复用性
     * sql语句中参数部分使用？替代，并使用动态参数，思想同上
     */
    public static <T> List<T> executeQuery(String sql,RowMap<T> rowMap,Object...objects ){
        List<T> list=new ArrayList<>();
        Connection connection=getConnection();
        PreparedStatement preparedStatement=null;
        ResultSet rSet=null;
        try {
            preparedStatement=connection.prepareStatement(sql);
            if(objects!=null) {
                for (int i=0;i<objects.length;i++) {
                    preparedStatement.setObject(i+1, objects[i]);
                    
                }
            }
            rSet=preparedStatement.executeQuery();
            while (rSet.next()) {
                T t=rowMap.rowMapping(rSet);
                list.add(t);
            }
        } catch (SQLException e) {
            // TODO 自动生成的 catch 块
            e.printStackTrace();
        }finally {
            close(connection, preparedStatement, rSet);
        }
        
        return list;
    }
    
}

以下为相关工具类

com.util.ColumnUtil.java

package com.util;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface ColumnUtil {
    //相应列名
    String value();
}

com.util.IDUtil.java

package com.util;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;


@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
//自增主键注解
public @interface IDUtil {

}

com.util.TableUtil.java

package com.util;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface TableUtil {
    //映射相应表名
    String value();
}

com.util.RowMap.java

package com.util;

import java.sql.ResultSet;

public interface RowMap<T> {
    //自定义result结果集
    //使用了匿名内部类的思想
    public T rowMapping(ResultSet rs);
}

以下为测试类：

com.model.User.java

package com.model;

import com.util.ColumnUtil;
import com.util.TableUtil;

@TableUtil("t_user")
//此javabean映射表名为"t_user"
public class User {
    @ColumnUtil("c_username")
    //属性username对应表中的c_username列
    private String username;
    //属性password对应表中的c_password列
    @ColumnUtil("c_password")
    private String password;
    public String getUsername() {
        return username;
    }
    public String getPassword() {
        return password;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    

}

tests.JDBCUtilTest.java

package tests;

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

import com.model.User;
import com.util.JDBCUtil;
import com.util.RowMap;

public class JDBCUtilTest {

    public static void main(String[] args) {
        User newUser=new User();
        newUser.setUsername(UUID.randomUUID().toString());
        newUser.setPassword("asd");
        JDBCUtil.insert(newUser);
        List<User> users=JDBCUtil.executeQuery("select * from t_user where c_username!=?",new RowMap<User>() {
            @Override
            //匿名内部类 定义resultset结果集
            public User rowMapping(ResultSet rs) {
                User user=new User();
                try {
                    user.setUsername(rs.getString("c_username"));
                    user.setPassword(rs.getString("c_password"));
                } catch (SQLException e) {
                    e.printStackTrace();
                }
                return user;
            }
        }, "JDBCUtil");//查找用户名不为JDBCUtil的用户
        for (User user : users) {
            System.out.println(user.getUsername()+"&&"+user.getPassword());
        }
        
    }

}

测试结果：

相应数据库：