JAVA JDBC

来源：互联网发布：mysql 查询语句编辑：程序博客网时间：2024/06/02 02:14

import java.sql.CallableStatement;  
import java.sql.Connection;  
import java.sql.DriverManager;  
import java.sql.PreparedStatement;  
import java.sql.ResultSet;  
import java.sql.ResultSetMetaData;  
import java.sql.SQLException;  
import java.util.ArrayList;  
import java.util.HashMap;  
import java.util.List;  
import java.util.Map;  
/** 
 * 数据库连接类 
 * 说明:封装了 无参，有参，存储过程的调用 
 * @author iflytek 
 * 
 */  
public class ConnectionDB {  
  
    /** 
     * 数据库驱动类名称 
     */  
    private static final String DRIVER = "com.microsoft.sqlserver.jdbc.SQLServerDriver";  
  
    /** 
     * 连接字符串 
     */  
    private static final String URLSTR = "jdbc:sqlserver://localhost:1433; databaseName=Northwind";  
  
    /** 
     * 用户名 
     */  
    private static final String USERNAME = "sa";  
  
    /** 
     * 密码 
     */  
    private static final String USERPASSWORD = "111111";  
  
    /** 
     * 创建数据库连接对象 
     */  
    private Connection connnection = null;  
  
    /** 
     * 创建PreparedStatement对象 
     */  
    private PreparedStatement preparedStatement = null;  
      
    /** 
     * 创建CallableStatement对象 
     */  
    private CallableStatement callableStatement = null;  
  
    /** 
     * 创建结果集对象 
     */  
    private ResultSet resultSet = null;  
  
    static {  
        try {  
            // 加载数据库驱动程序  
            Class.forName(DRIVER);  
        } catch (ClassNotFoundException e) {  
            System.out.println("加载驱动错误");  
            System.out.println(e.getMessage());  
        }  
    }  
  
    /** 
     * 建立数据库连接 
     * @return 数据库连接 
     */  
    public Connection getConnection() {  
        try {  
            // 获取连接  
            connnection = DriverManager.getConnection(URLSTR, USERNAME,  
                    USERPASSWORD);  
        } catch (SQLException e) {  
            System.out.println(e.getMessage());  
        }  
        return connnection;  
    }  
  
    /** 
     * insert update delete SQL语句的执行的统一方法 
     * @param sql SQL语句 
     * @param params 参数数组，若没有参数则为null 
     * @return 受影响的行数 
     */  
    public int executeUpdate(String sql, Object[] params) {  
        // 受影响的行数  
        int affectedLine = 0;  
          
        try {  
            // 获得连接  
            connnection = this.getConnection();  
            // 调用SQL   
            preparedStatement = connnection.prepareStatement(sql);  
              
            // 参数赋值  
            if (params != null) {  
                for (int i = 0; i < params.length; i++) {  
                    preparedStatement.setObject(i + 1, params[i]);  
                }  
            }  
              
            // 执行  
            affectedLine = preparedStatement.executeUpdate();  
  
        } catch (SQLException e) {  
            System.out.println(e.getMessage());  
        } finally {  
            // 释放资源  
            closeAll();  
        }  
        return affectedLine;  
    }  
  
    /** 
     * SQL 查询将查询结果直接放入ResultSet中 
     * @param sql SQL语句 
     * @param params 参数数组，若没有参数则为null 
     * @return 结果集 
     */  
    private ResultSet executeQueryRS(String sql, Object[] params) {  
        try {  
            // 获得连接  
            connnection = this.getConnection();  
              
            // 调用SQL  
            preparedStatement = connnection.prepareStatement(sql);  
              
            // 参数赋值  
            if (params != null) {  
                for (int i = 0; i < params.length; i++) {  
                    preparedStatement.setObject(i + 1, params[i]);  
                }  
            }  
              
            // 执行  
            resultSet = preparedStatement.executeQuery();  
  
        } catch (SQLException e) {  
            System.out.println(e.getMessage());  
        }  
  
        return resultSet;  
    }  
  
    /** 
     * 获取结果集，并将结果放在List中 
     *  
     * @param sql 
     *            SQL语句 
     * @return List 
     *                       结果集 
     */  
    public List<Object> excuteQuery(String sql, Object[] params) {  
        // 执行SQL获得结果集  
        ResultSet rs = executeQueryRS(sql, params);  
          
        // 创建ResultSetMetaData对象  
        ResultSetMetaData rsmd = null;  
          
        // 结果集列数  
        int columnCount = 0;  
        try {  
            rsmd = rs.getMetaData();  
              
            // 获得结果集列数  
            columnCount = rsmd.getColumnCount();  
        } catch (SQLException e1) {  
            System.out.println(e1.getMessage());  
        }  
  
        // 创建List  
        List<Object> list = new ArrayList<Object>();  
  
        try {  
            // 将ResultSet的结果保存到List中  
            while (rs.next()) {  
                Map<String, Object> map = new HashMap<String, Object>();  
                for (int i = 1; i <= columnCount; i++) {  
                    map.put(rsmd.getColumnLabel(i), rs.getObject(i));  
                }  
                list.add(map);  
            }  
        } catch (SQLException e) {  
            System.out.println(e.getMessage());  
        } finally {  
            // 关闭所有资源  
            closeAll();  
        }  
  
        return list;  
    }  
      
    /** 
     * 存储过程带有一个输出参数的方法 
     * @param sql 存储过程语句 
     * @param params 参数数组 
     * @param outParamPos 输出参数位置 
     * @param SqlType 输出参数类型 
     * @return 输出参数的值 
     */  
    public Object excuteQuery(String sql, Object[] params,int outParamPos, int SqlType) {  
        Object object = null;  
        connnection = this.getConnection();  
        try {  
            // 调用存储过程  
            callableStatement = connnection.prepareCall(sql);  
              
            // 给参数赋值  
            if(params != null) {  
                for(int i = 0; i < params.length; i++) {  
                    callableStatement.setObject(i + 1, params[i]);  
                }  
            }  
              
            // 注册输出参数  
            callableStatement.registerOutParameter(outParamPos, SqlType);  
              
            // 执行  
            callableStatement.execute();  
              
            // 得到输出参数  
            object = callableStatement.getObject(outParamPos);  
              
        } catch (SQLException e) {  
            System.out.println(e.getMessage());  
        } finally {  
            // 释放资源  
            closeAll();  
        }  
          
        return object;  
    }  
  
    /** 
     * 关闭所有资源 
     */  
    private void closeAll() {  
        // 关闭结果集对象  
        if (resultSet != null) {  
            try {  
                resultSet.close();  
            } catch (SQLException e) {  
                System.out.println(e.getMessage());  
            }  
        }  
  
        // 关闭PreparedStatement对象  
        if (preparedStatement != null) {  
            try {  
                preparedStatement.close();  
            } catch (SQLException e) {  
                System.out.println(e.getMessage());  
            }  
        }  
          
        // 关闭CallableStatement 对象  
        if (callableStatement != null) {  
            try {  
                callableStatement.close();  
            } catch (SQLException e) {  
                System.out.println(e.getMessage());  
            }  
        }  
  
        // 关闭Connection 对象  
        if (connnection != null) {  
            try {  
                connnection.close();  
            } catch (SQLException e) {  
                System.out.println(e.getMessage());  
            }  
        }     
    }  
}  

---------------------------------------------------------------------------略微修改后的版本（加了返回结果集一行一列的方法）-----------------------

import java.sql.CallableStatement;  
import java.sql.Connection;  
import java.sql.DriverManager;  
import java.sql.PreparedStatement;  
import java.sql.ResultSet;  
import java.sql.ResultSetMetaData;  
import java.sql.SQLException;  
import java.util.ArrayList;  
import java.util.HashMap;  
import java.util.List;  
import java.util.Map;  
/** 
 * 数据库连接类 
 * 说明:封装了 无参，有参，存储过程的调用 
 * @author iflytek 
 * 
 */  
public class ConnectionDB {  
  
    /** 
     * 数据库驱动类名称 
     */  
    private static final String DRIVER = "com.microsoft.sqlserver.jdbc.SQLServerDriver";  
  
    /** 
     * 连接字符串 
     */  
    private static final String URLSTR = "jdbc:sqlserver://localhost:1433; databaseName=Northwind";  
  
    /** 
     * 用户名 
     */  
    private static final String USERNAME = "sa";  
  
    /** 
     * 密码 
     */  
    private static final String USERPASSWORD = "111111";  
  
    /** 
     * 创建数据库连接对象 
     */  
    private Connection connnection = null;  
  
    /** 
     * 创建PreparedStatement对象 
     */  
    private PreparedStatement preparedStatement = null;  
      
    /** 
     * 创建CallableStatement对象 
     */  
    private CallableStatement callableStatement = null;  
  
    /** 
     * 创建结果集对象 
     */  
    private ResultSet resultSet = null;  
  
    static {  
        try {  
            // 加载数据库驱动程序  
            Class.forName(DRIVER);  
        } catch (ClassNotFoundException e) {  
            System.out.println("加载驱动错误");  
            System.out.println(e.getMessage());  
        }  
    }  
  
    /** 
     * 建立数据库连接 
     * @return 数据库连接 
     */  
    public Connection getConnection() {  
        try {  
            // 获取连接  
            connnection = DriverManager.getConnection(URLSTR, USERNAME,  
                    USERPASSWORD);  
        } catch (SQLException e) {  
            System.out.println(e.getMessage());  
        }  
        return connnection;  
    }  
  
    /** 
     * insert update delete SQL语句的执行的统一方法 
     * @param sql SQL语句 
     * @param params 参数数组，若没有参数则为null 
     * @return 受影响的行数 
     */  
    public int executeUpdate(String sql, Object[] params) {  
        // 受影响的行数  
        int affectedLine = 0;  
          
        try {  
            // 获得连接  
            connnection = this.getConnection();  
            // 调用SQL   
            preparedStatement = connnection.prepareStatement(sql);  
              
            // 参数赋值  
            if (params != null) {  
                for (int i = 0; i < params.length; i++) {  
                    preparedStatement.setObject(i + 1, params[i]);  
                }  
            }  
              
            // 执行  
            affectedLine = preparedStatement.executeUpdate();  
  
        } catch (SQLException e) {  
            System.out.println(e.getMessage());  
        } finally {  
            // 释放资源  
            closeAll();  
        }  
        return affectedLine;  
    }  
  
    /** 
     * SQL 查询将查询结果直接放入ResultSet中 
     * @param sql SQL语句 
     * @param params 参数数组，若没有参数则为null 
     * @return 结果集 
     */  
    private ResultSet executeQueryRS(String sql, Object[] params) {  
        try {  
            // 获得连接  
            connnection = this.getConnection();  
              
            // 调用SQL  
            preparedStatement = connnection.prepareStatement(sql);  
              
            // 参数赋值  
            if (params != null) {  
                for (int i = 0; i < params.length; i++) {  
                    preparedStatement.setObject(i + 1, params[i]);  
                }  
            }  
              
            // 执行  
            resultSet = preparedStatement.executeQuery();  
  
        } catch (SQLException e) {  
            System.out.println(e.getMessage());  
        }   
  
        return resultSet;  
    }  
      
    /** 
     * SQL 查询将查询结果：一行一列 
     * @param sql SQL语句 
     * @param params 参数数组，若没有参数则为null 
     * @return 结果集 
     */  
    public Object executeQuerySingle(String sql, Object[] params) {  
        Object object = null;  
        try {  
            // 获得连接  
            connnection = this.getConnection();  
              
            // 调用SQL  
            preparedStatement = connnection.prepareStatement(sql);  
              
            // 参数赋值  
            if (params != null) {  
                for (int i = 0; i < params.length; i++) {  
                    preparedStatement.setObject(i + 1, params[i]);  
                }  
            }  
              
            // 执行  
            resultSet = preparedStatement.executeQuery();  
  
            if(resultSet.next()) {  
                object = resultSet.getObject(1);  
            }  
              
        } catch (SQLException e) {  
            System.out.println(e.getMessage());  
        } finally {  
            closeAll();  
        }  
  
        return object;  
    }  
  
    /** 
     * 获取结果集，并将结果放在List中 
     *  
     * @param sql 
     *            SQL语句 
     * @return List 
     *                       结果集 
     */  
    public List<Object> excuteQuery(String sql, Object[] params) {  
        // 执行SQL获得结果集  
        ResultSet rs = executeQueryRS(sql, params);  
          
        // 创建ResultSetMetaData对象  
        ResultSetMetaData rsmd = null;  
          
        // 结果集列数  
        int columnCount = 0;  
        try {  
            rsmd = rs.getMetaData();  
              
            // 获得结果集列数  
            columnCount = rsmd.getColumnCount();  
        } catch (SQLException e1) {  
            System.out.println(e1.getMessage());  
        }  
  
        // 创建List  
        List<Object> list = new ArrayList<Object>();  
  
        try {  
            // 将ResultSet的结果保存到List中  
            while (rs.next()) {  
                Map<String, Object> map = new HashMap<String, Object>();  
                for (int i = 1; i <= columnCount; i++) {  
                    map.put(rsmd.getColumnLabel(i), rs.getObject(i));  
                }  
                list.add(map);  
            }  
        } catch (SQLException e) {  
            System.out.println(e.getMessage());  
        } finally {  
            // 关闭所有资源  
            closeAll();  
        }  
  
        return list;  
    }  
      
    /** 
     * 存储过程带有一个输出参数的方法 
     * @param sql 存储过程语句 
     * @param params 参数数组 
     * @param outParamPos 输出参数位置 
     * @param SqlType 输出参数类型 
     * @return 输出参数的值 
     */  
    public Object excuteQuery(String sql, Object[] params,int outParamPos, int SqlType) {  
        Object object = null;  
        connnection = this.getConnection();  
        try {  
            // 调用存储过程  
            callableStatement = connnection.prepareCall(sql);  
              
            // 给参数赋值  
            if(params != null) {  
                for(int i = 0; i < params.length; i++) {  
                    callableStatement.setObject(i + 1, params[i]);  
                }  
            }  
              
            // 注册输出参数  
            callableStatement.registerOutParameter(outParamPos, SqlType);  
              
            // 执行  
            callableStatement.execute();  
              
            // 得到输出参数  
            object = callableStatement.getObject(outParamPos);  
              
        } catch (SQLException e) {  
            System.out.println(e.getMessage());  
        } finally {  
            // 释放资源  
            closeAll();  
        }  
          
        return object;  
    }  
  
    /** 
     * 关闭所有资源 
     */  
    private void closeAll() {  
        // 关闭结果集对象  
        if (resultSet != null) {  
            try {  
                resultSet.close();  
            } catch (SQLException e) {  
                System.out.println(e.getMessage());  
            }  
        }  
  
        // 关闭PreparedStatement对象  
        if (preparedStatement != null) {  
            try {  
                preparedStatement.close();  
            } catch (SQLException e) {  
                System.out.println(e.getMessage());  
            }  
        }  
          
        // 关闭CallableStatement 对象  
        if (callableStatement != null) {  
            try {  
                callableStatement.close();  
            } catch (SQLException e) {  
                System.out.println(e.getMessage());  
            }  
        }  
  
        // 关闭Connection 对象  
        if (connnection != null) {  
            try {  
                connnection.close();  
            } catch (SQLException e) {  
                System.out.println(e.getMessage());  
            }  
        }     
    }  
}  

JDBC, Java Database Connecive, Java 数据库连接，是一组专门负责连接并操作数据库的标准，在整个JDBC 中实际上大量的提供的是接口。针对于各个不同的数据库生产商，只要想使用JAVA 进行数据库的开发，则对这些标准有所支持。

JDBC 在使用中常见的有以下三类：

JDBC-ODBC 桥连接：是SUN 在JDK的开发包中提供的最标准的一套JDBC 操作类库，使用的时候将JDBC-ODB-数据库，中间要经过一个ODBC 的连接，那么就意味着整体的性能将会降低，所以在开发中是绝对不会去使用JDBC-ODBC的连接方式的。

JDBC 连接，使用各个数据库提供商给定的数据库驱动程序，完成JDBC的开发，使用的时候需要在classpath中配置数据库的驱动程序

JDBC 网络连接：主要使用通过网络连接数据库

JDBC 的操作步骤

在进行JDBC 操作的时候可以按照以下的步骤完成：

1、加载数据库驱动程序，加载的时候需要将驱动程序配置到classpath之中

2、连接数据库，通过Connection 接口和 DriverManager 类完成

3、操作数据库，通过Statement、PreparedStatement、ResultSet 三个接口完成

4、关闭数据库，在实际开发中数据库资源非常有限，操作完之后必须关闭

数据库连接操作

在JDBC 的操作中，如果要想进行数据库的连接，则必须按照以上的几步完成

1、通过Class.forName()加载数据库的驱动程序

2、通过DriverManager 类进行数据库的连接，连接的时候要输入数据库的连接地址、用户名、密码

3、通过Connection 接口接收连接

[java] view plain copy
 print?
package org.connectiondemo;  
  
import java.sql.Connection;  
import java.sql.DriverManager;  
  
public class ConnectionJDBC {  
  
    /** 
     * @param args 
     */  
    //驱动程序就是之前在classpath中配置的JDBC的驱动程序的JAR 包中  
    public static final String DBDRIVER = "com.mysql.jdbc.Driver";  
    //连接地址是由各个数据库生产商单独提供的，所以需要单独记住  
    public static final String DBURL = "jdbc:mysql://localhost:3306/test";  
    //连接数据库的用户名  
    public static final String DBUSER = "root";  
    //连接数据库的密码  
    public static final String DBPASS = "";  
      
      
    public static void main(String[] args) throws Exception {  
        Connection con = null; //表示数据库的连接对象  
        Class.forName(DBDRIVER); //1、使用CLASS 类加载驱动程序  
        con = DriverManager.getConnection(DBURL,DBUSER,DBPASS); //2、连接数据库  
        System.out.println(con);  
        con.close(); // 3、关闭数据库  
    }  
  
}  

数据库更新操作

如果要想执行数据库的更新操作，则可以使用Statement接口，数据库更新就是增加、修改、删除

增加、更新、删除操作

[java] view plain copy
 print?
package org.updatedemo;  
  
import java.sql.Connection;  
import java.sql.DriverManager;  
import java.sql.Statement;  
  
public class UpdateDemo {  
  
    /** 
     * @param args 
     */  
    //驱动程序就是之前在classpath中配置的JDBC的驱动程序的JAR 包中  
    public static final String DBDRIVER = "com.mysql.jdbc.Driver";  
    //连接地址是由各个数据库生产商单独提供的，所以需要单独记住  
    public static final String DBURL = "jdbc:mysql://localhost:3306/test";  
    //连接数据库的用户名  
    public static final String DBUSER = "root";  
    //连接数据库的密码  
    public static final String DBPASS = "";  
      
      
    public static void main(String[] args) throws Exception {  
        Connection con = null; //表示数据库的连接对象  
        Statement stmt = null;   
        Class.forName(DBDRIVER); //1、使用CLASS 类加载驱动程序  
        con = DriverManager.getConnection(DBURL,DBUSER,DBPASS); //2、连接数据库  
        stmt = con.createStatement(); //3、Statement 接口需要通过Connection 接口进行实例化操作  
        stmt.executeUpdate("insert into java_study.person values(\'Tom\',20,\'SH\')"); //执行SQL 语句，插入、更新、删除数据  
        stmt.executeUpdate("update java_study.person set name='Jery' where age = 20");  
        stmt.executeUpdate("delete from java_study.person where age = 20");  
        con.close(); // 4、关闭数据库  
    }  
  
}  

数据库查询操作

通过SELECT 语句，可以查询数据中的内容，在MySQL 中直接查询的时候可以发现将返回全部的查询结果给用户看，那么对于程序的操作中也是一样的，所有的查询结果要返回到程序处进行输出查看，那么程序通过ResultSet 接口保存全部的查询结果，通过Statement 接口中的executeQuery()方法查询。

查询之后的数据需要分别的取出。通过 next ()方法找到返回的每一行数据，每一行中各个列的数据需要通过getXxx()方法取得，例如：

取得整型：getInt()

取得字符串：getString()

取得日期：getDate()

取得小数：getFloat()

[java] view plain copy
 print?
package org.querydemo;  
  
import java.sql.Connection;  
import java.sql.DriverManager;  
import java.sql.ResultSet;  
import java.sql.Statement;  
  
public class QueryDemo {  
  
    /** 
     * @param args 
     */  
    //驱动程序就是之前在classpath中配置的JDBC的驱动程序的JAR 包中  
    public static final String DBDRIVER = "com.mysql.jdbc.Driver";  
    //连接地址是由各个数据库生产商单独提供的，所以需要单独记住  
    public static final String DBURL = "jdbc:mysql://localhost:3306/test";  
    //连接数据库的用户名  
    public static final String DBUSER = "root";  
    //连接数据库的密码  
    public static final String DBPASS = "";  
      
      
    public static void main(String[] args) throws Exception {  
        Connection con = null; //表示数据库的连接对象  
        Statement stmt = null;  //表示数据库的更新操作  
        ResultSet result = null; //表示接收数据库的查询结果  
        Class.forName(DBDRIVER); //1、使用CLASS 类加载驱动程序  
        con = DriverManager.getConnection(DBURL,DBUSER,DBPASS); //2、连接数据库  
        stmt = con.createStatement(); //3、Statement 接口需要通过Connection 接口进行实例化操作  
        result = stmt.executeQuery("select name,age,address from java_study.person"); //执行SQL 语句，查询数据库  
        while (result.next()){  
            String name = result.getString("name");  
            int age = result.getInt("age");  
            String address = result.getString("address");  
            System.out.println(name+age+address);  
        }  
                result.close();  
                con.close(); // 4、关闭数据库  
    }  
  
}  

PreparedStatement

此接口是在实际的开发中使用最广泛的一个操作接口，此接口是Statement接口的子接口，采用预处理的方式完成

完成增加操作

[java] view plain copy
 print?
package org.preparedstatementdemo;  
  
import java.sql.Connection;  
import java.sql.DriverManager;  
import java.sql.PreparedStatement;  
import java.util.Date;  
  
public class PreparedStatementDemo  {  
  
    /** 
     * @param args 
     */  
  
    public static final String DBDRIVER = "com.mysql.jdbc.Driver";  
    //连接地址是由各个数据库生产商单独提供的，所以需要单独记住  
    public static final String DBURL = "jdbc:mysql://localhost:3306/test";  
    //连接数据库的用户名  
    public static final String DBUSER = "root";  
    //连接数据库的密码  
    public static final String DBPASS = "";  
      
    public static void main(String[] args) throws Exception {  
        // TODO Auto-generated method stub  
        Connection con = null; //表示数据库的连接对象  
        PreparedStatement pstmt = null; //表示数据库更新操作  
          
        String name = "Tom";  
        int age = 20;  
        Date date = new Date();       
        String sql = "insert into java_study.person values(?,?,?)";  
          
        Class.forName(DBDRIVER); //1、使用CLASS 类加载驱动程序  
          
        System.out.println(sql);  
        con = DriverManager.getConnection(DBURL,DBUSER,DBPASS); //2、连接数据库  
        pstmt = con.prepareStatement(sql); //使用预处理的方式创建对象  
        pstmt.setString(1, name); //第一个？号的内容  
        pstmt.setInt(2, age); //第二个？号的内容  
        pstmt.setDate(3, new java.sql.Date(date.getTime()));  
        pstmt.executeUpdate(); //执行SQL 语句，更新数据库  
        pstmt.close();  
        con.close(); // 4、关闭数据库  
    }  
  
}  

完成模糊操作

模糊查询要使用LIKE 语句，那么LIKE 语句需要使用%进行匹配

executeUpdate 的返回值是一个整数,指示受影响的行数(即更新计数)。

PreparedStament的setDate()的第2参数和ResultSet的getDate()方法的第2个参数都是java.sql.Date

[java] view plain copy
 print?
package org.preparedstatementquery;  
  
import java.sql.Connection;  
import java.sql.DriverManager;  
import java.sql.PreparedStatement;  
import java.sql.ResultSet;  
import java.util.Date;  
  
public class PreparedStatementQuery {  
  
    /** 
     * @param args 
     */  
    // TODO Auto-generated method stub  
    public static final String DBDRIVER = "com.mysql.jdbc.Driver";  
    //连接地址是由各个数据库生产商单独提供的，所以需要单独记住  
    public static final String DBURL = "jdbc:mysql://localhost:3306/test";  
    //连接数据库的用户名  
    public static final String DBUSER = "root";  
    //连接数据库的密码  
    public static final String DBPASS = "";   
      
    public static void main(String[] args) throws Exception {  
        Connection con = null; //表示数据库的连接对象  
        PreparedStatement pstmt = null; //表示数据库更新操作  
        ResultSet result = null;  
          
        String like_name ="Tom1";  
        int like_age = 12;  
          
        String sql = "select name,age,birthday from java_study.person where name like ? or age = ?";  
          
        Class.forName(DBDRIVER); //1、使用CLASS 类加载驱动程序  
          
        System.out.println(sql);  
        con = DriverManager.getConnection(DBURL,DBUSER,DBPASS); //2、连接数据库  
        pstmt = con.prepareStatement(sql); //使用预处理的方式创建对象  
        pstmt.setString(1, "%"+like_name+"%");  
        pstmt.setInt(2, like_age);  
  
        result = pstmt.executeQuery(); //执行SQL 语句，更新数据库  
        while (result.next()){  
            String name = result.getString("name");  
            int age = result.getInt("age");  
            Date date = result.getDate("birthday");  
            System.out.println(name+","+age+","+date);  
        }  
<pre name="code" class="java">                result.close();</pre>  pstmt.close();con.close(); // 4、关闭数据库}}<p></p>  
<p><br>  
</p>  
<pre></pre>  
<p></p>  
<p><br>  
</p>  
<p><strong>批处理</strong></p>  
<p>批处理，多条SQL 语句可以一次性执行完毕，称为批处理操作</p>  
<p><br>  
</p>  
<p></p><pre name="code" class="java">package org.addbetchdemo;  
  
import java.sql.Connection;  
import java.sql.DriverManager;  
import java.sql.PreparedStatement;  
import java.util.Date;  
  
public class AddDetchDemo {  
  
    /** 
     * @param args 
     */  
    public static final String DBDRIVER = "com.mysql.jdbc.Driver";  
    //连接地址是由各个数据库生产商单独提供的，所以需要单独记住  
    public static final String DBURL = "jdbc:mysql://localhost:3306/test";  
    //连接数据库的用户名  
    public static final String DBUSER = "root";  
    //连接数据库的密码  
    public static final String DBPASS = "";   
      
    public static void main(String[] args) throws Exception {  
        // TODO Auto-generated method stub  
        Connection con = null; //表示数据库的连接对象  
        PreparedStatement pstmt = null; //表示数据库更新操作  
          
        String sql = "insert into java_study.person values(?,?,?)";  
          
        Class.forName(DBDRIVER); //1、使用CLASS 类加载驱动程序  
          
        System.out.println(sql);  
        con = DriverManager.getConnection(DBURL,DBUSER,DBPASS); //2、连接数据库  
        pstmt = con.prepareStatement(sql); //使用预处理的方式创建对象  
          
        for (int i = 0;i<10;i++){  
            pstmt.setString(1, "org"+i); //第一个？号的内容  
            pstmt.setInt(2, i); //第二个？号的内容  
            pstmt.setDate(3, new java.sql.Date(new java.util.Date().getTime()));  
            pstmt.addBatch();  
        }  
        int[] i = pstmt.executeBatch(); //执行SQL 语句，更新数据库  
        System.out.println(i);  
        pstmt.close();  
        con.close(); // 4、关闭数据库  
    }  
  
}  
</pre><br>  
<p></p>  
<p><strong>事务处理</strong><br>  
</p>  
<p>通过设置 connection  的autocommit(false) 提交事务  con.commit(); 回滚事务 con.rollback()<br>  
</p>  
<p></p><pre name="code" class="java">package org.transactiondemo;  
  
import java.sql.Connection;  
import java.sql.DriverManager;  
import java.sql.Statement;  
  
public class TransactionDemo {  
  
    /** 
     * @param args 
     */  
    //驱动程序就是之前在classpath中配置的JDBC的驱动程序的JAR 包中  
    public static final String DBDRIVER = "com.mysql.jdbc.Driver";  
    //连接地址是由各个数据库生产商单独提供的，所以需要单独记住  
    public static final String DBURL = "jdbc:mysql://localhost:3306/test";  
    //连接数据库的用户名  
    public static final String DBUSER = "root";  
    //连接数据库的密码  
    public static final String DBPASS = "";  
      
    public static void main(String[] args) throws Exception {  
        // TODO Auto-generated method stub  
        Connection con = null; //表示数据库的连接对象  
        Statement stmt = null;   
        Class.forName(DBDRIVER); //1、使用CLASS 类加载驱动程序  
        con = DriverManager.getConnection(DBURL,DBUSER,DBPASS); //2、连接数据库  
          
        con.setAutoCommit(false);  
          
        stmt = con.createStatement(); //3、Statement 接口需要通过Connection 接口进行实例化操作  
          
        try{  
        stmt.addBatch("insert into java_study.person values(\'Tom\',20,\'2012-01-01\')"); //执行SQL 语句，插入、更新、删除数据  
        stmt.addBatch("insert into java_study.person values(\'Tom\',20,\'2012-01-01\')");  
        stmt.addBatch("insert into java_study.person values(\''Tom\',20,\'2012-01-01\')");  
            stmt.executeBatch();  
            con.commit();  
        } catch(Exception e){  
            con.rollback();  
        }  
          
          
  
        stmt.close();  
        con.close(); // 4、关闭数据库  
    }  
  
}  

CallableStatement:

import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;


public class Test {
static {
try {
Class.forName("com.mysql.jdbc.Driver");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}


public static void main(String[] args) {
try {
Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/testdb", "root", "111111");
CallableStatement call = conn.prepareCall("{call selectByTableName(?)}");
call.setString(1, "student");
ResultSet rs = call.executeQuery();
while(rs.next())
{
System.out.println(rs.getInt(1)+"\t"+rs.getString(2)+"\t"+rs.getString(3));
}
} catch (SQLException e) {
e.printStackTrace();
}
}


}


batch:
import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Random;


public class TestBatch {


private static void testStatementBatch()
{
Connection conn = null;
Statement stat = null;//会将每一条sql发给数据库，让数据库区编译运行
try {
conn = DBUtil.getConnection();
stat = conn.createStatement();
String sql1 = "create table tmp(id int key auto_increment , name varchar(30) not null)";
String sql2 = "insert tmp values(0,'tom'),(0,'jim'),(0,'ploy')";
String sql3 = "update tmp set name = 'lily' where id = 3";
stat.addBatch(sql1);
stat.addBatch(sql2);
stat.addBatch(sql3);
stat.executeBatch();//批量执行命令列表
} catch (SQLException e) {
e.printStackTrace();
}
finally {
DBUtil.close(conn, stat, null);
}
}

private static void testPreparedStatement()
{
Connection conn = null;
PreparedStatement ps = null;
String sql = "insert tmp values(0,?)";
String[] names = {"jim","tom","hili","jhon","张三","李四"};
Random r = new Random();
try {
conn = DBUtil.getConnection();
ps = conn.prepareStatement(sql);
for(int i = 1; i < 58; i++)
{
ps.setString(1, names[r.nextInt(names.length)]);
ps.addBatch();//将上面设置的参数添加到参数列表中
if(i % 10 == 0)
{
ps.executeBatch();//执行一批参数
ps.clearBatch();
}
}
ps.executeBatch();
ps.clearBatch();
} catch (SQLException e) {
e.printStackTrace();
}
finally{
DBUtil.close(conn, ps, null);
}
}

private static void testCallableStatement()
{
Connection conn = null;
CallableStatement stat = null;
ResultSet rs =null;
String sql = "{call selectByTableName(?)}";
try {
conn = DBUtil.getConnection();
stat = conn.prepareCall(sql);
stat.setString(1, "student");
rs = stat.executeQuery();

while(rs.next())
{
System.out.println(rs.getInt(1)+"\t"+rs.getString("sname")+"\t"+rs.getString("ssex")+"\t"+rs.getString("sdept"));
}
} catch (SQLException e) {
e.printStackTrace();
}
finally{
DBUtil.close(conn, stat, rs);
}
}

public static void main(String[] args) {
testCallableStatement();
}

}




JDBC是一个Java应用程序接口，作用是封装了对数据库的各种操作。JDBC由类和接口组成，使用Java开发数据库应用都需要4个主要的接口：Driver、Connection、Statement、ResultSet，这些接口定义了使用SQL访问数据库的一般架构。
Driver接口
Driver接口是所有JDBC程序必须实现的接口，该接口专门提供给数据库厂商使用。编写JDBC程序时，必须制定数据库驱动程序或类库加载到项目classpath中。
DriverManager类
DriverManager用于加载JDBC驱动并创建与数据库的连接。其中定义了2个重要的静态方法：
1 DriverManager.registerDriver(Driver driver) // 用于向DeriverManager注册给定的JDBC驱动程序2 DriverManager.getConnection(String url, String user, String pwd) // 建立与数据库的连接，返回表示连接的Connection对象
Connection接口
Connection代表与数据库的连接，其中定义了一系列的方法：
1 Connection.getMetaData(); // 返回表示数据库元数据的DatabaseMetaData对象2 Connection.createStatement(); // 创建一个Statement对象3 Connection.prepareStatement(String sql); // 创建一个PreparedStatement对象4 Connection.prepareCall(String sql); // 创建一个CallableStatement对象来调用数据库存储过程
Statement接口
Statement接口用于向数据库发送SQL语句。
1 Statement.execute(String sql); // 执行各种SQL语句，返回一个boolean类型值，true表示执行的SQL语句具备查询结果，可通过Statement.getResultSet()方法获取2 Statement.executeUpdate(String sql); // 执行SQL中的insert/update/delete语句，返回一个int值，表示受影响的记录的数目3 Statement.executeQuery(String sql); // 执行SQL中的select语句，返回一个表示查询结果的ResultSet对象
 
ResultSet接口
1 ResultSet.next(); // 将游标由当前位置移动到下一行2 ResultSet.getString(String columnName); // 获取指定字段的String类型值3 ResultSet.getString(int columnIndex); // 获取指定索引的String类型值4 ResuleSet.previous(); // 将游标由当前位置移动到上一行
 
2、程序示例数据库IP 192.168.1.150，数据库名称为test，数据表名称persion，表结构为：
 表中原有数据 
JDBC连接MySQL程序示例
 1 package server; 2  3 import java.sql.Connection; 4 import java.sql.DriverManager; 5 import java.sql.ResultSet; 6 import java.sql.Statement; 7  8 public class DemoJDBC { 9     public static void main(String[] args) throws Exception {10         // 加载驱动类11         Class.forName("com.mysql.jdbc.Driver");12         13         // 通过DriverManager获取数据库连接14         String url = "jdbc:mysql://192.168.1.150/test";15         String user = "teamtalk";16         String password = "123456";17         Connection connection = (Connection) DriverManager.getConnection(18                 url, user, password);19         20         // 通过Connection对象获取Statement对象、Statement执行SQL语句21         Statement statement = (Statement) connection.createStatement();  22         ResultSet resultSet = statement.executeQuery("select * from persion");23         24         // 操作ResultSet结果集25         while (resultSet.next()) {26             // 第一种获取字段方式27             System.out.println(resultSet.getString(1) + " " + 28                     resultSet.getString(2) + " " + resultSet.getString(3));29             System.out.print("---- ");30             // 第二种获取字段方式31             System.out.println(resultSet.getString("id") + " " +32                     resultSet.getString("name") + " " + resultSet.getString("age"));33         }34         35         int ret = statement.executeUpdate("insert persion (name, age) value ('bobo', 24)");36         if (ret > 0) {37             System.out.println("  insert ok");38             resultSet = statement.executeQuery("select * from persion");39   40             while (resultSet.next()) {41                 System.out.println(resultSet.getString(1) + " " + 42                         resultSet.getString(2) + " " + resultSet.getString(3));43             }44         }45         46         // 关闭数据库连接47         resultSet.close();48         statement.close();49         connection.close();50     }51 }
程序运行结果为：
  数据表中数据 
 
JDBC使用PreparedStatement进行数据插入操作程序示例
 1 package server; 2  3 import java.sql.Connection; 4 import java.sql.DriverManager; 5 import java.sql.ResultSet; 6 import java.sql.Statement; 7  8 import com.mysql.jdbc.PreparedStatement; 9 10 public class DemoJDBC {11     public static void main(String[] args) throws Exception {12         // 加载驱动类13         Class.forName("com.mysql.jdbc.Driver");14     15         // 通过DriverManager获取数据库连接16         String url = "jdbc:mysql://192.168.1.150/test";17         String user = "teamtalk";18         String password = "123456";19         Connection connection = (Connection) DriverManager.getConnection(20                 url, user, password);21         22         PreparedStatement statement = (PreparedStatement) connection.prepareStatement(23                 "insert persion (name, age) value (?, ?)");24         statement.setString(1, "hdu");25         statement.setInt(2, 21);26         statement.executeUpdate();27         28         ResultSet resultSet = statement.executeQuery("select * from persion");29         // 操作ResultSet结果集30         while (resultSet.next()) {31             // 第一种获取字段方式32             System.out.println(resultSet.getString(1) + " " + 33                     resultSet.getString(2) + " " + resultSet.getString(3));34         }35 36         // 关闭数据库连接37         resultSet.close();38         statement.close();39         connection.close();40     }41 }
程序输出为：
 数据库中数据为：

阅读全文

1 0