在IDEA中连接到MySQL

JDBC（重点）

数据库驱动

我们的程序会通过数据库驱动，和数据库打交道！

就会通过数据库驱动与数据库相关联

JDBC

SUN公司为了简化开发人员的（对数据库的统一）操作，提供了一个（Java操作数据库的）规范，俗称：JDBC

这些规范的实现由具体的厂商去做。

对于开发人员来说，我们只需要

java.sql

javax.sql

还需要导入一个数据库驱动包

第一个JDBC程序

创建测试数据库

CREATE DATABASE jdbcStudy CHARACTER SET utf8 COLLATE utf8_general_ci;
1. 
USE jdbcStudy;

CREATE TABLE `users`(
	id INT PRIMARY KEY,
	NAME VARCHAR(40),
	PASSWORD VARCHAR(40),
	email VARCHAR(60),
	birthday DATE
);

INSERT INTO `users`(id,NAME,PASSWORD,email,birthday)
VALUES(1,'zhansan','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. 导入数据库驱动（创建一个lib文件夹导入jar文件-->右键文件Add as Library）

3. 编写测试代码

package lijinyu.lesson01;

import java.sql.*;

//我的第一个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=false";
        String username="root";
        String password="ljy123456";
        // 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("birth="+ resultSet.getObject("birthday"));
        }
        // 6. 释放连接
        resultSet.close();
        statement.close();
        connection.close();

    }
}

步骤总结：

1. 加载驱动
2. 连接数据库DriverManager
3. 获得执行sql的对象 Statement
4. 获得返回的结果集
5. 释放连接

DriverManager

  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
//协议：  jdbc：mysql://主机地址：端口号/数据库名？参数1&参数2&参数3

//oralce -- 1521
//jdbc：oracle：thin：@localhost：1521：sid

Statement执行SQL的对象，PrepareStatement执行SQL的对象

String sql = “SELECT * FROM users”； // 编写SQL 
statement.execute(); //执行任何SQL
statement.executeQuery(); //查询操作返回ResultSet
statement.executeUpdate(); // 更新、插入、删除，都是用这个，返回一个受影响的行数

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

获得指定的数据类型

resultSet.getobject(); // 在不知道列类型的情况下使用 
//如果知道列的类型就使用特定的类型
resultSet.getstring()
resultSet.getin()
    ...

遍历，指针

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

释放资源

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

statement对象

jdbc中的statement对象用于向数据库发送SQL语句，想完成对数据库的增删改查，只需要通过这个对象向数据库发送增删改查语句即可。

Statement对象的executeUpdate方法，用于向数据库发送增、删、改的sql语句，executeUpdate执行完后，将会返回一个整数（即增删改语句导致了数据库几行数据发生了变化)。

Statement.executeQuery方法用于向数据库发送查询语句，executeQuery方法返回代表查询结果的ResultSet对象。

CRUD操作-create

使用executeUpdate（String sql）方法完成数据添加操作：

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

同理 delete update也是一样 只是sql不一样

CRUD操作-read

使用executeQuery方法来完成数据查询的操作

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

代码实现

提取工具类

package lijinyu.lesson02.utils;

import java.io.IOException;
import java.io.InputStream;
import java.sql.*;
import java.util.Properties;

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

            // 1.驱动只用加载一次
            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 connection, Statement st, ResultSet rs) {
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        if (st != null) {
            try {
                st.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        if (connection != null) {
            try {
                connection.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
    }
}

编写增删改的方法 executeUpdate

package lijinyu.lesson02;

import lijinyu.lesson02.utils.JdbcUtils;

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

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`) values(54,'ljy','8453')";

            int i = st.executeUpdate(sql);
            if (i > 0) {
                System.out.println("插入成功");
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        } finally {
            JdbcUtils.release(conn, st, rs);

        }
    }
}

package lijinyu.lesson02;

import lijinyu.lesson02.utils.JdbcUtils;

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

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 throwables) {
            throwables.printStackTrace();
        } finally {
            JdbcUtils.release(conn, st, rs);

        }
    }
}

package lijinyu.lesson02;

import lijinyu.lesson02.utils.JdbcUtils;

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

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`='ljy',`email`='84533616@qq.com' where id=1";

            int i = st.executeUpdate(sql);
            if (i > 0) {
                System.out.println("修改成功");
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        } finally {
            JdbcUtils.release(conn, st, rs);

        }
    }
}

查询

package lijinyu.lesson02;

import lijinyu.lesson02.utils.JdbcUtils;

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

public class TestSelect {
    public static void main(String[] args) {
        Connection conn = null;
        Statement st = null;
        ResultSet rs = null;
        // 1. 获取连接
        try {
            conn = JdbcUtils.getConnection();
            // 2. 获取执行对象
            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 throwables) {
            throwables.printStackTrace();
        } finally {
            JdbcUtils.release(conn, st, rs);
        }
    }
}

SQL注入的问题

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

package lijinyu.lesson02;

import lijinyu.lesson02.utils.JdbcUtils;

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

public class SQL注入 {
    public static void main(String[] args) {
        // 正常登录
        // login("ljy","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;
        // 1. 获取连接
        try {
            conn = JdbcUtils.getConnection();
            // 2. 获取执行对象
            st = conn.createStatement();

            //select * from users where `name`='ljy` 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"));
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        } finally {
            JdbcUtils.release(conn, st, rs);
        }
    }
}

PreparedStatement对象

PreparedStatement可以防止SQL注入，效率更高！

新增

package lijinyu.lesson03;

import lijinyu.lesson02.utils.JdbcUtils;

import java.util.Date;
import java.sql.*;

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`,`birthday`) values(?,?,?,?)";
            st = conn.prepareStatement(sql); //预编译SQL，先写SQL,然后不执行

            //手动给参数赋值
            //set(x,x) 第一个x代表第几个？ 第2个x代表具体的赋值
            st.setInt(1, 5); //id赋值
            st.setString(2, "lijiynu");
            st.setString(3, "123456789987");
            //注意点：sql.date  数据库
            //  util.date  java  new Date().getTime() 获得时间戳
            st.setDate(4, new java.sql.Date(new Date().getTime()));

            //执行
            int i = st.executeUpdate();
            if (i > 0) {
                System.out.println("插入成功");
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        } finally {
            JdbcUtils.release(conn, st, null);
        }
    }
}

删除

package lijinyu.lesson03;

import lijinyu.lesson02.utils.JdbcUtils;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Date;

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, 5);

            //执行
            int i = st.executeUpdate();
            if (i > 0) {
                System.out.println("删除成功");
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        } finally {
            JdbcUtils.release(conn, st, null);
        }
    }
}

更新

package lijinyu.lesson03;

import lijinyu.lesson02.utils.JdbcUtils;

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

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 throwables) {
            throwables.printStackTrace();
        } finally {
            JdbcUtils.release(conn, st, null);
        }
    }
}

查询

package lijinyu.lesson03;

import lijinyu.lesson02.utils.JdbcUtils;

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

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);  //预编译

            st.setInt(1, 1);  //传递参数

            //执行
            rs = st.executeQuery();
            if (rs.next()) {
                System.out.println(rs.getString("name"));
            }


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

防止SQL注入

package lijinyu.lesson03;

import lijinyu.lesson02.utils.JdbcUtils;

import java.sql.*;

public class SQL注入 {
    public static void main(String[] args) {
        // 正常登录
        login("李四", "123456");
        // login(" '' or 1=1", "123456");

    }

    //登录业务
    public static void login(String username, String password) {

        Connection conn = null;
        PreparedStatement st = null;
        ResultSet rs = null;
        // 1. 获取连接
        try {
            conn = JdbcUtils.getConnection();
            //PreparedStatement放注入的本质：把传递进来的参数当作字符
            //假设其中存在转义字符,就直接忽略，’会被直接转义
            String sql = "SELECT * FROM `users` WHERE `NAME`= ? AND `PASSWORD`=?";

            st = conn.prepareStatement(sql);
            st.setString(1, username);
            st.setString(2, password);

            rs = st.executeQuery(sql); //查询完毕。会返回一个结果集
            while (rs.next()) {
                System.out.println(rs.getString("NAME"));
                System.out.println(rs.getString("password"));
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        } finally {
            JdbcUtils.release(conn, st, rs);
        }
    }
}

使用IDEA连接数据库

连接mysql

选择数据库

查询数据库信息

更新信息

这里步骤二就是提交信息的意思

创建控制台 写SQL语句

表示切换数据库

如果连接数据库失败

在这里修改改数据库对应的版本SQL

JDBC操作事务

要么都成功，要么都失败

ACID原则

原子性：要么全部完成，要么都不完成

一致性：结果总数不变

隔离性：多个进程互不干扰

持久性： 一旦提交不可逆，持久化到数据库了。

隔离性的问题：

脏读：一个事务读取了另一个没有提交的事务

不可重复读：在同一个事务内，重复读取表中的数据，表数据发生了改变（不知道用原来的数据还是现在的数据）

虚度（幻读）：在一个事务内，读取到了别人插入的数据，导致了前后读出来的结果不一致

代码实现

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

package lijinyu.lesson04;

import lijinyu.lesson02.utils.JdbcUtils;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
// JDBC中的事务
public class TestTransaction {
    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();
            String sql2="update account set money = money+100 where name='B'";
            st = conn.prepareStatement(sql2);
            st.executeUpdate();

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

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

数据库连接池

数据库连接--执行完毕 --释放

连接--释放 十分浪费系统资源

池化技术：准备一些预先的资源，过来就连接预先准备好的

--- 开门--业务员：等待 -- 服务 --‘

15个业务员

最小连接数：10

最大连接数：15 业务最高承载上限

等待超时：100ms

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

开源数据源实现(拿来即用)

DBCP

C3P0

Druid：阿里巴巴

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

DBCP

需要用到的jar包：

commons-dbcp-1.4、commons-pool-1.6

C3P0

c3p0-0.9.5.5 、mchange-commons-java-0.2.19

结论

无论使用什么数据源，本质还是一样，DataSource接口不会变，方法就不会变