1、MySQL存储过程

  1.1、什么是存储过程

带有逻辑的sql语句；带有流程控制语句(if  while)等等 的sql语句

  1.2、存储过程的特点

1）执行效率非常快，存储过程是数据库的服务器端执行的。
      2）移植性很差，不同数据库的存储过程是不能移植的。

2、存储过程的语法

  1. -- 创建存储过程
    1 DELIMITER $  -- 声明存储过程的结束符
  2. 2    CREATE PROCEDURE pro_test() -- 创建存储过程  存储过程的名称(参数列表)
  3. 3 BEGIN  -- 开始
    4
  4. 5     -- 这中间可以写多个sql语句     -- sql语句+流程控制等
  5. 6  
  6. 7 END $ -- 结束 结束符
  1. 1 --执行存储过程
  2. 2 CALL pro_test(); -- call存储过程的名称(参数)
  1. 1 -- 存储过程名称里面的参数：
  2. 2 IN ：表示输入参数,可以携带数据存储过程中
  3. 3 OUT：表示输出参数,可以从存储过程中返回结果
  4. 4 INOUT：表示输入输出参数,既可以输入功能,也可输出功能
  1. -- 删除存储过程
  2. 1 DROP PROCEDURE pro_test; -- 删除存储过程  存储过程的名称;

3、实例演示

  3.1、带有参数的存储过程           Java代码调用存储过程的方法：https://www.cnblogs.com/dshore123/p/10582283.html

  1. 1 -- 需求：传入一个员工的id，查询员工的信息
  2. 2 DELIMITER $
  3. 3     CREATE PROCEDURE pro_findById(IN eid INT) -- IN: 输入参数； eid:传入参数的名称； int：传入参数的类型
  4. 4 BEGIN
  5. 5     SELECT * FROM employee WHERE id = eid;
  6. 6 END $
  7. 7
  8. 8 -- 调用
  9. 9 CALL pro_findByID(4)

调用pro_findByID() 后的结果图

          

  3.2、带有输出参数的存储过程

  1.  1 -- 带有输出参数的存储过程
  2.  2 DELIMITER $
  3.  3    CREATE PROCEDURE pro_test_out(OUT str VARCHAR(20))  -- out:输出参数
  4.  4 BEGIN
  5.  5    -- 给参数赋值
  6.  6    SET str = 'helloMySQL';
  7.  7 END $
  8.  8
  9.  9 CALL pro_test_out(@NAME); -- 调用pro_test_out存储过程
  10. 10 SELECT @NAME; -- 查询pro_test_out存储过程
  11. 11
  12. 12  -- 如何返回接收的返回数值
  13. 13  -- ****mysql的变量******
  14. 14  -- 全局变量(内置变量)：mysql数据库中内置的变量(所有连接都起作用)
  15. 15  -- 查看所有的全局变量：show variables;
  16. 16  -- 查看某个全局变量：select @@变量名
  17. 17  -- 修改全局变量：set 变量名 = 新值
  18. 18
  19. 19  -- 会话变量：只存在于当前客户端与数据库的一次连接当中；如果断开，那么会话变量将全部失效(丢失)。
  20. 20  -- 定义会话变量: set @变量 = 值;
  21. 21  -- 查看会话变量: select @变量;
  22. 22  -- character_set_client: 服务器的接收编码
  23. 23  -- character_set_results: 服务器的输出编码
  24. 24
  25. 25  -- 局部变量：在存储过程中使用的变量就叫局部变量；只要存储过程执行完毕，局部变量就丢失。
  26. 26

结果图

  3.3、带有输入输出参数的存储过程

  1.  1 -- 带有输入输出参数的存储过程
  2.  2 DELIMITER $
  3.  3    CREATE PROCEDURE pro_test_InOut(INOUT n INT)  -- INOUT: 输入输出参数
  4.  4 BEGIN
  5.  5    -- 查看变量
  6.  6    SELECT n;
  7.  7    SET n=500;
  8.  8 END $
  9.  9
  10. 10 -- 调用
  11. 11 SET @n=10;
  12. 12 CALL pro_test_InOut(@n);
  13. 13 SELECT @n;

结果图

          

  3.4、带有条件判断存储过程

  1.  1 -- 需求：输入一个整数，如果是1，则返回'星期一'；如果是2，则返回'星期二'；如果是3，则返回'星期三'。如果是其他，则返回'输入有误'
  2.  2 DELIMITER $
  3.  3   CREATE PROCEDURE pro_testIf(IN num INT,OUT str VARCHAR(32))
  4.  4 BEGIN
  5.  5    IF num=1 THEN
  6.  6       SET str = '星期一';
  7.  7    ELSEIF num = 2 THEN
  8.  8       SET str = '星期二';
  9.  9    ELSEIF num = 3 THEN
  10. 10       SET str = '星期三';
  11. 11    ELSE
  12. 12       SET str = '输入错误';
  13. 13    END IF;
  14. 14 END $
  15. 15
  16. 16 CALL pro_testIf(3,@str);
  17. 17 SELECT @str;

结果图

  3.5、带有循环功能的存储过程

  1.  1 -- 需求：输入一个整数，求和。例如:输入100 ,统计1~100的和
  2.  2 DELIMITER $
  3.  3    CREATE PROCEDURE pro_testWhile(IN num INT,OUT result INT)
  4.  4 BEGIN
  5.  5     -- 定义一个局部变量  for(int i=1;i<=100;i++)
  6.  6     DECLARE i INT DEFAULT 1; -- 定义一个局部变量i，int类型，默认值为1。
  7.  7     DECLARE vsum INT DEFAULT 0; -- 定义一个局部变量vsum，int类型，默认值为0。
  8.  8     WHILE i <= num DO
  9.  9        SET vsum = vsum + i;
  10. 10        SET i = i + 1;
  11. 11     END WHILE;
  12. 12     SET result = vsum;
  13. 13 END $
  14. 14
  15. 15 CALL pro_testWhile(100,@result);
  16. 16 SELECT @result;

结果图

Java基础 JDBC连接MySQL数据库============================

本文知识点（目录）：

1、什么是jdbc
    2、jdbc接口的核心API
    3、使用JDBC技术连接MySQL数据库的方法
    4、使用Statement执行sql语句（DDL、DML、DQL）
    5、使用PreparedStatement执行sql语句
    6、使用callablestaement执行sql语句，调用存储过程

7、附录（jdbc连接数据库 实操）
    8、完整的JDBC封装过程，及调用jdbc的使用过程实例

1、什么是jdbc

简单的讲就是：使用java代码(程序)发送sql语句的技术，称为jdbc技术。

2、jdbc接口的核心API

  1.  1 |-Driver 接口：表示java驱动程序接口。所有的具体的数据库厂商要实现的接口.
  2.  2    |-connect(String url, Properties info)：连接数据库的方法
  3.  3      Url：连接数据库的URL
  4.  4      URL语法：jdbc协议:数据库子协议://主机:端口/数据库名
  5.  5      User：数据库的用户名
  6.  6      Password：数据的用户密码
  7.  7 |-DriverManager 类：驱动管理器类，用于管理所有的注册的驱动程序
  8.  8    |-registerDriver(Driver driver)：注册驱动类对象
  9.  9    |-getConnection(String url, String user, String password)：获取连接对象
  10. 10 |-Connection 接口：表示java程序和数据库的连接对象
  11. 11    |-createStatement()
  12. 12    |-prepareStatement(String sql)：创建PreparedStatement对象
  13. 13    |-prepareCall(String sql)：创建CallableStatement对象
  14. 14 |-statement 接口：用于执行静态的sql语句
  15. 15    |-executeUpdate(String sql): 执行静态的sql语句（DDL、DML）
  16. 16    |-executeQuery(String sql) ：静态的查询sql语句（DQL）
  17. 17    |-PreparedStatement 接口：用于执行预编译sql语句
  18. 18      |-executeUpdate(String sql)：执行静态的sql语句（DDL、DML）
  19. 19      |-executeQuery(String sql)：静态的查询sql语句（DQL）
  20. 20    |-CallableStatement 接口：用于执行存储过程的sql语句(call xxx)
  21. 21 |-ResultSet 接口：用于封装查询出来的数据
  22. 22    |-next()：将光标移到下一行
  23. 23    |-getxxx(int columnIndex)：获取列的值（有getInt()、getString()、getArray()、getURL() 等等）
    24    |-getRow()：获取当前行编号。

3、使用JDBC技术连接MySQL数据库的方法

  1.  1 package com.shore.a_jdbc;
  2.  2
  3.  3 import java.sql.Connection;
  4.  4 import java.sql.Driver;
  5.  5 import java.sql.DriverManager;
  6.  6 import java.util.Properties;
  7.  7
  8.  8 /**
  9.  9  * @author DSHORE/2019-3-23
  10. 10  *
  11. 11  */
  12. 12 //连接MySQL数据库的几种方法
  13. 13 public class connJDBC {
  14. 14     //                 jdbc协议:数据库的子协议:主机:端口/要连接的数据库名称
  15. 15     private String url = "jdbc:mysql://localhost:3306/school";//连接数据库的URL链接
  16. 16     private String user = "root";//用户名
  17. 17     private String password = "123456";//密码
  18. 18     /*
  19. 19      * 第一种方法：
  20. 20      * */
  21. 21     public void test1() throws Exception{
  22. 22         //1.创建驱动程序类对象
  23. 23         Driver driver = new com.mysql.jdbc.Driver();
  24. 24         //Driver driver = new org.gjt.mm.mysql.Driver();//旧版本的创建方法
  25. 25         //设置用户名密码
  26. 26         Properties props = new Properties();
  27. 27         props.setProperty("user",user);
  28. 28         props.setProperty("password",password);
  29. 29         //2.连接数据库,返回连接对象
  30. 30         Connection conn = driver.connect(url, props);
  31. 31         System.out.println(conn);//返回值：com.mysql.jdbc.JDBC4Connection@29c56c60，表示已连接成功
  32. 32     }
  33. 33     /*
  34. 34      * 第二种方法：使用驱动管理器类连接数据库
  35. 35      * */
  36. 36     public void test2()throws Exception{
  37. 37         //1.创建驱动程序类对象
  38. 38         Driver driver = new com.mysql.jdbc.Driver();//MySQL数据库
  39. 39         //Driver driver2 = new com.oracle.jdbc.Driver();//Oracle数据库
  40. 40         //注册驱动程序(可以注册多个驱动)
  41. 41         DriverManager.registerDriver(driver);
  42. 42         //DriverManager.registerDriver(driver2);
  43. 43         //2.连接数据库
  44. 44         Connection conn=DriverManager.getConnection(url, user, password);
  45. 45         System.out.println(conn);
  46. 46     }
  47. 47     /*
  48. 48      * 第三种方法：使用加载驱动程序类 来注册 驱动程序。(推荐使用这种方式连接数据库)
  49. 49      * */
  50. 50     public void test3() throws Exception{
  51. 51         //通过得到字节码对象的方式加载静态代码块,从而注册驱动
  52. 52         Class.forName("com.mysql.jdbc.Driver");
  53. 53         //2.连接数据库
  54. 54         Connection conn = DriverManager.getConnection(url, user, password);
  55. 55         System.out.println(conn);
  56. 56     }
  57. 57 }

4、使用Statement执行sql语句

  4.1、执行DDL语句

  1.  1 package com.shore.b_statement;
  2.  2
  3.  3 import java.sql.Connection;
  4.  4 import java.sql.DriverManager;
  5.  5 import java.sql.SQLException;
  6.  6 import java.sql.Statement;
  7.  7
  8.  8 import org.junit.Test;
  9.  9 /*
  10. 10  *使用statement对象执行静态sql语句（创建表）
  11. 11  **/
  12. 12 public class Demo1 {
  13. 13     //连接数据库的URL
  14. 14     private String url="jdbc:mysql://localhost:3306/school";
  15. 15                  //jdbc协议:数据库的子协议:主机:端口/连接的数据库
  16. 16     private String user="root";//用户名
  17. 17     private String password="123456";//密码
  18. 18
  19. 19     //执行DDL语句
  20. 20     @Test
  21. 21     public void test1(){
  22. 22         Statement statement = null;
  23. 23         Connection connection = null;
  24. 24         try {
  25. 25             //1.注册驱动
  26. 26             Class.forName("com.mysql.jdbc.Driver");
  27. 27             //2.获取连接对象
  28. 28             connection = DriverManager.getConnection(url, user, password);
  29. 29             //3.创建statement
  30. 30             statement = connection.createStatement();
  31. 31             //4.准备sql语句
  32. 32             String sql = "CREATE TABLE student(id INT PRIMARY KEY AUTO_INCREMENT,NAME VARCHAR(32),sex VARCHAR(2));";//创建表
  33. 33             int count = statement.executeUpdate(sql);
  34. 34             System.out.println("影响行数："+count+"行！");
  35. 35         } catch (ClassNotFoundException e) {
  36. 36             e.printStackTrace();
  37. 37         } catch (SQLException e) {
  38. 38             e.printStackTrace();
  39. 39         }finally{
  40. 40             //5.关闭连接(顺序：后代开的先关闭)
  41. 41             try {
  42. 42                 if(statement != null) statement.close();
  43. 43                 if(connection != null) connection.close();
  44. 44             } catch (SQLException e) {
  45. 45                 e.printStackTrace();
  46. 46             }
  47. 47         }
  48. 48     }
  49. 49 }

  4.2、执行DML语句

封装工具类(JdbcUtil.java) 文件。（由于连接数据库和关闭资源的那部分代码是不变的，所以将他们封装起来，用到时 就直接调用即可）

  1.  1 package com.shore.util;
  2.  2
  3.  3 import java.io.FileInputStream;
  4.  4 import java.io.FileNotFoundException;
  5.  5 import java.io.IOException;
  6.  6 import java.sql.Connection;
  7.  7 import java.sql.DriverManager;
  8.  8 import java.sql.ResultSet;
  9.  9 import java.sql.SQLException;
  10. 10 import java.sql.Statement;
  11. 11 import java.util.Properties;
  12. 12
  13. 13 public class JdbcUtil { //把固定不变的那部分代码封装起来
  14. 14     //动态连接数据
  15. 15     private static String url = null;
  16. 16     private static String user = null;//用户名
  17. 17     private static String password = null;//密码
  18. 18     private static String driverClass = null;
  19. 19     //静态代码块中(只加载一次)
  20. 20     static{
  21. 21         //读取db.properties
  22. 22         Properties props = new Properties();
  23. 23         try {
  24. 24             FileInputStream fis = new FileInputStream("./src/db.properties");
  25. 25             //加载文件
  26. 26             props.load(fis);
  27. 27             url = props.getProperty("url");
  28. 28             user = props.getProperty("user");
  29. 29             password = props.getProperty("password");
  30. 30             driverClass = props.getProperty("driverClass");
  31. 31             //注册驱动
  32. 32             Class.forName(driverClass);
  33. 33         } catch (FileNotFoundException e) {
  34. 34             e.printStackTrace();
  35. 35         } catch (IOException e) {
  36. 36             e.printStackTrace();
  37. 37         } catch (ClassNotFoundException e) {
  38. 38             e.printStackTrace();
  39. 39             System.out.println("注册驱动失败");
  40. 40         }
  41. 41     }
  42. 42     //获取连接
  43. 43     public static Connection getConnection(){
  44. 44         try {
  45. 45             Connection conn = DriverManager.getConnection(url, user, password);
  46. 46             return conn;
  47. 47         } catch (SQLException e) {
  48. 48             e.printStackTrace();
  49. 49             throw new RuntimeException();
  50. 50         }
  51. 51     }
  52. 52     //释放资源
  53. 53     public static void close(Connection conn,Statement stmt,ResultSet rs){
  54. 54         try {
  55. 55             if(stmt != null) stmt.close();
  56. 56             if(conn != null) conn.close();
  57. 57             if(rs != null) rs.close();
  58. 58         } catch (SQLException e) {
  59. 59             e.printStackTrace();
  60. 60         }
  61. 61     }
  62. 62 }

db.properties配置文件（存储数据库链接、用户及密码等）

  1. 1 url = jdbc:mysql://localhost:3306/school  //把数据库的链接入口配置在一个文件中，方便以后操作(更改账号密码等等)
  2. 2 user = root
  3. 3 password = 123456
  4. 4 driverClass = com.mysql.jdbc.Driver

执行DML语句 正文

  1.  1 package com.shore.b_statement;
  2.  2
  3.  3 import java.sql.Connection;
  4.  4 import java.sql.ResultSet;
  5.  5 import java.sql.SQLException;
  6.  6 import java.sql.Statement;
  7.  7
  8.  8 import org.junit.Test;
  9.  9
  10. 10 import com.bw.util.JdbcUtil;
  11. 11
  12. 12 /**
  13. 13  * 使用statement执行DML语句（添加、删除、修改数据）
  14. 14  *
  15. 15  */
  16. 16 public class Demo2 {
  17. 17     /*
  18. 18      * 向student表中添加数据
  19. 19      * */
  20. 20     @Test
  21. 21     public void testInsert(){
  22. 22         ResultSet rs = null;
  23. 23         Connection conn = null;
  24. 24         Statement stmt = null;
  25. 25         //通过工具类获取;连接对象
  26. 26         conn = JdbcUtil.getConnection();
  27. 27         //常见statement对象
  28. 28         try {
  29. 29             stmt=conn.createStatement();
  30. 30         } catch (SQLException e) {
  31. 31             e.printStackTrace();
  32. 32         }
  33. 33         String sql = "INSERT INTO student(NAME,sex) VALUES('张三','女');";
  34. 34         try {
  35. 35             int count = stmt.executeUpdate(sql);
  36. 36             System.out.println(count);
  37. 37         } catch (SQLException e) {
  38. 38             e.printStackTrace();
  39. 39         }
  40. 40         JdbcUtil.close(conn,stmt,rs);
  41. 41     }
  42. 42     /*
  43. 43      * 修改student表中的数据
  44. 44      * */
  45. 45     @Test
  46. 46     public void testUpdate(){
  47. 47         ResultSet rs = null;
  48. 48         Connection conn =null;
  49. 49         Statement stmt = null;
  50. 50         //通过工具类获取;连接对象
  51. 51         conn = JdbcUtil.getConnection();
  52. 52         //常见statement对象
  53. 53         try {
  54. 54             stmt = conn.createStatement();
  55. 55         } catch (SQLException e) {
  56. 56             e.printStackTrace();
  57. 57         }
  58. 58         String sql = "UPDATE student SET NAME = '王五' WHERE id = 1;";
  59. 59         try {
  60. 60             int count=stmt.executeUpdate(sql);
  61. 61             System.out.println(count);
  62. 62         } catch (SQLException e) {
  63. 63             e.printStackTrace();
  64. 64         }
  65. 65         JdbcUtil.close(conn,stmt,rs);
  66. 66     }
  67. 67     /*
  68. 68      * 删除student表中的数据
  69. 69      * */
  70. 70     @Test
  71. 71     public void testDelete(){
  72. 72         ResultSet rs = null;
  73. 73         Connection conn = null;
  74. 74         Statement stmt = null;
  75. 75         //通过工具类获取;连接对象
  76. 76         conn = JdbcUtil.getConnection();
  77. 77         //常见statement对象
  78. 78         try {
  79. 79             stmt = conn.createStatement();
  80. 80         } catch (SQLException e) {
  81. 81             e.printStackTrace();
  82. 82         }
  83. 83         String sql = "DELETE FROM student WHERE id = 3;";
  84. 84         try {
  85. 85             int count = stmt.executeUpdate(sql);
  86. 86             System.out.println(count);
  87. 87         } catch (SQLException e) {
  88. 88             e.printStackTrace();
  89. 89         }
  90. 90         JdbcUtil.close(conn,stmt,rs);
  91. 91     }
  92. 92 }

  4.3、执行DQL语句

  1.  1 package com.shore.b_statement;
  2.  2
  3.  3 import java.sql.Connection;
  4.  4 import java.sql.ResultSet;
  5.  5 import java.sql.SQLException;
  6.  6 import java.sql.Statement;
  7.  7
  8.  8 import org.junit.Test;
  9.  9
  10. 10 import com.bw.util.JdbcUtil;
  11. 11
  12. 12 /*
  13. 13  * 使用statement执行sql语句(查询操作语句)
  14. 14  * */
  15. 15 public class Demo3 {
  16. 16     @Test
  17. 17     public void test1(){
  18. 18         ResultSet rs = null;
  19. 19         Connection conn = null;
  20. 20         Statement stmt = null;
  21. 21         //获取连接
  22. 22         conn = JdbcUtil.getConnection();
  23. 23         //创建statement
  24. 24         try {
  25. 25             stmt = conn.createStatement();
  26. 26         } catch (SQLException e) {
  27. 27             e.printStackTrace();
  28. 28         }
  29. 29         //准备sql语句
  30. 30         String sql = "SELECT * FROM student;";//查询表中所有数据
  31. 31         try {
  32. 32             rs=stmt.executeQuery(sql);
  33. 33             /*//移动光标
  34. 34             boolean flag=rs.next();
  35. 35             if(flag){
  36. 36                 //取出值
  37. 37                 //索引
  38. 38                 int id=rs.getInt(1);
  39. 39                 String name=rs.getString(2);
  40. 40                 String sex=rs.getString(3);
  41. 41                 System.out.println(id+","+name+","+sex);
  42. 42             }*/
  43. 43             //遍历结果
  44. 44             while(rs.next()){
  45. 45                 int id=rs.getInt("id");
  46. 46                 String name=rs.getString("name");
  47. 47                 String sex=rs.getString("sex");
  48. 48                 System.out.println(id+","+name+","+sex);
  49. 49             }
  50. 50         } catch (SQLException e) {
  51. 51             e.printStackTrace();
  52. 52         }finally{
  53. 53             JdbcUtil.close(conn, stmt, rs);
  54. 54         }
  55. 55     }
  56. 56 }

5、使用PreparedStatement执行sql语句

  1.  1 package com.shore.c_prepared;
  2.  2
  3.  3 import java.sql.Connection;
  4.  4 import java.sql.PreparedStatement;
  5.  5 import java.sql.ResultSet;
  6.  6 import java.sql.SQLException;
  7.  7
  8.  8 import org.junit.Test;
  9.  9
  10. 10 import com.bw.util.JdbcUtil;
  11. 11
  12. 12 /*
  13. 13  * preparedStatement执行sql语句（有效防止sql注入的问题）
  14. 14  * */
  15. 15 public class Demo1 {
  16. 16     //增加
  17. 17     @Test
  18. 18     public void testInsert(){
  19. 19         Connection conn = null;
  20. 20         PreparedStatement stmt = null;
  21. 21         ResultSet rs = null;
  22. 22         //1.获取连接
  23. 23         conn = JdbcUtil.getConnection();
  24. 24         //2准备预编译的sql
  25. 25         String sql = "INSERT INTO student(NAME,sex) VALUES(?,?);";//?表示一个参数的占位符
  26. 26         try {
  27. 27             //3执行预编译的sql语句(检查语法)
  28. 28             stmt = conn.prepareStatement(sql);
  29. 29             //4.设置参数
  30. 30             stmt.setString(1,"赵六"); //可用name作为参数代表“赵六” 从页面传值来此
  31. 31             stmt.setString(2,"女");
  32. 32             //5.发送参数,执行sql
  33. 33             int count = stmt.executeUpdate();
  34. 34             System.out.println("影响了"+count+"行");
  35. 35         } catch (SQLException e) {
  36. 36             e.printStackTrace();
  37. 37         }finally{
  38. 38             JdbcUtil.close(conn, stmt, rs);
  39. 39         }
  40. 40     }
  41. 41 }

6、使用callablestaement执行sql语句，调用存储过程

MySQL存储过程 相关知识点：https://www.cnblogs.com/dshore123/p/10559182.html

  1. 1 -- 1.带有输入参数的存储过程
  2. 2 DELIMITER $
  3. 3 CREATE PROCEDURE pro_test(IN sid INT)
  4. 4 BEGIN
  5. 5     SELECT * FROM student WHERE id=sid;
  6. 6 END $
  7. 7
  8. 8 CALL pro_test(2);
  1. 1 -- 2.执行带有输出参数的存储过程
  2. 2 DELIMITER $
  3. 3 CREATE PROCEDURE pro_test(IN sid INT,OUT sname VARCHAR(32))
  4. 4 BEGIN
  5. 5     SELECT NAME INTO sname FROM student WHERE id=sid;
  6. 6 END $
  7. 7
  8. 8 CALL pro_test(2,@sname);
  9. 9 SELECT @sname;

正文代码

  1.  1 package com.shore.d_callable;
  2.  2
  3.  3 import java.sql.CallableStatement;
  4.  4 import java.sql.Connection;
  5.  5 import java.sql.ResultSet;
  6.  6 import java.sql.SQLException;
  7.  7
  8.  8 import org.junit.Test;
  9.  9
  10. 10 import com.bw.util.JdbcUtil;
  11. 11
  12. 12 /**
  13. 13  * 使用CallableSatement调用存储过程
  14. 14  * @author lx
  15. 15  *
  16. 16  */
  17. 17 public class Demo1 {
  18. 18
  19. 19     /*
  20. 20      * 1.带有输入参数的存储过程
  21. 21      * CALL pro_test(2)
  22. 22      * */
  23. 23     @Test
  24. 24     public void test1(){
  25. 25         Connection conn = null;
  26. 26         ResultSet rs = null;
  27. 27         CallableStatement stmt = null;
  28. 28         //获取连接
  29. 29         conn = JdbcUtil.getConnection();
  30. 30         //准备sql
  31. 31         String sql = "CALL pro_test(?);"; //可以执行预编译的sql
  32. 32         try {
  33. 33             //预编译
  34. 34             stmt = conn.prepareCall(sql);
  35. 35             //设置参数
  36. 36             stmt.setInt(1, 2);
  37. 37             //注意:所有的存储过程的sql语句都是使用executeQuery
  38. 38             rs = stmt.executeQuery();
  39. 39             //遍历起结果
  40. 40             while(rs.next()){
  41. 41                 int id = rs.getInt("id");
  42. 42                 String name = rs.getString("name");
  43. 43                 String sex = rs.getString("sex");
  44. 44                 System.out.println(id+","+name+","+sex);
  45. 45             }
  46. 46         } catch (SQLException e) {
  47. 47             e.printStackTrace();
  48. 48         }finally{
  49. 49             JdbcUtil.close(conn, stmt, rs);
  50. 50         }
  51. 51     }
  52. 52     /*
  53. 53      *
  54. 54      * 2.执行带有输出参数的存储过程
  55. 55      * */
  56. 56     @Test
  57. 57     public void test2(){
  58. 58         Connection conn = null;
  59. 59         ResultSet rs = null;
  60. 60         CallableStatement stmt = null;
  61. 61         //获取连接
  62. 62         conn = JdbcUtil.getConnection();
  63. 63         //准备sql
  64. 64         String sql = "CALL pro_test(?,?);"; //第一个?是输入参数,第二个?是输出参数
  65. 65         try {
  66. 66             //预编译
  67. 67             stmt = conn.prepareCall(sql);
  68. 68             //设置参数
  69. 69             stmt.setInt(1, 2);
  70. 70             //设置输出参数
  71. 71             /*
  72. 72              *参数 一:参数的位置
  73. 73              *参数二:存储过程中输出参数的jdbc类型  varchar(32)
  74. 74              * */
  75. 75             stmt.registerOutParameter(2,java.sql.Types.VARCHAR);
  76. 76             //发送参数,执行
  77. 77             stmt.executeQuery();
  78. 78             /* //得到输出参数的值
  79. 79              * 索引值:预编译sql中的输出参数的位置
  80. 80              * */
  81. 81             String result = stmt.getString(2);//getxxx方法专门用于获取存储过程中的输出参数
  82. 82             System.out.println(result);
  83. 83         } catch (SQLException e) {
  84. 84             e.printStackTrace();
  85. 85         }finally{
  86. 86             JdbcUtil.close(conn, stmt, rs);
  87. 87         }
  88. 88     }
  89. 89 }

附录

创建表：contact

  1. 1 create contact(
  2. 2     id varchar(32) primary key,
  3. 3     name varchar(32),
  4. 4     sxe varchar(32),
  5. 5     age int,
  6. 6     phone varchar(32),
  7. 7     email varchar(32),
  8. 8     qq varchar(32)
  9. 9 );

使用“增删改查(CRUD)”操作，连接数据库

  1.   1 package com.shore.dao.impl;
  2.   2
  3.   3 import java.sql.Connection;
  4.   4 import java.sql.PreparedStatement;
  5.   5 import java.sql.ResultSet;
  6.   6 import java.sql.SQLException;
  7.   7 import java.util.ArrayList;
  8.   8 import java.util.List;
  9.   9 import java.util.UUID;
  10.  10
  11.  11 import com.shore.dao.ContactDAO;
  12.  12 import com.shore.entity.Contact;
  13.  13 import com.shore.util.JdbcUtil;
  14.  14
  15.  15 public class ContactDAOMySqlImpl implements ContactDAO{
  16.  16
  17.  17     //添加数据
  18.  18     public void addContact(Contact contact) {
  19.  19         Connection conn;
  20.  20         PreparedStatement stmt = null;
  21.  21         ResultSet rs = null;
  22.  22         conn = JdbcUtil.getConnection();
  23.  23         String sql = "insert into contact(id,name,sex,age,phone,email,qq) values(?,?,?,?,?,?,?)";
  24.  24         try {
  25.  25             //执行预编译的sql语句(检查语法)
  26.  26             stmt = conn.prepareStatement(sql);
  27.  27             String id = UUID.randomUUID().toString().replace("-","");
  28.  28             stmt.setString(1, id);
  29.  29             stmt.setString(2, contact.getName());
  30.  30             stmt.setString(3, contact.getSex());
  31.  31             stmt.setInt(4, contact.getAge());
  32.  32             stmt.setString(5, contact.getPhone());
  33.  33             stmt.setString(6, contact.getEmail());
  34.  34             stmt.setString(7, contact.getQq());
  35.  35             stmt.executeUpdate();
  36.  36         } catch (SQLException e) {
  37.  37             e.printStackTrace();
  38.  38         }finally{
  39.  39             JdbcUtil.close(conn, stmt, rs);
  40.  40         }
  41.  41     }
  42.  42
  43.  43     //查询所有数据
  44.  44     public List<Contact> finAll() {
  45.  45         Connection conn;
  46.  46         PreparedStatement stmt = null;
  47.  47         ResultSet rs = null;
  48.  48         //获取连接
  49.  49         conn = JdbcUtil.getConnection();
  50.  50         String sql = "select * from contact";
  51.  51         try {
  52.  52             //执行预编译的sql语句(检查语法)
  53.  53             stmt = conn.prepareStatement(sql);
  54.  54             //执行sql;
  55.  55             rs = stmt.executeQuery();
  56.  56             List<Contact> list = new ArrayList<Contact>();
  57.  57             while(rs.next()){
  58.  58                 //创建Contact对象
  59.  59                 Contact c = new Contact();
  60.  60                 c.setId(rs.getString("id"));
  61.  61                 c.setName(rs.getString("name"));
  62.  62                 c.setSex(rs.getString("sex"));
  63.  63                 c.setAge(rs.getInt("age"));
  64.  64                 c.setPhone(rs.getString("phone"));
  65.  65                 c.setEmail(rs.getString("email"));
  66.  66                 c.setQq(rs.getString("qq"));
  67.  67                 list.add(c);
  68.  68             }
  69.  69             return list;
  70.  70         } catch (SQLException e) {
  71.  71             e.printStackTrace();
  72.  72             throw new RuntimeException();
  73.  73         }finally{
  74.  74             JdbcUtil.close(conn, stmt, rs);
  75.  75         }
  76.  76     }
  77.  77
  78.  78     //根据id删除数据
  79.  79     public void delContact(String id) {
  80.  80         Connection conn;
  81.  81         PreparedStatement stmt = null;
  82.  82         ResultSet rs = null;
  83.  83         conn = JdbcUtil.getConnection();
  84.  84         String sql = "delete from contact where id=?";
  85.  85         try {
  86.  86             //执行预编译的sql语句(检查语法)
  87.  87             stmt = conn.prepareStatement(sql);
  88.  88             stmt.setString(1,id)
  89.  89             //发送参数,执行sql;
  90.  90             stmt.executeUpdate();
  91.  91         } catch (SQLException e) {
  92.  92             e.printStackTrace();
  93.  93         }finally{//关闭资源
  94.  94             JdbcUtil.close(conn, stmt, rs);
  95.  95         }
  96.  96     }
  97.  97
  98.  98     //修改数据
  99.  99     public void updateContact(Contact contact) {
  100. 100         Connection conn;
  101. 101         PreparedStatement stmt = null;
  102. 102         ResultSet rs = null;
  103. 103         conn = JdbcUtil.getConnection();
  104. 104         String sql = "update contact set name=?,sex=?,age=?,phone=?,email=?,qq=? where id=?";
  105. 105         try {
  106. 106             //执行预编译的sql语句(检查语法)
  107. 107             stmt=conn.prepareStatement(sql);
  108. 108             stmt.setString(1, contact.getName());
  109. 109             stmt.setString(2, contact.getSex());
  110. 110             stmt.setInt(3, contact.getAge());
  111. 111             stmt.setString(4, contact.getPhone());
  112. 112             stmt.setString(5, contact.getEmail());
  113. 113             stmt.setString(6, contact.getQq());
  114. 114             stmt.setString(7, contact.getId());
  115. 115             stmt.executeUpdate();
  116. 116         } catch (SQLException e) {
  117. 117             e.printStackTrace();
  118. 118         }finally{
  119. 119             JdbcUtil.close(conn, stmt, rs);
  120. 120         }
  121. 121     }
  122. 122
  123. 123     //根据id查询数据（作用于修改数据的时候）
  124. 124     public Contact findById(String id) {
  125. 125         Connection conn;
  126. 126         PreparedStatement stmt = null;
  127. 127         ResultSet rs = null;
  128. 128         //获取连接
  129. 129         conn = JdbcUtil.getConnection();
  130. 130         String sql = "select * from contact where id=?";
  131. 131         try {
  132. 132             //执行预编译的sql语句(检查语法)
  133. 133             stmt = conn.prepareStatement(sql);
  134. 134             stmt.setString(1, id);
  135. 135             rs = stmt.executeQuery();
  136. 136             Contact c = null;
  137. 137             while(rs.next()){
  138. 138                 //创建Contact对象
  139. 139                 c = new Contact();
  140. 140                 c.setId(rs.getString("id"));
  141. 141                 c.setName(rs.getString("name"));
  142. 142                 c.setSex(rs.getString("sex"));
  143. 143                 c.setAge(rs.getInt("age"));
  144. 144                 c.setPhone(rs.getString("phone"));
  145. 145                 c.setEmail(rs.getString("email"));
  146. 146                 c.setQq(rs.getString("qq"));
  147. 147             }
  148. 148             return c;
  149. 149         } catch (SQLException e) {
  150. 150             e.printStackTrace();
  151. 151             throw new RuntimeException();
  152. 152         }finally{
  153. 153             JdbcUtil.close(conn, stmt, rs);
  154. 154         }
  155. 155     }
  156. 156
  157. 157     //判断账号昵称是否重复，若重复，页面端显示此账号已存在，请重新取名
  158. 158     public boolean checkContact(String name) {
  159. 159         Connection conn;
  160. 160         PreparedStatement stmt = null;
  161. 161         ResultSet rs = null;
  162. 162         //获取数据库的连接
  163. 163         conn = JdbcUtil.getConnection();
  164. 164         //准备sql
  165. 165         String sql = "select * from contact where name = ?";
  166. 166         try {
  167. 167             //执行预编译的sql语句(检查语法)
  168. 168             stmt = conn.prepareStatement(sql);
  169. 169             //设置参数
  170. 170             stmt.setString(1, name);
  171. 171             //发送参数,执行sql
  172. 172             rs = stmt.executeQuery();
  173. 173             if(rs.next()){
  174. 174                 return true;
  175. 175             }else{
  176. 176                 return false;
  177. 177             }
  178. 178         } catch (SQLException e) {
  179. 179             e.printStackTrace();
  180. 180             throw new RuntimeException();
  181. 181         }finally{//关闭资源
  182. 182             JdbcUtil.close(conn, stmt, rs);
  183. 183         }
  184. 184     }
  185. 185 }

完整的JDBC封装过程，及调用jdbc的使用过程实例

db.properties 配置文件（配置了数据库的驱动、入口连接、用户名、密码），主要作用：方便以后修改

  1. 1 jdbcDriver=com.mysql.jdbc.Driver
  2. 2 url=jdbc:mysql://localhost:3306/school
  3. 3 userName=root
  4. 4 passWord=123456

JdbcUtils类，把不变动的、且每次都使用到的那部分代码封装起来

  1.  1 package com.shore.utils;
  2.  2
  3.  3 import java.io.InputStream;
  4.  4 import java.sql.Connection;
  5.  5 import java.sql.DriverManager;
  6.  6 import java.sql.ResultSet;
  7.  7 import java.sql.SQLException;
  8.  8 import java.sql.Statement;
  9.  9 import java.util.Properties;
  10. 10
  11. 11 /**
  12. 12  * @author DSHORE/2019-5-29
  13. 13  *
  14. 14  */
  15. 15 public class JdbcUtils {
  16. 16     //静态代码块执行后，这几个参数，就有值了
  17. 17     private static String jdbcDriver = "";
  18. 18     private static String url = "";
  19. 19     private static String userName = "";
  20. 20     private static String passWord = "";
  21. 21
  22. 22     private JdbcUtils() {
  23. 23     }
  24. 24
  25. 25     static {//静态代码块
  26. 26         try {
  27. 27             //读取配置文件db.properties，用于获取数据库的入口连接url、用户名、密码，以及数据库的驱动
  28. 28             InputStream inputStream = JdbcUtils.class.getResourceAsStream("/db.properties");
  29. 29             Properties properties = new Properties();
  30. 30             properties.load(inputStream);//加载文件
  31. 31             inputStream.close();
  32. 32             jdbcDriver = properties.getProperty("jdbcDriver");
  33. 33             url = properties.getProperty("url");
  34. 34             userName = properties.getProperty("userName");
  35. 35             passWord = properties.getProperty("passWord");
  36. 36             Class.forName(jdbcDriver); //注册驱动
  37. 37         } catch (Exception e) {
  38. 38             e.printStackTrace();
  39. 39         }
  40. 40     }
  41. 41
  42. 42     //获取连接
  43. 43     public static Connection getConnection() throws SQLException {
  44. 44         return DriverManager.getConnection(url, userName, passWord);
  45. 45     }
  46. 46
  47. 47     //关闭资源（比较严谨的写法）
  48. 48     public static void close(Connection connection, Statement statement,ResultSet resultSet) {
  49. 49         if (resultSet != null) {
  50. 50             try {
  51. 51                 resultSet.close();
  52. 52             } catch (SQLException e) {
  53. 53                 e.printStackTrace();
  54. 54             }finally{
  55. 55                 if (statement != null) {
  56. 56                     try {
  57. 57                         statement.close();
  58. 58                     } catch (SQLException e) {
  59. 59                         e.printStackTrace();
  60. 60                     }finally{
  61. 61                         if (connection != null) {
  62. 62                             try {
  63. 63                                 connection.close();
  64. 64                             } catch (SQLException e) {
  65. 65                                 e.printStackTrace();
  66. 66                             }
  67. 67                         }
  68. 68                     }
  69. 69                 }
  70. 70             }
  71. 71         }
  72. 72     }
  73. 73 }

↑ 此处封装已完成。

下面用个简单的例子来演示怎么使用：

  1.  1 package com.shore.test;
  2.  2
  3.  3 import java.sql.Connection;
  4.  4 import java.sql.PreparedStatement;
  5.  5 import java.sql.ResultSet;
  6.  6 import java.sql.SQLException;
  7.  7
  8.  8 import org.junit.Test;
  9.  9
  10. 10 import com.shore.utils.JdbcUtils;
  11. 11
  12. 12 /**
  13. 13  * @author DSHORE/2019-5-29
  14. 14  *
  15. 15  */
  16. 16 public class jdbcTest {
  17. 17
  18. 18     @Test
  19. 19     public void testInsert(){
  20. 20         Connection connection = null;
  21. 21         PreparedStatement preparedStatement = null;
  22. 22         ResultSet resultSet = null;
  23. 23         try {
  24. 24             //1.获取连接
  25. 25             connection = JdbcUtils.getConnection();
  26. 26             //2.准备预编译的sql
  27. 27             String sql = "insert into teacher(sname,sex) values(?,?);";//?表示一个参数的占位符
  28. 28             //3.执行预编译的sql语句(检查语法)
  29. 29             preparedStatement = connection.prepareStatement(sql);
  30. 30             //4.设置参数
  31. 31             preparedStatement.setString(1,"赵六"); //可用name作为参数代表“赵六” 从页面传值来此
  32. 32             preparedStatement.setString(2,"女");
  33. 33             //5.发送参数,执行sql
  34. 34             int count = preparedStatement.executeUpdate();
  35. 35             System.out.println("影响了"+count+"行");
  36. 36         } catch (SQLException e) {
  37. 37             e.printStackTrace();
  38. 38         }finally{
  39. 39             JdbcUtils.close(connection, preparedStatement, resultSet);
  40. 40         }
  41. 41     }
  42. 42 }

运行后，结果图：

ava基础MySQL存储过程 Java基础 JDBC连接MySQL数据库的更多相关文章

  1. java用JDBC连接MySQL数据库的详细知识点

    想实现java用JDBC连接MySQL数据库.需要有几个准备工作: 1.下载Connector/J的库文件,下载Connector/J的官网地址:http://www.mysql.com/downlo ...

  2. JAVA使用jdbc连接MYSQL简单示例

    以下展示的为JAVA使用jdbc连接MYSQL简单示例: import java.sql.DriverManager; import java.sql.ResultSet; import java.s ...

  3. JAVA通过JDBC连接Oracle数据库详解【转载】

    JAVA通过JDBC连接Oracle数据库详解 (2011-03-15 00:10:03) 转载▼http://blog.sina.com.cn/s/blog_61da86dd0100q27w.htm ...

  4. 【Java】JDBC连接MySQL

    JDBC连接MySQL 虽然在项目中通常用ORM的框架实现持久化.但经常因测试某些技术的需要,要写一个完整的JDBC查询数据库.写一个在这儿备份. 首先引入驱动包: <dependencies& ...

  5. java 通过jdbc连接MySQL数据库

    先了解下JDBC的常用接口 1.驱动程序接口Driver 每种数据库的驱动程序都应该提供一个实现java.sql.Driver接口的类,简称Driver类.通常情况下,通过java.lang.Clas ...

  6. Java使用JDBC连接MySQL数据库

    1.引用 JDBC(Java Data Base Connectivity,java数据库连接)是一种用于执行SQL语句的Java API,可以为多种关系数据库提供统一访问,它由一组用Java语言编写 ...

  7. java通过jdbc连接mysql数据库

    下载mysql驱动包: http://dev.mysql.com/downloads/file.php?id=456317 解压之后里面有个mysql-connector-java-5.1.35-bi ...

  8. 【转】Java 通过JDBC连接Mysql数据库的方法和实例【图文说明】

    JDBC(Java Data Base Connectivity,java数据库连接)是一种用于执行SQL语句的Java API,可以为多种关系数据库提供统一访问,它由一组用Java语言编写的类和接口 ...

  9. Java 通过JDBC连接Mysql数据库的方法和实例

    JDBC(Java Data Base Connectivity,java数据库连接)是一种用于执行SQL语句的Java API,可以为多种关系数据库提供统一访问,它由一组用Java语言编写的类和接口 ...

随机推荐

  1. Java 虚拟机垃圾收集机制详解

    本文摘自深入理解 Java 虚拟机第三版 垃圾收集发生的区域 之前我们介绍过 Java 内存运行时区域的各个部分,其中程序计数器.虚拟机栈.本地方法栈三个区域随线程共存亡.栈中的每一个栈帧分配多少内存 ...

  2. Spring Cloud Alibaba 初体验(六) Seata 及结合 MyBatis 与 MyBatis-Plus 的使用

    一.下载与运行 本文使用 Seata 1.1.0:https://github.com/seata/seata/releases Windows 环境下双击 bin/seata-server.bat ...

  3. day1(初始化项目结构)

    1.初始化项目结构  └─shiyanlou_project    │  .gitignore    │  README.en.md           # 英文    │  README.md    ...

  4. Executor类

    //测试的线程                                                           public class Record implements Run ...

  5. moviepy音视频开发：音频文件存取类AudioFileClip属性和方法介绍

    ☞ ░ 前往老猿Python博文目录 ░ 一.概述 AudioFileClip是AudioClip的直接子类,用于从一个音频文件或音频数组中读入音频到内存构建音频剪辑.但AudioFileClip并不 ...

  6. 第15.25节 PyQt(Python+Qt)入门学习：Model/View开发实战--使用QTableView展示Excel文件内容

    老猿Python博文目录 专栏:使用PyQt开发图形界面Python应用 老猿Python博客地址 一.概述 在前面的订阅专栏<第十九章.Model/View开发:QTableView的功能及属 ...

  7. 事后Postmortem会议

    会议图片 一.设想和目标 1. 我们的软件要解决什么问题?是否定义得很清楚?是否对典型用户和典型场景有清晰的描述? 我的软件是要建立一个失物招领网站,是一个为校园里的失误招领工作提供便利的平台.我们对 ...

  8. HuangB2ydjm

    Hi! 我现在呢还是学生,想想初中的同学都结婚生子了,自己,嗯.(啊!!!) 本科以及硕士读的都是应用统计 在这里请广大网友多多指教了! 如果有机会的话,大家可以一起造轮子 you can catch ...

  9. stringbuilder和stringbuffer速度比较

    同样的代码,只改了类型,分别为stringbuilder和stringbuffer,只比较一下,执行引擎为hive. 当数据量为100000条,string builder耗时280秒,stringb ...

  10. 如何更简单的使用Polly

    Polly 弹性瞬时错误处理库 Polly是一个C#实现的弹性瞬时错误处理库 它可以帮助我们做一些容错模式处理,比如: 超时与重试(Timeout and Retry) 熔断器(Circuit Bre ...