JDBC基础学习笔记

第一课

第一节：JDBC简介

JDBC(Java Data Base Connectivity，Java数据库连接) 是一种用于执行SQL语句的JavaAPI，可以为多种关系数据库提供统一访问，它由一组用Java语言编写的类和接口组成。JDBC提供了一种基准，据此可以构建更高级的工具和接口，使数据库开发人员能够编写数据库应用程序。

第二节：JDBC原理

JDBC原理:JDBC是以前SUN公司定义的一套访问数据库的接口（没有具体实现），一套标准，具体的实现是由各大数据库厂家去实现，每个数据库厂家都有自己的JDBC实现，也就是JDBC驱动实现类，Java应用程序连接指定数据库，需要使用厂家提供的JDBC驱动才能连接。（这里其实就是java多态的一种体现，一个接口可以有很多具体的实现）

第二课

第一节：JDBC连接数据库步骤

第一步：加载驱动

第二步：链接数据库

第三步：使用语句操作数据库

第四步：关闭数据库链接，释放资源；

第二节：在项目里配置数据库驱动

右击项目->Build Path -> Configure Build Path -> Add External JARs

第三节：加载数据库驱动

MySQL驱动名：com.mysql.jdbc.Driver

加载方式：Class.forName(驱动名)

第四节：连接及关闭数据库

1.DriverManager驱动管理类，主要负责获取一个数据库的连接；

static Connection getConnection(String url,String user,String password)

试图建立到给定数据库URL的连接。

2.MySQL数据库的连接地址格式

jdbc:mysql://IP:port/databasename

JDBC协议：JDBC URL中的协议总是JDBC

子协议：驱动程序名或数据库连接机制（这种机制可由一个或多个驱动程序支持），如mysql

子名称：一种标识数据库的方法。必须遵循//主机名:端口/子协议的标准URL命名约定，如//localhost:3306/db_book

3.Connection 接口

与特定数据库的连接（会话）

void close():立即释放此Connection对象的数据库和JDBC资源，而不是等待它们被自动回收

package package01;
import java.sql.*;
public class Demo2 {
    //驱动名称
    private static String jdbcName="com.mysql.jdbc.Driver";
    //数据库地址
    private static String dbUrl="jdbc:mysql://localhost:3306/data";
    private static String dbUserName="root";
    private static String dbPassword="root";
    public static void main(String[] args) {
        try {
            Class.forName(jdbcName);
            System.out.println("加载驱动成功！");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
            System.out.println("加载驱动失败！");
        }
        Connection con =null;
        try {
            //获取数据库连接
            con=DriverManager.getConnection(dbUrl, dbUserName, dbPassword);
            System.out.println("获取数据库连接成功！");
            System.out.println("进行数据库操作！");
        } catch (SQLException e) {
            e.printStackTrace();
            System.out.println("获取数据库连接失败！");
        }finally {
            try {
                con.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

第三课

ctrl + shift + f :格式化
ctrl + shift + / :多行用*号注释
alt + shift + s :调用方法

第一节：Statement接口引入

作用：用于执行静态SQL语句并返回它所生成结果的对象。

int executeUpdate(String sql)执行给定SQL语句，该语句可能为INSERT、UPDATE或DELETE语句，或者不返回任何内容的SQL语句（如SQL DDL语句）。

void close()立即释放此Statement对象的数据库和JDBC资源，而不是等待该对象自动关闭时发生此操作。

DbUtil类的实现：

package util;
import java.sql.*;
public class DbUtil {
    private static String dbUrl="jdbc:mysql://localhost:3306/demo";
    private static String dbUserName="root";
    private static String dbPassword="root";
    private static String jdbcName="com.mysql.jdbc.Driver";
    /*
     * 获取数据库连接
     */
    public Connection getCon()throws Exception{
        Class.forName(jdbcName);
        Connection con=DriverManager.getConnection(dbUrl, dbUserName, dbPassword);
        return con;
    }
    /**
     * 关闭数据库连接
     */
    public void close(Statement stmt,Connection con) throws Exception{
        if(stmt!=null){
            stmt.close();
            if(con!=null){
                con.close();
            }
        }
    } 
}

简单实现Statement接口的引入：

package package03;
import java.sql.*;
import util.DbUtil;
public class Demo01 {
    public static void main(String[] args) throws Exception{
        String sql = "insert into user values(2,'admin1','123456')";
        DbUtil dbUtil = new DbUtil();
        Connection con = dbUtil.getCon();//获取数据库连接
        Statement stmt = con.createStatement();//获取Statement
        int result = stmt.executeUpdate(sql);
        System.out.println("操作的结果："+result+"数据");
        stmt.close();//关闭statement
        con.close();//关闭数据库连接
    }
}

第二节：使用`Statement`接口实现添加数据操作

先封装一个Book类：

package model;
/**
 * 图书模型
 * @author Administrator
 */
public class Book {
    private int id;
    private String bookName;
    private String author;
    private String sex;
    private float price;
    private int bookDesc;
    private int bookTypeId;

    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getBookName() {
        return bookName;
    }
    public void setBookName(String bookName) {
        this.bookName = bookName;
    }
    public String getAuthor() {
        return author;
    }
    public void setAuthor(String author) {
        this.author = author;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public float getPrice() {
        return price;
    }
    public void setPrice(float price) {
        this.price = price;
    }
    public int getBookDesc() {
        return bookDesc;
    }
    public void setBookDesc(int bookDesc) {
        this.bookDesc = bookDesc;
    }
    public int getBookTypeId() {
        return bookTypeId;
    }
    public void setBookTypeId(int bookTypeId) {
        this.bookTypeId = bookTypeId;
    }
    public Book(int id, String bookName, String author, String sex, float price, int bookDesc, int bookTypeId) {
        super();
        this.id = id;
        this.bookName = bookName;
        this.author = author;
        this.sex = sex;
        this.price = price;
        this.bookDesc = bookDesc;
        this.bookTypeId = bookTypeId;
    }
}

InsertDemo.java:

package package03;
import java.sql.*;
import model.Book;
import util.DbUtil;
/**
 * 添加图书
 * @author Administrator
 */
public class InsertDemo {
    private static DbUtil dbUtil = new DbUtil();
    private static int addBook2(Book book) throws Exception{
        Connection con = dbUtil.getCon();//获取连接
        String sql ="insert into t_book values("+book.getId()+",'"+book.getBookName()+"','"+book.getAuthor()+"','"+book.getSex()+"',"+book.getPrice()+","+book.getBookDesc()+","+book.getBookTypeId()+");";
        Statement stmt = con.createStatement();
        int result = stmt.executeUpdate(sql);
        dbUtil.close(stmt, con);//关闭连接
        return result;
    }
    public static void main(String[] args) throws Exception {
        Book book = new Book(12,"搞定", "sss", "女", 152.0f, 16, 200);
        int result = addBook2(book);
        if (result==1) {
            System.out.println("添加成功");
        }else{
            System.out.println("添加失败");
        }
    }
}

第三节：使用`Statement`接口实现更新数据操作

UpdateDemo.java:

package package03;
import java.sql.*;
import model.Book;
import util.DbUtil;
/**
 * 更新图书
 * @author Administrator
 *
 */
public class UpdateDemo {
    private static DbUtil dbUtil = new DbUtil();
    private static int updateBook(Book book) throws Exception {
        String sql = "update t_book set bookName='" + book.getBookName() + "',author='" + book.getAuthor() + "',sex='"
                + book.getSex() + "',price='" + book.getPrice() + "',bookDesc=" + book.getBookDesc() + ",bookTypeId="
                + book.getBookTypeId() + " where id=" + book.getId();
        Connection con = dbUtil.getCon();
        Statement stmt = con.createStatement();
        int result = stmt.executeUpdate(sql);
        dbUtil.close(stmt, con);
        return result;
    }
    public static void main(String[] args) throws Exception {
        Book book = new Book(12, "java核心卷2", "我", "男", 196.3f, 999, 888);
        int result = updateBook(book);
        if (result == 1) {
            System.out.println("更新成功！");
        } else {
            System.out.println("更新失败！");
        }
    }
}

第四节：使用Statement 接口实现删除数据操作

DeleteDemo.java:

package package03;
import java.sql.*;
import util.DbUtil;
/**
 * 删除图书
 * @author Administrator
 */
public class DeleteDemo {
    private static DbUtil dbUtil = new DbUtil();
    private static int deleteBook(int id) throws Exception{
        String sql = "delete from t_book where id="+id;
        Connection con = dbUtil.getCon();
        Statement stmt = con.createStatement();
        int result = stmt.executeUpdate(sql);
        return result;
    }
    public static void main(String[] args) throws Exception{
        int result = deleteBook(3);
        if (result==1) {
            System.out.println("删除成功");
        }else{
            System.out.println("删除失败");
        }
    }
}

第四课

PreparedStatement是Statement的子接口，属于预处理操作，与直接使用Statement不同的是，PreparedStatement在操作时，是先在数据表中准备好了一条SQL语句，但是此SQL语句的具体内容暂时不设置，而是之后再进行设置。

（以后开发一般用PreparedStatement，不用Statement）

第一节：PreparedStatement接口引入

Connection con =dbUtil.getCon();
String sql = "insert into t_book values(?,?,?,?,?,?,?)";
PreparedStatement pstmt = con.prepareStatement(sql);
pstmt.setInt(1, book.getId());
pstmt.setString(2, book.getBookName());
pstmt.setString(3, book.getAuthor());
pstmt.setString(4, book.getSex());
pstmt.setFloat(5, book.getPrice());
pstmt.setInt(6, book.getBookDesc());
pstmt.setInt(7, book.getBookTypeId());
int result = pstmt.executeUpdate();
dbUtil.close(pstmt, con);
return result;

在DbUtil类中增加关闭PreparedStatement接口的方法：（调用Statement接口的关闭方法也可以）

public void close(PreparedStatement pstmt,Connection con) throws Exception{
    if(pstmt!=null){
        pstmt.close();
        if(con!=null){
            con.close();
        }
    }
}

第二节：使用PreparedStatement接口实现添加数据操作

InsertDemo.java:

package package04;
import java.sql.*;
import model.Book;
import util.DbUtil;
public class InsertDemo {
    private static DbUtil dbUtil = new DbUtil();
    private static int addBook(Book book) throws Exception{
        Connection con =dbUtil.getCon();
        String sql = "insert into t_book values(?,?,?,?,?,?,?)";
        PreparedStatement pstmt = con.prepareStatement(sql);
        pstmt.setInt(1, book.getId());
        pstmt.setString(2, book.getBookName());
        pstmt.setString(3, book.getAuthor());
        pstmt.setString(4, book.getSex());
        pstmt.setFloat(5, book.getPrice());
        pstmt.setInt(6, book.getBookDesc());
        pstmt.setInt(7, book.getBookTypeId());
        int result = pstmt.executeUpdate();
        dbUtil.close(pstmt, con);
        return result;
    }
    public static void main(String[] args) throws Exception{
        Book book = new Book(14,"python爬虫", "tom", "男", 15.2f, 280, 100);
        int result = addBook(book);
        if (result==1){
            System.out.println("添加成功");
        }else{
            System.out.println("添加失败");
        }
    }

}

第三节：使用PreparedStatement接口实现更新数据操作

UpdateDemo.java:

package package04;
import java.sql.*;
import model.Book;
import util.DbUtil;
public class UpdateDemo {
    private static DbUtil dbUtil = new DbUtil();
    private static int updateBook(Book book) throws Exception{
        Connection con=dbUtil.getCon();
        String sql = "update t_book set bookName=?,author=?,sex=?,price=?,bookDesc=?,bookTypeId=? where id=?";
        PreparedStatement pstmt = con.prepareStatement(sql);
        pstmt.setString(1, book.getBookName());
        pstmt.setString(2, book.getAuthor());
        pstmt.setString(3, book.getSex());
        pstmt.setFloat(4, book.getPrice());
        pstmt.setInt(5, book.getBookDesc());
        pstmt.setInt(6, book.getBookTypeId());
        pstmt.setInt(7, book.getId());
        int result = pstmt.executeUpdate();
        dbUtil.close(pstmt, con);
        return result;
    }
    public static void main(String[] args) throws Exception{
        Book book = new Book(14,"java", "Mary", "女", 300.6f, 44, 33);
        int result = updateBook(book);
        if (result == 1) {
            System.out.println("更新成功！");
        } else {
            System.out.println("更新失败！");
        }
    }
}

第四节：使用PreparedStatement接口实现删除数据操作

DeleteDemo.java:

package package04;
import java.sql.*;
import util.DbUtil;
public class DeleteDemo {
    private static DbUtil dbUtil = new DbUtil();
    private static int deleteBook(int id) throws Exception{
        Connection con= dbUtil.getCon();
        String sql = "delete from t_book where id=?";
        PreparedStatement pstmt =con.prepareStatement(sql);
        pstmt.setInt(1, id);
        int result = pstmt.executeUpdate();
        dbUtil.close(pstmt, con);
        return result;
    }
    public static void main(String[] args) throws Exception {
        int result = deleteBook(14);
        if (result==1) {
            System.out.println("删除成功");
        }else{
            System.out.println("删除失败");
        }
    }
}

第五课 ResultSet结果集

第一节：ResultSet结果集的引入

当我们查询数据库时，返回的是一个二维的结果集，我们这时候需要使用ResultSet来遍历结果集，获取每一行的数据。

第二节：使用ResultSet遍历查询结果

boolean next()将光标从当前位置向前移一行。
String getString(int columnIndex)以Java编程语言中String的形式获取此ResultSet对象的当前行中指定列的值。

String getString(String columnLabel)以Java编程语言中String的形式获取此ResultSet对象的当前行中指定列的值。

package package05;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
import model.Book;
import util.DbUtil;
/**
 * 遍历查询结果
 * @author Administrator
 */
public class Demo01 {
    private static DbUtil dbUtil = new DbUtil();
    private static void listBook() throws Exception {
        Connection con = dbUtil.getCon();
        String sql = "select * from t_book";
        PreparedStatement pstmt = con.prepareStatement(sql);
        ResultSet rs = pstmt.executeQuery();// 返回结果集ResultSet
        while (rs.next()) {
            int id = rs.getInt(1);
            String bookName = rs.getString(2);
            String author = rs.getString(3);
            String sex = rs.getString(4);
            Float price = rs.getFloat(5);
            int bookDesc = rs.getInt(6);
            int bookTypeId = rs.getInt(7);
            System.out.println("ID：" + id + ",书名：" + bookName + ",作者：" + author + ",性别：" + sex + ",价格：" + price
                    + ",图书分类：" + bookDesc + ",图书类别编号：" + bookTypeId);
            System.out.println("-----------------------");
        }
    }
    private static void listBook1() throws Exception {
        Connection con = dbUtil.getCon();
        String sql = "select * from t_book";
        PreparedStatement pstmt = con.prepareStatement(sql);
        ResultSet rs = pstmt.executeQuery();// 返回结果集ResultSet
        while (rs.next()) {
            int id = rs.getInt("id");
            String bookName = rs.getString("bookName");
            String author = rs.getString("author");
            String sex = rs.getString("sex");
            Float price = rs.getFloat("price");
            int bookDesc = rs.getInt("bookDesc");
            int bookTypeId = rs.getInt("bookTypeId");
            System.out.println("ID：" + id + ",书名：" + bookName + ",作者：" + author + ",性别：" + sex + ",价格：" + price
                    + ",图书分类：" + bookDesc + ",图书类别编号：" + bookTypeId);
            System.out.println("-----------------------");
        }
    }
    private static List<Book> listBook3() throws Exception{
        List<Book> bookList = new ArrayList<Book>();
        Connection con = dbUtil.getCon();
        String sql = "select * from t_book";
        PreparedStatement pstmt = con.prepareStatement(sql);
        ResultSet rs = pstmt.executeQuery();// 返回结果集ResultSet
        while (rs.next()) {
            int id = rs.getInt("id");
            String bookName = rs.getString("bookName");
            String author = rs.getString("author");
            String sex = rs.getString("sex");
            Float price = rs.getFloat("price");
            int bookDesc = rs.getInt("bookDesc");
            int bookTypeId = rs.getInt("bookTypeId");
            Book book = new Book(id,bookName, author, sex, price, bookDesc, bookTypeId);
            bookList.add(book);
        }
        return bookList;
    }
    public static void main(String[] args) throws Exception {
        //listBook();
        //listBook1();
        List<Book> bookList = listBook3();
        for (Book book : bookList) {
            System.out.println(book);
        }
    }
}

在Book模型中重写toString方法，获得输出值

public String toString() {
    return "["+this.id+","+this.bookName+","+this.author+","+this.sex+","+this.price+","+this.bookDesc+","+this.bookTypeId+"]";
}

第六课处理大数据对象

大数据对象处理主要有CLOB（character large object）和BLOB（binary large object）两种类型的字段；

在CLOB中可以存储大字符数据对象，比如长篇小说；

在BLOB中可以存放二进制大数据对象，比如图片，电影，音乐；

第一节：处理CLOB数据

数据库表中创建:

列名：context

数据类型：longtext

Book模型中新增context值

CLOBDemo.java

package package06;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.sql.Clob;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import model.Book;
import util.DbUtil;

public class CLOBDemo {
    private static DbUtil dbUtil = new DbUtil();
    private static int addBook(Book book) throws Exception{
        Connection con =dbUtil.getCon();
        String sql = "insert into t_book values(?,?,?,?,?,?,?,?)";
        PreparedStatement pstmt = con.prepareStatement(sql);
        pstmt.setInt(1, book.getId());
        pstmt.setString(2, book.getBookName());
        pstmt.setString(3, book.getAuthor());
        pstmt.setString(4, book.getSex());
        pstmt.setFloat(5, book.getPrice());
        pstmt.setInt(6, book.getBookDesc());
        pstmt.setInt(7, book.getBookTypeId());

        File context = book.getContext();//获取文件
        InputStream inputStream = new FileInputStream(context);
        pstmt.setAsciiStream(8,inputStream,context.length());

        int result = pstmt.executeUpdate();
        dbUtil.close(pstmt, con);
        return result;
    }

    private static void getBook(int id) throws Exception{
        Connection con = dbUtil.getCon();
        String sql = "select * from t_book where id=?";
        PreparedStatement pstmt=con.prepareStatement(sql);
        pstmt.setInt(1, id);
        ResultSet rs =pstmt.executeQuery();
        if(rs.next()){
            String bookName = rs.getString("bookName");
            String author = rs.getString("author");
            String sex = rs.getString("sex");
            Float price = rs.getFloat("price");
            int bookDesc = rs.getInt("bookDesc");
            int bookTypeId = rs.getInt("bookTypeId");

            Clob c=rs.getClob("context");
            String context = c.getSubString(1, (int)c.length());

            System.out.println("图书名称："+bookName);
            System.out.println("图书作者："+author);
            System.out.println("作者性别："+sex);
            System.out.println("图书价格："+price);
            System.out.println("图书类别："+bookDesc);
            System.out.println("图书类型ID："+bookTypeId);
            System.out.println("图书内容："+context);
        }
        dbUtil.close(pstmt, con);
    }

    public static void main(String[] args) throws Exception {

/*        File context = new File("c:/he.txt");
        Book book = new Book(16,"python555", "Jhon", "男", 16.3f, 14, 22, context);
        int result = addBook(book);
        if (result==1){
            System.out.println("添加成功");
        }else{
            System.out.println("添加失败");
        }*/
        getBook(16);
    }
}

第二节：处理BLOB数据

数据库表中创建:

列名：pic

数据类型：longblob

Book模型中新增pic值

BLOBDemo.java

package package06;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.sql.Blob;
import java.sql.Clob;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.concurrent.BlockingDeque;
import model.Book;
import util.DbUtil;

public class BLOBDemo {
    private static DbUtil dbUtil = new DbUtil();

    private static int addBook(Book book) throws Exception{
        Connection con =dbUtil.getCon();
        String sql = "insert into t_book values(?,?,?,?,?,?,?,?,?)";
        PreparedStatement pstmt = con.prepareStatement(sql);
        pstmt.setInt(1, book.getId());
        pstmt.setString(2, book.getBookName());
        pstmt.setString(3, book.getAuthor());
        pstmt.setString(4, book.getSex());
        pstmt.setFloat(5, book.getPrice());
        pstmt.setInt(6, book.getBookDesc());
        pstmt.setInt(7, book.getBookTypeId());

        File context = book.getContext();//获取文件
        InputStream inputStream = new FileInputStream(context);
        pstmt.setAsciiStream(8,inputStream,context.length());

        File pic = book.getPic();//获取图片文件
        InputStream inputStream2 = new FileInputStream(pic);
        pstmt.setBinaryStream(9,inputStream2);

        int result = pstmt.executeUpdate();
        dbUtil.close(pstmt, con);
        return result;
    }


    private static void getBook(int id) throws Exception{
        Connection con = dbUtil.getCon();
        String sql = "select * from t_book where id=?";
        PreparedStatement pstmt=con.prepareStatement(sql);
        pstmt.setInt(1, id);
        ResultSet rs =pstmt.executeQuery();
        if(rs.next()){
            String bookName = rs.getString("bookName");
            String author = rs.getString("author");
            String sex = rs.getString("sex");
            Float price = rs.getFloat("price");
            int bookDesc = rs.getInt("bookDesc");
            int bookTypeId = rs.getInt("bookTypeId");

            Clob c=rs.getClob("context");
            String context = c.getSubString(1, (int)c.length());

            Blob b =rs.getBlob("pic");
            FileOutputStream out = new FileOutputStream(new File("d:/photo.jpg"));
            out.write(b.getBytes(1, (int) b.length()));
            out.close();

            System.out.println("图书名称："+bookName);
            System.out.println("图书作者："+author);
            System.out.println("作者性别："+sex);
            System.out.println("图书价格："+price);
            System.out.println("图书类别："+bookDesc);
            System.out.println("图书类型ID："+bookTypeId);
            System.out.println("图书内容："+context);
        }
        dbUtil.close(pstmt, con);
    }

    public static void main(String[] args) throws Exception {        
 /*        File context = new File("c:/he.txt");
        File pic = new File("c:/pic.jpg");
        Book book = new Book(17,"vb","Black","男",16.3f,18,66,context,pic);
        int result = addBook(book);
        if (result==1){
            System.out.println("添加成功");
        }else{
            System.out.println("添加失败");
        }*/
        getBook(17);
    }
}

第七课使用CallableStatement接口调用存储过程

第一节：CallableStatement接口的引入

CallableStatement主要是调用数据库中的存储过程，CallableStatement也是Statement接口的子接口。在使用CallableStatement时可以接收存储过程的返回值。

第二节：使用CallableStatement 接口调用存储过程

void registerOutParameter(int parameterIndex, int sqlType)

按顺序位置parameterIndex将OUT参数注册为JDBC类型sqlType。

新建存储过程：

DELIMITER &&
CREATE PROCEDURE pro_getBookNameById(IN bookId INT,OUT bN VARCHAR(20))
 BEGIN
    SELECT bookName INTO bn FROM t_book WHERE id=bookId;
 END 
&&
DELIMITER ;

CALL pro_getBookNameById(10,@bookName);
SELECT @bookName;

调用存储过程，通过id查询bookName的Demo:

package package07;
import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.Types;
import util.DbUtil;

public class Demo01 {
    public static DbUtil dbUtil = new DbUtil();
    private static String getBookNameById(int id) throws Exception{
        Connection con = dbUtil.getCon();
        String sql= "{CALL pro_getBookNameById(?,?)}";
        CallableStatement cstmt = con.prepareCall(sql);

        cstmt.setInt(1, id);//设置第一个参数
        cstmt.registerOutParameter(2, Types.VARCHAR);//设置返回类型
        cstmt.execute();

        String bookName = cstmt.getString("bN");//获取返回值

        dbUtil.close(cstmt, con);
        return bookName;
    }
    public static void main(String[] args) throws Exception {
        System.out.println("图书名称:"+getBookNameById(16));
    }
}

第八课使用元数据分析数据库

第一节：使用DatabaseMetaData获取数据库基本信息

DatabaseMetaData可以得到数据库的一些基本信息，包括数据库的名称、版本，以及得到表的信息。

String getDatabaseProductName()获取此数据库产品的名称。

int getDriverMajorVersion()获取此JDBC驱动程序的主版本号。

int getDriverMinorVersion()获取此JDBC驱动程序的次版本号。

package package08;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import util.DbUtil;
public class Demo {
    public static void main(String[] args) throws Exception{
        DbUtil dbUtil = new DbUtil();
        Connection con =dbUtil.getCon();
        DatabaseMetaData dmd=con.getMetaData();//获取元数据
        System.out.println("数据库名称："+dmd.getDatabaseProductName());
        System.out.println("JDBC驱动版本："+dmd.getDriverMajorVersion()+"."+dmd.getDriverMinorVersion());
    }
}

第二节：使用ResultSetMetaData获取ResultSet对象中的信息

ResultSetMetaData可获取关于ResultSet对象中列的基本信息。

int getColumnCount()返回此ResultSet对象中的列数。

String getColumnName(int column)获取指定列的名称。

int getColumnTypeName(int column)获取指定列的SQL类型名称。

package package08;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSetMetaData;
import util.DbUtil;
public class Demo02 {
    public static void main(String[] args) throws Exception {
        DbUtil dbUtil = new DbUtil();
        Connection con = dbUtil.getCon();
        String sql = "select * from t_book";
        PreparedStatement pstmt =con.prepareStatement(sql);
        ResultSetMetaData rsmd = pstmt.getMetaData();//获取列的基本信息
        int num = rsmd.getColumnCount();//获取元数据列的总数
        System.out.println("共有"+num+"列");
        for (int i = 1; i <=num; i++) {
            System.out.println(rsmd.getColumnName(i)+","+rsmd.getColumnTypeName(i));
            //获取列的名称  + 指定列的sql类型名称
        }
    }
}

##　第九课

第一节：事务的概念

事务处理在数据库开发中有着非常重要的作用，所谓事务就是所有的操作要么一起成功，要么一起失败，事务本身具有原子性（Atomicity）、一致性（Consistency）、隔离性或独立性（Isolation）、持久性（Durability）4 个特性，这4 个特性也被称为ACID特征。

原子性：原子性是事务最小的单元，是不可再分隔的单元，相当于一个个小的数据库操作，这些操作必须同时成功，如果一个失败了，则一切的操作将全部失败。

一致性：指的是在数据库操作的前后是完全一致的，保证数据的有效性，如果事务正常操作则系统会维持有效性，如果事务出现了错误，则回到最原始状态，也要维持其有效性，这样保证事务开始时和结束时系统处于一致状态。

隔离性：多个事务可以同时进行且彼此之间无法访问，只有当事务完成最终操作时，才可以看到结果。

持久性：事务完成之后，它对于系统的影响是永久性的。该修改即使出现致命的系统故障也将一直保持。

第二节：`MySQL`对事务的支持

序号	命令	描述
1	`SET AUTOCOMMIT=0`	取消自动提交处理，开启事务处理
2	`SET AUTOCOMMIT=1`	打开自动提交处理，关闭事务处理
3	`START TRANSACTION`	启动事务
4	`BEGIN`	启动事务，相当于执行`START TRANSACTION`
5	`COMMIT`	提交事务
6	`ROLLBACK`	回滚全部事务
7	`SAVEPOINT`	事务保存点名称
8	`ROLLBACK TO SAVEPOINT`	保存点名称回滚操作到保存点

第三节：JDBC事务处理

第四节：事务保存点

db_bank.sql

CREATE DATABASE `db_bank`;
USE `db_bank`;
DROP TABLE IF EXISTS `t_account`;
CREATE TABLE `t_account` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `accountName` varchar(20) DEFAULT NULL,
  `accountBalance` int(11) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;
insert  into `t_account`(`id`,`accountName`,`accountBalance`) values (1,'张三',500),(2,'李四',1000);

package package09;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import util.DbUtil;
public class Demo01 {
    public static DbUtil dbUtil = new DbUtil();
    /*
     * 转出
     */
    public static void outCount(Connection con,String accountName,int account) throws Exception{
        String sql = "update t_account set accountBalance=accountBalance-? where accountName=?";
        PreparedStatement pstmt = con.prepareStatement(sql);
        pstmt.setInt(1, account);
        pstmt.setString(2,accountName);
        pstmt.executeUpdate();

    }
    /*
     * 转入
     */
    public static void inCount(Connection con,String accountName,int account) throws Exception{
        String sql = "update t_account set accountBalance=accountBalance+? where accountName=?";
        PreparedStatement pstmt = con.prepareStatement(sql);
        pstmt.setInt(1, account);
        pstmt.setString(2,accountName);
        pstmt.executeUpdate();

    }
    public static void main(String[] args){
        Connection con = null;
        try {
            con = dbUtil.getCon();
            con.setAutoCommit(false);//取消自动提交
            System.out.println("张三开始向李四转钱：");
            int account = 500;
            outCount(con, "张三", account);
            inCount(con, "李四", account);
            System.out.println("转账成功");
        } catch (Exception e) {
            try {
                con.rollback();
            } catch (SQLException e1) {
                // TODO Auto-generated catch block
                e1.printStackTrace();
            }
            e.printStackTrace();
        }finally {
            try {
                con.commit();//提交事务
                con.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

Tags: 编程基础

← 使用CC++实现复数抽象数据类型Complex PHP代码审计分段讲解 →

赏

使用支付宝打赏

使用微信打赏

若你觉得我的文章对你有帮助，欢迎点击上方按钮对我打赏

扫描二维码，分享此文章

第一课