一颗简单的JDBC栗子

前言：安装好数据库之后，我们编写的java程序是不能直接使用数据库的，而JDBC（Java Database Connectivity,即java数据库连接）是java语言里用来规范客户端程序访问数据库的API，有了它，我们就可以向各种关系型数据库发送SQL语句，从而实现对数据库的增删改查等操作。

准备工作：

1.数据库:这里以MySQL为例，创建一个Person表，四个字段分别为：自增主键id、姓名name、性别gender、年龄age

 DROP TABLE IF EXISTS `person`;
 CREATE TABLE `person` (
   `id` int(11) NOT NULL AUTO_INCREMENT,
   `name` varchar(11) DEFAULT NULL,
   `gender` varchar(11) DEFAULT NULL,
   `age` int(11) DEFAULT NULL,
   PRIMARY KEY (`id`)
 ) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8;

 INSERT INTO `person` VALUES ('', '小明', '男', '');
 INSERT INTO `person` VALUES ('', '小芳', '女', '');
 INSERT INTO `person` VALUES ('', '小刚', '男', '');
 INSERT INTO `person` VALUES ('', '小丽', '女', '');

2.数据库驱动程序jar包：这里使用的是mysql-connector-java-5.1.42-bin.jar

3.在eclipse中导入驱动包：右键项目点击Builder Path----Configure Builder Path----Add External JARs----找到jar包位置选择打开----Ok,可以开始搞事情了！

图示如下：

先完整演示一段简单的JDBC操作过程。

 package com.jdbc.demo;

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

 //一段完整的jdbc操作过程,后面会详细介绍，为了代码视图简洁，异常均抛出。
 public class Demo {

     public static void main(String[] args) throws ClassNotFoundException, SQLException {
         //第1步，注册加载驱动类
         Class.forName("com.mysql.jdbc.Driver");
         //第2步，获取数据库连接,方法中3个参数依次为：
         //url:就是你要连接的数据库的地址，不同的数据库格式会有差异
         //user:就是数据库的用户名，例如MySQL的root
         //password:数据库连接密码
         String url = "jdbc:mysql://127.0.0.1/hb?characterEncoding=utf-8";
         String user = "root";
         String password = "123123";
         Connection conn = DriverManager.getConnection(url, user, password);
         //第3步，构造语句集对象，为了简要直观，这里使用Statement,不过实际开发建议用PreparedStatement
         String sql = "select * from person";
         Statement stmt = conn.createStatement();
         //第4步，提交SQL语句，这是是查询，所以调用executeQuery方法，会返回一个集合，我们可以遍历输出其中信息；
         //如果是增删改，不同于数据库中的3种SQL语句，这里都是调用executeUpdate方法，返回的是int值
         ResultSet rs = stmt.executeQuery(sql);
         //第5步(可选)，处理结果，在这里我们输出Person表中所有人名
         while(rs.next()) {
             String name = rs.getString("name");
             System.out.println(name);
         }
         //第6步，关闭相关对象，这里为ResultSet,Statement,Connection
         //注意！关闭顺序和声明顺序相反!依次如下
         rs.close();
         stmt.close();
         conn.close();

     }

 }

程序运行结果如下：

相关API介绍

java.sql.Connection:

　　与数据库的连接，注意导包不要导错，因为导入MySQL驱动后，在com.mysql.jdbc下也有个Connection,如果导成这个会出错；

　　连接由JDBC管理层的DriverManager类调用getConnection方法获得，方法中后两个参数比较简单，一个用户名一个密码，第一个参数url格式则与各数据库有关

　　　　MySQL: jdbc:mysql://<host><：port>/<database_name>,默认端口3306，如果服务器使用默认端口则port可以省略,可以在URL中添加额外的连接属性jdbc:mysql://<host>:<port>/<database_name>?property1=value1&property2=value2；

　　　　ORACLE:jdbc:oracle:thin:@<host><：port>:<database_name>

java,sql.Statement 和java.sql.PreparedStatement

　　语句对象，用于提交SQL语句；

　　Statement通常用于执行静态SQL语句，statement.excute(sql)即可提交；

　　PreparedStatement可以执行动态SQL语句，允许参数化查询，而且性能更好，还可以有效避免SQL注入式攻击，后面示例都使用PreparedStatement

　　

java.sql.ResultSet:

　　指定SQL语句（通常为查询）执行返回的原始结果集，在实际开发我们通常对结果进行再封装，以方便调用

实体类Person

 package com.jdbc.entity;
 //实体类Person，属性与数据库中字段对应
 public class Person {
     private Integer id;
     private String name;
     private String gender;
     private Integer age;
     public Integer getId() {
         return id;
     }
     public void setId(Integer id) {
         this.id = id;
     }
     public String getName() {
         return name;
     }
     public void setName(String name) {
         this.name = name;
     }
     public String getGender() {
         return gender;
     }
     public void setGender(String gender) {
         this.gender = gender;
     }
     public Integer getAge() {
         return age;
     }
     public void setAge(Integer age) {
         this.age = age;
     }
     @Override
     public String toString() {
         return "Person [id=" + id + ", name=" + name + ", gender=" + gender
                 + ", age=" + age + "]";
     }

 }

JdbcUtil工具类供加载驱动类、获取连接、关闭对象

package com.jdbc.demo;

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

public class JdbcUtil {
    private static String driver = "com.mysql.jdbc.Driver";
    private static String url = "jdbc:mysql://127.0.0.1/hb?characterEncoding=utf-8";
    private static String username = "root";
    private static String password = "hjh123";
    //静态代码块中注册加载驱动类
    static {
        try {
            Class.forName(driver);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
    //封装获取连接方法
    public static Connection getConnection() {
        try {
            return DriverManager.getConnection(url, username, password);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }

    //封装关闭对象方法
    public static void close(ResultSet rs, Statement statement, Connection conn) {
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (statement != null) {
            try {
                statement.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

}

简易封装一个DAO类实现对Person表的增删改查

 package com.jdbc.demo;

 import java.sql.Connection;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.util.ArrayList;
 import java.util.List;

 import com.jdbc.entity.Person;

 //封装Person表的增删改查方法
 public class PersonDaoImpl {
     //这里的问号?是占位符,用于给将要传递的参数占位置，实现了动态SQL语句的执行
     //添加一条记录的SQL语句，第一个参数由于数据表中是主键自增，这里可以用null
     private static final String SQL_ADD = "insert into person values(null,?,?,?)";
     //删除，指定id的记录
     private static final String SQL_DEL = "delete from person where id = ?";
     //修改，指定id的记录
     private static final String SQL_UPD = "update person set name = ?,gender = ?,age = ? where id = ?";
     //查询，指定id记录
     private static final String SQL_ID = "select * from person where id = ?";
     //查询，所有记录
     private static final String SQL_ALL = "select * from person";

     //添加一条记录
     public boolean add(Person p) {
         Connection conn = JdbcUtil.getConnection();
         PreparedStatement ps = null;
         try {
             ps = conn.prepareStatement(SQL_ADD);
             //把我们传入的person对象的属性值分作为占位符的值传入,数组各值顺序对应占位符字段顺序
             Object[] params = {p.getName(),p.getGender(),p.getAge()};
             int len = params.length;
             for(int i = 0;i < len;i++) {
                 //！！！这里比较特殊，很多下标都是从0开始，例如数组，
                 //！！！但是这个setObject方法第一个索引参数是从1开始
                 ps.setObject(i+1, params[i]);
             }
             //这里的整型返回值line意指更新的记录数，或者说是数据库中受影响的记录行数
             //之前的Statement.excute方法要传入SQL语句字符串参数，
             //但是用了PreparedStatement就不用传参数了，因为在前面我们已经预定义处理了
             int line = ps.executeUpdate();
             if (line > 0) {
                 System.out.println("添加成功,受影响记录数为"+line);
                 return true;//结束，但是后面finally区代码会执行
             }
         } catch (SQLException e) {
             e.printStackTrace();
         } finally {
             //关闭相关对象
             JdbcUtil.close(null, ps, conn);
         }
         System.out.println("添加失败");
         return false;
     }
     //删除一条记录
     public boolean delete(int id) {
         Connection conn = JdbcUtil.getConnection();
         PreparedStatement ps = null;
         try {
             ps = conn.prepareStatement(SQL_DEL);
             ps.setInt(1, id);
             //这里的整型返回值line意指更新的记录数，或者说是数据库中受影响的记录行数
             int line = ps.executeUpdate();
             if (line > 0) {
                 System.out.println("删除成功,受影响记录数为"+line);
                 return true;//结束，但是后面finally区代码会执行
             }
         } catch (SQLException e) {
             e.printStackTrace();
         } finally {
             //关闭相关对象
             JdbcUtil.close(null, ps, conn);
         }
         System.out.println("删除失败");
         return false;
     }
     //修改一条记录
     public boolean update(Person p) {
         Connection conn = JdbcUtil.getConnection();
         PreparedStatement ps = null;
         try {
             ps = conn.prepareStatement(SQL_UPD);
             //把我们传入的person对象的属性值分作为占位符的值传入
             Object[] params = {p.getName(),p.getGender(),p.getAge(),p.getId()};
             int len = params.length;
             for(int i = 0;i < len;i++) {
                 //！！！这里比较特殊，很多下标都是从0开始，例如数组，
                 //！！！但是这个setObject方法第一个索引参数是从1开始
                 ps.setObject(i+1, params[i]);
             }
             //这里的整型返回值line意指更新的记录数，或者说是数据库中受影响的记录行数
             int line = ps.executeUpdate();
             if (line > 0) {
                 System.out.println("修改成功,受影响记录数为"+line);
                 return true;//结束，但是后面finally区代码会执行
             }
         } catch (SQLException e) {
             e.printStackTrace();
         } finally {
             //关闭相关对象
             JdbcUtil.close(null, ps, conn);
         }
         System.out.println("修改失败");
         return false;
     }
     //获取一条记录,这里返回的不再是布尔值，而是一个对应数据表中一条记录的Person对象
     public Person findById(int id) {
         Connection conn = JdbcUtil.getConnection();
         PreparedStatement ps = null;
         ResultSet rs = null;
         try {
             ps = conn.prepareStatement(SQL_ID);
             ps.setInt(1, id);
             //返回结果集，这里是查询指定id，所以结果集中应该最多只有一条记录
             rs = ps.executeQuery();
             if(rs.next()) {
                 Person p = new Person();
                 p.setId(id);
                 //这里的Result的getObject方法，参数为数据表中字段名，可以获取对应字段值
                 p.setName(rs.getString("name"));
                 p.setGender(rs.getString("gender"));
                 p.setAge(rs.getInt("age"));
                 return p;//返回p对象，结束
             }
         } catch (SQLException e) {
             e.printStackTrace();
         } finally {
             //关闭相关对象
             JdbcUtil.close(rs, ps, conn);
         }
         return null;
     }
     //获取所有记录，返回结果集不便操作，故封装到一个List中作为方法返回值
         public List<Person> findAll() {
             Connection conn = JdbcUtil.getConnection();
             PreparedStatement ps = null;
             ResultSet rs = null;
             List<Person> list = new ArrayList<>();
             try {
                 ps = conn.prepareStatement(SQL_ALL);
                 //返回结果集
                 rs = ps.executeQuery();
                 while(rs.next()) {
                     //创建一个Person对象
                     Person p = new Person();
                     //这里的Result的getObject方法，参数为数据表中字段名，可以获取对应字段值
                     p.setId(rs.getInt("id"));
                     p.setName(rs.getString("name"));
                     p.setGender(rs.getString("gender"));
                     p.setAge(rs.getInt("age"));
                     list.add(p);//添加至集合
                 }
                 return list;
             } catch (SQLException e) {
                 e.printStackTrace();
             } finally {
                 //关闭相关对象
                 JdbcUtil.close(rs, ps, conn);
             }
             return null;
         }
 }

小结

JDBC操作数据库步骤概述如下：

1.注册加载驱动类

2.获取连接

3.创建语句对象

4.执行SQL语句（excute）

5（可选）.处理结果

6.关闭相关对象（注意顺序：依次为ResultSet、Statement/PreparedStatement、Connction）

扩展

上述过程能基本完整实现对一个数据表的操作，但是只能针对固定的单个数据表，利用泛型、反射等技术，可对dao层代码进行抽取和封装，添加SQL语句实现联表查询，使得程序更具有通用性和灵活性，对任意的数据表都适用。在实际开发过程中，有框架已经封装了JDBC，如hibernate和mybatis，可以通过底层的JDBC操作进一步学习。