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.装好后,图如下出现你要添加的包。

(0)

相关推荐

  • JDBC连接MySql数据库步骤 以及查询、插入、删除、更新等

    主要内容: JDBC连接数据库步骤. 一个简单详细的查询数据的例子. 封装连接数据库,释放数据库连接方法. 实现查询,插入,删除,更新等十一个处理数据库信息的功能.(包括事务处理,批量更新等) 把十一个功能都放在一起. 安装下载的数据库驱动程序jar包,不同的数据库需要不同的驱动程序(这本该是第一步,但是由于属于安装类,所以我们放在最后) 一.JDBC连接数据库(编辑)步骤(主要有六个步骤) 1.注册驱动: Class.forName("com.mysql.jdbc.Driver");

  • JDBC连接MySQL数据库批量插入数据过程详解

    这篇文章主要介绍了JDBC连接MySQL数据库批量插入数据过程详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 1.读取本地json数据 2.jdbc理解数据库 3.批量插入 maven 引入jar包: <dependency> <groupId>com.alibaba</groupId> <artifactId>fastjson</artifactId> <version>1.2

  • Java之jdbc连接mysql数据库的方法步骤详解

    Java:jdbc连接mysql数据库 安装eclipse和mysql的步骤这里不赘述了. 1.一定要下jar包 要想实现连接数据库,要先下载mysql-connector-java-5.1.47(或者其他版本)的jar包.低版本的jar包不会出现时差问题的异常. 建议在下载界面点右边的"Looking for previous GA versions?"下载低版本的. https://www.jb51.net/article/190860.htm我看的是这个教程. 2.mysql前期

  • java基于jdbc连接mysql数据库功能实例详解

    本文实例讲述了java基于jdbc连接mysql数据库的方法.分享给大家供大家参考,具体如下: 一.JDBC简介 Java 数据库连接,(Java Database Connectivity,简称JDBC)是Java语言中用来规范客户端程序如何来访问数据库的应用程序接口,提供了诸如查询和更新数据库中数据的方法.JDBC也是Sun Microsystems的商标.它JDBC是面向关系型数据库的. 1.JDBC架构: JDBC API支持两层和三层处理模型进行数据库访问,但在一般的JDBC体系结构由

  • JDBC连接MySQL并实现模糊查询

    场景: 在学习JDBC的语言中,每次都执行通用的几步:即注册驱动,获取连接,创建操作,处理结果,释放资源 过于复杂,因此不妨将上述步骤封装成工具类,只对外提供方法! 描述: 这是不使用工具类的封装写出来的代码,比较冗余复杂 package com.zdx.JDBC; import java.sql.*; public class JAVA1129_5 { public static void main(String[] args) { //设置空对象,注册驱动,获取连接,创建操作,处理结果集,释

  • java jdbc连接mysql数据库实现增删改查操作

    jdbc相信大家都不陌生,只要是个搞java的,最初接触j2ee的时候都是要学习这么个东西的,谁叫程序得和数据库打交道呢!而jdbc就是和数据库打交道非常基础的一个知识,也是比较接近底层的,在实际的工作中大家用得更多的其实还是比较成熟的框架,例如Hibernate.Mybatis. 但是作为这些成熟框架的底层的jdbc却也是我们应该去掌握的,只有了解了jdbc的增删改查,这样在以后如果有兴趣去研究Hibernate或者Mybatis的源代码的时候才能更好的去理解这些成熟的框架是如何去实现增删改查

  • Java基于jdbc连接mysql数据库操作示例

    本文实例讲述了Java基于jdbc连接mysql数据库操作.分享给大家供大家参考,具体如下: import java.sql.Connection; import java.sql.DriverManager; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; public class MySQLDemo { private Connection conn = null; pri

  • Java使用jdbc连接MySQL数据库实例分析

    本文实例讲述了Java使用jdbc连接MySQL数据库的方法.分享给大家供大家参考,具体如下: 使用jdbc连接数据库: 可以直接在方法中定义url.user.psd等信息,也可以读取配置文件,但是在web项目中肯定是要使用第二种方式的,为了统一,只介绍第二种方式. 步骤 1.创建配置文件db.properties 无论是eclipse还是myeclipse,在工程下右键->new->file,以properties为后缀名就好了. 配置文件内容: #连接数据库的url,如果主机地址是loca

  • 使用Visual Studio Code连接MySql数据库并进行查询

    Visual Studio Code 是微软出品的一款强大的文本编辑器,本文介绍使用 VS Code 链接 MySql 数据库,并执行查询. 使用方法 Step1. 安装 Visual Studio Code VS Code 是一款跨平台的文本编辑器,访问VS Code 官网即可下载安装或者 本地绿色版安装 Step2. 打开 VS Code 并安装插件 安装插件: MySQL MySQL Syntax Step3. 开始使用 在文件菜单可以添加数据库连接: 按照步骤填写服务器.用户名.密码等:

  • JSP使用JDBC连接MYSQL数据库的方法

    本文实例讲述了JSP使用JDBC连接MYSQL数据库的方法.分享给大家供大家参考,具体如下: 1. 可在 http://www.mysql.com/products/connector-j/index.html下载MySQL JDBC驱动程序mysql-connector-java-*.jar,如我下载的是mysql-connector-java-5.1.18-bin.jar并加入到ClassPath下面,或加入到项目中.   2. 注册JDBC驱动程序 try { Class.forName(

随机推荐