MySQL学习完结（狂神说Java）

凭谁问，廉颇老矣

已于 2022-04-07 15:08:22 修改

阅读量92

点赞数

文章标签： java intellij-idea 学习

于 2022-04-06 16:19:04 首次发布

本文链接：https://blog.csdn.net/qq_43421528/article/details/123992900

版权

本文详细介绍了Java中使用JDBC进行数据库操作，包括加载驱动、创建数据库连接、Statement与PreparedStatement对象的使用，以及事务处理和数据库连接池的概念。内容涵盖基本的CRUD操作，重点讲解了PreparedStatement如何防止SQL注入，以及数据库连接池的配置与使用，例如DBCP数据源。最后，文章提到了数据库连接池如C3P0的配置和使用。

摘要由CSDN通过智能技术生成

文章目录

JDBC(重点)

JDBC(重点)

10.1 数据库驱动

驱动：声卡，显卡，数据库

在这里插入图片描述

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

10.2 JDBC

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

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

对于开发人员来说，我们只需要掌握JDBC接口的操作即可！

在这里插入图片描述

10.3 第一个JDBC程序

创建测试数据库

CREATE DATABASE `jdbcStudy` CHARACTER SET utf8 COLLATE utf8_general_ci;

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,'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')

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

package com.kuang.lesson01;

import java.net.ConnectException;
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
        String url="jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=false";
        String username="root";
        String password="newpassword";

        //3.连接成功，数据库对象Statement执行sql对象
        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();
    }
}

步骤总结：

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

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=false";
//mysql:3306
//jdbc:mysql://localhost:3306/数据库名？参数一&参数二&参数三
//oralce:1521
//jdbc:oracle:thin:@localhost:1521:sid

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

String sql="SELECT * FROM users";
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();//移动到指定行

释放资源

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=conn.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=conn.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=conn.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=conn.createStatement();
String sql="selete * from user where id=1";
ResultSet rs=st.executeQuery(sql);
while(rs.next()){
    //根据获取列的数据类型，分别调用rs的相应方法映射到java对象中
}

代码实现

提取工具类

package com.kuang.lesson02.utils;

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 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();
            }
        }
    }
}

编写增删改的方法，executeUpdate

package com.kuang.lesson02.utils;

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();
            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);
        }
    }
}

package com.kuang.lesson02.utils;

import com.kuang.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();
            String sql="INSERT INTO users(id,`NAME`,`PASSWORD`,`email`,`birthday`)"+
            "VALUES(4,'kuangshen','123456','23434343@qq.com','2020-1-1')";
            int i=st.executeUpdate(sql);
            if(i>0){
                System.out.println("插入成功");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            jdbcUtils.release(conn,st,rs);
        }
    }
}

package com.kuang.lesson02.utils;

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();
            String sql="UPDATE users SET `NAME`='kuangshen1',`password`='123' 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);
        }
    }
}

查询

package com.kuang.lesson02.utils;

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;
        try {
            conn=jdbcUtils.getConnection();
            st= conn.createStatement();
            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会被拼接

package com.kuang.lesson02.utils;

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("kuangshen1","123");
        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 username WHERE `NAME`='kuangshen' AND `password`='123456'
            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 e) {
            e.printStackTrace();
        }finally {
            jdbcUtils.release(conn,st,rs);
        }
    }
}

10.5 PreparedStatement对象

PreparedStatement对象可以防止sql注入，效率更好。

新增

package com.kuang.lesson03;

import com.kuang.lesson02.utils.jdbcUtils;

import javax.tools.JavaCompiler;
import java.sql.*;
import java.util.Date;

public class TestInsert {
    public static void main(String[] args) {
        Connection conn=null;
        PreparedStatement st =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);//id
            st.setString(2,"qinjiang");
            st.setString(3,"123456");
            st.setString(4,"1239293192@qq.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);
        }
    }
}

删除

package com.kuang.lesson03;

import com.kuang.lesson02.utils.jdbcUtils;

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

public class TestDelete {
    public static void main(String[] args) {
        Connection conn=null;
        PreparedStatement st =null;
        try {
            conn= jdbcUtils.getConnection();
            //区别
            //使用，占位符代替参数
            String sql="delete from users where id=?";
            st= conn.prepareStatement(sql);//预编译SQL，先写sql，然后不执行
            //手动给参数赋值
            st.setInt(1,4);//id
            //注意点：sql.date 数据库 java.sql.Date()
            //util.date Java   new Date().getTime() 获得时间戳
            //执行
            int i=st.executeUpdate();
            if(i>0){
                System.out.println("删除成功");
            }

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

修改

package com.kuang.lesson03;

import com.kuang.lesson02.utils.jdbcUtils;

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

public class TestUpdate {
    public static void main(String[] args) {
        Connection conn=null;
        PreparedStatement st =null;
        try {
            conn= jdbcUtils.getConnection();
            //区别
            //使用，占位符代替参数
            String sql="update users set `NAME`=? where id=?";
            st= conn.prepareStatement(sql);//预编译SQL，先写sql，然后不执行
            //手动给参数赋值
            st.setString(1,"kuangs");//执行
            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);
        }
    }
}

查询

package com.kuang.lesson03;

import com.kuang.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 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);//id
           //执行
            rs=st.executeQuery();
            if(rs.next()){
                System.out.println(rs.getString("NAME"));
            }

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

防止SQL注入

package com.kuang.lesson03;

import com.kuang.lesson02.utils.jdbcUtils;

import java.sql.*;

public class SQL注入 {
        public static void main(String[] args) {
            //login("kuangshen1","123");
            login(" 'or '1=1","'or'1=1");
        }
        //登陆业务
        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`=?";
                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"));
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }finally {
                jdbcUtils.release(conn,st,rs);
            }
        }
    }

10.6 使用IDEA连接数据库

在这里插入图片描述

连接成功后选择数据库

在这里插入图片描述

双击数据库查看

在这里插入图片描述

更新数据

在这里插入图片描述

连接失败，查看原因

在这里插入图片描述

10.7 事务

要么都成功，要么都失败

ACID原则

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

一致性：总数不变

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

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

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

代码实现

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

package com.kuang.lesson04;

import com.kuang.lesson02.utils.jdbcUtils;

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

public class TestTransaction1 {
    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("yes");
        } catch (SQLException e) {
            try{
                conn.rollback();//如果失败则回滚事务
            }catch(SQLException e1){
                e1.printStackTrace();
            }
            e.printStackTrace();
        }finally {
            jdbcUtils.release(conn,st,rs);
        }
    }
}

10.8 数据库连接池

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

连接–释放十分浪费资源

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

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

开源数据源实现

DBCP

C3P0

Druid：阿里巴巴

DBCP

配置文件bcpconfig.properties

#连接设置
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=false
username=root
password=newpassword

#<!-- 初始化连接 -->
initialSize=10

#最大连接数量
maxActive=50

#<!-- 最大空闲连接 -->
maxIdle=20

#<!-- 最小空闲连接 -->
minIdle=5

#<!-- 超时等待时间以毫秒为单位 6000毫秒/1000等于60秒 -->
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）。
#可用值为下列之一：（详情可见javadoc。）NONE,READ_UNCOMMITTED, READ_COMMITTED, REPEATABLE_READ, SERIALIZABLE
defaultTransactionIsolation=READ_UNCOMMITTED

工具类JdbcUtils_DBCP

package com.kuang.lesson05.utils;


import org.apache.commons.dbcp2.BasicDataSourceFactory;
import javax.sql.DataSource;
import java.io.InputStream;
import java.sql.*;
import java.util.Properties;

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();
            }
        }
    }

}

测试文件

package com.kuang.lesson05.utils;

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

public class TestDBCP {
    public static void main(String[] args) {
        Connection conn=null;
        PreparedStatement st =null;
        ResultSet re=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);//id
            st.setString(2,"qinjiang");
            st.setString(3,"123456");
            st.setString(4,"1239293192@qq.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_DBCP.release(conn,st,null);
        }
    }
}