数据库管理与JDBC实战-优快云博客

本文链接：https://blog.youkuaiyun.com/oldwangold/article/details/104553744

8、权限管理和备份

8.1 用户管理

SQL命令操作

用户表：mysql.user
本质：对这张表进行增删改查

-- 创建用户 CREATE USER 用户名 IDENTIFIED BY '密码'
CREATE USER wonjack IDENTIFIED BY '123456'

-- 修改密码（修改当前用户密码）
SET PASSWORD = PASSWORD('123456')

-- 修改密码（修改指定用户密码）
SET PASSWORD FOR wonjack = PASSWORD('123456')

-- 重命名  RENAME USER 原来的名字 TO 新的名字
RENAME USER wonjack TO wonjack2


-- 用户授权 ALL PRIVILEGES 全部的权限，库.表
-- ALL PRIVILEGES 除了给别人授权，其他都能够做
GRANT ALL PRIVILEGES ON *.* TO wonjack2

-- 查看权限
SHOW GRANTS FOR wonjack2 -- 查看指定用户的权限
SHOW GRANTS FOR root@localhost

-- ROOT 用户的权限：GRANT ALL PRIVILEGES ON *.* TO 'root@localhost' WITH GRANT OPTION

-- 撤销权限  REVOKE 哪些权限 在哪个库撤销 给谁撤销
REVOKE ALL PRIVILEGES ON *.* FROM wonjack2


-- 创建用户
CREATE USER wonjack IDENTIFIED BY '123456'
-- 删除用户
DROP USER wonjack

8.2 数据库备份

为什么备份：

保证重要的数据不丢失
数据转移 A ----> B

MySQL数据库备份的方式

直接拷贝物理文件
在SQLyog这种可视化工具中手动导出
使用命令行导出 mysqldump 命令行使用

# mysqldump -h 主机 -u 用户名 -p 密码 数据库 表名 > 物理磁盘位置/文件名
mysqldump -hlocalhost -uroot -p123456 school student > D:/a.sql

# mysqldump -h 主机 -u 用户名 -p 密码 数据库 表1 表2 表3 > 物理磁盘位置/文件名
mysqldump -hlocalhost -uroot -p123456 school student > D:/b.sql

# mysqldump -h 主机 -u 用户名 -p 密码 数据库 > 物理磁盘位置/文件名
mysqldump -hlocalhost -uroot -p123456 school > D:/c.sql

# 导入
# 在登录的情况下，切换到指定的数据库
# source 备份文件
source d:/a.sql
mysql -u用户名 -p密码 库名 < 备份文件

假设要备份数据库，防止数据丢失。
把数据库给朋友，sql文件给别人。

9、规范数据库设计

9.1 为什么需要设计

当数据库比较复杂的时候，我们就需要设计了。
糟糕的数据库设计：

数据冗余，浪费空间
数据插入和删除都会麻烦、异常【屏蔽使用物理外键】
程序性能差

良好的数据库设计：

节省内存空间
保证数据库的完整性
方便我们开发系统

软件开发中，关于数据库的设计：

分析需求：分析业务和需要处理的数据库的需求
概念设计：设计关系图 E-R 图

设计数据库的步骤：（个人博客）

收集信息，分析需求
- 用户表（用户登录注销，用户的个人信息，写博客，创建分类）
- 分类表（文章分类，谁创建的）
- 文章表（文章的信息）
- 评论表
- 友链表（友链信息）
- 自定义表（系统信息，某个关键的字，或者一些字段） key：value
标识实体（把需求落地到每个字段）
标识实体之间的关系
- 写博客：user --> blog
- 创建分类：user --> category
- 关注：user --> user
- 友链：links
- 评论：user-user-blog

9.2 三大范式

为什么需要数据规范化？

信息重复
更新异常
插入异常
- 如法正常显示信息
删除异常
- 丢失有效的信息

三大范式（了解）

第一范式（1NF）
原子性：保证每一列不可再分

第二范式（2NF）
前提：满足第一范式
每张表只描述一件事情

第三范式（3NF）
前提：满足第一范式和第二范式
第三范式需要确保数据表中的每一列数据都和主键直接相关，而不能间接相关。

（规范数据库的设计）

规范性和性能的问题
关联查询的表不得超过三张表

考虑商业化和需求和目标，（成本，用户体验）数据库的性能更加重要
在规范性能的问题的时候，需要适当的考虑一下规范性！
故意给某些表增加一些冗余的字段。（从多表查询变为单表查询）
故意增加一些计算列（从大数据量降低为小数据量的查询：索引）

10、JDBC

10.1 数据库驱动

驱动：声卡、显卡、数据库
在这里插入图片描述
我们的程序通过数据库驱动，和数据库打交道。

10.2 JDBC

SUN公司为了简化开发人员的（对数据库的统一）操作，提供了一个（Java操作数据库的）规范，俗称JDBC。
这些规范的实现由具体的厂商去做~
对于开发人员来说，只需要掌握JDBC接口的操作即可！
在这里插入图片描述
java.sql
javax.sql
还需要导入一个数据库驱动包

10.3 第一个JDBC程序

创建测试数据库

CREATE DATABASE jdbcStudy CHARACTER SET utf8 COLLATE utf8_general_ci;

USE jabcStudy;

INSERT INTO users(id,NAME,PASSWORD,email,birthday)
VALUES(1,'zhangsan','123456','zs@sina.com','1980-12-04'),
(2,'lisi','123456','lisi@sina.com','1981-12-04'),
(3,'wangwu','123456','wangwu@sina.com','1979-12-04');

1、创建一个普通项目
2、导入数据库驱动
3、编写数据库测试代码

// 我的第一个JDBC程序
public class JdbcFirstDemo {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        // 1. 加载驱动
        Class.forName("com.mysql.jdbc.Driver"); // 固定写法，加载驱动

        // 2. 用户信息和url
        // useUnicode=true&characterEncoding=utf8&useSSL=true
        String url = "jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=true";
        String username = "root";
        String password = "123456";

        // 3. 连接成功，数据库对象 Connection 代表数据库
        Connection connection = DriverManager.getConnection(url,username,password);

        // 4. 执行SQL的对象 Statement 执行sql对象
        Statement statement = connection.createStatement();

        // 5. 执行SQL的对象 去执行SQL，可能存在结果，查看返回结果
        String sql = "select * from users";
        ResultSet resultSet = statement.executeQuery(sql); // 返回的结果集，结果集中封装了我们全部的查询出来的结果

        while (resultSet.next()) {
            System.out.println("id=" + resultSet.getObject("id"));
            System.out.println("name=" + resultSet.getObject("name"));
            System.out.println("pwd=" + resultSet.getObject("password"));
            System.out.println("email=" + resultSet.getObject("email"));
            System.out.println("birthday=" + resultSet.getObject("birthday"));
            System.out.println("====================================");
        }

        // 6. 释放连接
        resultSet.close();
        statement.close();
        connection.close();
    }
}

步骤总结：
1、加载驱动
2、连接数据库
3、获取执行sql的对象
4、获得返回的结果集
5、释放连接

DriverManager

 // DriverManager.registerDriver(new com.mysql.jdbc.Driver());
Class.forName("com.mysql.jdbc.Driver"); // 固定写法，加载驱动
Connection connection = DriverManager.getConnection(url,username,password);

// connection 代表数据库
// 数据库设置自动提交
// 事务提交
// 事务回滚
connection.rollback();
connection.commit();
connection.setAutoCommit();

URL

String url = "jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=true";

// mysql -- 3306
// 协议://主机地址:端口号/数据库名?参数1&参数2&参数3
// oracle -- 1521
//jdbc:oracle:thin:@localhost:1521:sid

Statement：执行SQL的对象 prepareStatement() 执行SQL的对象

String sql = "select * from users"; // 编写SQL

statement.executeQuery(); // 查询操作，返回ResultSet
statement.execute(); // 执行任何SQL
statement.executeUpdate(); // 更新、插入、删除都是用这个，返回一个受影响的行数

ResultSet 查询的结果集：封装了所有的查询结果

获得指定的数据类型

resultSet.getObject(); // 在不知道列类型的情况下使用
 // 如果知道列的类型就使用指定的列
resultSet.getString();
resultSet.getInt();
resultSet.getFloat(); 
resultSet.getDate();
...

遍历，指针

resultSet.beforeFirst(); // 移动到最前面
resultSet.afterLast(); // 移动到最后面
resultSet.next(); // 移动到下一个数据
resultSet.previous(); // 移动到前一行
resultSet.absolute(row); // 移动到指定行

释放资源

// 6. 释放连接
resultSet.close();
statement.close();
connection.close(); // 耗资源，用完就关掉

10.4 statement对象

JDBC中的statement对象用于向数据库发送SQL语句，想完成对数据库的增删改查，只需要通过这个对象向数据库发送增删改查语句即可
Statement对象的executeUpdate方法，用于向数据库发送增、删、改的sql语句，executeUpdate执行完成后，将会返回一个整数（即增删改语句导致了数据库几行数据发生了变化）。
Statement.executeQuery方法用于向数据库发送查询语句，executeQuery方法返回代表查询结果的ResultSet对象。

CRUD-create

使用executeUpdate(String sql)方法完成数据添加操作，示例操作：

Statement st= connection.createStatement();
String sql =  "insert into user(...) values(...)";
int num = st.executeUpdate(sql);
if (num > 0) {
    System.out.println("插入成功！！！");
 }

CRUD操作-delete

使用executeUpdate(String sql)方法完成数据删除操作，示例操作：

Statement st= connection.createStatement();
String sql =  "delete from user where id=1";
int num = st.executeUpdate(sql);
if (num > 0) {
    System.out.println("删除成功！！！");
 }

CRUD操作-update

使用executeUpdate(String sql)方法完成数据修改操作，示例操作：

Statement st= connection.createStatement();
String sql =  "update user set name='' where name=''";
int num = st.executeUpdate(sql);
if (num > 0) {
    System.out.println("修改成功！！！");
 }

CRUD操作-read

使用executeQuery(String sql)方法完成数据查询操作，示例操作：

Statement st= connection.createStatement();
String sql =  "select * from user where id=1''";
ResultSet rs = st.executeQuery(sql);
while(re.next()) {
	//根据获取列的数据类型，分别调用rs的相应方法映射到java对象中
}

代码实现

1、提取工具类

public class JdbcUtils {

    private static String driver = null;
    private static String url = null;
    private static String username = null;
    private static String password = null;

    static {
        try {
            InputStream in = JdbcUtils.class.getClassLoader().getResourceAsStream("db.properties");
            Properties properties = new Properties();
            properties.load(in);

            driver = properties.getProperty("driver");
            url = properties.getProperty("url");
            username = properties.getProperty("username");
            password = properties.getProperty("password");

            // 驱动只要加载一次
            Class.forName(driver);

        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    // 获取连接
    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection(url,username,password);
    }


    // 释放连接资源
    public static void release(Connection conn, Statement st, ResultSet rs) {
        if(rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (st != null) {
            try {
                st.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

2、编写增删改的方法，executeUpdate

public class TestInsert {
    public static void main(String[] args) {
        Connection conn = null;
        Statement st = null;
        ResultSet rs = null;
        try {
            conn = JdbcUtils.getConnection(); // 获取数据库连接
            st = conn.createStatement(); // 获得SQL的执行对象
            String sql = "INSERT INTO `users`(`id`,`name`,`password`,`email`,`birthday`)" +
                    "VALUES(4,'wonjack','123445','235325@126.com','2020-02-29')";
            int i = st.executeUpdate(sql);
            if (i > 0) {
                System.out.println("插入成功！");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtils.release(conn,st,rs);
        }
    }
}

public class TestDelete {
    public static void main(String[] args) {
        Connection conn = null;
        Statement st = null;
        ResultSet rs = null;
        try {
            conn = JdbcUtils.getConnection(); // 获取数据库连接
            st = conn.createStatement(); // 获得SQL的执行对象
            String sql = "DELETE FROM `users` WHERE id=4";
            int i = st.executeUpdate(sql);
            if (i > 0) {
                System.out.println("删除成功！");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtils.release(conn,st,rs);
        }
    }
}

public class TestUpdate {
    public static void main(String[] args) {
        Connection conn = null;
        Statement st = null;
        ResultSet rs = null;
        try {
            conn = JdbcUtils.getConnection(); // 获取数据库连接
            st = conn.createStatement(); // 获得SQL的执行对象
            String sql = "UPDATE `users` SET `name`='jackie',`email`='66666666@88.com' WHERE id=1";
            int i = st.executeUpdate(sql);
            if (i > 0) {
                System.out.println("更新成功！");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtils.release(conn,st,rs);
        }
    }
}

3、查询executeQuery

public class TestSelect {
    public static void main(String[] args) {
        Connection conn = null;
        Statement st = null;
        ResultSet rs = null;

        try {
            conn = JdbcUtils.getConnection();
            st = conn.createStatement();

            // SQL
            String sql = "SELECT * FROM `users` WHERE id=1";

            rs = st.executeQuery(sql); // 查询完毕会返回一个结果集

            while (rs.next()) {
                System.out.println(rs.getString("name"));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtils.release(conn, st, rs);
        }
    }
}

SQL注入的问题

sql存在漏洞，会被攻击导致数据泄露，SQL会被拼接 or

public class SQL注入 {
    public static void main(String[] args) {

        // login("jackie","123456");
        login("'or '1=1", "' or '1=1"); // 技巧
    }

    // 登录业务
    public static void login(String username, String password) {
        Connection conn = null;
        Statement st = null;
        ResultSet rs = null;

        try {
            conn = JdbcUtils.getConnection();
            st = conn.createStatement();

            // SELECT * FROM `users` WHERE `name`='jackie' AND `password`='123456'

            // SELECT * FROM `users` WHERE `name`=''or '1=1' AND `password`='' or '1=1'
            String sql = "SELECT * FROM `users` WHERE `name`='" + username + "' AND `password`='" + password + "'";

            rs = st.executeQuery(sql); // 查询完毕会返回一个结果集

            while (rs.next()) {
                System.out.println(rs.getString("name"));
                System.out.println(rs.getString("password"));
                System.out.println("=========================");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtils.release(conn, st, rs);
        }
    }
}

10.5 PrepareStatement对象

PrepareStatement 可以防止SQL注入，并且效率更高。

1、新增

public class TestInsert {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement st = null;
//        ResultSet rs = null;

        try {
            conn = JdbcUtils.getConnection();

            // 区别
            // 使用 ？ 占位符代替参数
            String sql = "insert into `users`(`id`,`name`,`password`,`email`,`birthday`) values(?,?,?,?,?)";
            st = conn.prepareStatement(sql); // 预编译SQL，先写sql，然后不执行

            // 手动给参数赋值
            st.setInt(1,4);
            st.setString(2,"wonjackkkkkk");
            st.setString(3,"122222222");
            st.setString(4,"8888@777777.com");
            // 注意点：sql.Date  数据库 java.sql.Date()
            //       util.Date Java  new Date().getTime() 获得时间戳
            st.setDate(5, new java.sql.Date(new Date().getTime()));

            // 执行
            int i = st.executeUpdate();
            if (i > 0) {
                System.out.println("插入成功");
            }

        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtils.release(conn, st, null);
        }
    }
}

2、删除

public class TestDelete {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement st = null;
//        ResultSet rs = null;

        try {
            conn = JdbcUtils.getConnection();

            // 区别
            // 使用 ？ 占位符代替参数
            String sql = "delete from users where id=?";
            st = conn.prepareStatement(sql); // 预编译SQL，先写sql，然后不执行

            // 手动给参数赋值
            st.setInt(1, 4);

            // 执行
            int i = st.executeUpdate();
            if (i > 0) {
                System.out.println("删除成功");
            }

        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtils.release(conn, st, null);
        }
    }
}

3、更新

public class TestUpdate {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement st = null;
//        ResultSet rs = null;

        try {
            conn = JdbcUtils.getConnection();

            // 区别
            // 使用 ？ 占位符代替参数
            String sql = "update users set `name`=? where id=?;";
            st = conn.prepareStatement(sql); // 预编译SQL，先写sql，然后不执行

            // 手动给参数赋值
            st.setString(1, "轻狂少年");
            st.setInt(2, 1);
            // 执行
            int i = st.executeUpdate();
            if (i > 0) {
                System.out.println("更新成功");
            }

        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtils.release(conn, st, null);
        }
    }
}

4、查询

public class TestSelect {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement st = null;
        ResultSet rs = null;

        try {
            conn = JdbcUtils.getConnection();

            // 区别
            // 使用 ？ 占位符代替参数
            String sql = "select * from users where id=?;";
            st = conn.prepareStatement(sql); // 预编译SQL，先写sql，然后不执行

            // 手动给参数赋值
            st.setInt(1, 1);

            // 执行
            rs = st.executeQuery();

            if (rs.next()) {
                System.out.println(rs.getString("name"));
            }

        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtils.release(conn, st, rs);
        }
    }
}

5、防止SQL注入

public class SQL注入 {
    public static void main(String[] args) {

//         login("lisi","123456");
        login("'' or 1=1", "123456"); // 技巧
    }

    // 登录业务
    public static void login(String username, String password) {
        Connection conn = null;
        PreparedStatement st = null;
        ResultSet rs = null;

        try {
            conn = JdbcUtils.getConnection();
            // PreparedStatement 防止SQL注入的本质，把传递进来的参数当做字符
            // 假设存在转义字符，比如说 ' ，就会被直接转义
            String sql = "SELECT * FROM `users` WHERE `name`=? AND `password`=?"; // Mybatis

            st = conn.prepareStatement(sql);

            st.setString(1, username);
            st.setString(2, password);


            rs = st.executeQuery(); // 查询完毕会返回一个结果集

            while (rs.next()) {
                System.out.println(rs.getString("name"));
                System.out.println(rs.getString("password"));
                System.out.println("=========================");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtils.release(conn, st, rs);
        }
    }
}

10.6 事务

要么都成功，要么都失败

ACID原则

原子性：要么都完成，要么都不完成
一致性：总数不变
隔离性：多个进程互不干扰
持久性：一旦提交不可逆，持久化到数据库

隔离性的问题：
脏读：一个事务读取了另一个没有提交的事务
不可重复读：在同一个事务内，重复读取表中的数据，表数据发生了改变
幻读（虚读）：在一个事务内，读取了别人插入的数据，导致前后读出来结果不一致

代码实现：

1、开启事务 conn.setAutoCommit(false)
2、一组业务执行完毕，提交事务
3、可以在catch语句中显式的定义回滚语句，但默认失败就会回滚

public class TestTransaction2 {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement st = null;
        ResultSet rs = null;

        try {
            conn = JdbcUtils.getConnection();
            // 关闭数据库的自动提交功能，自动会开启事务
            conn.setAutoCommit(false); // 开启事务

            String sql1 = "update account set money = money - 100 where name='A'";
            st = conn.prepareStatement(sql1);
            st.executeUpdate();

            int x = 1/0; // 报错

            String sql2 = "update account set money = money + 100 where name='B'";
            st = conn.prepareStatement(sql2);
            st.executeUpdate();

            // 业务完毕，提交事务
            conn.commit();
            System.out.println("操作成功");


        } catch (SQLException e) {
            // 如果失败，则默认回滚
//            try {
//                conn.rollback(); // 如果失败则回滚事务
//            } catch (SQLException ex) {
//                ex.printStackTrace();
//            }
            e.printStackTrace();
        } finally {
            JdbcUtils.release(conn, st, rs);
        }
    }
}

10.7 数据库连接池

数据库连接 — 执行完毕 — 释放
连接 — 释放十分浪费系统资源
池化技术：准备一些预先的资源，过来就连接预先准备好的
最小连接数：10
最大连接数：15
等待超时：100ms

编写连接池：实现一个接口 DataSource

开源数据源实现（拿来即用）

DBCP
C3P0
Druid：阿里巴巴

使用了这些数据库连接池之后，我们在项目开发中就不需要编写连接数据库的代码了！

DBCP

commons-dbcp-1.4.jar：http://commons.apache.org/proper/commons-dbcp/download_dbcp.cgi
commons-pool-1.6.jar:http://commons.apache.org/proper/commons-pool/download_pool.cgi
dbcpconfig.properties:

# 连接设置 这里面的名字，是DBCP数据源中定义好的
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=true
username=root
password=123456

# 初始话连接
initialSize=10

# 最大连接数量
maxActive=50

# 最大空闲连接
maxIdle=20

# 最小空闲连接
minIdle=5

# 超时等待时间以毫秒为单位
maxWait=60000

# JDBC驱动建立连接时附带的连接属性属性的格式必须为这样：[属性名=property]
# 注意："user"与"password"两个属性会被明确地传递，因此这里不许要包含它们
connectionProperties=useUnicode=true;characterEncoding=UTF8

# 指定有连接池所创建的连接的自动提交（auto-commit）状态
defaultAutoCommit=true

# driver default 指定由连接池所创建的连接的只读（read-only）状态
# 如果没有设置该值，则“setReadOnly”方法将不被调用。（某些驱动并不支持只读模式，如：Informix）
defaultReadOnly=

# driver default 指定由连接池所创建的连接的事务级别（TransactionIsolation）
# 可用值为下列之一
defaultTransactionIsolation=READ_UNCOMMITTED

public class JdbcUtils_DBCP {

    private static DataSource dataSource = null;

    static {
        try {
            InputStream in = JdbcUtils_DBCP.class.getClassLoader().getResourceAsStream("dbcpconfig.properties");
            Properties properties = new Properties();
            properties.load(in);

            // 创建数据源 工厂模式 --> 创建
            dataSource = BasicDataSourceFactory.createDataSource(properties);


        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    // 获取连接
    public static Connection getConnection() throws SQLException {
        return dataSource.getConnection(); // 从数据源获取连接
    }


    // 释放连接资源
    public static void release(Connection conn, Statement st, ResultSet rs) {
        if(rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (st != null) {
            try {
                st.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

public class TestDBCP {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement st = null;
//        ResultSet rs = null;

        try {
            conn = JdbcUtils_DBCP.getConnection();

            // 区别
            // 使用 ？ 占位符代替参数
            String sql = "insert into `users`(`id`,`name`,`password`,`email`,`birthday`) values(?,?,?,?,?)";
            st = conn.prepareStatement(sql); // 预编译SQL，先写sql，然后不执行

            // 手动给参数赋值
            st.setInt(1,4);
            st.setString(2,"wonjackkkkkk");
            st.setString(3,"122222222");
            st.setString(4,"8888@777777.com");
            // 注意点：sql.Date  数据库 java.sql.Date()
            //       util.Date Java  new Date().getTime() 获得时间戳
            st.setDate(5, new java.sql.Date(System.currentTimeMillis()));

            // 执行
            int i = st.executeUpdate();
            if (i > 0) {
                System.out.println("插入成功");
            }

        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtils_DBCP.release(conn, st, null);
        }
    }
}