JDBC总结

0 概述

JDBC是一组能够执行SQL语句的API
1.    连接数据库的步骤：
1）       注册驱动  
    JDBC类库向DriverManager注册数据库驱动·
2）       建立连接

    使用DriverManager提供的getConnection()方法连接到数据库
3）       创建语句

    通过数据库的连接对象的createStatement方法建立SQL语句对象
4）       执行语句

    执行SQL语句，并将结果集合返回到ResultSet中
5）       处理结果

    使用while循环读取结果
6）       释放资源（注意关闭的顺序）

demo

 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();

一JDBC的使用方法

1.建立连接：

建立连接分为两个关键步骤：①加载驱动程序；②建立连接。此处所涉及到的Java类有：Class、Driver、DriverManager。

建立连接，需要提供3个必不可少的参数：①数据库名称；②数据库账号；③数据库密码。

关键代码：

① 加载驱动程序：Class.forName(“com.mysql.jdbc.Driver”);

② 建立连接：

Connection conn=DriverManager.getConnection(url,name,pwd);

此处，String url=”jdbc:mysql://localhost:3306/”+数据库名称

String name=数据库账号

 String pwd=数据库密码

需要说明的是，这两句关键代码所用的方法都会抛出异常，故应将这两句放在try-catch块里。

 

import java.sql.*; public class TestConnection{ static { try{ //加载驱动程序 Class.forName(“com.mysql.jdbc.Driver”); } catch(Exeception e){ e.printStackTrace(); } }   public static void main(String[] args){ String url=”jdbc:mysql://localhost:3306/lt_atm”; String name=”admin”; String pwd=”lt11235”; Connection conn=null; try{ //建立数据库连接 conn=DriverManager.getConnection(url,name,pwd); } catch(SQLExeception e){ e.printStackTrace(); } finally{ try{ conn.close(); } catch(SQLException e){    e.printStackTrace(); }   } } }

一般，我们在静态代码块里加载驱动程序，不需要每次调用时都重新加载一次驱动。

建立连接过程——流程图总结：

 

2.执行SQL命令：

①在建立起来的连接线上创建Statement对象；②用新建的Statement对象传送SQL命令；③接收Statement对象返回过来的结果。

管理系统将所接受的SQL命令分为两类：①写，具体来说就是增删改；②读，即查。对于写性质的SQL命令，管理系统会将受到影响的记录条数交给信使Statement；对于读性质的SQL命令，管理系统会将满足条件的所有记录封装在一个对象里交给信使Statement，而这个对象就是ResultSet类的对象。现在我们来看一些这些动作的关键代码：

 

增删改：stmt.executeUpdate(sql)，返回修改的记录条数

查：stmt.executeQuery，返回结果对象

 

关键代码：

创建信使

Statement stmt=conn.createStatement();

传送SQL命令&接收返回结果

l 添加记录：        

String sql=”INSERT INTO account VALUES (‘1132’,’金龙’,’男’,10000) ”;

int count=stmt.executeUpdate(sql);

 

修改记录：

String sql=”UPDATE account SET name=’无花’ WHERE accId=’1132’”;

int count=stmt.executeUpdate(sql);

 

删除记录：

String sql=”DELETE FROM account WHERE accId=’1132’”;

int count=stmt.executeUpdate(sql);

l 读性质的命令：

查询记录：

String sql=”SELECT * FROM account”;

ResultSet rs=stmt.executeQuery(sql);

 

接下来，我们以具体的程序例子来说明传送SQL命令的过程；再以流程图来总结该过程：

传送SQL命令过程——代码示例：

import java.sql.*;

public class TestExecute{

static {

try{

//加载驱动程序

Class.forName(“com.mysql.jdbc.Driver”);

System.out.println(“Success loading Driver!”);

}

catch(Exeception e){

e.printStackTrace();

}

}

 

public static void main(String[] args){

String url=”jdbc:mysql://localhost:3306/lt_atm”;

String name=”admin”;

String pwd=”lt11235”;

Connection conn=null;

try{

//建立数据库连接

conn=DriverManager.getConnection(url,name,pwd);

Statement stmt=conn.createStatement();

//添加记录的SQL命令

String sql_1=”INSERT INTO account VALUES

(‘1132’,’金龙’,’男’,10000) ”;

//修改记录的SQL命令

String sql_2=”UPDATE account SET name=’无花’ 

WHERE accId=’1132’”;

//删除记录的SQL命令

String sql_3=”DELETE FROM account WHERE accId=’1132’”;

 

//查询记录的SQL命令

String sql_4=”SELECT * FROM account”;

 

//传送SQL命令

int count_1=stmt.executeUpdate(sql_1);

int count_2= stmt.executeUpdate(sql_2);

int count_3= stmt.executeUpdate(sql_3);

ResultSet rs=stmt.executeQuery(sql_4);

 

}

catch(SQLExeception e){

e.printStackTrace();

}

finally{

try{

conn.close();

}

catch(SQLException e){

   e.printStackTrace();

}

}

}

}

 

传送SQL命令过程——流程图总结：

 

3.从返回的对象（结果集）中读取数据：

当是查找数据时，返回的是结果对象集合。

如何从返回的ResultSet对象中读取数据呢？

ResultSet对象中，除了每一条记录各占用一个位置，还有一些特殊作用的位置，其中有两个分别是：beforeFirst、afterLast。他们分别是第一条记录的前一个位置、最后一条记录的下一个位置。当我们用ResultSet对象封装了查询到的记录，游标初始位置置为beforeFirst。

ResultSet类中有一个next()方法，其作用就是移动游标，使其指向下一个位置。该方法的返回值是一个boolean类型变量，当移动游标后能指向一个有效记录，返回true，否则(比如说移动到了afterLast位置)返回false。ResultSet类还有一系列方法，可以统一写成getXXX()。其作用是从游标指向的记录中读取数据。其中XXX是String、Int、Double类的变量类型，取决于所要读取的字段的数据类型。

思路：①用得到的ResultSet对象调用next()方法，若返回true转向②，否则转向③；②调用getXXX方法，从游标当前指向的记录中读取各个字段的数值；然后调用next方法，若返回true，转向②，否则转向③。③读取过程完成，正常结束。

读取数据的过程——代码示例：

import java.sql.*;

public class TestExecute{

static {

try{

//加载驱动程序

Class.forName(“com.mysql.jdbc.Driver”);

System.out.println(“Success loading Driver!”);

}

catch(Exeception e){

e.printStackTrace();

}

}

public static void main(String[] args){

String url=”jdbc:mysql://localhost:3306/lt_atm”;

String name=”admin”;

String pwd=”lt11235”;

Connection conn=null;

try{

//建立数据库连接

conn=DriverManager.getConnection(url,name,pwd);

System.out.println(“Success eastablishing the Connection…”);

Statement stmt=conn.createStatement();

 

//查询记录的SQL命令

String sql=”SELECT * FROM account”;

//传送SQL命令

ResultSet rs=stmt.executeQuery(sql);

//读取数据

while(rs.next()){

String accId=rs.getString(1); //或者 rs.getString(“accId”);

String name=rs.getString(2);//或者 rs.getString(“name”);

Char sex=rs.getChar(3);//或者 rs.getChar(“sex”);

int count=rs.getInt(4);//或者 rs.getInt(“count”);

System.out.println(accId+”/t”+name+”/t”+sex+”/t”+count);

}

}

catch(SQLExeception e){

e.printStackTrace();

}

finally{

try{

conn.close();

}

catch(SQLException e){

   e.printStackTrace();

}

}

}

}

读取数据的过程——流程图总结：

 

二 动态执行SQL命令

动态SQL：程序运行时根据条件执行具体的内容。

1、条件动态化：

         编写一个方法，他从外界接收一个参数，并用这个参数使方法内部的SQL条件具体化，然后return一个结果。具体代码如下：

public static ResultSet sqlQuery(String accName){

String sql=”SELECT * FROM account WHERE name=’”+ accName +”’”;

.............................

return ResultSet；

}  

 

 

2、字段动态化：

  承上所述，此处所谓的字段动态化，就是我们不仅能按姓名来查询记录，还能根据其他字段来查询：比如说根据编号，根据身份，甚至是根据性别。在上文sqlQuery方法的基础上继续扩展，其代码如下：

 

public static ResultSet sqlQuery(String column,String value){

String sql=”SELECT * FROM account WHERE

’”+ column +”’=’”+ value +”’”;

.............................

return ResultSet；

}

 

 

   3、数据表动态化：

 目标是使他能不受具体数据表的限制（传入一个数据表参数），而是根据我们不同的需要，访问不同的数据表。代码：

 

     public static ResultSet sqlQuery(String table,String column,String value){

String sql=”SELECT * FROM ’”+ table +”’ WHERE

’”+ column +”’=’”+ value +”’”;

.............................

.............................

return ResultSet；

}

4、PreparedStatement类的介绍：

PreparedStatement是继承自Statement的类

PreparedStatement拥有Statement所有的特性和方法。但是与Statement不同在于PreparedStatement可以将SQL命令事先编译，并存储在PreparedStatement对象中，当需要执行多次相似的SQL命令时，能够比较高效地执行。

另外，PreparedStatement最主要的功能就是能够输入条件式的SQL命令   

     import java.sql.*;

public class VisitDB{

static {

try{

//加载驱动程序

Class.forName(“com.mysql.jdbc.Driver”);

}

catch(Exeception e){

e.printStackTrace();

}

}

//负责建立与数据库管理系统之间的连接

public static Connection getCon(){

String url=”jdbc:mysql://localhost:3306/lt_atm”;

String name=”admin”;

String pwd=”lt11235”;

Connection conn=null;

try{

//建立数据库连接

conn=DriverManager.getConnection(url,name,pwd);

   }

catch(SQLExeception e){

    conn=null;

e.printStackTrace();

}

      return conn;

}

//负责动态执行查询语句

public static ResultSet sqlQuery(String table,String column,String value){

Connection conn= VisitDB.getCon();

//条件式SQL命令，？表示待定参数

String sql=”SELECT * FROM ? WHERE ?=?”;

try{

//创建pstmt时就将sql命令传过去，使其预先编译

PreparedStatement pstmt=conn.prepareStatement(sql);

//表示第1个？的值为String类型的table

pstmt.setString(1,table);

    //表示第2个？的值为String类型的column

pstmt.setString(2, column);

//表示第3个？的值为String类型的value

pstmt.setString(3, value);

//让pstmt对象执行将编译好的SQL命令传过去，并接收结果

ResultSet rs=pstmt.executeQuery();

return rs;

}

catch(Exception e){

return null;

e.printStackTrace();

}

}

//负责关闭不再用的对象，释放系统资源

public static void close(ReaultSet rs,Statement stmt,Connection conn){

try{

rs.close();

stmt.close();

conn.close();

}

catch(Exception e){

e.printStackTrace();

}

}

}

    

  好了，此时我们的三个动态扩展也用PreparedStatement实现了。不得不提的是PreparedStatement类的setXXX系列的方法并不是只有setString一种，只是上例中我们只用到了这一种而已

三 批处理SQL命令

1、Statement的批处理功能

        Statement提供了批处理的功能，批处理多用在执行写操作的SQL命令时，如果一次要增删改很多条记录，使用批处理会减少对象在程序与数据库系统之间的交互，从而提高其性能。批处理的流程如下所示：

方法说明：

1、public void clearBatch() throws SQLException

 作用：将Statement对象的Batch中的所有SQL命令清空

2、public void addBatch(String sql) throws SQLException

 作用：插入一个SQL命令到Statemen对象中的Batch中

3、public int[] executeBatch() throws SQLException

作用：将Statement对象的Batch中的所有SQL命令传给数据库系统

代码示例：

Import java.sql.*;

public class TestBatch{

String[] sqls={“INSERT INTO account VALUES(‘13579’ , ’云飞’ , ‘男’ , 100)”,

”DELETE FROM account WHERE name=’无花’”,

”UPDATE account SET name=’铁手’ WHERE accId=’2468’”,}

public void testBatch(){

Connection conn=null;

try{

conn= VisitDB.getCon();

Statement stmt=conn.createStatement();

stmt.clearBatch();

for(int i=0;i<sqls.length;i++){

stmt.addBatch(sqls[i]);

}

stmt.executeBatch();

}

catch(Exception e){

e.printStackTrace();

}

 

}

}

 

2、PreparedStatement的批处理功能：

    PreparedStatement是Statement的子类，所以他也有批处理功能，其流程如下所示：

图中所涉及到的方法都已说过，就不再赘述了。现在我们直接来看一下代码示例：

public void testPreBatch(){

try{

Connection conn= VisitDB.getCon();

PreparedStatement  pstmt=conn.prepareStatement(

“DELETE FROM account WHERE name=?”);

pstmt.clearBatch();

pstmt.setString(“金龙”);

pstmt.addBatch();

pstmt.setString(“无花”);

pstmt.addBatch();

pstmt.setString(“楚香帅”)；

pstmt.addBatch();

 

pstmt.executeBatch();

}

catch(Exception e){

e.printStachTrace();

}

}

四 事务机制

事务最主要的功能是用来确保多个连续的数据库操作，能作为一个整体被对待。即在执行时，要么全部执行成功，否则全部执行失败——回到最初状态。

流程说明：

1、Connection对象调用setAutoCommit()方法，将AutoCommit设置为false，以取消自动提交事务机制（自动提交事务机制将每一条SQL命令看做是一个事务，每做一次数据库操作，会自动提交一次）。

    2、当一个逻辑事务所包含的SQL命令都被执行后，调用commit()方法，向数据库系统提交事务；这条语句通常是try块里最后一句。

3、中途如果发生任何错误或不明原因导致操作中断，调用rollback()方法，要求数据库系统执行Rollback操作。

 

方法说明：

public void setAutoCommit(boolean autoCommit) throws SQLException

    说明：设置是否自动提交事务。当true时，每执行一条SQL命令，数据库系统自动提交一次事务，即对数据库里的数据进行操作；当为false时，数据库系统不自动提交事务，知道遇到调用的commit（）方法。

    

public boolean getAutoCommit() throws SQLException

说明：获得当前的Commit方式

 

public void commit() throws SQLException

说明：指示数据库系统提交事务，将结果写进数据库

 

public void rollback() throws SQLException

说明：指示数据库执行恢复操作，将数据恢复到最初状态

 

流程图：

代码示例：

public void testTransaction(){

try{

Connection conn= VisitDB.getCon();

conn.setAutoCommit(false);

Statement stmt=con.createStatement();

String sql_1=”UPDATE account SET balance=balance-1000 

WHERE accId=’A’”;

String sql_1=”UPDATE account SET balance=balance+1000 

WHERE accId=’B’”;

conn.commit();

}

catch(SQLException ex){

ex.printStackTrace();

try{

conn.rollback();

}

catch(SQLException e){

e.printStackTrace();

}

}

 

}

 

SQL注入PreparedStatement和Statement 

PreparedStatement（从Statement扩展而来）相对Statement的优点：

1、没有SQL注入的问题。

2、Statement会使数据库频繁编译SQL，可能会造成数据库缓冲区溢出。

3、数据库和驱动可以对PreparedStatement进行优化（只有在相关联的数据库连接没有关闭的情况下有效）。

 

为什么要始终使用PreparedStatement代替Statement?

1 代码可维护性

（辨别： Statement：使用 +  PreparedStatement：使用？）
stmt.executeUpdate("insert into tb_name (col1,col2,col2,col4) values       (‘"+var1+"‘,‘"+var2+"‘,"+var3+",‘"+var4+"‘)");

注意Statement和PreparedStatement语句上的区别：Statement是在执行的时候才传入SQL语句，而PreparedStatement在创建的时候就已经传入了SQL语句。
perstmt = con.prepareStatement("insert into tb_name (col1,col2,col2,col4) values (?,?,?,?)");
perstmt.setString(1,var1);
perstmt.setString(2,var2);
perstmt.setString(3,var3);
perstmt.setString(4,var4);
perstmt.executeUpdate();

 

2 防止SQL注入
对于JDBC而言,SQL注入攻击只对Statement有效,对PreparedStatement是无效的,这是因为PreparedStatement不允许在插入时改变查询的逻辑结构.

SQL注射原理

SQL 注射能使攻击者绕过认证机制，完全控制远程服务器上的数据库

登陆验证

假如后台的sql语句时这样拼接的

select id from test where username=‘"+myname+"‘ and password=‘"+mypasswd+"‘ ";

表面上看，如果用户名和口令对匹配，那么该用户通过认证；否则，该用户不会通过认证——但是，事实果真如此吗？这里并没有对SQL命令进行设防，所以攻击者完全能够在用户名或者口令字段中注入SQL语句，从而改变SQL查询 。为此，我们仔细研究一下上面的SQL查询字符串:

上述代码认为字符串username和password都是数据，不过，攻击者却可以随心所欲地输入任何字符 。如果一位攻击者输入的用户名为

‘’OR 1=1—

而口令为

x

双划符号--告诉SQL解析器，右边的东西全部是注释，所以不必理会。这样，查询字符串相当于：

select id from test where username=‘‘ or 1=1;

因为现在只要用户名为长度为零的字符串‘‘或1=1这两个条件中一个为真，就返回用户标识符ID——我们知 道，1=1是恒为真的。所以这个语句将返回user_table中的所有ID。在此种情况下，攻击者在username字段放入的是SQL指令 ‘OR1=1--而非数据。

更为严重的情况是当username对应的是‘OR1=1;DROPTABLEuser_table;--

数据库中执行的sql语句就变成了：

select id from test where username=‘‘ or 1=1;drop table test

这个语句将执行句法上完全正确的SELECT语句，并利用drop命令清空test表。

应对策略

问题的关键就是不要用string构造sql语句，这样就不会利用输入的参数构造sql语句了。所以要用PreparedStatement替换Statement，即用占位符作为实参定义sql语句，从而避免sql注入攻击。

不管什么框架，还是纯JDBC，只用Preparedstatement,一定要用占位符作为实参来构造sql（或hql）语句。

String sql= "select * from test where usernmae=? and password=? " ;
PreparedStatement psm=conn.preparedStatement(sql);
psm.setString(1,myname);
psm.setString(2,mypasswd);
Result rs=psm.executeQuery(); 
if (rs.next){
rs.close();
con.close();
return false ;
}
else {
rs.close();
con.close();
return true ;
}