Java面向对象系列[v1.0.0][JDBC编程]

ゝ一世哀愁。 2022-12-11 13:45 244阅读 0赞

## JDBC4.2常用接口和类 ##

### DriverManager ###

*  DriverManager:用于管理JDBC驱动的服务类，程序中使用该类的主要功能是获取Connection对象，方法：`public static synchronized Connection getConnection(String url, String user, String pass) throws SQLException`获取url对应数据库的链接

### Connection ###

*  Connection:代表数据库连接对象，每个Connection代表一个物理连接会话，要访问数据库必须先获得数据库连接
    
     *  方法：`Statement createStatement() throws SQLException`返回一个Statement对象
     *  方法：`PreparedStatement prepareStatement(String sql)throw SQLException`返回预编译的Statement对象，即将SQL语句提交到数据库进行预编译
     *  方法：`CallableStatement prepareCall(String sql)throws SQLException`返回CallableStatement对象，用于调用存储过程
     *  三个方法都返回Statement对象，PreparedStatement、CallableStatement是Statement的子类，只有获得了Statement对象才可执行SQL语句
     *  方法：`SavePoint setSavepoint()`用于创建一个保存点
     *  方法：`SavePoint setSavepoint(String name)`用于创建一个指定名称的保存点
     *  方法：`void setTransactionIsolation(int level)`设置事务的隔离级别
     *  方法：`void rollback()`回滚事务
     *  方法：`void rollback(Savepoint savepoint)`将事务回滚到指定的保存点
     *  方法：`setAutoCommit(bollean autoCommit)`关闭自动提交，打开事务
     *  方法：`commit()`提交事务
     *  Java7为Connection新增了`setSchema(String schema)、getSchema()`两个方法，用于控制该Connection访问的数据库Schema
     *  Java7为Connection新增了`setNetworkTimeout(Executor executor, int milliseconds)、getNetworkTimeout()`两个方法，用于控制数据库连接的超时行为

### Statement ###

*  Statement:用于执行SQL语句的工具接口，可用于执行DDL、DCL、DML还可用于执行SQL查询，执行查询时会返回查询到的结果集
    
     *  方法：`ResultSet executeQuery(String sql) throws SQL Exception`该方法只能用于执行查询语句，并返回查询结果对应的ResultSet对象
     *  方法：`int executeUpdate(String sql) throws SQLException`该方法用于执行DML语句，并返回受影响的行数，也可以用于执行DDL语句，执行DDL语句将返回0
     *  方法：`bollean execute(String sql) throws SQLException`该方法可执行任何SQL语句，如果执行后第一个结果为ResultSet对象，则返回true，如果执行后第一个结果为受影响的行数或没有任何结果则返回false
     *  Java7为Statement新增了`closeOnCompletion()`方法，如果Statement执行了该方法，则当所有依赖于该Statement的ResultSet关闭时，该Statment会自动关闭
     *  Java7为Statement新增了`isCloseOnCompletion()`方法，该方法用于判断该Statement是否打开了`closeOnCompletion`
     *  Java8为Statement新增了多个重载的`executeLargeUpdate()`方法，他们相当于增强的`executeUpdate()`方法，返回值类型为long，当DML语句影响的记录条数超过Integer.MAX\_VALUE时，就应该使用executeLargeUpdate()方法

### PreparedStatement ###

*  PreparedStatement:预编译的Statement对象，它是Statement的子接口，允许数据库预编译SQL语句(这些SQL通常带有参数)，以后每次只改变SQL命令的参数，避免数据库每次都需要编译SQL语句，性能更佳，相对于Statement而言，使用PreparedStatement执行SQL语句时，无需再传入SQL语句，只需要为预编译的SQL语句传入参数值即可，它比Statement多了如下方法
    
     *  `void setXxx(int parameterIndex, Xxx value)`：该方法根据传入参数值的类型不同，需要使用不同的方法，传入的值根据索引传给SQL语句中指定位置的参数
     *  > PreparedStatement同样有executeUpdate()、executeQuery()和execute()方法，只不过这三个方法无须接收SQL字符串，因为PreparedStatement对象已经预编译了SQL命令，只要为这些命令传入参数即可
     *  Java8为PreparedStatement增加了不带参数的executeLargeUpdate()方法，执行DML语句影响的记录条数可能超过Integer.MAX\_VALUE时，就应该使用executeLargeUpdate()方法

### ResultSet ###

*  ResultSet:结果集对象，该对象包含访问结果集的方法，ResultSet可以通过列索引或列名获得列数据，它包含如下常用方法移动记录指针
    
     *  方法：`void close()`释放ResultSet对象
     *  方法：`boolean absolute(int row)`将结果集的记录指针移动到第row行，如果row是负数，则移动到倒数第row行，如果移动后的记录指针指向一条有效记录，则该方法返回true
     *  方法：`void beforeFirst()`将ResultSet的记录指针定位到首行之前，这是ResultSet结果集记录指针的初始状态，即记录指针的起始位置位于第一行之前
     *  方法：`boolean first()`将ResultSet的记录指针定位到首行，如果移动后的记录指针指向一条有效记录，则返回true
     *  方法：`boolean previous()`将ResutlSet的记录指针定位到上一行，如果移动后的记录指针指向一条有效记录，则该方法返回true
     *  方法：`boolean next()`将ResultSet的记录指针定位到下一行，如果移动后的记录指针指向一条有效记录，则该方法返回true
     *  方法：`boolean last()`将ResultSet的记录指针定位到最后一行，如果移动后的记录指针指向一条有效记录，则该方法返回true
     *  方法：`void afterLast()`将ResultSet的记录指针定位到最后一行之后

> JDK1.4以前，使用默认方法创建Statement所查询的ResultSet不支持absolute()、previous()等移动记录指针的方法，只支持next()这个移动记录指针的方法，也就是说只能向下移动，且每次只能移动一格

> JDK1.5之后是完全支持的

*  当移动了记录指针到指定行后，便可以通过ResutlSet的`getXxx(int columnIndex)`或`getXxx(String columnLabel)`方法来获取当前行、指定列的值，前者根据列索引获取，后者根据列名获取
 *  Java7新增了`<T>T getObject(int columnIndex, Class<T>type)`和`<T>T getObject(String columnLabel, Class<T>type)`两个泛型方法，可以获取任意类型的值

## JDBC数据库编程步骤 ##

### 加载数据驱动 ###

使用Class泪的forName()静态方法来加载驱动`Class.forName(driverClass)`,新的JDBC驱动已经可以通过SPI自动注册驱动类了，在JDBC驱动JAR包的META-INF\\services路径下会包含一个java.sql.Driver文件，该文件指定了JDBC驱动类，因此如果使用新的驱动JAR包，这步可以省略

// 加载MySQL驱动
    Class.forName("com.mysql.jdbc.Driver");
    // 加载Oracle驱动
    Class.forName("oracle.jdbc.driver.OracleDriver");

从实例代码看，加载驱动时并不是真正使用数据库驱动类，只是使用数据库驱动类名的字符串

### 获取数据库链接 ###

通过DriverManager获取数据库链接`DriverManager.getConnection(String url, String user, String pass);`  
数据库URL通常遵循`jdbc:subprotocol:other stuff`写法，其中jdbc是固定的，而subprotocol指定连接到特定数据库的驱动，other和stuff没有较强的规律，不同的数据库的URL写法差异较大，例如MySQL的`jdbc:mysql://hostname:port/databasename`，Oracle的`jdbc:oracle:thin:@hostname:port:database`

### 创建Statement对象 ###

通过Connection对象创建Statement对象

*  `createStatement()`:创建基本的Statement对象
 *  `prepareStatement(String sql)`:根据传入的SQL语句创建预编译的Statement对象
 *  `prepareCall(String sql)`:根据传入的SQL语句创建CallableStatement对象

### 使用Statement执行SQL ###

所有的Statement都有如下三个方法来执行SQL

*  `execute()`:可以执行任何SQL
 *  `executeUpdate()`:主要用于执行DML和DDL语句，执行DML语句返回受SQL语句影响的行数，执行DDL语句返回0
 *  `executeQuery()`:只能执行查询语句，返回ResultSet结果集对象

### 操作结果集 ###

如果执行的SQL语句是查询语句，则执行结果将返回一个ResultSet对象，该对象里保存了SQL语句查询结果

*  `next()/previous()/first()/last()/beforeFirst()/afterLast()/absolute()`
 *  `getXxx()`使用列索引作为参数性能更好，使用列名作为参数可读性更好

### 回收数据库资源 ###

关闭ResultSet、Statement、Connection等资源

### 代码示例 ###

import java.sql.*;
    
    public class ConnMySql
    { 
    	public static void main(String[] args) throws Exception
    	{ 
    		// 1.加载驱动，使用反射的知识，现在记住这么写。
    		Class.forName("com.mysql.cj.jdbc.Driver");
    		try (
    			// 2.使用DriverManager获取数据库连接,
    			// 其中返回的Connection就代表了Java程序和数据库的连接
    			// 不同数据库的URL写法需要查驱动文档知道，用户名、密码由DBA分配
    			Connection conn = DriverManager.getConnection(
    				"jdbc:mysql://127.0.0.1:3306/select_test?useSSL=false&serverTimezone=UTC",
    				"root", "32147");
    			// 3.使用Connection来创建一个Statment对象
    			Statement stmt = conn.createStatement();
    			// 4.执行SQL语句
    			/* Statement有三种执行sql语句的方法： 1 execute 可执行任何SQL语句。- 返回一个boolean值， 如果执行后第一个结果是ResultSet，则返回true，否则返回false 2 executeQuery 执行Select语句 － 返回查询到的结果集 3 executeUpdate 用于执行DML语句。－ 返回一个整数， 代表被SQL语句影响的记录条数 */
    			ResultSet rs = stmt.executeQuery("select s.*, teacher_name"
    				+ " from student_table s, teacher_table t"
    				+ " where t.teacher_id = s.java_teacher"))
    		{ 
    			// ResultSet有系列的getXxx(列索引 | 列名)，用于获取记录指针
    			// 指向行、特定列的值，不断地使用next()将记录指针下移一行，
    			// 如果移动之后记录指针依然指向有效行，则next()方法返回true。
    			while (rs.next())
    			{ 
    				System.out.println(rs.getInt(1) + "\t"
    					+ rs.getString(2) + "\t"
    					+ rs.getString(3) + "\t"
    					+ rs.getString(4));
    			}
    		}
    	}
    }

连接数据库应该使用SSL连接，连接更安全  
Java7改写了Connection、Statement、ResultSet等接口，都继承了AutoCloseable接口，因此可以由try语句来关闭

### CMD ###

set CLASSPATH=%CLASSPATH%;..\mysql-connector-java-8.0.13.jar
    java ConnMySql
    cmd

## 使用Statement执行SQL ##

使用Statement执行DDL和DML语句的步骤与执行普通查询基本类似，区别在于执行了DDL后返回值为0，执行了DML后返回的是受影响的数据条数

### executeLargeUpdate()/executeUpdate() ###

#### 将数据库配置信息分离 ####

driver=com.mysql.cj.jdbc.Driver
    url=jdbc:mysql://127.0.0.1:3306/select_test?useSSL=false&serverTimezone=UTC
    user=root
    pass=32147

#### 代码示例 ####

##### 执行DDL #####

import java.util.*;
    import java.io.*;
    import java.sql.*;
    
    public class ExecuteDDL
    { 
    	private String driver;
    	private String url;
    	private String user;
    	private String pass;
    	public void initParam(String paramFile)
    		throws Exception
    	{ 
    		// 使用Properties类来加载属性文件
    		var props = new Properties();
    		props.load(new FileInputStream(paramFile));
    		driver = props.getProperty("driver");
    		url = props.getProperty("url");
    		user = props.getProperty("user");
    		pass = props.getProperty("pass");
    	}
    	public void createTable(String sql) throws Exception
    	{ 
    		// 加载驱动
    		Class.forName(driver);
    		try (
    			// 获取数据库连接
    			Connection conn = DriverManager.getConnection(url, user, pass);
    			// 使用Connection来创建一个Statment对象
    			Statement stmt = conn.createStatement())
    		{ 
    			// 执行DDL,创建数据表
    			stmt.executeUpdate(sql);
    		}
    	}
    	public static void main(String[] args) throws Exception
    	{ 
    		var ed = new ExecuteDDL();
    		ed.initParam("mysql.ini");
    		ed.createTable("create table jdbc_test "
    			+ "( jdbc_id int auto_increment primary key, "
    			+ "jdbc_name varchar(255), "
    			+ "jdbc_desc text);");
    		System.out.println("-----建表成功-----");
    	}
    }

##### CMD #####

set CLASSPATH=%CLASSPATH%;../mysql-connector-java-8.0.13.jar
    java ExecuteDDL
    cmd

##### 执行DML #####

import java.util.*;
    import java.io.*;
    import java.sql.*;
    
    public class ExecuteDML
    { 
    	private String driver;
    	private String url;
    	private String user;
    	private String pass;
    
    	public void initParam(String paramFile)
    		throws Exception
    	{ 
    		// 使用Properties类来加载属性文件
    		var props = new Properties();
    		props.load(new FileInputStream(paramFile));
    		driver = props.getProperty("driver");
    		url = props.getProperty("url");
    		user = props.getProperty("user");
    		pass = props.getProperty("pass");
    	}
    	public int insertData(String sql) throws Exception
    	{ 
    		// 加载驱动
    		Class.forName(driver);
    		try (
    			// 获取数据库连接
    			Connection conn = DriverManager.getConnection(url,
    				user, pass);
    			// 使用Connection来创建一个Statment对象
    			Statement stmt = conn.createStatement())
    		{ 
    			// 执行DML,返回受影响的记录条数
    			return stmt.executeUpdate(sql);
    		}
    	}
    	public static void main(String[] args) throws Exception
    	{ 
    		var ed = new ExecuteDML();
    		ed.initParam("mysql.ini");
    		int result = ed.insertData("insert into jdbc_test(jdbc_name, jdbc_desc)"
    			+ "select s.student_name, t.teacher_name "
    			+ "from student_table s, teacher_table t "
    			+ "where s.java_teacher = t.teacher_id;");
    		System.out.println("--系统中共有" + result + "条记录受影响--");
    	}
    }

##### CMD #####

set CLASSPATH=%CLASSPATH%;../mysql-connector-java-8.0.13.jar
    java ExecuteDML
    cmd

### execute() ###

Statement的execute()方法几乎可以执行任何SQL语句，但比较麻烦，通常没有必要使用它来执行SQL，使用executeQuery()和executeUpdate()方法更简单，但如果不知道SQL语句的类型，则只能使用execute()方法  
使用execute()方法执行SQL返回值只是个boolean值，它表明执行的SQL语句是否返回了ResultSet对象，Statement提供了两个方法获取执行结果

*  getResultSet():获取该Statement执行查询语句所返回的ResultSet对象
 *  getUpdateCount():获取该Statement()执行DML语句所影响的记录条数

#### 代码示例 ####

import java.util.*;
    import java.io.*;
    import java.sql.*;
    
    public class ExecuteSQL
    { 
    	private String driver;
    	private String url;
    	private String user;
    	private String pass;
    	public void initParam(String paramFile) throws Exception
    	{ 
    		// 使用Properties类来加载属性文件
    		var props = new Properties();
    		props.load(new FileInputStream(paramFile));
    		driver = props.getProperty("driver");
    		url = props.getProperty("url");
    		user = props.getProperty("user");
    		pass = props.getProperty("pass");
    	}
    	public void executeSql(String sql) throws Exception
    	{ 
    		// 加载驱动
    		Class.forName(driver);
    		try (
    			// 获取数据库连接
    			Connection conn = DriverManager.getConnection(url,
    				user, pass);
    			// 使用Connection来创建一个Statement对象
    			Statement stmt = conn.createStatement())
    		{ 
    			// 执行SQL,返回boolean值表示是否包含ResultSet
    			boolean hasResultSet = stmt.execute(sql);
    			// 如果执行后有ResultSet结果集
    			if (hasResultSet)
    			{ 
    				try (
    					// 获取结果集
    					ResultSet rs = stmt.getResultSet())
    				{ 
    					// ResultSetMetaData是用于分析结果集的元数据接口
    					ResultSetMetaData rsmd = rs.getMetaData();
    					int columnCount = rsmd.getColumnCount();
    					// 迭代输出ResultSet对象
    					while (rs.next())
    					{ 
    						// 依次输出每列的值
    						for (var i = 0; i < columnCount; i++)
    						{ 
    							System.out.print(rs.getString(i + 1) + "\t");
    						}
    						System.out.print("\n");
    					}
    				}
    			}
    			else
    			{ 
    				System.out.println("该SQL语句影响的记录有"
    					+ stmt.getUpdateCount() + "条");
    			}
    		}
    	}
    	public static void main(String[] args) throws Exception
    	{ 
    		var es = new ExecuteSQL();
    		es.initParam("mysql.ini");
    		System.out.println("------执行删除表的DDL语句-----");
    		es.executeSql("drop table if exists my_test");
    		System.out.println("------执行建表的DDL语句-----");
    		es.executeSql("create table my_test"
    			+ "(test_id int auto_increment primary key, "
    			+ "test_name varchar(255))");
    		System.out.println("------执行插入数据的DML语句-----");
    		es.executeSql("insert into my_test(test_name) "
    			+ "select student_name from student_table");
    		System.out.println("------执行查询数据的查询语句-----");
    		es.executeSql("select * from my_test");
    	}
    }

#### CMD ####

set CLASSPATH=%CLASSPATH%;../mysql-connector-java-8.0.13.jar
    java ExecuteSQL
    cmd

*  可以看到使用Statement不同的方法执行SQL的效果，执行DDL显示受影响的记录条数为0，执行DML语句显示插入修改删除的记录条数，执行查询语句则输出查询结果
 *  程序获得SQL执行结果时并没有根据各列的数据类型调用相应的getXxx()方法，而是直接使用getString()方法来取得，ResultSet的getString()方法几乎可以获得除Blob之外的任意类型列的值，因为所有的数据类型都可以自动转换成字符串类型

## 使用PreparedStatement执行SQL ##

如果经常需要执行结构相似的SQL，例如

insert into student_table values(null, 'davieyang1', 1);
    insert into student_table values(null, 'davieyang2', 2);

对于这种SQL可以使用带占位符(?)参数的SQL语句来代替

insert into student_table values(null, ?, ?);

Statement执行SQL语句时，不允许使用问号占位符参数，并且这个问号占位符必须获得值后才能执行，JDBC提供了PreparedStatement接口，它是Statement的子接口，可以预编译SQL，预编译后的SQL被存储在PreparedStatement对象中，然后可以使用该对象多次高效的执行该SQL

### 创建PreparedStatement对象 ###

创建PreparedStatement对象使用Connection的prepareStatement()方法

pstmt = conn.prepareStatement("insert into student_table values(null, ?, 1)");

*  PreparedStatement也提供了execute()、executeUpdate()、executeQuery()三个方法来执行SQL语句，但这三个方法无须参数，因为PreparedStatement已经存储了预编译的SQL语句
 *  PreparedStatement提供了setXxx(int index, Xxx value)方法来传入参数值，用于替换带有占位符的SQL中的占位符，否则无法执行，如果程序很清楚PreparedStatement预编译的SQL语句中各参数的类型，则使用相应的setXxx()方法来传入参数即可，如果不清楚，则可以使用setObject()方法来传入参数，由PreparedStatement负责类型转换

### 代码示例 ###

import java.util.*;
    import java.io.*;
    import java.sql.*;
    
    public class PreparedStatementTest
    { 
    	private String driver;
    	private String url;
    	private String user;
    	private String pass;
    	public void initParam(String paramFile) throws Exception
    	{ 
    		// 使用Properties类来加载属性文件
    		var props = new Properties();
    		props.load(new FileInputStream(paramFile));
    		driver = props.getProperty("driver");
    		url = props.getProperty("url");
    		user = props.getProperty("user");
    		pass = props.getProperty("pass");
    		// 加载驱动
    		Class.forName(driver);
    	}
    	public void insertUseStatement() throws Exception
    	{ 
    		long start = System.currentTimeMillis();
    		try (
    			// 获取数据库连接
    			Connection conn = DriverManager.getConnection(url,
    				user, pass);
    			// 使用Connection来创建一个Statment对象
    			Statement stmt = conn.createStatement())
    		{ 
    			// 需要使用100条SQL语句来插入100条记录
    			for (var i = 0; i < 100; i++)
    			{ 
    				stmt.executeUpdate("insert into student_table values("
    					+ " null, '姓名" + i + "', 1)");
    			}
    			System.out.println("使用Statement费时:"
    				+ (System.currentTimeMillis() - start));
    		}
    	}
    	public void insertUsePrepare() throws Exception
    	{ 
    		long start = System.currentTimeMillis();
    		try (
    			// 获取数据库连接
    			Connection conn = DriverManager.getConnection(url,
    				user, pass);
    			// 使用Connection来创建一个PreparedStatement对象
    			PreparedStatement pstmt = conn.prepareStatement(
    				"insert into student_table values(null, ?, 1)"))
    
    		{ 
    			// 100次为PreparedStatement的参数设值，就可以插入100条记录
    			for (var i = 0; i < 100; i++)
    			{ 
    				pstmt.setString(1, "姓名" + i);
    				pstmt.executeUpdate();
    			}
    			System.out.println("使用PreparedStatement费时:"
    				+ (System.currentTimeMillis() - start));
    		}
    	}
    	public static void main(String[] args) throws Exception
    	{ 
    		var pt = new PreparedStatementTest();
    		pt.initParam("mysql.ini");
    		pt.insertUseStatement();
    		pt.insertUsePrepare();
    	}
    }

**此外，使用PreparedStatement使用参数非常便利，但Statement则不得不拼接字符串，将参数拼接进去再传递参数值，而字符串拼接往往容易出错，PreparedStatement无疑降低了编程复杂度**

#### CMD ####

set CLASSPATH=%CLASSPATH%;../mysql-connector-java-8.0.13.jar
    java PreparedStatementTest
    cmd

### SQL注入 ###

driver=com.mysql.cj.jdbc.Driver
    url=jdbc:mysql://127.0.0.1:3306/select_test?useSSL=false&serverTimezone=UTC
    user=root
    pass=32147

**使用PreparedStatement还可以用于防止SQL注入**

import java.awt.*;
    import java.awt.event.*;
    import javax.swing.*;
    import java.util.*;
    import java.io.*;
    import java.sql.*;
    
    public class LoginFrame
    { 
    	private final String PROP_FILE = "mysql.ini";
    	private String driver;
    	// url是数据库的服务地址
    	private String url;
    	private String user;
    	private String pass;
    	// 登录界面的GUI组件
    	private JFrame jf = new JFrame("登录");
    	private JTextField userField = new JTextField(20);
    	private JTextField passField = new JTextField(20);
    	private JButton loginButton = new JButton("登录");
    	public void init() throws Exception
    	{ 
    		var connProp = new Properties();
    		connProp.load(new FileInputStream(PROP_FILE));
    		driver = connProp.getProperty("driver");
    		url = connProp.getProperty("url");
    		user = connProp.getProperty("user");
    		pass = connProp.getProperty("pass");
    		// 加载驱动
    		Class.forName(driver);
    		// 为登录按钮添加事件监听器
    		loginButton.addActionListener(e -> { 
    			// 登录成功则显示“登录成功”
    			if (validate(userField.getText(), passField.getText()))
    			{ 
    				JOptionPane.showMessageDialog(jf, "登录成功");
    			}
    			// 否则显示“登录失败”
    			else
    			{ 
    				JOptionPane.showMessageDialog(jf, "登录失败");
    			}
    		});
    		jf.add(userField, BorderLayout.NORTH);
    		jf.add(passField);
    		jf.add(loginButton, BorderLayout.SOUTH);
    		jf.pack();
    		jf.setVisible(true);
    	}
    
    	private boolean validate(String userName, String userPass)
    	{ 
    		// 执行查询的SQL语句
    		var sql = "select * from jdbc_test "
    			+ "where jdbc_name = '" + userName
    			+ "' and jdbc_desc = '" + userPass + "'";
    		System.out.println(sql);
    		try (
    			Connection conn = DriverManager.getConnection(url, user, pass);
    			Statement stmt = conn.createStatement();
    			ResultSet rs = stmt.executeQuery(sql))
    		{ 
    			// 如果查询的ResultSet里有超过一条的记录，则登录成功
    			if (rs.next())
    			{ 
    				return true;
    			}
    		}
    		catch (Exception e)
    		{ 
    			e.printStackTrace();
    		}
    		return false;
    	}
    
    	private boolean validate(String userName, String userPass)
    	{ 
    		try (
    			Connection conn = DriverManager.getConnection(url, user, pass);
    			PreparedStatement pstmt = conn.prepareStatement(
    				"select * from jdbc_test where jdbc_name = ? and jdbc_desc = ?"))
    		{ 
    			pstmt.setString(1, userName);
    			pstmt.setString(2, userPass);
    			try (
    				ResultSet rs = pstmt.executeQuery())
    			{ 
    				//如果查询的ResultSet里有超过一条的记录，则登录成功
    				if (rs.next())
    				{ 
    					return true;
    				}
    			}
    		}
    		catch (Exception e)
    		{ 
    			e.printStackTrace();
    		}
    		return false;
    	}
    
    	public static void main(String[] args) throws Exception
    	{ 
    		new LoginFrame().init();
    	}
    }

正常使用当然没问题，但如果用户输入的是’or true or’则拼接的SQL处理就会出问题，将这个字符串放到拼接的SQL中`select * from jdbc_test where jdbc_name=' ' or ture or ' ' and jdbc_desc=' '`很显然SQL将true当成了直接量

### PreparedStatement优势 ###

>  *  PreparedStatement预编译SQL语句，性能更好
>  *  PreparedStatement无需拼接SQL，编程简单
>  *  PreparedStatement防止SQL注入，安全性高

使用PreparedStatement执行带占位符参数的SQL语句，占位符只能代替普通值，不能代替表名，列名等数据库对象，更不能代替数据库关键字例如select、insert等

## 使用CallableStatement调用存储过程 ##

delimiter //
    create procedure add_pro(a int, b int, out sum int)
    begin
    set sum = a+b;
    end;
    //

SQL语句将MySQL的语句结束符改为双斜线，如此在创建存储过程中便可以使用分号作为分隔符，而不是以往的语句结束符

### 创建CallableStatement对象 ###

调用存储过程使用CallableStatement，可以通过Connection的prepareCall()方法来创建CallableStatement对象，创建该对象时候需要传入调用存储过程的SQL语句，调用存储过程总是这个格式：\{call 过程名(?,?,?..)\}，其中问号作为存储过程参数的占位符

cstmt = conn.prepareClaa("{call add_pro(?,?,?)}");

存储过程既有传入参数也有传出参数，CallableStatement提供了方法来处理这两类参数“

*  setXxx()方法为传入参数设置值
 *  registerOutParameter()方法来注册该参数
 *  getXxx()方法获取指定传出参数的值

//注册CallableStatement的第三个参数是int类型
    cstmt.registerOutParameter(3, Types.INTEGER);

### 代码示例 ###

> 传入参数分别是4、5，执行加法后传出总和9

import java.awt.*;
    import java.awt.event.*;
    import javax.swing.*;
    import java.util.*;
    import java.io.*;
    import java.sql.*;
    
    public class CallableStatementTest
    { 
    	private String driver;
    	private String url;
    	private String user;
    	private String pass;
    	public void initParam(String paramFile) throws Exception
    	{ 
    		// 使用Properties类来加载属性文件
    		var props = new Properties();
    		props.load(new FileInputStream(paramFile));
    		driver = props.getProperty("driver");
    		url = props.getProperty("url");
    		user = props.getProperty("user");
    		pass = props.getProperty("pass");
    	}
    	public void callProcedure() throws Exception
    	{ 
    		// 加载驱动
    		Class.forName(driver);
    		try (
    			// 获取数据库连接
    			Connection conn = DriverManager.getConnection(url, user, pass);
    			// 使用Connection来创建一个CallableStatment对象
    			CallableStatement cstmt = conn.prepareCall(
    				"{call add_pro(?, ?, ?)}"))
    		{ 
    			cstmt.setInt(1, 4);
    			cstmt.setInt(2, 5);
    			// 注册CallableStatement的第三个参数是int类型
    			cstmt.registerOutParameter(3, Types.INTEGER);
    			// 执行存储过程
    			cstmt.execute();
    			// 获取，并输出存储过程传出参数的值。
    			System.out.println("执行结果是: " + cstmt.getInt(3));
    		}
    	}
    	public static void main(String[] args) throws Exception
    	{ 
    		var ct = new CallableStatementTest();
    		ct.initParam("mysql.ini");
    		ct.callProcedure();
    	}
    }

### CMD ###

set CLASSPATH=%CLASSPATH%;../mysql-connector-java-8.0.13.jar
    java CallableStatementTest
    cmd