JDBC技术
Posted ekertree
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了JDBC技术相关的知识，希望对你有一定的参考价值。
JDBC
一、JDBC概述
数据的持久化
-
持久化(persistence)：把数据保存到可掉电式存储设备中以供之后使用。大多数情况下，特别是企业级应用，数据持久化意味着将内存中的数据保存到硬盘上加以”固化”，而持久化的实现过程大多通过各种关系数据库来完成。
-
持久化的主要应用是将内存中的数据存储在关系型数据库中，当然也可以存储在磁盘文件、XML数据文件中。
Java中的数据存储技术
-
在Java中，数据库存取技术可分为如下几类：
-
JDBC直接访问数据库
-
JDO (Java Data Object )技术
-
第三方O/R工具，如Hibernate, Mybatis 等
-
-
JDBC是java访问数据库的基石，JDO、Hibernate、MyBatis等只是更好的封装了JDBC。
JDBC介绍
- JDBC(Java Database Connectivity)是一个独立于特定数据库管理系统、通用的SQL数据库存取和操作的公共接口（一组API），定义了用来访问数据库的标准Java类库，（java.sql,javax.sql）使用这些类库可以以一种标准的方法、方便地访问数据库资源。
- JDBC为访问不同的数据库提供了一种统一的途径，为开发者屏蔽了一些细节问题。
- JDBC的目标是使Java程序员使用JDBC可以连接任何提供了JDBC驱动程序的数据库系统，这样就使得程序员无需对特定的数据库系统的特点有过多的了解，从而大大简化和加快了开发过程。
- 如果没有JDBC，那么Java程序访问数据库时是这样的：
- 有了JDBC，Java程序访问数据库时是这样的：
- 总结如下：
JDBC体系结构
- JDBC接口（API）包括两个层次：
- 面向应用的API：Java API，抽象接口，供应用程序开发人员使用（连接数据库，执行SQL语句，获得结果）。
- 面向数据库的API：Java Driver API，供开发商开发数据库驱动程序用。
JDBC是sun公司提供一套用于数据库操作的接口，java程序员只需要面向这套接口编程即可。
不同的数据库厂商，需要针对这套接口，提供不同实现。不同的实现的集合，即为不同数据库的驱动。 ————面向接口编程
JDBC程序编写步骤
补充：ODBC(Open Database Connectivity，开放式数据库连接)，是微软在Windows平台下推出的。使用者在程序中只需要调用ODBC API，由 ODBC 驱动程序将调用转换成为对特定的数据库的调用请求。
二、获取数据库连接
要素一：Driver接口实现类
Driver接口介绍
-
java.sql.Driver 接口是所有 JDBC 驱动程序需要实现的接口。这个接口是提供给数据库厂商使用的，不同数据库厂商提供不同的实现。
-
在程序中不需要直接去访问实现了 Driver 接口的类，而是由驱动程序管理器类(java.sql.DriverManager)去调用这些Driver实现。
- Oracle的驱动：oracle.jdbc.driver.OracleDriver
- mySql的驱动： com.mysql.jdbc.Driver
-
将上述jar包拷贝到Java工程的一个目录中，习惯上新建一个lib文件夹。
在驱动jar上右键-->Build Path-->Add to Build Path 
注意：如果是Dynamic Web Project（动态的web项目）话，则是把驱动jar放到WebContent（有的开发工具叫WebRoot）目录中的WEB-INF目录中的lib目录下即可
加载与注册JDBC驱动
-
加载驱动：加载 JDBC 驱动需调用 Class 类的静态方法 forName()，向其传递要加载的 JDBC 驱动的类名
- Class.forName(“com.mysql.jdbc.Driver”);
-
注册驱动：DriverManager 类是驱动程序管理器类，负责管理驱动程序
-
使用DriverManager.registerDriver(com.mysql.jdbc.Driver)来注册驱动
-
通常不用显式调用 DriverManager 类的 registerDriver() 方法来注册驱动程序类的实例，因为 Driver 接口的驱动程序类都包含了静态代码块，在这个静态代码块中，会调用 DriverManager.registerDriver() 方法来注册自身的一个实例。下图是MySQL的Driver实现类的源码：
-
要素二：URL
-
JDBC URL 用于标识一个被注册的驱动程序，驱动程序管理器通过这个 URL 选择正确的驱动程序，从而建立到数据库的连接。
-
JDBC URL的标准由三部分组成，各部分间用冒号分隔。
- jdbc:子协议:子名称
- 协议：JDBC URL中的协议总是jdbc
- 子协议：子协议用于标识一个数据库驱动程序
- 子名称：一种标识数据库的方法。子名称可以依不同的子协议而变化，用子名称的目的是为了定位数据库提供足够的信息。包含主机名(对应服务端的ip地址)，端口号，数据库名
-
举例：
-
几种常用数据库的 JDBC URL
-
MySQL的连接URL编写方式：
- jdbc:mysql://主机名称:mysql服务端口号/数据库名称?参数=值&参数=值
- jdbc:mysql://localhost:3306/test
- jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8（如果JDBC程序与服务器端的字符集不一致，会导致乱码，那么可以通过参数指定服务器端的字符集）
- jdbc:mysql://localhost:3306/test?user=root&password=123456
-
Oracle 9i的连接URL编写方式：
- jdbc:oracle:thin:@主机名称:oracle服务端口号:数据库名称
- jdbc:oracle:thin:@localhost:1521:test
-
SQLServer的连接URL编写方式：
-
jdbc:sqlserver://主机名称:sqlserver服务端口号:DatabaseName=数据库名称
-
jdbc:sqlserver://localhost:1433:DatabaseName=test
-
-
要素三：用户名和密码
- user,password可以用“属性名=属性值”方式告诉数据库
- 可以调用 DriverManager 类的 getConnection() 方法建立到数据库的连接
数据库连接方式举例
连接方式一
@Test
public void testConnection1() {
try {
//提供java.sql.Driver接口实现类的对象
Driver driver = null;
driver = new com.mysql.jdbc.Driver();
//提供url，指明具体操作的数据
String url = "jdbc:mysql://localhost:3306/test";
//jdbc:mysql:协议
//localhost:ip
//3306:端口号
//test:test数据库
//提供Properties的对象，指明用户名和密码
Properties info = new Properties();
info.setProperty("user", "root");
info.setProperty("password", "root");
//调用driver的connect()，获取连接
Connection con = driver.connect(url, info);
System.out.println(con);
} catch (SQLException e) {
e.printStackTrace();
}
}
上述代码中显式出现了第三方数据库的API
连接方式二
对方式一的迭代，出现了第三方的东西，为了具有可移植性，不希望出现第三方的东西。
@Test
public void testConnection2() {
try {
//实例化Driver
String className = "com.mysql.jdbc.Driver";
Class clazz = Class.forName(className);
Driver driver = (Driver) clazz.newInstance();
//提供url，指明具体操作的数据
String url = "jdbc:mysql://localhost:3306/test";
//提供Properties的对象，指明用户名和密码
Properties info = new Properties();
info.setProperty("user", "root");
info.setProperty("password", "root");
//调用driver的connect()，获取连接
Connection conn = driver.connect(url, info);
System.out.println(conn);
} catch (Exception e) {
e.printStackTrace();
}
}
连接方式三
使用DriverManager替换Driver
@Test
public void testConnection3() {
try {
//数据库连接的4个基本要素：
String url = "jdbc:mysql://localhost:3306/test";
String user = "root";
String password = "root";
String driverName = "com.mysql.jdbc.Driver";
//实例化Driver
Class clazz = Class.forName(driverName);
Driver driver = (Driver) clazz.newInstance();
//注册驱动
DriverManager.registerDriver(driver);
//获取连接
Connection conn = DriverManager.getConnection(url, user, password);
System.out.println(conn);
} catch (Exception e) {
e.printStackTrace();
}
}
连接方式四
直接省略实例化、注册驱动，在首次调用mysql的driver类时，有静态代码块包含了注册驱动的语句，所以不再需要我们手动注册，只是mysql可以省略，其他还是要有的
@Test
public void testConnection4() {
try {
//数据库连接的4个基本要素：
String url = "jdbc:mysql://localhost:3306/test";
String user = "root";
String password = "abc123";
String driverName = "com.mysql.jdbc.Driver";
//加载驱动 （①实例化Driver ②注册驱动）
Class.forName(driverName);
//Driver driver = (Driver) clazz.newInstance();
//注册驱动
//DriverManager.registerDriver(driver);
/*
可以注释掉上述代码的原因，是因为在mysql的Driver类中声明有：
static {
try {
DriverManager.registerDriver(new Driver());
} catch (SQLException var1) {
throw new RuntimeException("Can\'t register driver!");
}
}
*/
//3.获取连接
Connection conn = DriverManager.getConnection(url, user, password);
System.out.println(conn);
} catch (Exception e) {
e.printStackTrace();
}
}
连接方式五
将数据库连接需要的4个基本信息声明在配置文件中，通过读取配置文件的方式，获取连接
配置文件properties放在src下
user=root
password=root
url=jdbc:mysql://localhost:3306/test
driverClass=com.mysql.jdbc.Driver
@Test
public void testConnection5() throws Exception {
//1.加载配置文件
InputStream is = ConnectionTest.class.getClassLoader().getResourceAsStream("jdbc.properties");
Properties pros = new Properties();
pros.load(is);
//2.读取配置信息
String user = pros.getProperty("user");
String password = pros.getProperty("password");
String url = pros.getProperty("url");
String driverClass = pros.getProperty("driverClass");
//3.加载驱动
Class.forName(driverClass);
//4.获取连接
Connection conn = DriverManager.getConnection(url,user,password);
System.out.println(conn);
}
使用配置文件的好处：
①实现了代码和数据的分离，如果需要修改配置信息，直接在配置文件中修改，不需要深入代码
②如果修改了配置信息，省去重新编译的过程。
三、使用PreparedStatement实现CRUD操作
-
数据库连接被用于向数据库服务器发送命令和 SQL 语句，并接受数据库服务器返回的结果。其实一个数据库连接就是一个Socket连接。
-
在 java.sql 包中有 3 个接口分别定义了对数据库的调用的不同方式：
- Statement：用于执行静态 SQL 语句并返回它所生成结果的对象。
- PrepatedStatement：SQL 语句被预编译并存储在此对象中，可以使用此对象多次高效地执行该语句。
- CallableStatement：用于执行 SQL 存储过程
使用Statement操作数据表的弊端
-
通过调用 Connection 对象的 createStatement() 方法创建该对象。该对象用于执行静态的 SQL 语句，并且返回执行结果。
-
Statement 接口中定义了下列方法用于执行 SQL 语句：
int excuteUpdate(String sql)：执行更新操作INSERT、UPDATE、DELETE ResultSet executeQuery(String sql)：执行查询操作SELECT -
但是使用Statement操作数据表存在弊端：
- 问题一：存在拼串操作，繁琐
- 问题二：存在SQL注入问题
-
SQL 注入是利用某些系统没有对用户输入的数据进行充分的检查，而在用户输入数据中注入非法的 SQL 语句段或命令(如：
SELECT user, password FROM user_table WHERE user=\'a\' OR 1 = \' AND password = \' OR \'1\' = \'1\')，从而利用系统的 SQL 引擎完成恶意行为的做法。 -
对于 Java 而言，要防范 SQL 注入，只要用 PreparedStatement(从Statement扩展而来) 取代 Statement 就可以了。
-
代码演示：
public class StatementTest { // 使用Statement的弊端：需要拼写sql语句，并且存在SQL注入的问题 @Test public void testLogin() { Scanner scan = new Scanner(System.in); System.out.print("用户名："); String userName = scan.nextLine(); System.out.print("密 码："); String password = scan.nextLine(); // SELECT user,password FROM user_table WHERE USER = \'1\' or \' AND PASSWORD = \'=\'1\' or \'1\' = \'1\'; String sql = "SELECT user,password FROM user_table WHERE USER = \'" + userName + "\' AND PASSWORD = \'" + password + "\'"; User user = get(sql, User.class); if (user != null) { System.out.println("登陆成功!"); } else { System.out.println("用户名或密码错误！"); } } // 使用Statement实现对数据表的查询操作 public <T> T get(String sql, Class<T> clazz) { T t = null; Connection conn = null; Statement st = null; ResultSet rs = null; try { // 1.加载配置文件 InputStream is = StatementTest.class.getClassLoader().getResourceAsStream("jdbc.properties"); Properties pros = new Properties(); pros.load(is); // 2.读取配置信息 String user = pros.getProperty("user"); String password = pros.getProperty("password"); String url = pros.getProperty("url"); String driverClass = pros.getProperty("driverClass"); // 3.加载驱动 Class.forName(driverClass); // 4.获取连接 conn = DriverManager.getConnection(url, user, password); st = conn.createStatement(); rs = st.executeQuery(sql); // 获取结果集的元数据 ResultSetMetaData rsmd = rs.getMetaData(); // 获取结果集的列数 int columnCount = rsmd.getColumnCount(); if (rs.next()) { t = clazz.newInstance(); for (int i = 0; i < columnCount; i++) { // //1. 获取列的名称 // String columnName = rsmd.getColumnName(i+1); // 1. 获取列的别名 String columnName = rsmd.getColumnLabel(i + 1); // 2. 根据列名获取对应数据表中的数据 Object columnVal = rs.getObject(columnName); // 3. 将数据表中得到的数据，封装进对象 Field field = clazz.getDeclaredField(columnName); field.setAccessible(true); field.set(t, columnVal); } return t; } } catch (Exception e) { e.printStackTrace(); } finally { // 关闭资源 if (rs != null) { try { rs.close(); } catch (SQLException e) { e.printStackTrace(); } } if (st != null) { try { st.close(); } catch (SQLException e) { e.printStackTrace(); } } if (conn != null) { try { conn.close(); } catch (SQLException e) { e.printStackTrace(); } } } return null; } }
综上：
PreparedStatement的使用
- 可以通过调用 Connection 对象的 preparedStatement(String sql) 方法获取 PreparedStatement 对象
- PreparedStatement 接口是 Statement 的子接口，它表示一条预编译过的 SQL 语句
- PreparedStatement 对象所代表的 SQL 语句中的参数用问号(?)来表示，调用 PreparedStatement 对象的 setXxx() 方法来设置这些参数. setXxx() 方法有两个参数，第一个参数是要设置的 SQL 语句中的参数的索引(从 1 开始)，第二个是设置的 SQL 语句中的参数的值
PreparedStatement 对比 Statement
-
代码的可读性和可维护性。
-
PreparedStatement 能最大可能提高性能：
- DBServer会对预编译语句提供性能优化。因为预编译语句有可能被重复调用，所以语句在被DBServer的编译器编译后的执行代码被缓存下来，那么下次调用时只要是相同的预编译语句就不需要编译，只要将参数直接传入编译过的语句执行代码中就会得到执行。
- 在statement语句中,即使是相同操作但因为数据内容不一样,所以整个语句本身不能匹配,没有缓存语句的意义.事实是没有数据库会对普通语句编译后的执行代码缓存。这样每执行一次都要对传入的语句编译一次。
- (语法检查，语义检查，翻译成二进制命令，缓存)
-
PreparedStatement 可以防止 SQL 注入
Java与SQL对应数据类型转换表
| Java类型 | SQL类型 |
|---|---|
| boolean | BIT |
| byte | TINYINT |
| short | SMALLINT |
| int | INTEGER |
| long | BIGINT |
| String | CHAR,VARCHAR,LONGVARCHAR |
| byte array | BINARY , VAR BINARY |
| java.sql.Date | DATE |
| java.sql.Time | TIME |
| java.sql.Timestamp | TIMESTAMP |
JDBCUtils工具类
通用增删改查、获取链接，关闭资源
public class JDBCUtils { public static Connection getConnection() { //获取连接 Connection connection = null; PreparedStatement ps = null; try { //读取配置文件 InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("jdbc.properties"); Properties pros = new Properties(); pros.load(is); String user = pros.getProperty("user"); String password = pros.getProperty("password"); String url = pros.getProperty("url"); String driverClass = pros.getProperty("driverClass"); //加载驱动 Class.forName(driverClass); //获取连接 connection = (Connection) DriverManager.getConnection(url, user, password); } catch (ClassNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (SQLException e) { // TODO Auto-generated catch block e.printStackTrace(); } return connection; } //关闭资源 public static void closeResource(Connection connection,Statement ps) { try { if(ps!=null) ps.close(); } catch (SQLException e) { // TODO Auto-generated catch block e.printStackTrace(); } try { if(connection!=null) connection.close(); } catch (SQLException e) { // TODO Auto-generated catch block e.printStackTrace(); } } //关闭资源 public static void closeResource(Connection connection,Statement ps,ResultSet rs) { try { if(ps!=null) ps.close(); } catch (SQLException e) { // TODO Auto-generated catch block e.printStackTrace(); } try { if(connection!=null) connection.close(); } catch (SQLException e) { // TODO Auto-generated catch block e.printStackTrace(); } try { if(rs!=null) rs.close(); } catch (SQLException e) { // TODO Auto-generated catch block e.printStackTrace(); } } //通用的增、删、改操作 返回表中的一条记录 public static int update(String sql,Object ... args){ Connection conn = null; PreparedStatement ps = null; try { //1.获取数据库的连接 conn = JDBCUtils.getConnection(); //2.获取PreparedStatement的实例 (或：预编译sql语句) ps = conn.prepareStatement(sql); //3.填充占位符 for(int i = 0;i < args.length;i++){ ps.setObject(i + 1, args[i]); } //4.执行sql语句 /* * execute() * 如果执行的是查询操作，有返回结果，则返回true， * 如果是增删改，没有返回结果，则返回false */ //方式一： //ps.execute(); /* * executeUpdate() * 会返回影响数据库表中的行数 */ //方式二： return ps.executeUpdate(); } catch (Exception e) { e.printStackTrace(); }finally{ //5.关闭资源 JDBCUtils.closeResource(conn, ps); } return 0; } //通用的查询 public static <T>T getInstance(Class<T> clazz,String sql,Object ...args) { Connection connection = null; PreparedStatement ps = null; ResultSet rs = null; try { connection = JDBCUtils.getConnection(); ps = connection.prepareStatement(sql); for(int i = 0;i < args.length;i++) { ps.setObject(i+1, args[i]); } rs = ps.executeQuery(); //获取结果集的元素据 ResultSetMetaData rsmd = rs.getMetaData(); //通过resultsetmetadata获取结果集的列数 int columnCount = rsmd.getColumnCount(); if(rs.next()) { T t = null; try { t = clazz.newInstance(); } catch (InstantiationException e) { // TODO Auto-generated catch block e.printStackTrace(); } for(int i = 0;i < columnCount;i++) { //获取这一列的列值 Object columnValue = rs.getObject(i+1); //获取每个列的列名 不用了 //String columnName = rsmd.getColumnName(i+1); //获取每个列的别名 String columnLabel = rsmd.getColumnLabel(i+1); //给对象指定的某个属性赋值为columnValue,通过反射 Field field = clazz.getDeclaredField(columnLabel); //使私有属性可以访问 field.setAccessible(true); field.set(t, columnValue); } return t; } } catch (NoSuchFieldException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (SecurityException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IllegalArgumentException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IllegalAccessException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (SQLException e) { // TODO Auto-generated catch block e.printStackTrace(); }finally { JDBCUtils.closeResource(connection, ps, rs); } return null; } public static <T> List<T> getForList(Class<T> clazz,String sql,Object ...args) { Connection connection = null; PreparedStatement ps = null; ResultSet rs = null; try { connection = JDBCUtils.getConnection(); ps = connection.prepareStatement(sql); for(int i = 0;i < args.length;i++) { ps.setObject(i+1, args[i]); } rs = ps.executeQuery(); //获取结果集的元素据 ResultSetMetaData rsmd = rs.getMetaData(); //通过resultsetmetadata获取结果集的列数 int columnCount = rsmd.getColumnCount(); //创建集合对象 ArrayList<T> list = new ArrayList<T>(); while(rs.next()) { T t = null; try { t = clazz.newInstance(); } catch (InstantiationException e) { // TODO Auto-generated catch block e.printStackTrace(); } for(int i = 0;i < columnCount;i++) { //获取这一列的列值 Object columnValue = rs.getObject(i+1); //获取每个列的列名 不用了 //String columnName = rsmd.getColumnName(i+1); //获取每个列的别名 String columnLabel = rsmd.getColumnLabel(i+1); //给对象指定的某个属性赋值为columnValue,通过反射 Field field = clazz.getDeclaredField(columnLabel); //使私有属性可以访问 field.setAccessible(true); field.set(t, columnValue); } list.add(t); } return list; } catch (NoSuchFieldException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (SecurityException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IllegalArgumentException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IllegalAccessException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (SQLException e) { // TODO Auto-generated catch block e.printStackTrace(); }finally { JDBCUtils.closeResource(connection, ps, rs); } return null; }}
JDBC API小结
两种思想
-
面向接口编程的思想
-
ORM思想(object relational mapping)
- 一个数据表对应一个java类
- 表中的一条记录对应java类的一个对象
- 表中的一个字段对应java类的一个属性
sql是需要结合列名和表的属性名来写。注意起别名。
两种技术
- JDBC结果集的元数据：ResultSetMetaData
- 获取列数：getColumnCount()
- 获取列的别名：getColumnLabel()
- 通过反射，创建指定类的对象，获取指定的属性并赋值
四、操作BLOB类型字段
MySQL BLOB类型
-
MySQL中，BLOB是一个二进制大型对象，是一个可以存储大量数据的容器，它能容纳不同大小的数据。
-
插入BLOB类型的数据必须使用PreparedStatement，因为BLOB类型的数据无法使用字符串拼接写的。
-
MySQL的四种BLOB类型(除了在存储的最大信息量上不同外，他们是等同的)
- 实际使用中根据需要存入的数据大小定义不同的BLOB类型。
- 需要注意的是：如果存储的文件过大，数据库的性能会下降。
- 如果在指定了相关的Blob类型以后，还报错：xxx too large，那么在mysql的安装目录下，找my.ini文件加上如下的配置参数： max_allowed_packet=16M。同时注意：修改了my.ini文件之后，需要重新启动mysql服务。
向数据表中插入大数据类型
//获取连接 Connection connection = JDBCUtils.getConnection(); String sql = "insert into customers(name,email,birth,photo)value(?,?,?,?)"; PreparedStatement ps = null; FileInputStream fis = null; try { ps = connection.prepareStatement(sql); // 填充占位符 ps.setObject(1, "马牛逼"); ps.setObject(2, "mnb@163.com"); ps.setObject(3, "1968-6-6"); // 操作Blob类型的变量 fis = new FileInputStream(new File("C:\\\\Users\\\\sanmu\\\\Desktop\\\\1.jpg")); ps.setBlob(4, fis); //执行 ps.execute(); } catch (FileNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (SQLException e) { // TODO Auto-generated catch block e.printStackTrace(); } try { fis.close(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } JDBCUtils.closeResource(connection, ps);
修改数据表中的Blob类型字段
//获取连接 Connection connection = JDBCUtils.getConnection(); String sql = "update customers set photo = ? where id = ?"; PreparedStatement ps = null; FileInputStream fis = null; try { ps = connection.prepareStatement(sql); // 填充占位符 ps.setObject(1, "马牛逼"); ps.setObject(2, "mnb@163.com"); ps.setObject(3, "1968-6-6"); // 操作Blob类型的变量 fis = new FileInputStream(new File("C:\\\\Users\\\\sanmu\\\\Desktop\\\\1.jpg")); ps.setBlob(4, fis); //执行 ps.execute(); } catch (FileNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (SQLException e) { // TODO Auto-generated catch block e.printStackTrace(); } try { fis.close(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } JDBCUtils.closeResource(connection, ps);
从数据表中读取大数据类型
Connection connection = JDBCUtils.getConnection(); String sql = "select id,name,email,birth,photo from customers where id = ?"; PreparedStatement ps = null; ResultSet rs = null; InputStream is = null; FileOutputStream fos = null; try { ps = connection.prepareStatement(sql); ps.setInt(1, 22); rs = ps.executeQuery(); if(rs.next()) { int id = rs.getInt("id"); String name = rs.getString("name"); String email = rs.getString("email"); Date birth = rs.getDate("birth"); Customer customer = new Customer(id, name, email, birth); System.out.println(customer); //将blob类型的数据下载下来，以文件的方式保存到本地 Blob photo = rs.getBlob("photo"); is = photo.getBinaryStream(); fos = new FileOutputStream("C:\\\\\\\\Users\\\\\\\\sanmu\\\\\\\\Desktop\\\\\\\\2.jpg"); byte[] buffer = new byte[1024]; int len; while((len = is.read(buffer)) != -1) { fos.write(buffer, 0, len); } } } catch (FileNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (SQLException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); }finally { try { if(is != null) is.close(); if(fos != null) fos.close(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } JDBCUtils.closeResource(connection, ps, rs); } }
五、批量插入
批量执行SQL语句
当需要成批插入或者更新记录时，可以采用Java的批量更新机制，这一机制允许多条语句一次性提交给数据库批量处理。通常情况下比单独提交处理更有效率
JDBC的批量处理语句包括下面三个方法：
- addBatch(String)：添加需要批量处理的SQL语句或是参数；
- executeBatch()：执行批量处理语句；
- clearBatch():清空缓存的数据
通常我们会遇到两种批量执行SQL语句的情况：
- 多条SQL语句的批量处理；
- 一个SQL语句的批量传参；
高效的批量插入
举例：向数据表中插入20000条数据
- 数据库中提供一个goods表。创建如下：
CREATE TABLE goods(id INT PRIMARY KEY AUTO_INCREMENT,NAME VARCHAR(20));
使用Statement
Connection conn = JDBCUtils.getConnection();Statement st = conn.createStatement();for(int i = 1;i <= 20000;i++){ String sql = "insert into goods(name) values(\'name_\' + "+ i +")"; st.executeUpdate(sql);}
使用PreparedStatement
long start = System.currentTimeMillis(); Connection conn = JDBCUtils.getConnection(); String sql = "insert into goods(name)values(?)";PreparedStatement ps = conn.prepareStatement(sql);for(int i = 1;i <= 20000;i++){ ps.setString(1, "name_" + i); ps.executeUpdate();} long end = System.currentTimeMillis();System.out.println("花费的时间为：" + (end - start));//82340 JDBCUtils.closeResource(conn, ps);
改进1
- 修改1： 使用 addBatch() / executeBatch() / clearBatch()
- 修改2：mysql服务器默认是关闭批处理的，我们需要通过一个参数，让mysql开启批处理的支持。
- ?rewriteBatchedStatements=true 写在配置文件的url后面
- 修改3：使用更新的mysql 驱动：mysql-connector-java-5.1.37-bin.jar
@Testpublic void testInsert1() throws Exception{ long start = System.currentTimeMillis(); Connection conn = JDBCUtils.getConnection(); String sql = "insert into goods(name)values(?)"; PreparedStatement ps = conn.prepareStatement(sql); for(int i = 1;i <= 1000000;i++){ ps.setString(1, "name_" + i); //1.“攒”sql ps.addBatch(); if(i % 500 == 0){ //2.执行 ps.executeBatch(); //3.清空 ps.clearBatch(); } } long end = System.currentTimeMillis(); System.out.println("花费的时间为：" + (end - start));//20000条：625 //1000000条:14733 JDBCUtils.closeResource(conn, ps);}
最终的改进
- 层次四：在层次三的基础上操作
- 使用Connection 的 setAutoCommit(false) / commit()
@Testpublic void testInsert2() throws Exception{ long start = System.currentTimeMillis(); Connection conn = JDBCUtils.getConnection(); //1.设置为不自动提交数据 conn.setAutoCommit(false); String sql = "insert into goods(name)values(?)"; PreparedStatement ps = conn.prepareStatement(sql); for(int i = 1;i <= 1000000;i++){ ps.setString(1, "name_" + i); //1.“攒”sql ps.addBatch(); if(i % 500 == 0){ //2.执行 ps.executeBatch(); //3.清空 ps.clearBatch(); } } //2.提交数据 conn.commit(); long end = System.currentTimeMillis(); System.out.println("花费的时间为：" + (end - start));//1000000条:4978 JDBCUtils.closeResource(conn, ps);}
六、数据库事务
数据库事务介绍
-
事务：一组逻辑操作单元,使数据从一种状态变换到另一种状态。
-
事务处理（事务操作）：保证所有事务都作为一个工作单元来执行，即使出现了故障，都不能改变这种执行方式。当在一个事务中执行多个操作时，要么所有的事务都被提交(commit)，那么这些修改就永久地保存下来；要么数据库管理系统将放弃所作的所有修改，整个事务回滚(rollback)到最初状态。
-
为确保数据库中数据的一致性，数据的操纵应当是离散的成组的逻辑单元：当它全部完成时，数据的一致性可以保持，而当这个单元中的一部分操作失败，整个事务应全部视为错误，所有从起始点以后的操作应全部回退到开始状态。
JDBC事务处理
-
数据一旦提交，就不可回滚。
-
数据什么时候意味着提交？
- 当一个连接对象被创建时，默认情况下是自动提交事务：每次执行一个 SQL 语句时，如果执行成功，就会向数据库自动提交，而不能回滚。
- 关闭数据库连接，数据就会自动的提交。如果多个操作，每个操作使用的是自己单独的连接，则无法保证事务。即同一个事务的多个操作必须在同一个连接下。
-
JDBC程序中为了让多个 SQL 语句作为一个事务执行：
- 调用 Connection 对象的 setAutoCommit(false); 以取消自动提交事务
- 在所有的 SQL 语句都成功执行后，调用 commit(); 方法提交事务
- 在出现异常时，调用 rollback(); 方法回滚事务
若此时 Connection 没有被关闭，还可能被重复使用，则需要恢复其自动提交状态 setAutoCommit(true)。尤其是在使用数据库连接池技术时，执行close()方法前，建议恢复自动提交状态。
【案例：用户AA向用户BB转账100】
public void testJDBCTransaction() { Connection connection = null; try { // 1.获取数据库连接 conn = JDBCUtils.getConnection(); // 2.开启事务 conn.setAutoCommit(false); // 3.进行数据库操作 String sql1 = "update user_table set balance = balance - 100 where user = ?"; update(connection, sql1, "AA"); // 模拟网络异常 //System.out.println(10 / 0); String sql2 = "update user_table set balance = balance + 100 where user = ?"; update(connection, sql2, "BB"); // 4.若没有异常，则提交事务 connection.commit(); } catch (Exception e) { e.printStackTrace(); // 5.若有异常，则回滚事务 try { connection.rollback(); } catch (SQLException e1) { e1.printStackTrace(); } } finally { try { //6.恢复每次DML操作的自动提交功能 conn.setAutoCommit(true); } catch (SQLException e) { e.printStackTrace(); } //7.关闭连接 JDBCUtils.closeResource(connection, null, null); } }
其中，对数据库操作的方法为：
//考虑事务的通用增、删、改操作 public static int update(Connection connection,String sql,Object ... args){ PreparedStatement ps = null; try { //1.获取PreparedStatement的实例 (或：预编译sql语句) ps = connection.prepareStatement(sql); //2.填充占位符 for(int i = 0;i < args.length;i++){ ps.setObject(i + 1, args[i]); } //3.执行sql语句 /* * execute() * 如果执行的是查询操作，有返回结果，则返回true， * 如果是增删改，没有返回结果，则返回false */ //方式一： //ps.execute(); /* * executeUpdate() * 会返回影响数据库表中的行数 */ //方式二： return ps.executeUpdate(); } catch (Exception e) { e.printStackTrace(); }finally{ //5.关闭资源 JDBCUtils.closeResource(null, ps);//不要关闭连接 } return 0; }
增加考虑事务JDBCUtils工具类
package utils;import java.io.IOException;import java.io.InputStream;import java.lang.reflect.Field;import java.sql.Connection;import java.sql.DriverManager;import java.sql.PreparedStatement;import java.sql.ResultSet;import java.sql.ResultSetMetaData;import java.sql.SQLException;import java.sql.Statement;import java.util.ArrayList;import java.util.List;import java.util.Properties;public class JDBCUtils { public static Connection getConnection() { //获取连接 Connection connection = null; PreparedStatement ps = null; try { //读取配置文件 InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("jdbc.properties"); Properties pros = new Properties(); pros.load(is); String user = pros.getProperty("user"); String password = pros.getProperty("password"); String url = pros.getProperty("url"); String driverClass = pros.getProperty("driverClass"); //加载驱动 Class.forName(driverClass); //获取连接 connection = (Connection) DriverManager.getConnection(url, user, password); } catch (ClassNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (SQLException e) { // TODO Auto-generated catch block e.printStackTrace(); } return connection; } //关闭资源 public static void closeResource(Connection connection,Statement ps) { try { if(ps!=null) ps.close(); } catch (SQLException e) { // TODO Auto-generated catch block e.printStackTrace(); } try { if(connection!=null) connection.close(); } catch (SQLException e) { // TODO Auto-generated catch block e.printStackTrace(); } } //关闭资源 public static void closeResource(Connection connection,Statement ps,ResultSet rs) { try { if(ps!=null) ps.close(); } catch (SQLException e) { // TODO Auto-generated catch block e.printStackTrace(); } try { if(connection!=null) connection.close(); } catch (SQLException e) { // TODO Auto-generated catch block e.printStackTrace(); } try { if(rs!=null) rs.close(); } catch (SQLException e) { // TODO Auto-generated catch block e.printStackTrace(); } } //通用的增、删、改操作 返回表中的一条记录 public static int update(String sql,Object ... args){ Connection conn = null; PreparedStatement ps = null; try { //1.获取数据库的连接 conn = JDBCUtils.getConnection(); //2.获取PreparedStatement的实例 (或：预编译sql语句) ps = conn.prepareStatement(sql); //3.填充占位符 for(int i = 0;i < args.length;i++){ ps.setObject(i + 1, args[i]); } //4.执行sql语句 /* * execute() * 如果执行的是查询操作，有返回结果，则返回true， * 如果是增删改，没有返回结果，则返回false */ //方式一： //ps.execute(); /* * executeUpdate() * 会返回影响数据库表中的行数 */ //方式二： return ps.executeUpdate(); } catch (Exception e) { e.printStackTrace(); }finally{ //5.关闭资源 JDBCUtils.closeResource(conn, ps); } return 0; } //考虑事务的通用增、删、改操作 public static int update(Connection connection,String sql,Object ... args){ PreparedStatement ps = null; try { //1.获取PreparedStatement的实例 (或：预编译sql语句) ps = connection.prepareStatement(sql); //2.填充占位符 for(int i = 0;i < args.length;i++){ ps.setObject(i + 1, args[i]); } //3.执行sql语句 /* * execute() * 如果执行的是查询操作，有返回结果，则返回true， * 如果是增删改，没有返回结果，则返回false */ //方式一： //ps.execute(); /* * executeUpdate() * 会返回影响数据库表中的行数 */ //方式二： return ps.executeUpdate(); } catch (Exception e) { e.printStackTrace(); }finally{ //5.关闭资源 JDBCUtils.closeResource(null, ps);//不要关闭连接 } return 0; } //通用的查询单个 public static <T>T getInstance(Class<T> clazz,String sql,Object ...args) { Connection connection = null; PreparedStatement ps = null; ResultSet rs = null; try { connection = JDBCUtils.getConnection(); ps = connection.prepareStatement(sql); for(int i = 0;i < args.length;i++) { ps.setObject(i+1, args[i]); } rs = ps.executeQuery(); //获取结果集的元素据 ResultSetMetaData rsmd = rs.getMetaData(); //通过resultsetmetadata获取结果集的列数 int columnCount = rsmd.getColumnCount(); if(rs.next()) { T t = null; try { t = clazz.newInstance(); } catch (InstantiationException e) { // TODO Auto-generated catch block e.printStackTrace(); } for(int i = 0;i < columnCount;i++) { //获取这一列的列值 Object columnValue = rs.getObject(i+1); //获取每个列的列名 不用了 //String columnName = rsmd.getColumnName(i+1); //获取每个列的别名 String columnLabel = rsmd.getColumnLabel(i+1); //给对象指定的某个属性赋值为columnValue,通过反射 Field field = clazz.getDeclaredField(columnLabel); //使私有属性可以访问 field.setAccessible(true); field.set(t, columnValue); } return t; } } catch (NoSuchFieldException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (SecurityException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IllegalArgumentException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IllegalAccessException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (SQLException e) { // TODO Auto-generated catch block e.printStackTrace(); }finally { JDBCUtils.closeResource(connection, ps, rs); } return null; } //考虑事务的查询单个 public static <T>T getInstance(Connection connection,Class<T> clazz,String sql,Object ...args) { PreparedStatement ps = null; ResultSet rs = null; try { connection = JDBCUtils.getConnection(); ps = connection.prepareStatement(sql); for(int i = 0;i < args.length;i++) { ps.setObject(i+1, args[i]); } rs = ps.executeQuery(); //获取结果集的元素据 ResultSetMetaData rsmd = rs.getMetaData(); //通过resultsetmetadata获取结果集的列数 int columnCount = rsmd.getColumnCount(); if(rs.next()) { T t = null; try { t = clazz.newInstance(); } catch (InstantiationException e) { // TODO Auto-generated catch block e.printStackTrace(); } for(int i = 0;i < columnCount;i++) { //获取这一列的列值 Object columnValue = rs.getObject(i+1); //获取每个列的列名 不用了 //String columnName = rsmd.getColumnName(i+1); //获取每个列的别名 String columnLabel = rsmd.getColumnLabel(i+1); //给对象指定的某个属性赋值为columnValue,通过反射 Field field = clazz.getDeclaredField(columnLabel); //使私有属性可以访问 field.setAccessible(true); field.set(t, columnValue); } return t; } } catch (NoSuchFieldException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (SecurityException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IllegalArgumentException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IllegalAccessException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (SQLException e) { // TODO Auto-generated catch block e.printStackTrace(); }finally { JDBCUtils.closeResource(null, ps, rs); } return null; } //查询多个 public static <T> List<T> getForList(Class<T> clazz,String sql,Object ...args) { Connection connection = null; PreparedStatement ps = null; ResultSet rs = null; try { connection = JDBCUtils.getConnection(); ps = connection.prepareStatement(sql); for(int i = 0;i < args.length;i++) { ps.setObject(i+1, args[i]); } rs = ps.executeQuery(); //获取结果集的元素据 ResultSetMetaData rsmd = rs.getMetaData(); //通过resultsetmetadata获取结果集的列数 int columnCount = rsmd.getColumnCount(); //创建集合对象 ArrayList<T> list = new ArrayList<T>(); while(rs.next()) { T t = null; try { t = clazz.newInstance(); } catch (InstantiationException e) { // TODO Auto-generated catch block e.printStackTrace(); } for(int i = 0;i < columnCount;i++) { //获取这一列的列值 Object columnValue = rs.getObject(i+1); //获取每个列的列名 不用了 //String columnName = rsmd.getColumnName(i+1); //获取每个列的别名 String columnLabel = rsmd.getColumnLabel(i+1); //给对象指定的某个属性赋值为columnValue,通过反射 Field field = clazz.getDeclaredField(columnLabel); //使私有属性可以访问 field.setAccessible(true); field.set(t, columnValue); } list.add(t); } return list; } catch (NoSuchFieldException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (SecurityException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IllegalArgumentException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IllegalAccessException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (SQLException e) { // TODO Auto-generated catch block e.printStackTrace(); }finally { JDBCUtils.closeResource(connection, ps, rs); } return null; } //考虑事务的查询多个 public static <T> List<T> getForList(Connection connection,Class<T> clazz,String sql,Object ...args) { PreparedStatement ps = null; ResultSet rs = null; try { connection = JDBCUtils.getConnection(); ps = connection.prepareStatement(sql); for(int i = 0;i < args.length;i++) { ps.setObject(i+1, args[i]); } rs = ps.executeQuery(); //获取结果集的元素据 ResultSetMetaData rsmd = rs.getMetaData(); //通过resultsetmetadata获取结果集的列数 int columnCount = rsmd.getColumnCount(); //创建集合对象 ArrayList<T> list = new ArrayList<T>(); while(rs.next()) { T t = null; try { t = clazz.newInstance(); } catch (InstantiationException e) { // TODO Auto-generated catch block e.printStackTrace(); } for(int i = 0;i < columnCount;i++) { //获取这一列的列值 Object columnValue = rs.getObject(i+1); //获取每个列的列名 不用了 //String columnName = rsmd.getColumnName(i+1); //获取每个列的别名 String columnLabel = rsmd.getColumnLabel(i+1); //给对象指定的某个属性赋值为columnValue,通过反射 Field field = clazz.getDeclaredField(columnLabel); //使私有属性可以访问 field.setAccessible(true); field.set(t, columnValue); } list.add(t); } return list; } catch (NoSuchFieldException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (SecurityException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IllegalArgumentException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IllegalAccessException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (SQLException e) { // TODO Auto-generated catch block e.printStackTrace(); }finally { JDBCUtils.closeResource(null, ps, rs); } return null; }}
事务的ACID属性
-
原子性（Atomicity）
原子性是指事务是一个不可分割的工作单位，事务中的操作要么都发生，要么都不发生。 -
一致性（Consistency）
事务必须使数据库从一个一致性状态变换到另外一个一致性状态。 -
隔离性（Isolation）
事务的隔离性是指一个事务的执行不能被其他事务干扰，即一个事务内部的操作及使用的数据对并发的其他事务是隔离的，并发执行的各个事务之间不能互相干扰。 -
持久性（Durability）
持久性是指一个事务一旦被提交，它对数据库中数据的改变就是永久性的，接下来的其他操作和数据库故障不应该对其有任何影响。
数据库的并发问题
-
对于同时运行的多个事务, 当这些事务访问数据库中相同的数据时, 如果没有采取必要的隔离机制, 就会导致各种并发问题:
- 脏读: 对于两个事务 T1, T2, T1 读取了已经被 T2 更新但还没有被提交的字段。之后, 若 T2 回滚, T1读取的内容就是临时且无效的。
- 不可重复读: 对于两个事务T1, T2, T1 读取了一个字段, 然后 T2 更新了该字段。之后, T1再次读取同一个字段, 值就不同了。
- 幻读: 对于两个事务T1, T2, T1 从一个表中读取了一个字段, 然后 T2 在该表中插入了一些新的行。之后, 如果 T1 再次读取同一个表, 就会多出几行。
-
数据库事务的隔离性: 数据库系统必须具有隔离并发运行各个事务的能力, 使它们不会相互影响, 避免各种并发问题。
-
一个事务与其他事务隔离的程度称为隔离级别。数据库规定了多种事务隔离级别, 不同隔离级别对应不同的干扰程度, 隔离级别越高, 数据一致性就越好, 但并发性越弱。
四种隔离级别
数据库提供的4种事务隔离级别：
-
数据库提供的4种事务隔离级别：
-
Oracle 支持的 2 种事务隔离级别：READ COMMITED, SERIALIZABLE。 Oracle 默认的事务隔离级别为: READ COMMITED 。
-
Mysql 支持 4 种事务隔离级别。Mysql 默认的事务隔离级别为: REPEATABLE READ。
在MySql中设置隔离级别
-
每启动一个 mysql 程序, 就会获得一个单独的数据库连接. 每个数据库连接都有一个全局变量 @@tx_isolation, 表示当前的事务隔离级别。
-
查看当前的隔离级别:
SELECT @@tx_isolation; -
设置当前 mySQL 连接的隔离级别:
set transaction isolation level read committed; -
设置数据库系统的全局的隔离级别:
set global transaction isolation level read committed; -
补充操作：
-
创建mysql数据库用户：
create user tom identified by \'abc123\'; -
授予权限
#授予通过网络方式登录的tom用户，对所有库所有表的全部权限，密码设为abc123.grant all privileges on *.* to tom@\'%\' identified by \'abc123\'; #给tom用户使用本地命令行方式，授予atguigudb这个库下的所有表的插删改查的权限。grant select,insert,delete,update on atguigudb.* to tom@localhost identified by \'abc123\';
-
Java中关于隔离级别的操作
获取当前隔离级别：
System.out.println(connection.getTransactionIsolation());
取消自动提交：
connection.setAutoCommit(false);
设置数据库隔离级别：
connection.setTransactionIsolation(level);
七、DAO及相关实现类
- DAO：Data Access Object访问数据信息的类和接口，包括了对数据的CRUD（Create、Retrival、Update、Delete），而不包含任何业务相关的信息。有时也称作：BaseDAO
- 作用：为了实现功能的模块化，更有利于代码的维护和升级。
BaseDAO.java
public abstract class BaseDAO { //考虑事务的通用增、删、改操作 public int update(Connection connection,String sql,Object ... args){ PreparedStatement ps = null; try { //1.获取PreparedStatement的实例 (或：预编译sql语句) ps = connection.prepareStatement(sql); //2.填充占位符 for(int i = 0;i < args.length;i++){ ps.setObject(i + 1, args[i]); } //3.执行sql语句 /* * execute() * 如果执行的是查询操作，有返回结果，则返回true， * 如果是增删改，没有返回结果，则返回false */ //方式一： //ps.execute(); /* * executeUpdate() * 会返回影响数据库表中的行数 */ //方式二： return ps.executeUpdate(); } catch (Exception e) { e.printStackTrace(); }finally{ //5.关闭资源 JDBCUtils.closeResource(null, ps);//不要关闭连接 } return 0; } //考虑事务的查询单个 public <T>T getInstance(Connection connection,Class<T> clazz,String sql,Object ...args) { PreparedStatement ps = null; ResultSet rs = null; try { connection = JDBCUtils.getConnection(); ps = connection.prepareStatement(sql); for(int i = 0;i < args.length;i++) { ps.setObject(i+1, args[i]); } rs = ps.executeQuery(); //获取结果集的元素据 ResultSetMetaData rsmd = rs.getMetaData(); //通过resultsetmetadata获取结果集的列数 int columnCount = rsmd.getColumnCount(); if(rs.next()) { T t = null; try { t = clazz.newInstance(); } catch (InstantiationException e) { // TODO Auto-generated catch block e.printStackTrace(); } for(int i = 0;i < columnCount;i++) { //获取这一列的列值 Object columnValue = rs.getObject(i+1); //获取每个列的列名 不用了 //String columnName = rsmd.getColumnName(i+1); //获取每个列的别名 String columnLabel = rsmd.getColumnLabel(i+1); //给对象指定的某个属性赋值为columnValue,通过反射 Field field = clazz.getDeclaredField(columnLabel); //使私有属性可以访问 field.setAccessible(true); field.set(t, columnValue); } return t; } } catch (NoSuchFieldException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (SecurityException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IllegalArgumentException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IllegalAccessException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (SQLException e) { // TODO Auto-generated catch block e.printStackTrace(); }finally { JDBCUtils.closeResource(null, ps, rs); } return null; } //考虑事务的查询多个 public <T> List<T> getForList(Connection connection,Class<T> clazz,String sql,Object ...args) { PreparedStatement ps = null; ResultSet rs = null; try { connection = JDBCUtils.getConnection(); ps = connection.prepareStatement(sql); for(int i = 0;i < args.length;i++) { ps.setObject(i+1, args[i]); } rs = ps.executeQuery(); //获取结果集的元素据 ResultSetMetaData rsmd = rs.getMetaData(); //通过resultsetmetadata获取结果集的列数 int columnCount = rsmd.getColumnCount(); //创建集合对象 ArrayList<T> list = new ArrayList<T>(); while(rs.next()) { T t = null; try { t = clazz.newInstance(); } catch (InstantiationException e) { // TODO Auto-generated catch block e.printStackTrace(); } for(int i = 0;i < columnCount;i++) { //获取这一列的列值 Object columnValue = rs.getObject(i+1); //获取每个列的列名 不用了 //String columnName = rsmd.getColumnName(i+1); //获取每个列的别名 String columnLabel = rsmd.getColumnLabel(i+1); //给对象指定的某个属性赋值为columnValue,通过反射 Field field = clazz.getDeclaredField(columnLabel); //使私有属性可以访问 field.setAccessible(true); field.set(t, columnValue); } list.add(t); } return list; } catch (NoSuchFieldException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (SecurityException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IllegalArgumentException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IllegalAccessException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (SQLException e) { // TODO Auto-generated catch block e.printStackTrace(); }finally { JDBCUtils.closeResource(null, ps, rs); } return null; } //用于查询特殊值的通用方法 public <E> E getValue(Connection connection,String sql,Object ...args) { PreparedStatement ps = null; ResultSet rs = null; try { ps = connection.prepareStatement(sql); for(int i = 0;i < args.length;i++) { ps.setObject(i+1, args[i]); } rs = ps.executeQuery(); if(rs.next()) { return (E)rs.getObject(1); } } catch (SQLException e) { // TODO Auto-generated catch block e.printStackTrace(); }finally { JDBCUtils.closeResource(null, ps, rs); } return null; }}
对于其他类DAO，可先提供相应的接口interface，其中包含需要实现的功能，然后再创建一个实现类xxximpl.java，继承 extends BaseDAO,实现对应接口 implement xxx
升级的BaseDAO
因为BaseDAO是作为父类被实现类继承，实现类的类型已经确定，方法中的类的参数完全可以通过泛型来去掉。