最全 jdbc从入门到精通

妖狐艹你老母 2022-07-13 15:27 224阅读 0赞

1.  **JDBC是什么？**
    
        jdbc是 java数据库连接(java DataBase Connectivity)技术的简称，由一组使用java语言编写的类与接口组成，可以为多种关系数据库提供统一访问。
2.  **没有使用jdbc之前操作[数据库][Link 1]的操作**
    
    1> 通过[MySQL][Link 1]的客户端工具，登录数据库服务器 （mysql -u root -p 密码）;   
    2>编写sql语句；   
    3>发送sql语句到数据库。
3.  **使用jdbc之后操作数据库的操作**
    
    登录数据库服务器（连接数据库服务器），获：取数据库的IP地址、端口、数据库用户名、密码。

/** * jdbc连接数据库 * @author APPle * */
    public class Demo1 { 
        //连接数据库的URL
        private String url = "jdbc:mysql://localhost:3306/day17";
                            // jdbc协议:数据库子协议:主机:端口/连接的数据库 //
    
        private String user = "root";//用户名
        private String password = "root";//密码
    
        /** * 第一种方法 * @throws Exception */
        @Test
        public void test1() throws Exception{
            //1.创建驱动程序类对象
            Driver driver = new com.mysql.jdbc.Driver(); //新版本
            //Driver driver = new org.gjt.mm.mysql.Driver(); //旧版本
    
            //设置用户名和密码
            Properties props = new Properties();
            props.setProperty("user", user);
            props.setProperty("password", password);
    
            //2.连接数据库，返回连接对象
            Connection conn = driver.connect(url, props);
    
            System.out.println(conn);
        }
    
        /** * 使用驱动管理器类连接数据库(注册了两次，没必要) * @throws Exception */
        @Test
        public void test2() throws Exception{
            Driver driver = new com.mysql.jdbc.Driver();
            //Driver driver2 = new com.oracle.jdbc.Driver();
            //1.注册驱动程序(可以注册多个驱动程序)
            DriverManager.registerDriver(driver);
            //DriverManager.registerDriver(driver2);
    
            //2.连接到具体的数据库
            Connection conn = DriverManager.getConnection(url, user, password);
            System.out.println(conn);
    
        }
    
        /** * （推荐使用这种方式连接数据库） * 推荐使用加载驱动程序类 来 注册驱动程序 * @throws Exception */
        @Test
        public void test3() throws Exception{
            //Driver driver = new com.mysql.jdbc.Driver();
    
            //通过得到字节码对象的方式加载静态代码块，从而注册驱动程序
            Class.forName("com.mysql.jdbc.Driver");
    
            //Driver driver2 = new com.oracle.jdbc.Driver();
            //1.注册驱动程序(可以注册多个驱动程序)
            //DriverManager.registerDriver(driver);
            //DriverManager.registerDriver(driver2);
    
            //2.连接到具体的数据库
            Connection conn = DriverManager.getConnection(url, user, password);
            System.out.println(conn);
    
        }
    
    }
    
     
      
       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
      
     
      
       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

3.jdbc接口核心api

java.sql.*   和  javax.sql.*
    
            |- Driver接口： 表示java驱动程序接口。所有的具体的数据库厂商要来实现此接口。
                |- connect(url, properties):  连接数据库的方法。
                        url: 连接数据库的URL 
                            URL语法： jdbc协议:数据库子协议://主机:端口/数据库
                            user： 数据库的用户名
                            password： 数据库用户密码
            |- DriverManager类： 驱动管理器类，用于管理所有注册的驱动程序
                |-registerDriver(driver)  : 注册驱动类对象
                |-Connection getConnection(url,user,password);  获取连接对象
    
            |- Connection接口： 表示java程序和数据库的连接对象。
                    |- Statement createStatement() ： 创建Statement对象
                    |- PreparedStatement prepareStatement(String sql)  创建PreparedStatement对象
                    |- CallableStatement prepareCall(String sql) 创建CallableStatement对象
    
            |- Statement接口： 用于执行静态的sql语句
                    |- int executeUpdate(String sql)  ： 执行静态的更新sql语句（DDL，DML）
                    |- ResultSet executeQuery(String sql)  ：执行的静态的查询sql语句（DQL）
    
            |-PreparedStatement接口：用于执行预编译sql语句
                    |- int executeUpdate() ： 执行预编译的更新sql语句（DDL，DML）
                    |-ResultSet executeQuery()  ： 执行预编译的查询sql语句（DQL）
    
                |-CallableStatement接口：用于执行存储过程的sql语句（call xxx）
                        |-ResultSet executeQuery()  ： 调用存储过程的方法
    
            |- ResultSet接口：用于封装查询出来的数据
                    |- boolean next() ： 将光标移动到下一行
                    |-getXX() : 获取列的值

4.使用Statement执行sql语句

4.1 执行DDL语句

/** * 执行DDL语句(创建表) */
        @Test
        public void test1(){
            Statement stmt = null;
            Connection conn = null;
            try {
                //1.驱动注册程序
                Class.forName("com.mysql.jdbc.Driver");
    
                //2.获取连接对象
                conn = DriverManager.getConnection(url, user, password);
    
                //3.创建Statement
                stmt = conn.createStatement();
    
                //4.准备sql
                String sql = "CREATE TABLE student(id INT PRIMARY KEY AUTO_INCREMENT,NAME VARCHAR(20),gender VARCHAR(2))";
    
                //5.发送sql语句，执行sql语句,得到返回结果
                int count = stmt.executeUpdate(sql);
    
                //6.输出
                System.out.println("影响了"+count+"行！");
            } catch (Exception e) {
                e.printStackTrace();
                throw new RuntimeException(e);
            } finally{
                //7.关闭连接(顺序:后打开的先关闭)
                if(stmt!=null)
                    try {
                        stmt.close();
                    } catch (SQLException e) {
                        e.printStackTrace();
                        throw new RuntimeException(e);
                    }
                if(conn!=null)
                    try {
                        conn.close();
                    } catch (SQLException e) {
                        e.printStackTrace();
                        throw new RuntimeException(e);
                    }
            }
        }
    
     
      
       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
      
     
      
       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

4.2 执行DML语句

/** * 使用Statement执行DML语句 * @author APPle * */
    public class Demo2 { 
        private String url = "jdbc:mysql://localhost:3306/day17";
        private String user = "root";
        private String password = "root";
    
        /** * 增加 */
        @Test
        public void testInsert(){
            Connection conn = null;
            Statement stmt = null;
            try {
                //通过工具类获取连接对象
                conn = JdbcUtil.getConnection();
    
                //3.创建Statement对象
                stmt = conn.createStatement();
    
                //4.sql语句
                String sql = "INSERT INTO student(NAME,gender) VALUES('李四','女')";
    
                //5.执行sql
                int count = stmt.executeUpdate(sql);
    
                System.out.println("影响了"+count+"行");
    
            } catch (Exception e) {
                e.printStackTrace();
                throw new RuntimeException(e);
            } finally{
                //关闭资源
                JdbcUtil.close(conn, stmt);
            }
        }
    
        /** * 修改 */
        @Test
        public void testUpdate(){
            Connection conn = null;
            Statement stmt = null;
            //模拟用户输入
            String name = "陈六";
            int id = 3;
            try {
                /*//1.注册驱动 Class.forName("com.mysql.jdbc.Driver"); //2.获取连接对象 conn = DriverManager.getConnection(url, user, password);*/
                //通过工具类获取连接对象
                conn = JdbcUtil.getConnection();
    
                //3.创建Statement对象
                stmt = conn.createStatement();
    
                //4.sql语句
                String sql = "UPDATE student SET NAME='"+name+"' WHERE id="+id+"";
    
                System.out.println(sql);
    
                //5.执行sql
                int count = stmt.executeUpdate(sql);
    
                System.out.println("影响了"+count+"行");
    
            } catch (Exception e) {
                e.printStackTrace();
                throw new RuntimeException(e);
            } finally{
                //关闭资源
                JdbcUtil.close(conn, stmt);
            }
        }
    
        /** * 删除 */
        @Test
        public void testDelete(){
            Connection conn = null;
            Statement stmt = null;
            //模拟用户输入
            int id = 3;
            try {
                /*//1.注册驱动 Class.forName("com.mysql.jdbc.Driver"); //2.获取连接对象 conn = DriverManager.getConnection(url, user, password);*/
                //通过工具类获取连接对象
                conn = JdbcUtil.getConnection();
    
                //3.创建Statement对象
                stmt = conn.createStatement();
    
                //4.sql语句
                String sql = "DELETE FROM student WHERE id="+id+"";
    
                System.out.println(sql);
    
                //5.执行sql
                int count = stmt.executeUpdate(sql);    
                System.out.println("影响了"+count+"行");
    
            } catch (Exception e) {
                e.printStackTrace();
                throw new RuntimeException(e);
            } finally{
                //关闭资源
                JdbcUtil.close(conn, stmt);
            }
        }
    }
    
     
      
       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
      
     
      
       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

/** * jdbc工具类 * */ public class JdbcUtil { private static String url = null; private static String user = null; private static String password = null; private static String driverClass = null; /** * 静态代码块中（只加载一次） */ static{ try { //读取db.properties文件 Properties props = new Properties(); /** * . 代表java命令运行的目录 * 在java项目下，. java命令的运行目录从项目的根目录开始 * 在web项目下， . java命令的而运行目录从tomcat/bin目录开始 * 所以不能使用点. */ //FileInputStream in = new FileInputStream("./src/db.properties"); /** * 使用类路径的读取方式 * / : 斜杠表示classpath的根目录 * 在java项目下，classpath的根目录从bin目录开始 * 在web项目下，classpath的根目录从WEB-INF/classes目录开始 */ InputStream in = JdbcUtil.class.getResourceAsStream("/db.properties"); //加载文件 props.load(in); //读取信息 url = props.getProperty("url"); user = props.getProperty("user"); password = props.getProperty("password"); driverClass = props.getProperty("driverClass"); //注册驱动程序 Class.forName(driverClass); } catch (Exception e) { e.printStackTrace(); System.out.println("驱程程序注册出错"); } } /** * 抽取获取连接对象的方法 */ public static Connection getConnection(){ try { Connection conn = DriverManager.getConnection(url, user, password); return conn; } catch (SQLException e) { e.printStackTrace(); throw new RuntimeException(e); } } /** * 释放资源的方法 */ public static void close(Connection conn,Statement stmt){ if(stmt!=null){ try { stmt.close(); } catch (SQLException e) { e.printStackTrace(); throw new RuntimeException(e); } } if(conn!=null){ try { conn.close(); } catch (SQLException e) { e.printStackTrace(); throw new RuntimeException(e); } } } public static void close(Connection conn,Statement stmt,ResultSet rs){ if(rs!=null) try { rs.close(); } catch (SQLException e1) { e1.printStackTrace(); throw new RuntimeException(e1); } if(stmt!=null){ try { stmt.close(); } catch (SQLException e) { e.printStackTrace(); throw new RuntimeException(e); } } if(conn!=null){ try { conn.close(); } catch (SQLException e) { e.printStackTrace(); throw new RuntimeException(e); } } } } 
     
      
       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
      
     
      
       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

4.3 执行DQL语句

/** * 使用Statement执行DQL语句（查询操作） */
    public class Demo3 { 
    
        @Test
        public void test1(){
            Connection conn = null;
            Statement stmt = null;
            try{
                //获取连接
                conn = JdbcUtil.getConnection();
                //创建Statement
                stmt = conn.createStatement();
                //准备sql
                String sql = "SELECT * FROM student";
                //执行sql
                ResultSet rs = stmt.executeQuery(sql);
    
                //移动光标
                /*boolean flag = rs.next(); flag = rs.next(); flag = rs.next(); if(flag){ //取出列值 //索引 int id = rs.getInt(1); String name = rs.getString(2); String gender = rs.getString(3); System.out.println(id+","+name+","+gender); //列名称 int id = rs.getInt("id"); String name = rs.getString("name"); String gender = rs.getString("gender"); System.out.println(id+","+name+","+gender); }*/
    
                //遍历结果
                while(rs.next()){
                    int id = rs.getInt("id");
                    String name = rs.getString("name");
                    String gender = rs.getString("gender");
                    System.out.println(id+","+name+","+gender);
                }
    
            }catch(Exception e){
                e.printStackTrace();
                throw new RuntimeException(e);
            }finally{
                JdbcUtil.close(conn, stmt);
            }
        }
    }
    
     
      
       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
      
     
      
       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

5.使用PreparedStatement执行sql语句

public class Demo1 { 
    
        /** * 增加 */
        @Test
        public void testInsert() {
            Connection conn = null;
            PreparedStatement stmt = null;
            try {
                //1.获取连接
                conn = JdbcUtil.getConnection();
    
                //2.准备预编译的sql
                String sql = "INSERT INTO student(NAME,gender) VALUES(?,?)"; //?表示一个参数的占位符
    
                //3.执行预编译sql语句(检查语法)
                stmt = conn.prepareStatement(sql);
    
                //4.设置参数值
                /** * 参数一： 参数位置 从1开始 */
                stmt.setString(1, "李四");
                stmt.setString(2, "男");
    
                //5.发送参数，执行sql
                int count = stmt.executeUpdate();
    
                System.out.println("影响了"+count+"行");
    
            } catch (Exception e) {
                e.printStackTrace();
                throw new RuntimeException(e);
            } finally {
                JdbcUtil.close(conn, stmt);
            }
        }
    
        /** * 修改 */
        @Test
        public void testUpdate() {
            Connection conn = null;
            PreparedStatement stmt = null;
            try {
                //1.获取连接
                conn = JdbcUtil.getConnection();
    
                //2.准备预编译的sql
                String sql = "UPDATE student SET NAME=? WHERE id=?"; //?表示一个参数的占位符
    
                //3.执行预编译sql语句(检查语法)
                stmt = conn.prepareStatement(sql);
    
                //4.设置参数值
                /** * 参数一： 参数位置 从1开始 */
                stmt.setString(1, "王五");
                stmt.setInt(2, 9);
    
                //5.发送参数，执行sql
                int count = stmt.executeUpdate();
    
                System.out.println("影响了"+count+"行");
    
            } catch (Exception e) {
                e.printStackTrace();
                throw new RuntimeException(e);
            } finally {
                JdbcUtil.close(conn, stmt);
            }
        }
    
        /** * 删除 */
        @Test
        public void testDelete() {
            Connection conn = null;
            PreparedStatement stmt = null;
            try {
                //1.获取连接
                conn = JdbcUtil.getConnection();
    
                //2.准备预编译的sql
                String sql = "DELETE FROM student WHERE id=?"; //?表示一个参数的占位符
    
                //3.执行预编译sql语句(检查语法)
                stmt = conn.prepareStatement(sql);
    
                //4.设置参数值
                /** * 参数一： 参数位置 从1开始 */
                stmt.setInt(1, 9);
    
                //5.发送参数，执行sql
                int count = stmt.executeUpdate();
    
                System.out.println("影响了"+count+"行");
    
            } catch (Exception e) {
                e.printStackTrace();
                throw new RuntimeException(e);
            } finally {
                JdbcUtil.close(conn, stmt);
            }
        }
    
        /** * 查询 */
        @Test
        public void testQuery() {
            Connection conn = null;
            PreparedStatement stmt = null;
            ResultSet rs = null;
            try {
                //1.获取连接
                conn = JdbcUtil.getConnection();
    
                //2.准备预编译的sql
                String sql = "SELECT * FROM student"; 
    
                //3.预编译
                stmt = conn.prepareStatement(sql);
    
                //4.执行sql
                rs = stmt.executeQuery();
    
                //5.遍历rs
                while(rs.next()){
                    int id = rs.getInt("id");
                    String name = rs.getString("name");
                    String gender = rs.getString("gender");
                    System.out.println(id+","+name+","+gender);
                }
    
            } catch (Exception e) {
                e.printStackTrace();
                throw new RuntimeException(e);
            } finally {
                //关闭资源
                JdbcUtil.close(conn,stmt,rs);
            }
        }
    }
    
     
      
       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
      
     
      
       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

--------------------

PreparedStatement vs Statment   
1）语法不同：PreparedStatement可以使用预编译的sql，而Statment只能使用静态的sql   
2）效率不同： PreparedStatement可以使用sql缓存区，效率比Statment高   
3）安全性不同： PreparedStatement可以有效防止sql注入，而Statment不能防止sql注入。

推荐使用PreparedStatement

6.CallableStatement执行存储过程

/** * 使用CablleStatement调用存储过程 * @author APPle * */
    public class Demo1 { 
    
        /** * 调用带有输入参数的存储过程 * CALL pro_findById(4); */
        @Test
        public void test1(){
            Connection conn = null;
            CallableStatement stmt = null;
            ResultSet rs = null;
            try {
                //获取连接
                conn = JdbcUtil.getConnection();
    
                //准备sql
                String sql = "CALL pro_findById(?)"; //可以执行预编译的sql
    
                //预编译
                stmt = conn.prepareCall(sql);
    
                //设置输入参数
                stmt.setInt(1, 6);
    
                //发送参数
                rs = stmt.executeQuery(); //注意： 所有调用存储过程的sql语句都是使用executeQuery方法执行！！！
    
                //遍历结果
                while(rs.next()){
                    int id = rs.getInt("id");
                    String name = rs.getString("name");
                    String gender = rs.getString("gender");
                    System.out.println(id+","+name+","+gender);
                }
    
            } catch (Exception e) {
                e.printStackTrace();
                throw new RuntimeException(e);
            } finally {
                JdbcUtil.close(conn, stmt ,rs);
            }
        }
    
        /** * 执行带有输出参数的存储过程 * CALL pro_findById2(5,@NAME); */
        @Test
        public void test2(){
            Connection conn = null;
            CallableStatement stmt = null;
            ResultSet rs = null;
            try {
                //获取连接
                conn = JdbcUtil.getConnection();
                //准备sql
                String sql = "CALL pro_findById2(?,?)"; //第一个？是输入参数，第二个？是输出参数
    
                //预编译
                stmt = conn.prepareCall(sql);
    
                //设置输入参数
                stmt.setInt(1, 6);
                //设置输出参数(注册输出参数)
                /** * 参数一： 参数位置 * 参数二： 存储过程中的输出参数的jdbc类型 VARCHAR(20) */
                stmt.registerOutParameter(2, java.sql.Types.VARCHAR);
    
                //发送参数，执行
                stmt.executeQuery(); //结果不是返回到结果集中，而是返回到输出参数中
    
                //得到输出参数的值
                /** * 索引值： 预编译sql中的输出参数的位置 */
                String result = stmt.getString(2); //getXX方法专门用于获取存储过程中的输出参数
    
                System.out.println(result);
    
            } catch (Exception e) {
                e.printStackTrace();
                throw new RuntimeException(e);
            } finally {
                JdbcUtil.close(conn, stmt ,rs);
            }
        }
    }

[Link 1]: http://lib.csdn.net/base/mysql