服务器之家

服务器之家 > 正文

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

时间：2021-04-26 15:02     来源/作者：疯狂的兔子

主要内容：

  •  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

?
1
2
3
4
5
6
7
8
9
10
            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资源。但是顺序要和你定义对象的时候相反，就像关门一样，从里面先关，一直往外关。

                       如下示例：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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();
     }
  }

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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
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();
     }
    }
  }

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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
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.查询数据

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
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();
      }
    }
  }
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
//查询数据，结果倒着显示，倒序
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.插入数据

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
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.删除数据

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
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.更新数据

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
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();

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
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.查找存储过程无参数的

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
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.查找存储过程有参数的

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
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.普通处理

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
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);

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
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.分页显示

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
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.结果集可以滚动

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
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();
      }
    }
}

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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
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。

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

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

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

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

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

原文链接：https://www.cnblogs.com/wuziyue/p/4827295.html

标签：
mysql JDBC 

相关文章

热门资讯

2020微信伤感网名听哭了 让对方看到心疼的伤感网名大全
2020微信伤感网名听哭了 让对方看到心疼的伤感网名大全 2019-12-26
yue是什么意思 网络流行语yue了是什么梗
yue是什么意思 网络流行语yue了是什么梗 2020-10-11
背刺什么意思 网络词语背刺是什么梗
背刺什么意思 网络词语背刺是什么梗 2020-05-22
苹果12mini价格表官网报价 iPhone12mini全版本价格汇总
苹果12mini价格表官网报价 iPhone12mini全版本价格汇总 2020-11-13
Intellij idea2020永久破解，亲测可用！！！
Intellij idea2020永久破解，亲测可用！！！ 2020-07-29
返回顶部