JDBC

 JDBC是一个java应用程序到一个指定数据库的连接

安装SQL Server Driver
使用SQL Server Driver需要添加下面3个类库：msbase.jar,mssqlserver.jar,msutil.jar
在Eclipse中添加jar包需要：projectname->build path->Configuare buile path->Libraries->Add Jars

使用JDBC的6个步骤：
 1.加载JDBC驱动   Class.forName("DriverClassName");
 2.创建连接       Connection con=DriverMannager.getConnection(url,username,password);
 3.创建Statement对象  Statement st=con.creatStatement();   
    或者
      PreparedStatement ps=con.preparedStatement(sqlString);//定义一个PreparedStatement对象
      ps.setXxx(int arg,Xxx x);// 为PreparedStatement对象绑定参数
 4.执行查询，返回一个ResultSet对象  ResultSet rs=st.executeQuery(sqlString);
    或者
      ResultSet rs=ps.executeQuery();
 5.处理结果 
      while(rs.next()){ 
     ...
     Code
     ...
     }
6.关闭连接    con.close();
  注意：如果执行查询操作，必须使用executeQuery()方法，如果执行删除，插入，更新等操作，必须 使用executeUpdate()方法。
        相对于Statement ,PreparedStatement比较快。PreparedStatement比较灵活，可以先将全部参数绑定之后执行，然后又改变其中的一个参数后再执行。并且可以使用一个循环对参数进行绑定(先定义数组，然后使用一个循环，对参数进行循环绑定)。

写JDBC程序规范：
eg:
  public class TestJDBC{
  public static void main(String[] args){
    Connection conn=null;
    Statement stmt=null;
    ResultSet rs=null;
   try{
       Class.forName("oracle.jdbc.driver.OracleDriver");
      conn=DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:databaseName","admin","admin");
      stmt=conn.creatStatement();
      rs=stmt.executeQuery("select * from employee");
      while(rs.next()){
        System.out.println(rs.getString("name"));
        System.out.println(rs.getInt("id"));
        }
      }catch(ClassNotFoundException e) {
         e.printlnStackTrace();
      }catch(SQLException e) {
         e.printlnStackTrace();
      }finally{
           try{
         if(rs!=null){
    rs.close();
   rs=null;
   }
                 if(stmt!=null){
    stmt.close();
   stmt=null;
   }
                 if(conn!=null){
    conn.close();
   conn=null;
   }
       }catch(SQLException e){
      e.printStackTrace();
  }
         }
  }
}

 

使用CallableStatement调用存储过程:
 1.加载驱动
 2.建立连接
 3.创建CallableStatement对象：CallableStatement cs=con.prepareCall("{call StoreProcedureName(?,?)}");
 4.绑定参数    cs.setXxx(int arg,Xxx x);
   注册输出参数类型   cs.registerOutParameter(int arg,java.sql.TYPES.CHAR);
 5.执行语句   cs.execute();
 6.处理结果   cs.getXxx(int arg);
 7.关闭连接

JDBC批处理：使用批处理的话，不用创建多个Statement对象或者PreparedStatement
 1.加载驱动
 2.建立连接conn
 3.创建Statement对象stmt或者PreparedStatement pstmt：
 4.添加批处理中的SQL语句：stmt.addBatch();
 5.执行批处理语句   stmt.executeBatch();
 6.处理结果  
 7.关闭连接
eg：
public class TestJDBC{
  public static void main(String[] args){
    Connection conn=null;
    PreparedStatement pstmt=null;
    ResultSet rs=null;
   try{
      Class.forName("oracle.jdbc.driver.OracleDriver");
      conn=DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:databaseName","admin","admin");
      pstmt=conn.preparedStatement("insert into employee value(?,?)");
    
      ps.setInt(1,12);
      ps.setString(2,"haha");
      ps.addBatch();
    

      ps.setInt(1,13);
      ps.setString(2,"heihei");
      ps.addBatch();
    
      ps.setInt(1,14);
      ps.setString(2,"hehe");
      ps.addBatch();
    
      ps.executeBatch();
      }catch(ClassNotFoundException e) {
         e.printlnStackTrace();
      }catch(SQLException e) {
         e.printlnStackTrace();
      }finally{
           try{
         if(rs!=null){
    rs.close();
   rs=null;
   }
                 if(pstmt!=null){
    pstmt.close();
   pstmt=null;
   }
                 if(conn!=null){
    conn.close();
   conn=null;
   }
       }catch(SQLException e){
      e.printStackTrace();
  }
         }
  }
}

 

表的联接：
  有时你需要使用2个或者更多的表去获取你想得到的数据，这个时候我们可以考虑将表联结
  联结是一种将2个或者更多的表关联的数据库操作，要将多个表关联起来，表与表之间必须共享一个公用的字段。
  在一个SQL语句中，你需要标识每个字段用以下方式：Table1.commonFieldName=Talbe2.commonFieldName  eg:book.publishId=publish.publishId;

数据库中的事务：
 事务：
    进行事务处理中的所有的SQL语句执行成功，事务处理才会成功；进行事务处理中的所有SQL语句中有一条语句没执行成功，那么这个事务处理将会失败。
 使用事务：
    数据库中的事务处理是将被执行的一个或者更多的语句的集合作为一个单元统一执行
 提交一个事务：
    隐藏自动提交之后，所有的SQL语句只有当你调用Commit()方法后才会被提交。 
      eg:
       con.setAutoCommit(false);//隐藏自动提交,不能自动提交,那么就需要手动提交,等待操作(就好像用户在转账前的准备工作)
       PreparedStatement ps=con.prepareStatement(update coffees set sales=? where                                                  cof_name like ?);
       ps.setInt(1,50);
       ps.setString(2,"Colombian");
       ps.executeUpdate();

       PreparedStatement ps1=con.prepareStatement(update coffees set total=total+? where                                                  cof_name like ?);
       ps1.setInt(1,50);
       ps1.setString(2,"Colombian");
       ps1.executeUpdate();
       con.commit();//操作完毕后，将上面2个更新操作作为一个事务提交(就好像用户操作转账过程后，确认此次转账)
       con.setAutoCommit(true);//设置自动提交，恢复现场，因为默认是自动提交的

可滚动的结果集：
 1.加载驱动
 2.建立连接
 3.创建Statement对象：Statement cs=con.creatStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet_CONCUR_READ_ONLY);
//如果这里不加参数，结果集只能向后滚，加了参数就可以向前滚还可以定位，注意ResultSet_CONCUR_READ_ONLY这个参数表示只能读，而如果是ResultSet_CONCUR_UPDATABLE，则表示可以对结果集进行更新操作
 5.执行语句 
 6.处理结果  
 7.关闭连接

事物回滚：
    要取消一个事务处理，可以调用rollBack()方法。它将终止事务并且将数据库恢复到进行事务处理之前的原始状态；如果你在一个事务处理中执行多个语句，并且其中一个语句产生SQLException，你应该调用rollback()方法去终止事务。

数据库连接池：
  为什么要采用连接池？
    为每个用户创建一个新的数据库连接是花费时间的，每个用户打开一个数据库连接是难以实施的(访问同一个WEB站点的用户是相当多的)，所以我们就需要提供一个数据库连接池让该应用程序的当前使用者去打开数据库连接。通俗的说："谁要一个数据库连接就到这个数据库连接池中打开一个数据库连接，拿来主义！"， 当用户用完之后又释放到数据库连接池中。供其他用户使用。
 
创建一个数据库连接池的步骤：
     1.从www.apache.org下载DBCP.jar ,commons-collections-3.1.jar,commons-pool-1.2.jar
     2.将上面的jar文件放置到classpath中
     3.安装数据库或者选择去连接一个数据库
   完成一个数据库操作：
      1.建立一个BasicDataSource
         BasicDataSource ds=new BasicDataSource();
         ds.setDriverClassName("DriverClassName");
         ds.setUsername("username");
         ds.setPassword("password");
         ds.setUrl("url");
         ds.setMaxActive(count);
      2.从数据源得到一个连接：
          Connection con=ds.getConnection();
      3.处理和关闭：
          preparedStatement ps=con.prepareStatement(sqlString);
          ps.setXxx(int arg,Xxx x);
          ...
          ResultSet rs=ps.executeQuery();
          ...
          con.close();

     单子模式创建一个数据源工厂：
    
        public class DataSourceFactory{
             private static BasicDataSource ds;
            public static BasicDataSource getDataSource(){
               try{
                  if(ds==null){
                    ds=new BasicDataSource();
                    ds.setDriverClassName("DriverClassName");
                    ds.setUsername("username");
                    ds.setPassword("password");
                    ds.setUrl("url");
                    ds.setMaxActive(count);
                   }
                  return ds;
                  }
             }
        }

Data Access Objects(DAO):
   一个数据访问对象(DAO)提供对数据库的创建，添加，更新，查找，删除等操作。
   数据访问对象通常利用它的客户端使用数据传输对象(DTO)去交换数据。
   数据访问对象总是提供其他方法去查找多个结果，并且将查找到的结果一个一个地装入一个List和Collection中，最后返回一个List对象和Collection对象。
  通常情况下，我们将DAO定义成一个Interface。
  Interface BookDAO{
    public void add(BookDTO book);
    public void delete(int bookId);
    public List findAll();
    public BookDTO findById(int bookId);
    public void update(BookDTO book);
   }
   public class BookDAOImplement{
   public void add(BookDTO book){
   //Add操作code
   .......
  }
  public void delete(int bookId){
   //delete操作code
   .......
  }
  public List findAll(){
   List list=new ArrayList();//定义一个List对象
   //数据库查询操作
   //将查询到的每一条记录用BookDTO封装 ；可以使用Constructor或者set()方法
   //将每个BookDTO对象添加到List对象中去；list.add(book);
   //返回List对象；return list；
  }
  public BookDTO findById(int bookId){
   //通过参数查询数据库中的一条记录，然后用BookDTO封装，最后返回该BookDTO对象
  }
  public void update(BookDTO book){
   //更新操作code
   ........
  }
   }

通常，我们也可以创建一个DAO工厂，该工厂主要用来获取(生产)一个DAO对象：
   public class DAOFactory{
   public BookDAO getBookDAO(Connection con){
     BookDAO bookDAO=new BookDAO(con);
      return bookDAO;
   .......
   }
  }

DTO:数据传输对象，简单地说：DTO里面就是一个set和get器