JDBC操作数据库的三种方式比较

Posted 我心自在

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了JDBC操作数据库的三种方式比较相关的知识,希望对你有一定的参考价值。

        JDBC(java Database Connectivity)java数据库连接,是一种用于执行上sql语句的javaAPI,可以为多种关系型数据库提供统一访问接口。我们项目中经常用到的mysql、oracle、DB2等关系型数据库均是通过JDBC来访问的,现在主流的ORM框架Hibernate、Mybatis等均是在JDBC的基础上做的进一步封装、优化。一般小型的项目,可以直接用JDBC来访问数据库,简单方便。我在进过几个项目后,总结了三总JDBC的基本用法,对这几种用法做一个总结

第一种、连接池+ JDBC

        连接池通过将已经建立好的连接保存在连接池中,当有请求的时候,直接使接对数据库进行访问,从而节省了创建连接和关闭连接的时间,性能得到了提高,总之一句话,连接池就是为了提升性能。常用的连接池有DBCP、c3p0、DRUID等,原理都一样。下面是实例:

首先创建连接池:

技术分享图片
public class ConnDBUtil{       

private static final Log logger = LogFactory.getLog(ConnDBUtil.class);

       private static Properties JDBCPOP = new PropertiesUtil().getProperties("jdbc.properties");

       private static ComboPooledDataSource cpds;

       static{

              try {

                     cpds = new ComboPooledDataSource();

                     cpds.setDriverClass(JDBCPOP.getProperty("driverName"));

                     cpds.setJdbcUrl(JDBCPOP.getProperty("url"));

                     cpds.setUser(JDBCPOP.getProperty("user"));

                     cpds.setPassword(JDBCPOP.getProperty("drowssap"));

                     cpds.setAcquireIncrement(Integer.parseInt(JDBCPOP.getProperty("acquireIncrement")));

                     cpds.setInitialPoolSize(Integer.parseInt(JDBCPOP.getProperty("initialPoolSize")));

                     cpds.setMinPoolSize(Integer.parseInt(JDBCPOP.getProperty("minPoolSize")));

                     cpds.setMaxPoolSize(Integer.parseInt(JDBCPOP.getProperty("maxPoolSize")));

                     cpds.setIdleConnectionTestPeriod(Integer.parseInt(JDBCPOP

                                   .getProperty("idleConnectionTestPeriod")));

              } catch (PropertyVetoException e) {

                     logger.error("c3p0连接异常:"+e.getMessage(),e);

              }

       }

       /**

        * 获得c3p0连接

        * @return Connection

        */

       public Connection getConnection(){

              Connection conn = null;

              try {

                     conn= cpds.getConnection();

              } catch (SQLException e) {

                     logger.error(e.getMessage(),e);

                     e.fillInStackTrace();

              }

              return conn;

       }

      

       public  void c3p0Static(ComboPooledDataSource cpds){

              try {

                     logger.info("c3p0总连接数:"+cpds.getNumConnections());

                     logger.info("c3p0正在使用连接数:"+cpds.getNumBusyConnections());

                     logger.info("c3p0空闲连接数:"+cpds.getNumIdleConnections());

              } catch (SQLException e) {

                     logger.error(e.getMessage(),e);

              }

       }
View Code

接下来获取连接,jdbc操作数据库,以一个简单的查询为例:

技术分享图片
public class Dao{

public String queryHtable(String username) {

              Connection conn=null;

              PreparedStatement ps=null;

              ResultSet rs=null;

              String HTable=null;

              try {

                     String sql="select tab_name FROM table_user "

                                   + "WHERE USER_NAME=‘"+username+"‘";

                     conn=ConnDBUtil.getConnection();

                     ps=conn.prepareStatement(sql);

                     rs=ps.executeQuery();

                     while(rs.next()){

                            HTable=rs.getString("USE_HTABLE");

                     }

              } catch (SQLException e) {

                     logger.error(e.getMessage(),e);

                     e.fillInStackTrace();

              }finally{

                     closeAll(rs, ps, conn);

              }

              return HTable;

       }

//关闭资源

       private static void closeAll(ResultSet rs, PreparedStatement ps, Connection conn) {

              if(rs != null){

                     try {

                            rs.close();

                     } catch (SQLException e) {

                            logger.error(e.getMessage(),e);

                            e.fillInStackTrace();

                     }

              }

              if(ps != null){

                     try {

                            ps.close();

                     } catch (SQLException e) {

                            logger.error(e.getMessage(),e);

                            e.fillInStackTrace();

                     }

                    

              }

              if(conn != null){

                     try {

                            conn.close();

                     } catch (SQLException e) {

                            logger.error(e.getMessage(),e);

                            e.fillInStackTrace();

                     }

              }

       }
View Code

以上就是一种非常简单的JDBC操作数据库的例子,缺点是代码耦合度非常高。

第二种、ThreadLocal+JDBC

        ThreadLocal,线程局部变量,作用非常简单就是为每一个使用该变量的线程提供一个变量值的副本,这样,每一个线程都可以独立改变自己的副本而不受其他线程的影响,也不会和其他线程副本冲突,从而提高线程安全性,也就是说,每一个线程完全拥有该变量。从源码我们可以看到ThreadLocal是如何维护线程变量副本的,思路很简单,ThreadLocal类中存在一个Map,Map中存储的就是变量副本。

技术分享图片
public class GetConnectionType {
    public static Connection getConnection() throws SQLException, ClassNotFoundException {
        String url = "jdbc:mysql://localhost:3306/test";
        String driver = "com.mysql.jdbc.Driver";
        String username = "root";
        String password = "123456";
        Class.forName(driver);
        Connection connection = DriverManager.getConnection(url, username, password);
        return connection;
    }
}
View Code

 

技术分享图片
public class GetConnection {
    
    private static ThreadLocal<Connection> local = new ThreadLocal<>();
    //获取连接
    public static Connection getConnection() throws ClassNotFoundException, SQLException {
        Connection conn = local.get();
        if (conn == null) {
            conn = GetConnectionType.getConnection();
            conn.setAutoCommit(false);
            local.set(conn);
        }
        return conn;
    }
    //提交事务
    public static void commit() {
        try {
            if (local.get() != null) {
                local.get().commit();
                local.get().close();
                local.set(null);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    //回滚
    public static void rollback() {
        try {
            if (local.get() != null) {
                local.get().rollback();
                local.get().close();
                local.set(null);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}
View Code

 

技术分享图片
public List<Bookinfo> getAllBookinfo() throws SQLException, ClassNotFoundException {
        List listBookinfo = new ArrayList();
        String sql = "select * from bookinfo order by id asc";
        Connection conn = GetConnection.getConnection();
        PreparedStatement ps = conn.prepareStatement(sql);
        ResultSet rs = ps.executeQuery();
        while (rs.next()) {
            int idDB = rs.getInt("id");
            String booknameDB = rs.getString("bookname");
            double bookpriceDB = rs.getDouble("bookprice");
            Bookinfo bookinfo = new Bookinfo();
            bookinfo.setId(idDB);
            bookinfo.setBookname(booknameDB);
            bookinfo.setBookprice(bookpriceDB);
            listBookinfo.add(bookinfo);
        }
        rs.close();
        ps.close();
        return listBookinfo;
    }
View Code

 

第三种、通过反射连接JDBC

        什么是反射?反射就是对于任何一个类,,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够任意调用它的任何方法和属性;这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。(来自:百度百科)。代码如下:

技术分享图片
public class ConnUtil {

private static Log logger = LogFactory.getLog(ConnUtil.class);

       private static String  sqlDriver;

       private static String  url;

       private static String username;

       private static String password;

       private static Properties JDBCP = new PropertiesUtil().getProperties("jdbc.properties");

       static{

              try {

                     sqlDriver=JDBCP.getProperty("driverName");

                     url=JDBCP.getProperty("url");

                     username=JDBCP.getProperty("user");

                     password=JDBCP.getProperty("drowssap");

                     Class.forName(sqlDriver);

              } catch (ClassNotFoundException e) {

                     logger.error("mysql注册驱动出错:"+e.getMessage(),e);

              }

       }

       /**

        * 获取数据库连接

        * @return Connection

        */

       public static Connection getConn(){

              Connection connection=null;

              try {

                     connection= DriverManager.getConnection(url, username, password);

              } catch (SQLException e) {

                     logger.error("数据库建立连接出错:"+e.getMessage(),e);

              }

              return connection;

       }

       /**

        * 关闭连接

        * @param objects

        */

       public static void close(Object...objects){

              try {

                     if(objects!=null){

                            for(Object obj:objects){

                                   if(obj instanceof Connection){

                                          ((Connection) obj).close();

                                   }else if(obj instanceof PreparedStatement){

                                          ((PreparedStatement) obj).close();

                                   }else if(obj instanceof ResultSet){

                                          ((ResultSet) obj).close();

                                   }

                            }

                     }

              } catch (SQLException e) {

                     logger.error("数据库连接关闭异常:"+e.getMessage(),e);

              }

       }

}
View Code

数据库连接,操作数据库:

技术分享图片
public class Dao {

       private static Log logger = LogFactory.getLog(Dao.class);

       /**

        * 查询所有

        * @param sql

        * @param c

        * @return

        */

       public static<T> List<T> queryAll(String sql,Class<T> c){

              Connection connection=null;

              PreparedStatement pStatement=null;

              ResultSet rSet=null;

              List<T> list=new ArrayList<T>();

              try {

                     connection=ConnUtil.getConn();

                     pStatement=connection.prepareStatement(sql);

                     rSet=pStatement.executeQuery();

                    

                     while(rSet.next()){

                            //通过反射赋值

                            T t=c.newInstance();

                            //获取所有属性

                            Field[] fields=c.getDeclaredFields();

                            //便利属性并赋值

                            for(Field f:fields){

                                   //获取属性名

                                   String fName=f.getName();

                                   //获取属性值

                                   Object objValue=rSet.getObject(fName);

                                   //给属性设置值

                                   Method method=c.getMethod(setter(fName), f.getType());

                                   method.invoke(t, objValue);

                            }

                            list.add(t);

                     }

              } catch (SQLException  e) {

                     logger.error("数据库异常:"+e.getMessage(),e);

              }catch (InstantiationException | IllegalAccessException e1 ){

                     logger.error("反射异常:"+e1.getMessage(),e1);

              } catch (NoSuchMethodException e) {

                     logger.error("方法错误:"+e.getMessage(),e);

              } catch (SecurityException e) {

                     logger.error("安全异常:"+e.getMessage(),e);

              } catch (IllegalArgumentException e) {

                     logger.error("非法转换异常:"+e.getMessage(),e);

              } catch (InvocationTargetException e) {

                     logger.error("InvocationTargetException异常:"+e.getMessage(),e);

              }finally{

                     ConnUtil.close(rSet,pStatement,connection);

              }

             

              return list;

       }

       /**

        * 条件查询

        * @param sql

        * @param c

        * @return

        */

       public static<T> List<T> queryByCondition(String sql,Class<T> c,Object...objects){

             

              Connection connection=null;

              PreparedStatement pStatement=null;

              ResultSet rSet=null;

              List<T> list=new ArrayList<T>();

             

             

                     try {

                            connection=ConnUtil.getConn();

                            pStatement=connection.prepareStatement(sql);

                            if(objects!=null){

                                   for(int i=0;i<objects.length;i++){

                                          pStatement.setObject(i+1, objects[i]);

                                   }

                            }

                            rSet=pStatement.executeQuery();

                           

                            ResultSetMetaData resultSetMetaData=rSet.getMetaData();

                            int count=resultSetMetaData.getColumnCount();

                            while(rSet.next()){

                                   //通过反射赋值

                                   T t=c.newInstance();

                                   for (int i = 0; i < count; i++) {

                                          //获取属性名

                                          String fName=resultSetMetaData.getColumnName(i);

                                          //获取所有属性

                                          Field field=c.getDeclaredField(fName);

                                          //给属性设置值

                                          Method method=c.getMethod(setter(fName), field.getType());

                                          //获取属性值

                                          Object objValue=rSet.getObject(fName);

                                          method.invoke(t, objValue);

                                   }

                                   list.add(t);

                            }

                     } catch (InstantiationException e) {

                            e.printStackTrace();

                     } catch (IllegalAccessException e) {

                            e.printStackTrace();

                     } catch (NoSuchFieldException e) {

                            e.printStackTrace();

                     } catch (SecurityException e) {

                            e.printStackTrace();

                     } catch (NoSuchMethodException e) {

                            e.printStackTrace();

                     } catch (IllegalArgumentException e) {

                            e.printStackTrace();

                     } catch (InvocationTargetException e) {

                            e.printStackTrace();

                     } catch (SQLException e) {

                            e.printStackTrace();

                     }finally{

                            ConnUtil.close(rSet,pStatement,connection);

                     }

              return list;

       }

       /**

        * 更新操作,包括 insert delete update

        * @param sql

        * @param objects

        * @return flag

        */

       public static boolean update(String sql,Object...objects){

              Connection connection=null;

              PreparedStatement pStatement=null;

              boolean flag=false;

              try {

                     connection=ConnUtil.getConn();

                     pStatement=connection.prepareStatement(sql);

                    

                     if(objects!=null){

                            for(int i=0;i<objects.length;i++){

                                   pStatement.setObject(i+1, objects[i]);

                            }

                     }

                     flag=pStatement.execute();

              } catch (SQLException e) {

                     e.printStackTrace();

              }finally{

                     ConnUtil.close(pStatement,connection);

              }

              return flag;

       }

       private static String setter(String name){

              return "set"+name.substring(0,1).toUpperCase()+name.substring(1);

       }  

}
View Code

 总结

        JDBC操作数据库,看似简单,但是细节很多,需要我们自己管理数据连接,稍不小心会出现连接未关闭的情况,这样会浪费系统的资源,为了避免我们自己管理JDBC,所以出现了很多框架,如Mybatis、hibernate这种ORM持久性框架,他们对JDBC做了很好的封装,另外有Spring框架的支持,不需要我们去额外维护数据库的连接,我们可以把全部精力放在业务的实现上面,但是JDBC是我们必须会的一个非常重要的知识点,熟悉了JDBC的原理,才能更好的理解框架的应用。以上是在学习和做项目过程中总结的几种JDBC用法各有优缺点,希望能对大家的学习有所帮助。

以上是关于JDBC操作数据库的三种方式比较的主要内容,如果未能解决你的问题,请参考以下文章

JDBC注册驱动的三种方式(MySQL)

JDBC 创建连接对象的三种方式 properties文件的建立编辑和信息获取

springboot读取配置文件的三种方式

oracle的三种连接方式

java加载jdbc驱动三种方式的比较

Spring之jdbcTemplate:查询的三种方式(单个值单个对象对象集合)