Jdbc访问数据库篇

一万年太久，只争朝夕

What JDBC

上部

JDBC（Java DataBase Connectivity）Java 数据库连接，主要提供编写 Java 数据库应用程序的 API 支持

java.sql包中定义的常用的基本的 JDBC API：

类 DriverManager－管理一组 JDBC 驱动程序的基本服务 接口 Connection－获得与特定数据库的连接

接口 Statement－用于执行静态 SQL 语句并返回它所生成结果的对象

接口 ResultSet－表示数据库结果集的数据表，通常通过执行

查询数据库的语句生成 类 SQLException－有关数据库操作的异常

使用JDBC 访问数据库的前提条件

数据库的主机地址（ＩＰ地址）localhost 127.0.0.1 如果你访问的是别人的数据库，记得输入别人的ＩＰ

端口号：oracle 1521 ，MySql 3306， SqlServer 1433 因为我连得数据库是oracle，Ojdbc14.jar包，千万别忘了

数据的用户名/密码

JDBC核心API

Driver接口：驱动程序接口

Connection connect(String url, Properties info) 用于连接数据库的方法

可以使用驱动程序管理类获取这样的连接

DriverManager.getConnection(String url, String user, String password)

Connection 接口 :代表和数据库的连接

Statement createStatement() 创建Statement接口的对象

PreparedStatement prepareStatement(String sql) 创建PreparedStatement接口的对象

Statement接口 用于执行静态sql语句

int executeUpdate(String sql) 执行DDL和DML语句，如果不记得什么是DDL和DML，可以参考上一篇oracle基础

ResultSet executeQuery(String sql) 执行DQL语句，同理

PreparedStatement接口 ： 用于执行预编译的sql语句

int executeUpdate(String sql) 执行DDL和DML语句

ResultSet executeQuery(String sql) 执行DQL语句

ResultSet接口：表示数据库的结果集

boolean next() 将光标转移到下一行的位置

getXXX() 获取结果集中每列的值

很少用，了解

CallableStatement prepareCall(String sql)

CallableStatement接口 ：（了解）用于存储过程的SQL语句

 下部

详解DriverManager类

用DriverManager加载驱动，，获得与数据库的连接，

驱动设备管理器进行连接

Driver driver = new oracle.jdbc.OracleDriver();

DriverManager.registerDriver(driver);

//推荐使用该方法

//驱动程序（只注册一次）

Class.forName("oracle.jdbc.driver.OracleDriver");

关于url 的写法

jdbc:oracle:thin:@localhost:1521:orcl

详解Connection 类

用于与数据库的连接，数据库与客户端的打交道都是由Connection方法来完成的，常用方法：

createStatement()：创建向数据库发送sql的statement对象。

prepareStatement(sql) ：创建向数据库发送预编译sql的PrepareSatement对象。

setAutoCommit(boolean autoCommit)：设置事务是否自动提交。

commit() ：提交事务。

rollback() ：回滚事务。

详解Statement 接口

Statement对象用于向数据库发送SQL语句， Statement对象常用方法：

executeQuery(String sql) ：用于向数据发送查询语句。

executeUpdate(String sql)：用于向数据库发送insert、update或delete语句

详解ResultSet 接口

ResultSet用于代表Sql语句的执行结果。开始的时候，游标在第一行之前，调用ResultSet.next() 方法，可以使游标指向具体的数据行，进行调用方法获取该行的数据。
　　ResultSet既然获得数据库执行后的对象，提供了获取数据的get 方法
　　获取指定类型的数据，例如：
　　　　getString(int index)
　　　　getString(String columnName)

　　ResultSet还提供了对结果集进行滚动的方法：

next()：移动到下一行

关于释放资源：

切记一点，一定要记得关闭，还有就是先开的后关，后开的先关。

详解部分参照API文档：

代码展示

目录结构：

 package Jdbc;

 import java.sql.Connection;
 import java.sql.DriverManager;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.sql.Statement;

 /**
  * statement 用于执行静态sql 但是实际开发很少用， PreparedStatement ：用于执行预编译的sql语句
  * @author Administrator
  *
  */
 public class FirstJdbc {

     private static String user = "scott";
     private static String password = "tiger";
     private static String url = "jdbc:oracle:thin:@localhost:1521:orcl";

     public static void main(String[] args) throws ClassNotFoundException, SQLException {

         // 加载驱动

         Class.forName("oracle.jdbc.driver.OracleDriver");

         //获取数据库连接

         Connection conn = DriverManager.getConnection(url, user, password);

         System.out.println(conn);
         // 下面是输出 conn 的结果 ；证明数据库连接成功
         //oracle.jdbc.driver.T4CConnection@5afec107

         //准备sql语句
         String sql =  "select * from userinfo";

         //获取用于向数据库发送sql语句的statement
         Statement stmt = conn.createStatement();
         //获取数据库连接对象
         ResultSet rs = stmt.executeQuery(sql);
         while(rs.next()){

             System.out.println("uname="+rs.getString("uname"));
             System.out.println("upass="+rs.getString("upass"));
         }
         //关闭连接，释放资源(遵循原则 先开喉管)
         rs.close();
         stmt.close();
         conn.close();
     }

 }

 package Jdbc;

 import java.sql.Connection;
 import java.sql.DriverManager;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.sql.Statement;

 public class SecondJdbc {

     /**
      * PreparedStatement ：用于执行预编译的sql语句，动态拼接sql    ?作为占位符, 可以有效的防止Sql注入的问题
      *
      */
     private static Connection conn = null;
     private static String user = "scott";
     private static String password = "tiger";
     private static String url = "jdbc:oracle:thin:@localhost:1521:orcl";

     public static void main(String[] args) throws ClassNotFoundException, SQLException { //为了使页面使页面干净，在这里处理的异常都向外抛出
         // TODO Auto-generated method stub

         // 加载驱动

         Class.forName("oracle.jdbc.driver.OracleDriver");

         //获取数据库连接

         Connection conn = DriverManager.getConnection(url, user, password);

         System.out.println(conn);
         // 下面是输出 conn 的结果 ；证明数据库连接成功
         //oracle.jdbc.driver.T4CConnection@5afec107

         //准备sql语句
         String sql =  "insert into userinfo(uname,upass)values (?,?)";

         //获取用于向数据库发送sql语句的preparedStatement
         PreparedStatement stmt = conn.prepareStatement(sql);
         //设置参数 注意这里的参数设置从1开始，不像数组等下标从0开始
         stmt.setString(1,"张作霖");
         stmt.setString(2, "123");
         //获取数据库连接对象
         int count = stmt.executeUpdate();
         //事务处理
         if(count>0){
             conn.commit();
         }else{
             //这里的rollback肯定执行不了，因为上面执行的sql(insert)用户名是可以重复的，用重名的可能性
             conn.rollback();
         }
         System.out.println("影响了"+count+"行");
         //关闭连接，释放资源(遵循原则 先开喉管)

         stmt.close();
         conn.close();
     }

 }

 package Jdbc;

 import java.sql.Connection;
 import java.sql.DriverManager;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;

 import javax.naming.Context;
 import javax.naming.InitialContext;
 import javax.naming.NamingException;
 import javax.sql.DataSource;

 /**
  * 为了日后开发方便，不用频繁的获取驱动，获取连接，
  * 定义url ,数据库，用户名 等参数，所以自己封装Jdbc工具类
  *
  */
 public class JdbcUtils {

     //定义url 数据库用户名和密码
     private static Connection conn = null;
     private static PreparedStatement pst;
     private static String user = "scott";
     private static String password = "tiger";
     private static String url = "jdbc:oracle:thin:@localhost:1521:orcl";

     private JdbcUtils() {
     }

     //单例模式
     public static Connection getcConnection() {
         if (conn == null) {
             try {
                 Class.forName("oracle.jdbc.driver.OracleDriver");
                 conn = DriverManager.getConnection(url, user, password);
                 System.out.println("获取connection连接成功");

             } catch (ClassNotFoundException e) {
                 System.out.println("加载驱动失败");
                 e.printStackTrace();
             } catch (SQLException e) {
                 System.out.println("连接数据库失败");
                 e.printStackTrace();
             }
         }
         return conn;

     }
     //之前用作数据库连接池连接，自己封装，如果没有用请忽略
 /*    public static Connection getPoolConnection(){
         if(conn==null){
             try {
                 Context context = new InitialContext();
                 DataSource ds =
                  (DataSource) context.lookup("java:/comp/env/jdbc/oracleds");
                 conn = ds.getConnection();
                 System.out.println("连接池数据库成功！");
             } catch (NamingException e) {
                 System.out.println("连接池数据库失败！");
                 e.printStackTrace();
             } catch (SQLException e) {
                 System.out.println("连接池数据库失败！");
                 e.printStackTrace();
             }
         }

         return conn;
     }*/

     //关闭连接
     public static void close() {

         try {
             if (conn != null) {
                 conn.close();
                 conn = null;
             }
             if (pst != null) {
                 pst.close();
                 pst = null;
             }
             System.out.println("关闭成功");
         } catch (SQLException e) {
             System.out.println("关闭失败");
             e.printStackTrace();
         }

     }

     // 执行更新操作
     public static int executeUpdate(String sql, Object[] obj) {
         int count = 0;

         try {
             pst = conn.prepareStatement(sql);
             if (obj != null) {
                 for (int i = 0; i < obj.length; i++) {
                     pst.setObject(i + 1, obj[i]);
                 }
             }
             count = pst.executeUpdate();
         } catch (SQLException e) {
             count = 0;
             e.printStackTrace();
         }

         return count;
     }
     //执行查询操作，带参数
     public static ResultSet executeQuery(String sql, Object obj[]) {
         ResultSet rs = null;
         try {
             pst = conn.prepareStatement(sql);
             if (obj != null) {
                 for (int i = 0; i < obj.length; i++) {
                     pst.setObject(i + 1, obj[i]);
                 }
             }
             rs = pst.executeQuery();
         } catch (SQLException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }

         return rs;
     }
     //执行查询操作.无参数
     public static ResultSet executeQuery(String sql) {
         ResultSet rs = null;

         try {
             pst = conn.prepareStatement(sql);
             rs = pst.executeQuery();
         } catch (SQLException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }

         return rs;
     }
     //开始事物
     public static void beginTransation() {
         try {
             conn.setAutoCommit(false);
             System.out.println("开始事物");
         } catch (SQLException e) {
             System.out.println("开始事物失败");
             e.printStackTrace();
         }

     }
     //提交事物
     public static void commit() {
         try {
             conn.commit();
             System.out.println("提交事物");
         } catch (SQLException e) {
             System.out.println("提交事物失败");
             e.printStackTrace();
         }

     }
     //回滚事物
     public static void rollback(){
         try {
             conn.rollback();
             System.out.println("回滚事务");
         } catch (SQLException e) {
             System.out.println("回滚事务失败");
             e.printStackTrace();
         }
     }
 }

数据库表

select * from userinfo;

第一次代码FirstJdbc 执行的结果：

第二次代码SecondJdbc 执行的结果: