jdbc总结-CSDN博客

jdbc

1. 连接数据库的步骤：

1）注册驱动

2）建立连接

3）创建语句

4）执行语句

5）处理结果

6）释放资源（注意关闭的顺序）

实例//1.注册驱动

DriverManager.registerDriver(newcom.mysql.jdbc.Driver()); System.setProperty("jdbc.drivers", "com.mysql.jdbc.Driver"); Class.forName("com.mysql.jdbc.Driver");//推荐方式 //2.建立连接 String url = "jdbc:mysql:localhost:3306/jdbc"; String user = "root"; String password = "mysql"; Connection conn = DriverManager.getConnection(url,user,password); //3.创建语句 Statement st = conn.createStatement(); //4.执行语句 ResultSet rs = st.executeQuery("select * from user"); //5.处理结果 while(rs.next()){//按行来遍历 System.out.println(rs.getObject(1) + "\t" + rs.getObject(2) + "\t" +rs.getObject(3) + "\t" + rs.getObject(4)); } //6.释放资源（注意关闭的顺序） rs.close(); st.close(); conn.close();

2. 注意在jdbc中的sql注入问题，解决的办法是使用PreparedStatement ：PreparedStatement ps = null;// 利用PreparedStatement而不用Statement是因为PreparedStatement能够对输入的内容进行过滤，除去sql的关键字，防止此问题。

3. 数据库中对大文本的写入和读取：clob类的处理

public class ClobTest { /** * @param args * @throws Exception */ public static void main(String[] args) throws Exception { //create(); read(); } //数据库的读取操作 static void read() throws SQLException, Exception { Connection conn = null; Statement st = null; ResultSet rs = null; try { conn = JdbcUtils.getConnection(); // 3.创建语句 st = conn.createStatement(); // 4.执行语句 rs = st.executeQuery("select big_text from clob_test"); // 5.处理结果 while (rs.next()) {// 按行来遍历 Reader reader = rs.getCharacterStream(1); Filefile = newFile("CRUD_bak.java"); Writerwriter = new BufferedWriter(new FileWriter(file)); char[] buff = new char[1024]; for(int i = 0; (i = reader.read(buff))>0;){ writer.write(buff,0, i); } writer.close(); reader.close(); } } finally { JdbcUtils.free(rs, st, conn); } } //数据库的创建操作 static void create() throws SQLException, IOException { Connection conn = null; PreparedStatement ps = null; ResultSet rs = null; try { conn = JdbcUtils.getConnection(); // 3.创建语句 String sql = "insertinto clob_test(big_text) values(?)"; ps = conn.prepareStatement(sql); File file = new File("src/com/lcq/jdbc/CRUD.java"); Reader reader = newBufferedReader(newFileReader(file)); //传递大块的文本文档 ps.setCharacterStream(1,reader, file.length()); int i = ps.executeUpdate(); reader.close(); System.out.println("i = " + i); } finally { JdbcUtils.free(rs, ps, conn); } } }

4. 问题blob类型读取二进制文件

数据库编译时异常的处理，编写自己的异常类

package com.lcq.jdbc.impl; public class DaoException extends RuntimeException { /** * */ private static final long serialVersionUID = 1L; public DaoException() { // TODO Auto-generatedconstructor stub } public DaoException(String message) { super(message); // TODO Auto-generatedconstructor stub } public DaoException(Throwablecause) { super(cause); // TODO Auto-generatedconstructor stub } public DaoException(String message, Throwable cause) { super(message, cause); // TODO Auto-generatedconstructor stub } } 在使用时 catch(SQLException e){ //异常的处理，转化为运行时异常 throw new DaoException(e.getMessage(),e); }

在sql中SQLException是编译时异常，所以要抛出，但是如果只是向上抛出的话，会导致业务层和数据访问层的关系复杂，后期维护不便；因此最好的解决方法是在数据访问层中将异常catch住，编写异常类进行处理，在运行时如果上层能够处理就处理。从而使业务层和数据访问层耦合度减少。

5. 一个类的实例化的过程中首先执行的是静态代码块，然后是构造函数。

事务的处理问题：

/** * 事务处理范例 * 从账户1转账到账户2十元 * */ static void test() throws SQLException { Connection conn = null; Statement st = null; ResultSet rs = null; Savepoint sp = null; try { conn = JdbcUtils.getConnection(); // 3.创建语句 Conn.setAutoCommit(false);//设置自动提交无效 st = conn.createStatement(); // 4.执行语句 String sql = "updateuser set money=money-10 where id=1"; st.executeUpdate(sql); //设置回滚点 sp =conn.setSavepoint(); sql = "update userset money=money+10 where id=3"; st.executeUpdate(sql); sql = "selectmoney from user where id=2"; rs = st.executeQuery(sql); float money = 0.0f; // 5.处理结果 if (rs.next()) {// 按行来遍历 money = rs.getFloat("money"); } if(money > 300){ throw new RuntimeException("已经达到最大值！"); } sql = "update userset money=money+10 where id=2"; st.executeUpdate(sql); conn.commit(); } catch(RuntimeException e){ if(conn != null && sp != null) //回滚到设置的点 conn.rollback(sp); //递交，使以上操作有效 conn.commit(); throw e; }catch(SQLException e){ if(conn != null) conn.rollback(); throwe; }finally { JdbcUtils.free(rs, st, conn); } }

7. 跨越多个数据源的事务（JTA）实现分布式的数据处理，事务处理步骤：

1）打开事务

2）提交事务

3）回滚事务

8. 在数据库中编写组件（函数），通过ps = conn.prepareStatement(sql,Statement.RETURN_GENERATED_KEYS);//能够得到数据库中的组件。这样通过组件可以在用户向数据库中添加数据时，在返回时可以用组件对结果进行标识，说明数据已经在数据库中得到更新。

9. 批处理，对sql语句的打包。

10.

根据用户的查询需求进行查询，并将结果封装为Map返回

public classResultSetMetaDataTest { /** * @param args * @throws SQLException */ public static void main(String[] args) throws SQLException { List<Map<String, Object>> datas = read("select * from user"); System.out.println(datas); } static List<Map<String, Object>> read(String sql) throws SQLException { Connection conn = null; PreparedStatement ps = null; ResultSet rs = null; try { conn = JdbcUtils.getConnection(); ps = conn.prepareStatement(sql); rs = ps.executeQuery(); ResultSetMetaDatarsmd = rs.getMetaData(); //得到结果集的列数 intcount = rsmd.getColumnCount(); String[] colNames = new String[count]; for(int i = 1; i < colNames.length;i++){ colNames[i-1] = rsmd.getColumnName(i); } List<Map<String, Object>> datas = newArrayList<Map<String, Object>>(); // 5.处理结果 while (rs.next()) {// 按行来遍历,将每一行添加到map中，list中最后存放的是表 Map<String,Object> data = new HashMap<String, Object>(); for(inti = 1;i<= colNames.length;i++){ data.put(colNames[i-1],rs.getObject(i)); } datas.add(data); } return datas; } finally { JdbcUtils.free(rs, ps, conn); } } }

11. 对象与关系的映射（利用反射）

public class ORMTest { /** * @param args * @throwsInvocationTargetException * @throwsIllegalAccessException * @throws SQLException * @throwsIllegalArgumentException * @throws InstantiationException */ public static void main(String[] args) throws IllegalArgumentException, SQLException, IllegalAccessException,InvocationTargetException, InstantiationException { User user = (User) getObject( "select idas Id ,name as Name, birthday as Birthday,money as Money from user whereid=2", User.class); System.out.println(user); } static ObjectgetObject(String sql, Class clazz) throws SQLException, IllegalArgumentException, IllegalAccessException, InvocationTargetException, InstantiationException { Connection conn = null; PreparedStatement ps = null; ResultSet rs = null; try { conn = JdbcUtils.getConnection(); ps = conn.prepareStatement(sql); rs = ps.executeQuery(); ResultSetMetaData rsmd = rs.getMetaData(); // 得到结果集的列数 int count = rsmd.getColumnCount(); String[] colNames = new String[count]; for (int i = 1; i <= colNames.length; i++) { colNames[i - 1] = rsmd.getColumnLabel(i); } Object object = null; Method[] ms = clazz.getMethods(); // 5.处理结果 if (rs.next()) {// 按行来遍历,将每一行添加到map中，list中最后存放的是表 object = clazz.newInstance(); for (int i = 0; i < colNames.length; i++) { String colName = colNames[i]; String methodName = "set" + colName; // System.out.println(methodName); for (Method m : ms) { if (methodName.equals(m.getName())) { m.invoke(object, rs.getObject(colName)); } } } } return object; } finally { JdbcUtils.free(rs, ps, conn); } } }

12. 创建数据库连接池，先创建多个连接，将连接一次放在List的尾部，用的时候从List的头部取出连接，使用连接；用完释放连接的时候是将连接返回到连接池的尾部，供后边的用户使用。达到连接重复使用的目地。

/** * * 创建数据库连接池 */ import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; import java.util.LinkedList; public class MyDataSource { private static String url = "jdbc:mysql://localhost:3306/jdbc"; private static String user = "root"; private static String password = "mysql"; private LinkedList<Connection>connectionsPoll = new LinkedList<Connection>(); public MyDataSource(){ for(int i = 0; i<5;i++){ try { this.connectionsPoll.addLast(this.createConnection()); } catch (SQLException e) { throw newExceptionInInitializerError(e); } } } public Connection getConnection(){ return this.connectionsPoll.removeFirst(); } private Connection createConnection() throws SQLException{ return DriverManager.getConnection(url, user, password); } public void free(Connection conn){ this.connectionsPoll.addLast(conn); } }

13. 对创建连接的优化，利用dbcp作为数据源，从数据源中取出连接。编写自己的数据源。对代码的优化是从“变与不变”入手的。

14. 通过模板模式对增删改查进行优化，利用抽象和继承实现。

15. 利用工厂模式和sping对数据库的封装进行最终版本的实现。

转载于:https://www.cnblogs.com/lcqBlogs/archive/2012/02/19/2392373.html