jdbc总结

jdbc
1.    连接数据库的步骤：
1）       注册驱动
2）       建立连接
3）       创建语句
4）       执行语句
5）       处理结果
6）       释放资源（注意关闭的顺序）
实例//1.注册驱动
    
[java]
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类的处理
[java]
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类型读取二进制文件
数据库编译时异常的处理，编写自己的异常类
[java]
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.    一个类的实例化的过程中首先执行的是静态代码块，然后是构造函数。
6.    
事务的处理问题：
[java]
/**
* 事务处理范例
* 从账户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返回www.atcpu.com
[java]
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. 对象与关系的映射（利用反射）
[java]
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;
                  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的头部取出连接，使用连接；用完释放连接的时候是将连接返回到连接池的尾部，供后边的用户使用。达到连接重复使用的目地。
[java]
/**
*
* 创建数据库连接池
*/
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对数据库的封装进行最终版本的实现。