JDBC连接(MySql)数据库步骤，以及查询、插入、删除、更新等十一个处理数据库信息的功能。（转）

主要内容：

•  JDBC连接数据库步骤。
• 一个简单详细的查询数据的例子。
• 封装连接数据库，释放数据库连接方法。
• 实现查询，插入，删除，更新等十一个处理数据库信息的功能。（包括事务处理，批量更新等）
• 把十一个功能都放在一起。

• 安装下载的数据库驱动程序jar包,不同的数据库需要不同的驱动程序(这本该是第一步，但是由于属于安装类，所以我们放在最后)

 一.JDBC连接数据库(编辑)步骤(主要有六个步骤)。

       1.注册驱动： Class.forName("com.mysql.jdbc.Driver");显示的加载到JVM中

       2.获取连接：(1) param1:  要连接数据库的url-----》 String url="jdbc:mysql://localhost:3306/test?"+ "useUnicode=true&characterEncoding=UTF8";//防止乱码

                            param2：要连接数据库的用户名--》 String user="h4"; 

                            param3：要连接数据库的密码----》 String pass="111"; 

                            Connection conn=DriverManager.getConnection(url,user,pass)；//DriverManager下的方法：getConnection(String url,String username,String password)

                       (2)接下来我们分析下url："jdbc(这是协议以jdbc开头):mysql(这是子协议，数据库管理系统名称)://localhost(数据库来源地址):3306(目标端口)/test(要查询的表)?"

                                                   "useUnicode=true&characterEncoding=UTF8";添加这个是为了防止乱码，指定使用Unicode字符集 ，且使用UTF-8来编辑。

       3.创建一个Statement语句对象(主要三种方法): Statement stmt=conn.createStatement();//Connection接口下的方法：Statement createStatement()

                                                                               PreparedStatement pstmt = conn.PreparedStatement() ;

                                                                  CallableStatement cstmt =  conn.prepareCall("{CALL demoSp(? , ?)}") ;

                                     下面我们来分析下他们：(1) Statement与 PreparedStatement对象的区别，后者可以动态设置查询参数

                                                  (2)设置参数的方法 PreparedStatement.setXXXX(parameterIndex,value)，如果数据库参数类型是varchar 则用setString，如果参数类型是Integer 则用setInt

                                                                                                    (3)CallableStatement.setXXXX(parameterIndex,value)   //按照参数的顺序设置value

                                                                                                          CallableStatement.setXXXX(parameterName,value)  //按照参数的名字来设置value,这个名字是在定义存储过程的时候的形式参数的名字

                                                                                (4)CallableStatement.registerOutParameter方法用于声明一个存储过程输出类型的参数，用以接收存储过程的输出值

        4.执行SQL语句: ResultSet rs=stmt.executeQuery(Sql);除了查询语句是executeQuery();其他全部是executeUpdate();

                           Statement接口下的方法：

                                                                      boolean     execute(String sql):执行SQL语句，如果返回值是结果集则为true,否则为false

                                                                       ResultSet  executeQuery(String sql):执行SQL语句，返回值为ResultSet

                                                                       int            executeUpdate(String sql):执行SQL语句，返回值为所影响的行数

        5.处理结果集：ResultSet对象的getXxxx方法，取决于数据库中表的字段的类型，例如：varchar2  对应方法是getString ,如果是 integer 对应方法是getInt/getLong

                               While(rs.next()){

                                     rs.getInt(columnIndex);  //通过列的序号来获取字段的值

                                            rs.getString(columnName);//通过列的名字来获取字段的值

              ResultSet接口下常见的方法：beforeFirst();将游标移动到ResultSet中第一条记录(的前面)

                                          afterLast();将游标移动到ResultSet中最后一条记录(的后面)

                                          absolute(intcolumn):将游标移动到相对于第一行的指定行，负数则为相对于最后一条记录

                                          previous():将游标上移一行

                                          next():将游标下移一行

                                                                   ResultSet.TYPE_SCROLL_SENSITIVE          结果集可以滚动

                                                                   ResultSet.CONCUR_READ_ONLY   结果集只读，不能修改

           6.关闭资源： 操作完以后要关闭jdbc来释放jdbc资源。但是顺序要和你定义对象的时候相反，就像关门一样，从里面先关，一直往外关。

                       如下示例：

                                     if(rs !=null){//1.关闭结果集
                                             try{
                                                    rs.close();
                                                } catch (SQLException e){
                                                     e.printStackTrace();
                                               }
                                           }
                                   if(stmt !=null){//2.关闭声明的对象
                                            try{
                                                  stmt.close();
                                              }catch(SQLException e){
                                                    e.printStackTrace();
                                                  }
                                           }
                                   if(conn !=null){//3.关闭连接 （记住一定要先关闭前面的1.2.然后在关闭连接）
                                           try{
                                                 conn.close();
                                           }catch(Exception e){
                                              e.printStackTrace();
                                             }
                                        }
       

 

---

                             
二.下面是一个简单的(详细的)查询数据的例子。

package javacore1;//这是你建的一个包名。

import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;         //左边这五个是你在写程序时要导入的包名，记住是要在java.sql下的包。
import java.sql.SQLException;
import java.sql.Statement;
public class jdbc { //定义一个类
   public static void main(String[] args){ //主方法
      try{
          String driver="com.mysql.jdbc.Driver";              //1.定义驱动程序名为driver内容为com.mysql.jdbc.Driver
          String url="jdbc:mysql://localhost:3306/test?"      //2.定义url；jdbc是协议；mysql是子协议：表示数据库系统管理名称；localhost：3306是你数据库来源的地址和目标端口；test是我本人建的表位置所在处，你以你的为标准。
                  + "useUnicode=true&characterEncoding=UTF8"; //防止乱码；useUnicode=true表示使用Unicode字符集；characterEncoding=UTF8表示使用UTF-8来编辑的。
          String user="h4";                                   //3.定义用户名，写你想要连接到的用户。
          String pass="111";                                  //4.用户密码。
          String querySql="select * from employees";          //5.你想要查找的表名。
          Class.forName(driver);                              //6.注册驱动程序，用java.lang包下面的class类里面的Class.froName();方法 此处的driver就是1里面定义的driver，也可以  Class.forName("com.mysql.jdbc.Driver");
          Connection conn=DriverManager.getConnection(url,user,pass);//7.获取数据库连接,使用java.sql里面的DriverManager的getConnectin(String url , String username ,String password )来完成
                                                                             //括号里面的url，user，pass便是前面定义的2,3,4步骤内容；
          Statement stmt=conn.createStatement();   //8.构造一个statement对象来执行sql语句：主要有Statement，PreparedStatement，CallableStatement三种实例来实现
                                                   //    三种实现方法分别为：Statement stmt = con.createStatement() ;  
                                                     //                   PreparedStatement pstmt = conn.prepareStatement(sql) ;   
                                                     //                   CallableStatement cstmt =  conn.prepareCall("{CALL demoSp(? , ?)}") ;
          ResultSet rs=stmt.executeQuery(querySql);//9.执行sql并返还结束 ；ResultSet executeQuery(String sqlString)：用于返还一个结果集（ResultSet）对象。
     while(rs.next()){    //10.遍历结果集 
          System.out.println("人员编号:"+rs.getString("employee_id")+"工资:"+rs.getString("salary")+"姓名:"+rs.getString("last_name"));//使用getString()方法获取你表里的资料名
           }
     if(rs !=null){//11.关闭记录集
          try{
              rs.close();
          } catch (SQLException e){
            e.printStackTrace();
           }
         }
     if(stmt !=null){//12.关闭声明的对象
          try{
              stmt.close();
          }catch(SQLException e){
           e.printStackTrace();
           }
         }
     if(conn !=null){//13.关闭连接 （记住一定要先关闭前面的11.12.然后在关闭连接，就像关门一样，先关里面的，最后关最外面的）
          try{
              conn.close();
          }catch(SQLException e){
            e.printStackTrace();
          }
        }
          }catch(Exception e){
           e.printStackTrace();
          }
        }
    }

 三.为了更加直观，我们把获取数据库连接和释放连接封装在方法里，以便于后面更好的操作。

package javacore1;

import java.sql.Connection;
import java.sql.DriverManager;

public class jdbc{
    public static void main(String[] args){
          
    Connection conn= getConnection("h4", "111"); //获取数据库连接

    /*,,,,此处为方法名来获取连接,例如 query(conn),,,,,*/
    
        releaseConnection(conn); // 释放数据库连接
   }
     
    /*,,,,,,,,,,此处构建一个你想要的功能的方法,,,,,,,,,,,,*/


//数据库连接
public static Connection getConnection(String user, String pass) {
             
              Connection conn = null;//声明连接对象
              String driver = "com.mysql.jdbc.Driver";// 驱动程序类名
              String url = "jdbc:mysql://localhost:3306/test?" // 数据库URL
                         + "useUnicode=true&characterEncoding=UTF8";// 防止乱码
       try {
            Class.forName(driver);// 注册(加载)驱动程序
            conn = DriverManager.getConnection(url, user, pass);// 获取数据库连接
           } catch (Exception e) {
             e.printStackTrace();
          }
            return conn;
         }
// 释放数据库连接
public static void releaseConnection(Connection conn) {
         try {
              if (conn != null)
                   conn.close();
             } catch (Exception e) {
               e.printStackTrace();
             }
         }
     }

四.实现查询、插入、删除、更新等十一个处理数据库信息的功能。

1.查询数据

package javacore1;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class Query {
    public static void main(String[] args) {
        Connection conn = getConnection("h4", "111");// 获取数据库连接
            query(conn);     //方法名调用数据库连接
        releaseConnection(conn);//释放数据库连接
  }
//查询数据，定义的query方法
public static void query(Connection conn){
        String Sql="select * from employees";
        try{
            Statement stmt=conn.createStatement(); //也可以使用PreparedStatement来做
            ResultSet rs=stmt.executeQuery(Sql);//执行sql语句并返还结束
                                                                       
       while(rs.next()){//遍历结果集 ，向下一行                              
            System.out.println("人员编号:"+rs.getString("employee_id")+"工资:"+rs.getString("salary"));
            }
          if(rs !=null){
            try{
                rs.close();
            } catch (SQLException e){
            e.printStackTrace();
           }
        }
        if(stmt !=null){
            try{
               stmt.close();
            }catch(SQLException e){
             e.printStackTrace();
          }
        }
        if(conn !=null){
            try{
                conn.close();
               }catch(SQLException e){
                e.printStackTrace();
            }
        }
     }catch(Exception e){
       e.printStackTrace();
     }
 }
//数据库连接
  public static Connection getConnection(String user, String pass) {
            Connection conn = null;//声明连接对象
            String driver = "com.mysql.jdbc.Driver";// 驱动程序类名
            String url = "jdbc:mysql://localhost:3306/test?" // 数据库URL
                       + "useUnicode=true&characterEncoding=UTF8";// 防止乱码
     try {
          Class.forName(driver);// 注册(加载)驱动程序
          conn = DriverManager.getConnection(url, user, pass);// 获取数据库连接
         } catch (Exception e) {
           e.printStackTrace();
        }
          return conn;
       }
//释放数据库连接
  public static void releaseConnection(Connection conn) {
       try {
            if (conn != null)
                 conn.close();
           } catch (Exception e) {
             e.printStackTrace();
           }
       }
   }

//查询数据，结果倒着显示，倒序
package javacore1;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class Query {
    public static void main(String[] args) {
        Connection conn = getConnection("h4", "111");// 获取数据库连接
            query(conn);     //方法名调用数据库连接
        releaseConnection(conn);//释放数据库连接
  }
//查询数据，定义的query方法
public static void query(Connection conn){
        String Sql="select * from employees";
        try{
            Statement stmt=conn.createStatement(); //也可以使用PreparedStatement来做
            ResultSet rs=stmt.executeQuery(Sql);//执行sql语句并返还结束
            rs.afterLast();     //先跳到最后一行                                  
       while(rs.previous()){//遍历结果集 ，向上一行                              
            System.out.println("人员编号:"+rs.getString("employee_id")+"工资:"+rs.getString("salary"));
            }
          if(rs !=null){
            try{
                rs.close();
            } catch (SQLException e){
            e.printStackTrace();
           }
        }
        if(stmt !=null){
            try{
               stmt.close();
            }catch(SQLException e){
             e.printStackTrace();
          }
        }
        if(conn !=null){
            try{
                conn.close();
               }catch(SQLException e){
                e.printStackTrace();
            }
        }
     }catch(Exception e){
       e.printStackTrace();
     }
 }
//数据库连接
  public static Connection getConnection(String user, String pass) {
            Connection conn = null;//声明连接对象
            String driver = "com.mysql.jdbc.Driver";// 驱动程序类名
            String url = "jdbc:mysql://localhost:3306/test?" // 数据库URL
                       + "useUnicode=true&characterEncoding=UTF8";// 防止乱码
     try {
          Class.forName(driver);// 注册(加载)驱动程序
          conn = DriverManager.getConnection(url, user, pass);// 获取数据库连接
         } catch (Exception e) {
           e.printStackTrace();
        }
          return conn;
       }
//释放数据库连接
  public static void releaseConnection(Connection conn) {
       try {
            if (conn != null)
                 conn.close();
           } catch (Exception e) {
             e.printStackTrace();
           }
       }
   }

 2.插入数据

package javacore1;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
public class Insert {
    public static void main(String[] args) {
        Connection conn = getConnection("h3", "111111");    // 获取数据库连接
            insert(conn);    //方法名调用数据库连接
        releaseConnection(conn);// 释放数据库连接
      }
//插入数据    
     public static void insert(Connection conn) {  
            try {  
                  String sql = "insert into employees(employee_id,last_name,salary,department_id,userid)"  
                        + " values ('100010', 'xiaogou', '7000','004','9')"; // 插入数据的sql语句  
                  Statement stmt1 =conn.createStatement();    // 创建用于执行静态sql语句的Statement对象  
                  int count = stmt1.executeUpdate(sql);  // 执行插入操作的sql语句，并返回插入数据的个数       
               System.out.println("向biao中插入了 " + count + " 条数据"); //输出插入操作的处理结果  
               conn.close();   //关闭数据库连接  
                } catch (SQLException e) {  
                  e.printStackTrace(); 
             }  
        }      
//数据库连接
    public static Connection getConnection(String user, String pass) {
            Connection conn = null;//声明连接对象
            String driver = "com.mysql.jdbc.Driver";// 驱动程序类名
            String url = "jdbc:mysql://localhost:3306/test?" // 数据库URL
                    + "useUnicode=true&characterEncoding=UTF8";// 防止乱码
            try {
                Class.forName(driver);// 注册(加载)驱动程序
                conn = DriverManager.getConnection(url, user, pass);// 获取数据库连接
            } catch (Exception e) {
                e.printStackTrace();
            }
             return conn;
        }
//释放数据库连接
    public static void releaseConnection(Connection conn) {
            try {
                if (conn != null)
                    conn.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
       }
}

3.删除数据

package javacore1;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
public class Delete {
    public static void main(String[] args) {
        Connection conn = getConnection("h3", "111111");    // 获取数据库连接
             delete(conn);    //方法名调用数据库连接；
        releaseConnection(conn);// 释放数据库连接
}
//删除数据
    public static void delete(Connection conn){
        String Sql = "delete  from employees  where employee_id=100009";
    try {
         Statement stmt = conn.createStatement();// 或者用PreparedStatement方法
         stmt.executeUpdate(Sql);//执行sql语句
    if (stmt != null) {
    try {
         stmt.close();
         } catch (SQLException e) {
         e.printStackTrace();
         }
       }
    } catch (SQLException e) {
         e.printStackTrace();
       }
        
    }
//数据库连接
    public static Connection getConnection(String user, String pass) {
        Connection conn = null;//声明连接对象
        String driver = "com.mysql.jdbc.Driver";// 驱动程序类名
        String url = "jdbc:mysql://localhost:3306/test?" // 数据库URL
                + "useUnicode=true&characterEncoding=UTF8";// 防止乱码
        try {
            Class.forName(driver);// 注册(加载)驱动程序
            conn = DriverManager.getConnection(url, user, pass);// 获取数据库连接
        } catch (Exception e) {
            e.printStackTrace();
        }
        return conn;
    }
// 释放数据库连接
    public static void releaseConnection(Connection conn) {
        try {
            if (conn != null)
                conn.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

4.更新数据

package javacore1;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
public class Update {
    public static void main(String[] args) {
         Connection conn = getConnection("h3", "111111");    // 获取数据库连接
             update(conn);     //方法名调用数据库连接
         releaseConnection(conn);// 释放数据库连接
     }
//更新数据  
  public static void update(Connection conn){
          String Sql = "update  employees set salary=8000 where employee_id=100005";
    try {
         Statement stmt1 = conn.createStatement();//或者用PreparedStatement方法
         stmt1.executeUpdate(Sql);//执行sql语句
    if (stmt1 != null) {
         try {
            stmt1.close();
         } catch (SQLException e) {
            e.printStackTrace();
         }
     }
        } catch (SQLException e) {
           e.printStackTrace();
         }
      }
//数据库连接
    public static Connection getConnection(String user, String pass) {
        Connection conn = null;//声明连接对象
        String driver = "com.mysql.jdbc.Driver";// 驱动程序类名
        String url = "jdbc:mysql://localhost:3306/test?" // 数据库URL
                + "useUnicode=true&characterEncoding=UTF8";// 防止乱码
        try {
            Class.forName(driver);// 注册(加载)驱动程序
            conn = DriverManager.getConnection(url, user, pass);// 获取数据库连接
        } catch (Exception e) {
            e.printStackTrace();
        }
         return conn;
    }
// 释放数据库连接
    public static void releaseConnection(Connection conn) {
        try {
            if (conn != null)
                conn.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

5.转账（事物处理）

JDBC处理事务通过关闭连接的自动提交实现的：

    Connection.setAutoCommit(false);
提交事务：
    Connection.commit();
回滚事务
    回滚部分：
       Connection.rollback(Savepoint);
   全部回滚：
      Connection.rollback();

package javacore1;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
public class TransCash {
    public static void main(String[] args) {
        Connection conn = getConnection("h3", "111111");// 获取数据库连接
            transCash(conn);   //方法名调用数据库连接
        releaseConnection(conn);// 释放数据库连接
  }
//转账(数据调换)(原来数据为100和500，实现这个功能后变成500和100，其实说白了就是更新数据，改数据)
  public static void transCash(Connection conn){
        Statement stmt = null;
    try{
          conn.setAutoCommit(false);//关闭自动提交
            String sql = "update employees set salary=500 where employee_id=100001";
            stmt = conn.createStatement();
            stmt.executeUpdate(sql);            
                  sql = "update employees set salary=100 where employee_id=100002";
            stmt.executeUpdate(sql);//执行sql语句，上面的两个工资将会调换

              //int i=1/0;如果这样，那么将不可以完成任务，因为这是一个完整的事物，有一点失败，将全部失败
          conn.commit();//提交事务
       }catch(Exception e){
         e.printStackTrace();
       }finally{
    try{
         if(stmt != null){  stmt.close();
            }catch(Exception e){
              e.printStackTrace();
            }
          }
        }
//数据库连接
    public static Connection getConnection(String user, String pass) {
        Connection conn = null;//声明连接对象
        String driver = "com.mysql.jdbc.Driver";// 驱动程序类名
        String url = "jdbc:mysql://localhost:3306/test?" // 数据库URL
                + "useUnicode=true&characterEncoding=UTF8";// 防止乱码
        try {
            Class.forName(driver);// 注册(加载)驱动程序
            conn = DriverManager.getConnection(url, user, pass);// 获取数据库连接
        } catch (Exception e) {
            e.printStackTrace();
        }
       return conn;
    }
//释放数据库连接
    public static void releaseConnection(Connection conn) {
        try {
            if (conn != null)
                conn.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

6.查找存储过程无参数的

package javacore1;
import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
public class ExecProc {
    public static void main(String[] args) {
        Connection conn = getConnection("h3", "111111");    // 获取数据库连接
           execProc(conn);//方法名调用数据库连接
        releaseConnection(conn);// 释放数据库连接
    }
//调用无参存储过程；
      public static void execProc(Connection conn){
               String sql = "{call raisesalary}";
          try {
              CallableStatement cstmt = conn.prepareCall(sql);
              cstmt.executeUpdate();
          } catch (SQLException e) {
            e.printStackTrace();
          }
       }
//数据库连接
        public static Connection getConnection(String user, String pass) {
                Connection conn = null;//声明连接对象
                String driver = "com.mysql.jdbc.Driver";// 驱动程序类名
                String url = "jdbc:mysql://localhost:3306/test?" // 数据库URL
                        + "useUnicode=true&characterEncoding=UTF8";// 防止乱码
                try {
                    Class.forName(driver);// 注册(加载)驱动程序
                    conn = DriverManager.getConnection(url, user, pass);// 获取数据库连接
                } catch (Exception e) {
                    e.printStackTrace();
                }
                 return conn;
            }
// 释放数据库连接
        public static void releaseConnection(Connection conn) {
                try {
                    if (conn != null)
                        conn.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
           }
    }

7.查找存储过程有参数的  

package javacore1;
import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Types;
public class GetMulti {
    public static void main(String[] args) {
         Connection conn = getConnection("h3", "111111");    // 获取数据库连接
            int cnt = getMulti(conn);            //查找存储过程；   
            System.out.println("人员编号：" + cnt); 
         releaseConnection(conn);// 释放数据库连接
    }
//查找存储过程有参
    public static int getMulti(Connection conn) {
           int dept_id = 100001;
           int cnt = 0;
           String sql = "{call calc_emp_count(?,?)}";
        try {
              CallableStatement cstmt = conn.prepareCall(sql);//初始化Statement对象
              cstmt.setInt(1, dept_id);//CallableStatement.setxxx(参数，值)或者(数字,值),而PreparedStatement.setxxx(数字,值)只能这样
              cstmt.setInt(2, cnt);    //
              cstmt.registerOutParameter(2, Types.INTEGER);//声明输出参数
              cstmt.executeUpdate();//执行sql语句
              cnt = cstmt.getInt(2);//获取结果
          if (cstmt != null) {
                cstmt.close();// 释放Statement对象
              }
            } catch (Exception e) {
              e.printStackTrace();
          }
           return cnt;
      }
//数据库连接
    public static Connection getConnection(String user, String pass) {
            Connection conn = null;//声明连接对象
            String driver = "com.mysql.jdbc.Driver";// 驱动程序类名
            String url = "jdbc:mysql://localhost:3306/test?" // 数据库URL
                    + "useUnicode=true&characterEncoding=UTF8";// 防止乱码
            try {
                Class.forName(driver);// 注册(加载)驱动程序
                conn = DriverManager.getConnection(url, user, pass);// 获取数据库连接
            } catch (Exception e) {
                e.printStackTrace();
            }
             return conn;
        }
//释放数据库连接
    public static void releaseConnection(Connection conn) {
            try {
                if (conn != null)
                    conn.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
       }
}

8.普通处理

package javacore1;
import java.sql.Connection;
import java.sql.Date;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
public class PlanInsert {
    public static void main(String[] args) {
        Connection conn = getConnection("h3", "111111");    // 获取数据库连接
           planInsert(conn);    //方法名调用数据库连接
        releaseConnection(conn);// 释放数据库连接
      }
//普通处理
     public static void planInsert(Connection conn) {  
         try {  
               String sql = "insert into test_user1(userid,username,loadingtime)"  
                     + " values (?,?,?)"; // 插入数据的sql语句  
               PreparedStatement pstmt=conn.prepareStatement(sql);
               long startTime=System.currentTimeMillis();
             for(int i=0;i<1000;i++){
                 pstmt.setLong(1, i);
                 pstmt.setString(2, "user"+i);
                 pstmt.setDate(3, new Date(System.currentTimeMillis()));
                 pstmt.executeUpdate();
             }
         System.out.println("总共耗时："+(System.currentTimeMillis() - startTime));
               pstmt.close();   //关闭数据库连接  
           } catch (SQLException e) {  
             e.printStackTrace(); 
         } 
     }    
//数据库连接
    public static Connection getConnection(String user, String pass) {
            Connection conn = null;//声明连接对象
            String driver = "com.mysql.jdbc.Driver";// 驱动程序类名
            String url = "jdbc:mysql://localhost:3306/test?" // 数据库URL
                    + "useUnicode=true&characterEncoding=UTF8";// 防止乱码
            try {
                Class.forName(driver);// 注册(加载)驱动程序
                conn = DriverManager.getConnection(url, user, pass);// 获取数据库连接
            } catch (Exception e) {
                e.printStackTrace();
            }
             return conn;
        }
//释放数据库连接
    public static void releaseConnection(Connection conn) {
            try {
                if (conn != null)
                    conn.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
       }
}

 

9.批量处理

获得原来JDBC事务的模式：

boolean currentTransactionModle = con.getAutoCommit();

设置成事务模式(关闭自动提交)：
con.setAutoCommit(false);
Statement stm = con.createStatement();
三个异构的sql语句：
String sql1 = "delete from user where id = 8";
String sql2 = "update user set name='java' where id = 7";
String sql3 = "insert into user(name,password) values('jdbc','jdbc')";
添加到Statement的批量处理缓冲区中：
stm.addBatch(sql1);
stm.addBatch(sql2);
stm.addBatch(sql3);
执行批量更新：
stm.executeBatch();
提交本次批量更新的事务：
con.commit();
回复原来的事务模式：
con.setAutoCommit(currentTransactionModle);

package javacore1;
import java.sql.Connection;
import java.sql.Date;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
public class BatchInsert {
    public static void main(String[] args) {
        Connection conn = getConnection("h3", "111111");    // 获取数据库连接
           batchInsert(conn);    //方法名调用数据库连接
        releaseConnection(conn);// 释放数据库连接
      }
//批量插入的速度要比普通处理的速度快
     public static void batchInsert(Connection conn) {  
         try {  
               String sql = "insert into test_user1(userid,username,loadingtime)"  
                     + " values (?,?,?)"; // 插入数据的sql语句  
               PreparedStatement pstmt=conn.prepareStatement(sql);
               long startTime=System.currentTimeMillis();
             for(int i=0;i<1000;i++){
                 pstmt.setLong(1, i);
                 pstmt.setString(2, "user"+i);
                 pstmt.setDate(3, new Date(System.currentTimeMillis()));
                 pstmt.addBatch();//添加到批量处理
             }
             int[] result=pstmt.executeBatch();
          System.out.println("总共耗时："+(System.currentTimeMillis() - startTime));
             pstmt.close();   //关闭数据库连接  
          } catch (SQLException e) {  
             e.printStackTrace(); 
         } 
     }    
//数据库连接
    public static Connection getConnection(String user, String pass) {
            Connection conn = null;//声明连接对象
            String driver = "com.mysql.jdbc.Driver";// 驱动程序类名
            String url = "jdbc:mysql://localhost:3306/test?" // 数据库URL
                    + "useUnicode=true&characterEncoding=UTF8";// 防止乱码
            try {
                Class.forName(driver);// 注册(加载)驱动程序
                conn = DriverManager.getConnection(url, user, pass);// 获取数据库连接
            } catch (Exception e) {
                e.printStackTrace();
            }
             return conn;
        }
//释放数据库连接
    public static void releaseConnection(Connection conn) {
            try {
                if (conn != null)
                    conn.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
       }
}

10.分页显示

package javacore1;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
public class Paging {
    public static void main(String[] args) {
        Connection conn = getConnection("h3", "111111");    // 获取数据库连接
            paging(conn,1,3);//方法名调用数据库连接,且定义显示第几行到第几行
        releaseConnection(conn);// 释放数据库连接
   }
//分页查询
    public static void paging(Connection conn,int startIndex,int total){
        try{
            String sql="select * from employees limit ?,?";
            PreparedStatement pstmt=conn.prepareStatement(sql);
            pstmt.setInt(1, startIndex);
            pstmt.setInt(2, total);
            ResultSet rs=pstmt.executeQuery();
        while(rs.next()){
                System.out.print("工号："+rs.getInt(1));
               System.out.println("部门编号："+rs.getInt("department_id"));
            }rs.close();
            pstmt.close();
          }catch(SQLException e){
            e.printStackTrace();
        }
    }
//数据库连接
    public static Connection getConnection(String user, String pass) {
            Connection conn = null;//声明连接对象
            String driver = "com.mysql.jdbc.Driver";// 驱动程序类名
            String url = "jdbc:mysql://localhost:3306/test?" // 数据库URL
                    + "useUnicode=true&characterEncoding=UTF8";// 防止乱码
            try {
                Class.forName(driver);// 注册(加载)驱动程序
                conn = DriverManager.getConnection(url, user, pass);// 获取数据库连接
            } catch (Exception e) {
                e.printStackTrace();
            }
             return conn;
        }
// 释放数据库连接
    public static void releaseConnection(Connection conn) {
            try {
                if (conn != null)
                    conn.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
       }
}

11.结果集可以滚动

package javacore1;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
public class ScrpllResult {
    public static void main(String[] args) {
          Connection conn = getConnection("h3", "111111");    // 获取数据库连接
             scrpllResult(conn);//方法名调用数据库连接
          releaseConnection(conn);// 释放数据库连接
      }
//结果集滚动显示
    public static void scrpllResult(Connection conn){
        try{
            String sql="select * from employees";                         //结果集可以滚动      //并发性,结果集只读，不可以修改
            PreparedStatement pstmt=conn.prepareStatement(sql, ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY);
            ResultSet rs=pstmt.executeQuery();
        while(rs.next()){  //向下一行遍历
                System.out.print("工号："+rs.getLong(1));
                System.out.println("名字"+rs.getString("last_name"));
           }while(rs.previous()){//向上一行遍历
                System.out.print("工号："+rs.getLong(1));
                System.out.println("工资"+rs.getInt("salary"));
             }
               rs.absolute(6);//表示直接跳到第几行
            if(rs.next()){
                System.out.print("工号："+rs.getLong(1));
                System.out.println("..........部门编号："+rs.getString("department_id"));
              }
                rs.close();
                pstmt.close();
            }catch(SQLException e){
                e.printStackTrace();
            }
        }    
//数据库连接
    public static Connection getConnection(String user, String pass) {
            Connection conn = null;//声明连接对象
            String driver = "com.mysql.jdbc.Driver";// 驱动程序类名
            String url = "jdbc:mysql://localhost:3306/test?" // 数据库URL
                    + "useUnicode=true&characterEncoding=UTF8";// 防止乱码
            try {
                Class.forName(driver);// 注册(加载)驱动程序
                conn = DriverManager.getConnection(url, user, pass);// 获取数据库连接
            } catch (Exception e) {
                e.printStackTrace();
            }
             return conn;
        }
// 释放数据库连接
    public static void releaseConnection(Connection conn) {
            try {
                if (conn != null)
                    conn.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
       }
}

五.把上面十一个放在一起当然最方便省事。(需要用谁，只需把前面的注释打开便行)

package javacore1;
import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.Date;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.Types;
public class jdbcMySql {
public static void main(String[] args) {
    Connection conn = getConnection("h3", "111111");    // 获取数据库连接
           //query(conn); //1.查询数据
           //insert(conn);//2.插入数据
           //delete(conn);//3.删除数据
           //update(conn);//4.更新数据
           //transCash(conn);//5.转账
           //execProc(conn);//6.查找存储过程无参数的
           //int cnt = getMulti(conn);//7.查找存储过程有参数的   
           //System.out.println("人员编号：" + cnt);//查找存储过程有参数的
           //planInsert(conn);//8.普通处理
           //batchInsert(conn);//9.批量处理
           // paging(conn,1,3);//10.分页显示
           //scrpllResult(conn);//11.结果集可以滚动
        releaseConnection(conn);// 释放数据库连接
     }
//1.查询数据，定义的query方法
public static void query(Connection conn){
        String Sql="select * from employees";
        try{
            Statement stmt=conn.createStatement(); //也可以使用PreparedStatement来做
          ResultSet rs=stmt.executeQuery(Sql);//执行sql语句并返还结束
                                                   
     while(rs.next()){//遍历结果集                               
            System.out.println("人员编号:"+rs.getString("employee_id")+"工资:"+rs.getString("salary"));
            }
          if(rs !=null){
            try{
                rs.close();
            } catch (SQLException e){
            e.printStackTrace();
           }
        }
        if(stmt !=null){
            try{
               stmt.close();
            }catch(SQLException e){
             e.printStackTrace();
          }
        }
        if(conn !=null){
            try{
                conn.close();
               }catch(SQLException e){
                e.printStackTrace();
            }
        }
     }catch(Exception e){
       e.printStackTrace();
     }
}
//2.插入数据    
     public static void insert(Connection conn) {  
            try {  
                  String sql = "insert into employees(employee_id,last_name,salary,department_id,userid)"  
                        + " values ('100010', 'xiaogou', '7000','004','9')"; // 插入数据的sql语句  
                  Statement stmt1 =conn.createStatement();    // 创建用于执行静态sql语句的Statement对象  
                  int count = stmt1.executeUpdate(sql);  // 执行插入操作的sql语句，并返回插入数据的个数       
               System.out.println("向biao中插入了 " + count + " 条数据"); //输出插入操作的处理结果  
               conn.close();   //关闭数据库连接  
                } catch (SQLException e) {  
                  e.printStackTrace(); 
             }  
        }
//3.删除数据
    public static void delete(Connection conn){
            String Sql = "delete  from employees  where employee_id=100009";
        try {
             Statement stmt = conn.createStatement();// 或者用PreparedStatement方法
             stmt.executeUpdate(Sql);//执行sql语句
        if (stmt != null) {
        try {
             stmt.close();
             } catch (SQLException e) {
             e.printStackTrace();
             }
           }
        } catch (SQLException e) {
             e.printStackTrace();
           }
            
        }
//4.更新数据  
    public static void update(Connection conn){
              String Sql = "update  employees set salary=8000 where employee_id=100005";
        try {
             Statement stmt1 = conn.createStatement();//或者用PreparedStatement方法
             stmt1.executeUpdate(Sql);//执行sql语句
        if (stmt1 != null) {
             try {
                stmt1.close();
             } catch (SQLException e) {
                e.printStackTrace();
             }
         }
            } catch (SQLException e) {
               e.printStackTrace();
             }
          }    
//5.转账(数据调换)(原来数据为100和500，实现这个功能后变成500和100，其实说白了就是更新数据，改数据)
  public static void transCash(Connection conn){
            Statement stmt = null;
        try{
              conn.setAutoCommit(false);//关闭自动提交
                String sql = "update employees set salary=500 where employee_id=100001";
                stmt = conn.createStatement();
                stmt.executeUpdate(sql);            
                      sql = "update employees set salary=100 where employee_id=100002";
                stmt.executeUpdate(sql);//执行sql语句，上面的两个工资将会调换
              conn.commit();//提交事务
           }catch(Exception e){
             e.printStackTrace();
           }finally{
        try{
             if(stmt != null)stmt.close();
                }catch(Exception e){
                  e.printStackTrace();
                }
              }
            }
//6.调用无参存储过程；
  public static void execProc(Connection conn){
           String sql = "{call raisesalary}";
      try {
          CallableStatement cstmt = conn.prepareCall(sql);
          cstmt.executeUpdate();
      } catch (SQLException e) {
        e.printStackTrace();
      }
   } 
//7.查找存储过程有参
  public static int getMulti(Connection conn) {
           int dept_id = 100001;
           int cnt = 0;
           String sql = "{call calc_emp_count(?,?)}";
        try {
              CallableStatement cstmt = conn.prepareCall(sql);//初始化Statement对象
              cstmt.setInt(1, dept_id);//CallableStatement.setxxx(参数，值)或者(数字,值),而PreparedStatement.setxxx(数字,值)只能这样
              cstmt.setInt(2, cnt);    //
              cstmt.registerOutParameter(2, Types.INTEGER);//声明输出参数
              cstmt.executeUpdate();//执行sql语句
              cnt = cstmt.getInt(2);//获取结果
          if (cstmt != null) {
                cstmt.close();// 释放Statement对象
              }
            } catch (Exception e) {
              e.printStackTrace();
          }
           return cnt;
      }
//8.普通处理
     public static void planInsert(Connection conn) {  
         try {  
               String sql = "insert into test_user1(userid,username,loadingtime)"  
                     + " values (?,?,?)"; // 插入数据的sql语句  
               PreparedStatement pstmt=conn.prepareStatement(sql);
               long startTime=System.currentTimeMillis();
             for(int i=0;i<1000;i++){
                 pstmt.setLong(1, i);
                 pstmt.setString(2, "user"+i);
                 pstmt.setDate(3, new Date(System.currentTimeMillis()));
                 pstmt.executeUpdate();
             }
         System.out.println("总共耗时："+(System.currentTimeMillis() - startTime));
               pstmt.close();   //关闭数据库连接  
           } catch (SQLException e) {  
             e.printStackTrace(); 
         } 
     } 
//9.批量插入的速度要比普通处理的速度快
    public static void batchInsert(Connection conn) {  
             try {  
                   String sql = "insert into test_user1(userid,username,loadingtime)"  
                         + " values (?,?,?)"; // 插入数据的sql语句  
                   PreparedStatement pstmt=conn.prepareStatement(sql);
                   long startTime=System.currentTimeMillis();
                 for(int i=0;i<1000;i++){
                     pstmt.setLong(1, i);
                     pstmt.setString(2, "user"+i);
                     pstmt.setDate(3, new Date(System.currentTimeMillis()));
                     pstmt.addBatch();//添加到批量处理
                 }
                 int[] result=pstmt.executeBatch();
              System.out.println("总共耗时："+(System.currentTimeMillis() - startTime));
                 pstmt.close();   //关闭数据库连接  
              } catch (SQLException e) {  
                 e.printStackTrace(); 
             } 
         }
//10.分页查询
   public static void paging(Connection conn,int startIndex,int total){
            try{
                String sql="select * from employees limit ?,?";
                PreparedStatement pstmt=conn.prepareStatement(sql);
                pstmt.setInt(1, startIndex);
                pstmt.setInt(2, total);
                ResultSet rs=pstmt.executeQuery();
            while(rs.next()){
                    System.out.print("工号："+rs.getInt(1));
                   System.out.println("部门编号："+rs.getInt("department_id"));
                }rs.close();
                pstmt.close();
              }catch(SQLException e){
                e.printStackTrace();
            }
        }
//11.结果集滚动显示
     public static void scrpllResult(Connection conn){
         try{
             String sql="select * from employees";                         //结果集可以滚动                                               //并发性,结果集只读，不可以修改
             PreparedStatement pstmt=conn.prepareStatement(sql, ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY);
             ResultSet rs=pstmt.executeQuery();
         while(rs.next()){  //向下一行遍历
                 System.out.print("工号："+rs.getLong(1));
                 System.out.println("名字"+rs.getString("last_name"));
            }while(rs.previous()){//向上一行遍历
                 System.out.print("工号："+rs.getLong(1));
                 System.out.println("工资"+rs.getInt("salary"));
              }
                rs.absolute(6);//表示直接跳到第几行
             if(rs.next()){
                 System.out.print("工号："+rs.getLong(1));
                 System.out.println("..........部门编号："+rs.getString("department_id"));
               }
                 rs.close();
                 pstmt.close();
             }catch(SQLException e){
                 e.printStackTrace();
             }
         } 
//数据库连接
public static Connection getConnection(String user, String pass) {
          Connection conn = null;//声明连接对象
          String driver = "com.mysql.jdbc.Driver";// 驱动程序类名
          String url = "jdbc:mysql://localhost:3306/test?" // 数据库URL
                     + "useUnicode=true&characterEncoding=UTF8";// 防止乱码
   try {
        Class.forName(driver);// 注册(加载)驱动程序
        conn = DriverManager.getConnection(url, user, pass);// 获取数据库连接
       } catch (Exception e) {
         e.printStackTrace();
      }
        return conn;
     }
//释放数据库连接
public static void releaseConnection(Connection conn) {
     try {
          if (conn != null)
               conn.close();
         } catch (Exception e) {
           e.printStackTrace();
         }
     }
 }

 六.安装下载的数据库驱动程序jar包,不同的数据库需要不同的驱动程序（但是安装方法都是一样的）

在使用JDBC编程时需要连接数据库，导入JAR包是必须的，导入其它的jar包方法同样如此，导入的方法是 

打开eclipse

1.右击要导入jar包的项目，点properties 

2.左边选择java build path,右边选择libraries 

3.选择add External jars 

4.选择jar包的按照路径下的
确定后就行了。

Java连接MySQL的最新驱动包下载地址 

http://www.mysql.com/downloads/connector/j

 

1.鼠标放在你建的根目录上面。右击，然后选择最下面的properties。

 

2.然后左边选择java build path,右边选择libraries ，在选择右边的add External jars ，选择jar包的路径，点击确定就可以了

 

3.装好后，图如下出现你要添加的包。