优化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());

         }

     }

 }

测试结果：

相应数据库：

巴特西

优化JDBC封装

最新文章

热门文章