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用法各有优缺点，但愿能对你们的学习有所帮助。