JDBC超详细笔记

最新推荐文章于 2020-08-24 00:01:02 发布
最新推荐文章于 2020-08-24 00:01:02 发布
阅读量2k 收藏 8
点赞数 4
分类专栏： JavaWeb 文章标签： 数据库 mysql jdbc java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42601136/article/details/107206947
版权

JDBC 超详细笔记

引言：

        本文主要分享了有关JDBC的内容包括：JDBC的概述（思想和环境的搭建）、JDBC的核心6步、ResultSet结果集、SQL注入问题、Statement接口、PreparedStatement接口（案例）、登录案例、封装工具类、ORM、DAO、日期类型的封装、JDBC事务、连接池（Druid德鲁伊连接池）以及若干案例；

文章目录

1. JBDC概述

             JDBC（Java DataBase Connectivity）：Java连接数据库，可以使用Java语言连接数据库完成CRUD操作；

  • CRUD：指在做计算处理时的增加(Create)、读取查询(Retrieve)、更新(Update)和删除(Delete)几个单词的首字母简写；

1.1 JDBC核心思想

Java中定义了访问数据库的接口，可以为多种关系型数据库提供统一的访问方式；

由数据库厂商提供驱动实现类(Driver数据库驱动)；

在这里插入图片描述

1.2 MySQL中JDBC驱动包

JDBC下载路径：https://dev.mysql.com/downloads/connector/

1.3 JDBC API

JDBC 是由多个接口和类进行功能实现；

在这里插入图片描述

1.4 环境的搭建

  1. 在项目下新建 lib 文件夹（New—>directory），用于存放 jar 文件；
  2. 将MySQL驱动文件mysql-connector-java-5.1.25-bin.jar 复制到项目的lib文件夹中；
  3. 选中lib文件夹 右键选择 add as library；

2. JDBC的开发六步

2.1 加载驱动

使用Class.forName(“com.mysql.jdbc.Driver”);手动加载字节码文件到JVM中

Class.forName("com.mysql.jdbc.Driver");

2. 2 连接数据库

通过DriverManager.getConnection(url,user,password);获得数据库连接对象

Connection connection = DriverManager.getConnection
("jdbc:mysql://localhost:3306/database？useUnicode=true&characterEncoding=utf8","root","root");
  • URL(Uniform Resource Locator)统一资源定位符：由协议、IP、端口、SID（程序实例名称）组成

2.3 获取执行的SQL的对象

通过Connection对象获得Statement对象，用于对数据库进行通用访问的

功能:针对预计执行更新操作

  • Statement createStatement() ：创建一条 SQL 语句对象
Statement statement = connection.createStatement();

2.4 编写SQL语句并执行

编写SQL语句，并执行，接收执行后的结果

  • int executeUpdate(String sql:静态sql) :DDL(不返回内容) ,DML(操作语句,返回具体的行数)

    • 参数：SQL 语句
    • 返回值：返回对数据库影响的行数

  • ResultSet executeQuery(String sql)：用于发送 DQL 语句，执行查询的操作。select

    • 参数：SQL 语句
    • 返回值：查询的结果集
 String sql = "update stu set student_name = '张三' where student_id = '1004'";
 int result = statement.executeUpdate(sql);
  • 在编写DML语句时，要注意字符串参数的符号是单引号 ‘值’
  • DML语句：增、删、改时，执行的结果是受影响行数(int类型)；
  • DQL语句：查询时，返回的是数据结果集(ResultSet结果集)；

2.5 处理结果

接收并处理操作结果

 if(result > 0){
       System.out.println("成功！");
  }else{
        System.out.println("失败！");
  }
  • 受影响行数：逻辑判断，方法返回
  • 查询结果集：迭代、依次获取

2.6 释放资源

遵循的是先开后关的原则，释放过程中用到的所有资源对象

statement.close();
connection.close();

2.7 增删改案例

综合核心六步，实现增删改

   public static void main(String[] args) throws Exception  {
        //1.加载驱动    将驱动字节码文件加载到JVM中
        Class.forName("com.mysql.jdbc.Driver");
        //2.连接数据库
        String url = "jdbc:mysql://localhost:3306/companydb?useUnicode=true&characterEncoding=utf8";//连接地址
        String user = "root" ;
        String password = "root";
        Connection connection = DriverManager.getConnection(url,user,password);
       //测试是否连接成功
        System.out.println(connection);
        //3.获取执行SQL的对象  Statement
        Statement statement = connection.createStatement();
        //4.编写SQL语句,并执行SQL语句
        //增加
        String sql1 = "INSERT INTO stu(student_id,student_name,sex,birthday,phone,GradeId) VALUES('1003','kaka','男','2001-06-01','123456189',1);";
        //删除
        String sql2 = "delete from stu where student_id = '1003'";
        //修改
        String sql3 = "update stu set student_name = '张三' where student_id = '1004'";
        int result = statement.executeUpdate(sql3);
        //5.处理结果
        if(result > 0){
            System.out.println("成功！");
        }else{
            System.out.println("失败！");
        }
        //6.释放资源    先开后关
        statement.close();
        connection.close();
    }
}

3. ResultSet(结果集)

在执行查询SQL后，存放查询到的结果集数据;

3.1 接收结果集

ResultSet resultSet = statement.executeQuery(sql)；

ResultSet executeQuery(String sql)：用于发送 DQL 语句，执行查询的操作，select

  • 参数：SQL 语句
  • 返回值：查询的结果集
String sql = "select student_id,student_name,sex,birthday,phone,GradeId from stu";
ResultSet resultSet =  statement.executeQuery(sql);

3.2 遍历ResultSet中的数据

ResultSet以表(Table)结构进行临时结果的存储，需要通过JDBC API将其中的数据进行依次获取

  • boolean next()：数据行指针，初始位置在第一行数据前，每调用一次boolean next()方法，ResultSet中指针向下移动一行，结果为true，表示当前行有数据；
  • int /String …getInt(int columnIndex) ：获取当前列的编号对应的内容第一列就是1…
  • int/String…getInt(String Stringcolumn)：通过类的名称获取的信息
boolean next() throws SQLException;//判断resultSet结果集中下一行是否有数据
int getInt(int columnIndex) throws SQLException;//获得当前行的第N列的int值
int getInt(String columnLabel) throws SQLException;//获得当前行columnLabel列的int值
  • 列的编号从1开始；

3.3 查询案例

3.3.1 根据列名进行查询

/**
 * 方式一
 * 根据列名
 * JDBC查询数据库表的数据
 */
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;

public class TestDQL {
    public static void main(String[] args) throws Exception{
        //1.注册驱动
        Class.forName("com.mysql.jdbc.Driver");
        //2.获得连接
        String url = "jdbc:mysql://localhost:3306/companydb?useUnicode = true&characterEncoding = utf8";
        String user = "root";
        String password = "root";
        Connection connection = DriverManager.getConnection(url,user,password);
        //3.获取执行的对象
        Statement statement = connection.createStatement();
        //4.编写SQL语句     查询
        String sql = "select student_id,student_name,sex,birthday,phone,GradeId from stu";
        ResultSet resultSet =  statement.executeQuery(sql);
        //5.处理结果
        while(resultSet.next()){//判断是否有下一行
            //1.根据列名获取当前行的每一列数据
            String student_id = resultSet.getString("student_id");
            String student_name = resultSet.getString("student_name");
            String sex = resultSet.getString("sex");
            String birthday = resultSet.getString("birthday");
            String phone = resultSet.getString("phone");
            String gradeId = resultSet.getString("gradeId");
            System.out.println(student_id+"\t"+student_name+"\t"+sex+"\t"+birthday+"\t"+phone+"\t"+gradeId);
        }
        //6.释放资源
        resultSet.close();
        statement.close();
        connection.close();
    }
}

3.3.2 根据列的下标进行查询

//方式二前面步骤如上：
//5.处理结果
while(resultSet.next()){//判断是否有下一行
    //1.根据列名获取当前行的每一列数据
    String student_id = resultSet.getString(1);
    String student_name = resultSet.getString(2);
    String sex = resultSet.getString(3);
    String birthday = resultSet.getString(4);
    String phone = resultSet.getString(5);
    String gradeId = resultSet.getString(6);
    System.out.println(student_id+"\t"+student_name+"\t"+sex+"\t"+birthday+"\t"+phone+"\t"+gradeId);
}

3.4 常见的错误

  • java.lang.ClassNotFoundException ：找不到类(类名书写错误、没有导入jar包)；
  • com.mysql.jdbc.exceptions.jdbc4.MySQLSyntaxErrorException ：与SQL语句相关的错误（表名列名书写错误、约束错误、插入的值是String类型，但是没有加单引号）建议：在客户端工具中测试sql语句后，再粘贴到代码中来；
  • com.mysql.jdbc.exceptions.jdbc4.MySQLIntegrityConstraintViolationException: Duplicate entry ‘1003’ for key ‘PRIMARY’ ：主键值已存在，更改要插入的主键值；
  • com.mysql.jdbc.exceptions.jdbc4.MySQLSyntaxErrorException:Unknown column ‘password’ in ：可能输入的值的类型不对，确定插入元素时，对应的值的类型是否正确；

4. SQL注入问题

          当用户输入的数据中有SQL关键字或语法时，并且参与了SQL语句的编译，导致SQL语句编译后条件结果为true，一直得到正确的结果。称为SQL注入；

  • 如：XXX‘ or 1 = 1；# 将后面部分注释

避免SQL注入：

          由于编写的SQL语句，是在用户输入数据后，整合后再编译成SQL语句。所以为了避免SQL注入的问题，使SQL语句在用户输入数据前，SQL语句已经完成编译，成为了完整的SQL语句，再进行填充数据；

5. PreparedStatement接口

5.1 PreparedStatement

PreparedStatement 是 Statement 接口的子接口，继承于父接口中所有的方法，是一个预编译的 SQL 语句；

好处：

  1. prepareStatement()会先将 SQL 语句发送给数据库预编译。PreparedStatement 会引用着预编译后的结果。 可以多次传入不同的参数给 PreparedStatement 对象并执行。减少 SQL 编译次数，提高效率；
  2. 安全，避免SQL注入；
  3. 可以动态的填充数据，执行多个同构的SQL语句；
  4. 提高可读性；

5.2 接口方法

  • PreparedStatement prepareStatement(String sql)：指定预编译的 SQL 语句，SQL 语句中使用占位符? 创建一个语句对象；
  • int executeUpdate() ：执行 DML，增删改的操作，返回影响的行数；
  • ResultSet executeQuery()：执行 DQL，查询的操作，返回结果集；

5.2.1 参数标记

ResultSet executeQuery()：操作DQL语句进行查询

//1.预编译SQL语句
 PreparedStatement preparedStatement = connection.prepareStatement(sql);
  • 应用PreparedStatement时，SQL字符串的参数都由?符号站位，被称为参数标记。在执行该SQL语句前，要为每个参数赋值；

5.2.2 动态参数绑定

preparedStatement.setXxx(下标,值)：参数下标是从1开始，为指定占位符下标绑定值；

//2.为占位符下标赋值
preparedStatement.setString(1,username);
preparedStatement.setString(2,password);

5.3 PreparedStatement使用步骤

  1. 编写 SQL 语句，未知内容使用?占位：“SELECT * FROM user WHERE name=? AND password=?”;
  2. )获得 PreparedStatement 对象；
  3. 设置实际参数：setXxx(占位符的位置, 真实的值)；
  4. 执行参数化 SQL 语句；
  5. 关闭资源；

5.4 案例

public User select(int id){
        connection = DBUtils.getConnection();
        String sql = "select id,username,password,sex,email,address from user where id = ?;";
        try {
            preparedStatement = connection.prepareStatement(sql);
            preparedStatement.setInt(1,id);
            resultSet = preparedStatement.executeQuery();
            while(resultSet.next()){
                int id = resultSet.getInt("id");
                String username = resultSet.getString("username");
                String password = resultSet.getString("password");
                String sex = resultSet.getString("sex");
                String email = resultSet.getString("email");
                String address = resultSet.getString("address");
                User user = new User(id,username,password,sex,email,address);
                return user;
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            DBUtils.closeAll(connection,preparedStatement,resultSet);
        }
        return null;
    }

6. Statement和PreparedStatement的区别

Statement：

  • 执行对象执行对应的sql语句(DDl,DQL,DML)
  • DDL/DML：executeUpdate(String sql) — >int
  • DQL：executeQuery(String sql) ---->ResultSet 结果集
  • 安全隐患：
    • 在拼接sql语句,使用一些关键字和表中的字段进行拼接（SQL注入）
    • 执行效率低
    • 录入不存在用户名以及不存在密码依然可以登录成功

PreparedStatement：

  • 获取预编译对象,会将参数化的sql发送给数据库
  • 通过setXXX（参数1,参数2）给这些占位符进行赋值
    • XXX:表示类型 :给id字段设置数据如：setInt(1,1)
    • 参数1:当前预编译的sql语句中的第几个占位符
    • 参数2:给当前这个占位符赋值的实际值是什么
  • 预编译对象进行参数赋值
    • 预编译对象.setString(1,“zhangsan”)
    • 预编译对象.setString(2,“123”) ;
  • 特点：
    • 防止的SQL注入(更安全的)
    • 执行效率高

7. 综合案例—登录

7.1 创建表并插入数据

CREATE TABLE `user`(
	id INT PRIMARY KEY AUTO_INCREMENT,
	username VARCHAR(20) NOT NULL,
	`password` VARCHAR(20) NOT NULL,
	phone VARCHAR(11)
)CHARSET = utf8;
INSERT INTO `user`(username, `password`,phone) VALUES ('kaka','123','12345678910');
INSERT INTO `user`(username, `password`,phone) VALUES ('tangtang','456',NULL);
SELECT * FROM `user`;

7.2 实现登录

/**
 * 登录操作
 * 通过控制台，用户输入用户名和密码;
 * 用户输入的用户名和密码作为参数，编写查询SQL语句;
 * 如果查询到用户，则用户存在，提示登录成功，反之，提示失败;
 */

import java.util.Scanner;
import java.sql.*;
public class TestSafeLogin {
    public static void main(String[] args) throws Exception{
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入用户名：");
        String username = sc.next();
        System.out.println("请输入密码：");
        String password = sc.next();
        //1.注册驱动
        Class.forName("com.mysql.jdbc.Driver");
        //2.获得连接
        String url = "jdbc:mysql://localhost:3306/companydb?useUnicode = true&characterEncoding = utf8";
        Connection connection = DriverManager.getConnection(url,"root","root");
        //3.获取执行的对象
        String sql ="select * from user where username = ? and password = ?";
        //预编译
        PreparedStatement preparedStatement = connection.prepareStatement(sql);
        //为SQL语句赋值
        preparedStatement.setString(1,username);
        preparedStatement.setString(2,password);
        //4.执行SQL语句
        ResultSet resultSet =  preparedStatement.executeQuery();
        //5.处理结果
        if(resultSet.next()){
            System.out.println("登录成功");
        }else{
            System.out.println("登录失败");
        }
        //6.释放资源
        resultSet.close();
        preparedStatement.close();
        connection.close();
    }
}

8. 封装工具类

8.1 jdbc.properties

  • 在src目录下新建jdbc.properties文件
driver = com.mysql.jdbc.Driver
url = jdbc:mysql://localhost:3306/db0707?useUnicode=true&characterEncoding=utf8
user = root
password = root

8.2 JDBCUtils.java

  • 工具类的实现
public class JDBCUtils {
	//定义成员
	private static String url;
	private static String user;
	private static String password;
	private static String driver;
	
	static{
		try {
			Properties prop = new Properties();
			ClassLoader classLoader = JDBCUtils.class.getClassLoader();
			URL urlPath = classLoader.getResource("jdbc.properties"); 
			String path = urlPath.getPath();
			prop.load(new FileReader(path));
			
			url = prop.getProperty("url");
			user = prop.getProperty("user");
			password = prop.getProperty("password");
			//加载驱动
			Class.forName(prop.getProperty("driver"));
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	//获取数据库连接对象
	public static Connection getConnection(){
		try {
			Connection conn = DriverManager.getConnection(url, user, password);
			return conn;
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return null;
	}
	
	//释放资源(DDL、DML)
	public static void close(Statement stmt,Connection conn){
		if(stmt != null){
			try {
				stmt.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		if(conn!=null) {
			try {
				conn.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
	}
	//针对DQL语句的关闭
	public static void close(ResultSet rs,Statement stmt,Connection conn) {
		if(rs!=null) {
			try {
				rs.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		if(stmt!=null) {
			try {
				stmt.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		
		if(conn!=null) {
			try {
				conn.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
	}
}

9. ORM（Object Relational Mapping）

ORM（Object Relational Mapping）

从数据库查询到的结果集(ResultSet)在进行遍历时，逐行遍历，取出的都是零散的数据。在实际应用开发中，我们需要将零散的数据进行封装整理；

9.1 创建表

CREATE TABLE `user`(
	id INT PRIMARY KEY,#主键
	username VARCHAR(20) NOT NULL,
	`password` VARCHAR(20) NOT NULL,#非空
	sex CHAR(2),
	email VARCHAR(50) NOT NULL,
	address VARCHAR(20) NOT NULL
)CHARSET = utf8;
INSERT INTO `user` (id,username,`password`,sex,email,address)
VALUES (1001,'kaka','123','男','123456789@qq.com','陕西省');

9.2 封装工具类

/**
 * 数据库工具类
 * 1.获取连接 connection
 * 2.释放资源
 * 可跨平台方案
 */
import java.io.*;
import java.sql.*;
import java.util.Properties;
public class DBUtils{
    //配置文件集合    永远不变
    private static final Properties properties = new Properties();
    static {
        try {
            //使用类自带的流
            //首次使用工具类，触发类加载
            InputStream is = DBUtils.class.getResourceAsStream("/db.properties");
            //通过流将配置信息的内容分割成键值对
            //将is流中的配置文件信息，加载到集合中
            properties.load(is);
            Class.forName(properties.getProperty("driver"));
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    //获得连接
    public static Connection getConnection(){
        Connection connection = null;
        try {
            connection = DriverManager.getConnection(properties.getProperty("url"),properties.getProperty("username"),properties.getProperty("password"));
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return connection;
    }
    //释放资源
    public static void closeAll(Connection connection, Statement statement, ResultSet resultSet) {
        try {
            if (resultSet != null) {
                resultSet.close();
            }
            if (statement != null) {
                statement.close();
            }
            if (connection != null) {
                connection.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

9.3 User类

public class User {
    private int id;
    private String username;
    private String password;
    private String sex;
    private String email;
    private String address;
    public User(){}

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", sex='" + sex + '\'' +
                ", email='" + email + '\'' +
                ", address='" + address + '\'' +
                '}';
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public User(int id, String username, String password, String sex, String email, String address) {
        this.id = id;
        this.username = username;
        this.password = password;
        this.sex = sex;
        this.email = email;
        this.address = address;
    }
}

9.4 OrmSelect类

/**
 * ORM查询
 */
import java.sql.*;
public class OrmSelect {
    public static void main(String[] args) {
        Connection connection = DBUtils.getConnection();
        String sql = "select id,username,PASSWORD,sex,email,address from `user`;";
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        try {
            preparedStatement = connection.prepareStatement(sql);
            resultSet = preparedStatement.executeQuery();
            //拿到每一行数据
            while (resultSet.next()) {
                //拿到每一列的数据
                User user = new User();
                int id = resultSet.getInt("id");
                String username = resultSet.getString("username");
                String password = resultSet.getString("password");
                String sex = resultSet.getString("sex");
                String email = resultSet.getString("email");
                String address = resultSet.getString("address");
                //将零散的数据，封装在User对象里
                user.setId(id);
                user.setUsername(username);
                user.setPassword(password);
                user.setSex(sex);
                user.setEmail(email);
                user.setAddress(address);
                System.out.println(user);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            DBUtils.closeAll(connection, preparedStatement, resultSet);
        }
    }
}

10. DAO（Data Access Object）

            DAO（Data Access Object）数据访问对象：将所有对同一张表的操作都封装在一个XXXDaoImpl对象中、根据增删改查的不同功能，实现具体的方法(insert,update,delete,select,selectAll)；

  • 对于任何一张表中的数据进行操作时（增、删、改、查）；应将对于一张表的所有操作统一封装在一个数据访问对象中为了实现重用；

10.1 创建表

CREATE TABLE employee(
	id INT PRIMARY KEY AUTO_INCREMENT,
	NAME VARCHAR(30),
	sex VARCHAR(2),
	salary DOUBLE
) CHARSET = utf8;

10.2 创建Employee类

public class Employee {
	private int id;//工号
	private String name;//名字
	private String sex;//性别
	private double salary ;//工资
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	public double getSalary() {
		return salary;
	}
	public void setSalary(double salary) {
		this.salary = salary;
	}
	@Override
	public String toString() {
		return "employee [id=" + id + ", name=" + name + ", sex=" + sex + ",  salary="
				+ salary + "]";
	}
	public Employee() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Employee(int id, String name, String sex, double salary) {
		super();
		this.id = id;
		this.name = name;
		this.sex = sex;
		this.salary = salary;
	}
}

10.3 封装工具类

见第7个板块

10.4 UserDaoImpl

/*
 *对数据库中emp;oyee表的一系列操作(增删改查) 
 *实现增删改查
 */
public class UserDaoImpl {
		private Connection conn = null;
		private PreparedStatement stmt = null;
		private ResultSet rs = null;
		
		//增加
		public int insert(Employee emp){
			try {
				//数据库连接对象
				conn = JDBCUtils.getConnection();
				//编写SQL语句
				String sql = "insert into employee (id,name,sex,salary) values(?,?,?,?);";
				//预编译对象
				stmt = conn.prepareStatement(sql);
				//执行更新
				stmt.setInt(1, emp.getId());
				stmt.setString(2, emp.getName());
				stmt.setString(3, emp.getSex());
				stmt.setDouble(4, emp.getSalary());
				
				int i = stmt.executeUpdate();
				return i;
			} catch (Exception e) {
				e.printStackTrace();
			} finally{
				JDBCUtils.close(stmt, conn);
			}
			return 0;
		}
		
		//删除
		public int delete (int id){
			conn = JDBCUtils.getConnection();
			String sql = "delete from employee where id = ?";
			try {
				stmt = conn.prepareStatement(sql);
				//获取id
				stmt.setInt(1, id);
				return stmt.executeUpdate();
			} catch (SQLException e) {
				e.printStackTrace();
			}finally{
				JDBCUtils.close(stmt, conn);
			}
			return 0;
		}
		
		//修改
		public int update(Employee emp){
			conn = JDBCUtils.getConnection();
			String sql = "update employee set name = ?,sex = ?,salary = ? where id = ?";
			try {
				stmt = conn.prepareStatement(sql);
				//执行更新
				stmt.setString(1, emp.getName());
				stmt.setString(2, emp.getSex());
				stmt.setDouble(3, emp.getSalary());
				stmt.setInt(4, emp.getId());
				return stmt.executeUpdate();
			} catch (SQLException e) {
				e.printStackTrace();
			}finally{
				JDBCUtils.close(stmt, conn);
			}
			return 0;
		}
		
		//查询
		public List<Employee> selectAll(){
			conn = JDBCUtils.getConnection();
			String sql = "select id,name,sex,salary from employee";
			List<Employee> empList = new ArrayList<Employee>();
			 try {
				 stmt = conn.prepareStatement(sql);
	             rs = stmt.executeQuery();
	             while(rs.next()){
	                int id = rs.getInt("id");
	                String name = rs.getString("name");
	                String sex = rs.getString("sex");
	                double salary = rs.getDouble("salary");
	                Employee  emp = new Employee(id, name, sex, salary);
	               //每封装完一个对象，添加到集合当中
	                empList.add(emp);
	            }
	            return empList;
	        } catch (SQLException e) {
	            e.printStackTrace();
	        }finally {
	        	JDBCUtils.close(stmt, conn);
	        }
			return null;
			
		}
}

10.5 测试类

public class JDBCTest {
	public static void main(String[] args) {
		//新增
		UserDaoImpl udi = new UserDaoImpl();
		Employee emp = new Employee(3,"wangwu","nv",4555);
		int result = udi.insert(emp);
		if(result > 0){
			System.out.println("success");
		}else{
			System.out.println("defeat");
		}
		
		//删除
		int result = udi.delete(3);
		System.out.println(result);
		
		//修改
		Employee emp = new Employee(1,"kaka","m",12345);
		int result = udi.update(emp);
		System.out.println(result);
		
		//查询
		List<Employee> empList = udi.selectAll();
		empList.forEach(System.out::println);
		
	}
}

11. 日期类型

  • java.util.Date

    java语言常规应用层面的日期类型；可以通过字符串创建对应的时间对象；无法直接通过JDBC插入数据库

  • java.sql.Date

    不可以通过字符串创建对应的时间对象；只能通过毫秒值创建对象；可以直接通过JDBC插入数据库

sql赋util可以，util赋sql不行，因为sql是util的子类；

11.1 日期格式化工具

  • SimpleDateFormat 日期格式化
//自定义一个时间
String str = "2020-02-02";
//日期转换将字符串转为 java.util.Date
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
//将日期字符串转换成 util.Date类型
java.util.Date utilDate  = sdf.parse(str);
System.out.println(utilDate);

11.2 日期工具类

/**
 * 日期转换
 * 字符串转UtilDate
 * 字符串转SqlDate
 * utilDate转成SqlDate
 */
import java.text.ParseException;
import java.text.SimpleDateFormat;
public class DateUtils {
    private static final SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
    //字符串转Util
    public static java.util.Date strToUtilDate(String str) {
        try {
            return simpleDateFormat.parse(str);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return null;
    }
    //字符串转sql(不常用)
    public static java.sql.Date strToSqlDate(String str){
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
        try {
            java.util.Date date = simpleDateFormat.parse(str);
            return new java.sql.Date(date.getTime());
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return null;
    }

    //util转sql
    public static java.sql.Date utilToSql(java.util.Date date){
        return new java.sql.Date(date.getTime());
    }
}

11.3 测试类

  public static void main(String[] args) throws ParseException{
        //1.java.util.Date
        // 当前系统时间
        System.out.println(new java.util.Date());

        //自定义一个时间
        String str = "2020-02-02";
        //日期转换将字符串转为 java.util.Date
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        //将日期字符串转换成 util.Date类型
        java.util.Date utilDate  = sdf.parse(str);
        System.out.println(utilDate);

        //sql.Date  需要毫秒值，来构建一个日期
        java.sql.Date sqlDate = new java.sql.Date(utilDate.getTime());
        System.out.println(sqlDate);

        java.util.Date date = DateUtils.strToUtilDate("2020-03-28");
        System.out.println(date);

        java.sql.Date date2 = DateUtils.utilToSql(date);
        System.out.println(date2);
    }
}

12. JDBC事务

使用JDBC操作事务，在对业务进行操作的时候，将业务操作使用事务进行管理，操作结果要么同时成功，要么同时失败；

  • void setAutoCommit(boolean autoCommit)：

    参数是 true 或 false 如果设置为 false，表示关闭自动提交，相当于开启事务

  • void commit()：提交事务

  • void rollback()：回滚事务

12.1 开发步骤

  1. 获取连接
  2. 开启事务
  3. 获取到 PreparedStatement
  4. 使用 PreparedStatement 执行两次更新操作
  5. 正常情况下提交事务
  6. 出现异常回滚事务
  7. 关闭资源

12.2 创建表

CREATE TABLE account(
	id INT PRIMARY KEY AUTO_INCREMENT,
	NAME VARCHAR(10),
	balance DOUBLE
);
-- 插入账户 
INSERT INTO account (NAME , balance) VALUE ('zhangsan',1000);
INSERT INTO account (NAME , balance) VALUE ('lisi',1000);

12.3 加入事务处理

public class JDBCDemo {
	public static void main(String[] args) {
		Connection conn = null ;
		PreparedStatement ps1 = null ;
		PreparedStatement ps2 = null ;
		try {
			
			//获取数据库的连接对象
			 conn = JDBCUtils.getConnection() ;  
 				//开启事务  //Mysql:中开启 start transaction ;
			 conn.setAutoCommit(false);  //false开启收到提交  ,true自动提交
			
			//准备sql语句
			String sqlStr1 = "update account set balance = balance - ? where id = ?" ;
			String sqlStr2 = "update account set balance = balance + ? where id = ?" ;
			
			//使用连接对象获取预编译对象,给数据库发送sql进行预编译操作
			 ps1 = conn.prepareStatement(sqlStr1) ;
			 ps2 = conn.prepareStatement(sqlStr2) ; 
			 //分别设置参数
			 ps1.setDouble(1, 500);
			 ps1.setInt(2, 1);
			 
			 ps2.setDouble(1, 500);
			 ps2.setInt(2, 2);
			 
			 //进行更新
			 int count1 = ps1.executeUpdate() ;
			 System.out.println(count1);
			 System.out.println(sqlStr1);
			 
			 
			 //模拟中间有问题
			 int x = 3 / 0 ; //程序问题了,程序结束
			 
			 int count2 = ps2.executeUpdate() ;
			 System.out.println(count2);
			 System.out.println(sqlStr2);
			 //提交事务
			 conn.commit(); 
		} catch (SQLException e) {
			//回滚 //如果程序问题了,执行catch语句  
			if(conn!=null) {
				try {
					conn.rollback();
				} catch (SQLException e1) {
					e1.printStackTrace();
				} 
			}
			e.printStackTrace();
		}finally {
			JDBCUtils.close(ps1, conn);
			JDBCUtils.close(ps2, null);
		}
	}
}

12.4 DBUtils封装事务控制

  //开启事务
    public static void begin(){
        Connection connection = getConnection();
        try {
            connection.setAutoCommit(false);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    //提交事务
    public static void commit(){
        Connection connection = getConnection();
        try {
            connection.commit();
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            DBUtils.closeAll(connection,null,null);
        }
    }
    //回滚事务
    public static void rollback(){
        Connection connection = getConnection();
        try {
            connection.rollback();
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            DBUtils.closeAll(connection,null,null);
        }
    }

13.连接池

JDBC每次连接数据库，都要获得一个连接对象。每次创建一个连接对象，都是一个较大的资源，如果在连接量较大的场景下，会极大的浪费资源，容易内存溢出。

连接池就是一个容器,创建好数据库连接对象之后,将这些连接对象存储到容器(初始化)中,每次使用连接对象之后,而是将连接对象归还到连接池中,等待下一次利用；

13.1 c3p0连接池

Java中提供了一个接口DataSource，通过实现该接口，可以创建连接池

使用连接池:c3p0: 需要提供的对应的mysql的c3p0相关的jar包

导入:c3p0-0.9.5.2.jar核心jar包以及它相关的依赖jar包 mchange-commons-java-0.2.12.jar

13.2 Druid（德鲁伊）

Druid 是目前比较流行高性能的，分布式列存储

一、亚秒级查询

二、实时数据注入

三、可扩展的PB级存储

四、多环境部署

五、丰富的社区

13.2.1 Druid配置

  • 创建druid.properties 配置文件
  • 引入druid-1.0.9.jar包
  • 需要借助工厂类DruidDataSourceFactory 创建具体的连接池
  • 获取DataSouce:连接池对象(接口) 通过连接池获取数据库的连接
  • Connection getConnection() throws SQLException;

13.2.2 database.properties 文件配置

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/db0708?useUnicode=true&characterEncoding=utf8
username=root
password=root
#初始化连接
initialSize=10
#最大连接数量
maxActive=30
#最小空闲连接
minIdle=5
#超时等待时间以毫秒为单位
maxWait=5000

13.2.3 连接池工具类

import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;
import javax.sql.DataSource;
import com.alibaba.druid.pool.DruidDataSourceFactory;

/*
 *将Druid连接池的获取通过工具类进行封装使用连接池创建连接对象(每次close()都会归还到连接池中),
 *操作DDL,DML,DQL都一样
 */
public class JDBCUtils {
	//获取数据库连接池
	private static DataSource ds;
	
	//提供静态代码块
	//加载配置文件
	static{
		try{
			//创建Properties集合类对象
			Properties prop = new Properties();
			//加载配置文件
			InputStream inputStream = JDBCUtils.class.getClassLoader().getResourceAsStream("druid.properties");
			
			//加载
			prop.load(inputStream);
			inputStream.close();
			
			//创建连接池对象
			ds = DruidDataSourceFactory.createDataSource(prop);
			
		} catch(IOException e){
			e.printStackTrace();
		}catch(Exception e){
			e.printStackTrace();
		}
	}
	//获取连接
	public static Connection getConnection() throws SQLException {
		return ds.getConnection() ;
	}
	
	//定义一个方法,获取存在的连接池
	public static DataSource getDataSource() {
		return ds ;
	}
	
	//释放资源
	public static void close(Statement stmt,Connection conn) {
		
		close(null,stmt,conn) ;
	}

	public static void close(ResultSet rs, Statement stmt, Connection conn) {
		if(rs!=null) {
			try {
				rs.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		
		if(stmt!=null) {
			try {
				stmt.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		
		if(conn!=null) {
			try {
				conn.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
	}
}

12.2.4 创建表

-- 创建账户表
CREATE TABLE account(
	id INT PRIMARY KEY AUTO_INCREMENT,
	NAME VARCHAR(10),
	balance DOUBLE
)CHARSET = utf8;
-- 插入账户 
INSERT INTO account (NAME , balance) VALUE ('张三',1000);
INSERT INTO account (NAME , balance) VALUE ('李四',1000);

12.2.5 测试类

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import com.kaka.utils.JDBCUtils;

public class DruidTest {
public static void main(String[] args) {
		Connection conn = null ;
		PreparedStatement stmt  = null ;
		try {
			//获取连接
			conn = JDBCUtils.getConnection() ;
			//准备sql :给account表中插入数据
			String sql = "insert into account values(null,?,?)" ;
			//获取预编译对象
			stmt = conn.prepareStatement(sql) ;
			//设置参数
			stmt.setString(1, "王五");
			stmt.setDouble(2, 3000);
			
			//执行更新
			int count = stmt.executeUpdate();
			System.out.println("更新成功,影响了"+count);
		} catch (SQLException e) {
			e.printStackTrace();
		}finally {
			JDBCUtils.close(stmt, conn);
		}
	}
}
Willing卡卡
关注
专栏目录
jdbc笔记（完整）
雪顶儿的博客
12-31 739
JDBC：java database connection一  Why JDBC    我们一直说，计算机是用来帮助人们进行快速运算的。运算最根本的依据是数据。那么我们需要有操作的数据的来源，并且最终计算完成后，需要数据能够长久的保存，也就是数据能够持久化。        持久化：                                 写入到    狭义上讲  内存对象 --------...
JDBC入门详细笔记
qq_45968017的博客
03-25 227
笔记根据此视频完成 个人博客链接：https://www.qingbo1011.top/ 点击此处前往 Java数据库连接，（Java Database Connectivity，简称JDBC）是Java语言中用来规范客户端程序如何来访问数据库的应用程序接口，提供了诸如查询和更新数据库中数据的方法。JDBC是面向关系型数据库的。 JDBC本质：官方（sun公司）定义的一套操作所有关系型数据库的规则，即接口。各个数据库厂商去实现这套接口，提供数据库驱动jar包。我们可以使用这套接口（JDBC）编程，真正
JDBC笔记 JDBC笔记
09-07
一、概述： JDBC从物理结构上说就是Java语言访问数据库的一套接口集合。从本质上来说就是调用者（程序员）和实现者（数据库厂商）之间的协议。JDBC的实现由数据库厂商以驱动程序的形式提供。JDBC API 使得开发人员可以使用纯Java的方式来连接数据库，并进行操作。 ODBC：基于C语言的数据库访问接口。 JDBC也就是Java版的ODBC。 JDBC的特性：高度的一致性、简单性（常用的接口只有4、5个）。 1．在JDBC中包括了两个包：java.sql和javax.sql。 ① java.sql 基本功能。这个包中的类和接口主要针对基本的数据库编程服务，如生成连接、执行语句以及准备语句和运行批处理查询等。同时也有一些高级的处理，比如批处理更新、事务隔离和可滚动结果集等。 ② javax.sql 扩展功能。它主要为数据库方面的高级操作提供了接口和类。如为连接管理、分布式事务和旧有的连接提供了更好的抽象，它引入了容器管理的连接池、分布式事务和行集等。 注：除了标出的Class,其它均为接口。 API 说明 java.sql.Connection 与特定数据库的连接（会话）。能够通过getMetaData方法获得数据库提供的信息、所支持的SQL语法、存储过程和此连接的功能等信息。代表了数据库。 java.sql.Driver 每个驱动程序类必需实现的接口，同时，每个数据库驱动程序都应该提供一个实现Driver接口的类。 java.sql.DriverManager (Class) 管理一组JDBC驱动程序的基本服务。作为初始化的一部分，此接口会尝试加载在”jdbc.drivers”系统属性中引用的驱动程序。只是一个辅助类，是工具。 java.sql.Statement 用于执行静态SQL语句并返回其生成结果的对象。 java.sql.PreparedStatement 继承Statement接口，表示预编译的SQL语句的对象，SQL语句被预编译并且存储在PreparedStatement对象中。然后可以使用此对象高效地多次执行该语句。 java.sql.CallableStatement 用来访问数据库中的存储过程。它提供了一些方法来指定语句所使用的输入/输出参数。 java.sql.ResultSet 指的是查询返回的数据库结果集。 java.sql.ResultSetMetaData 可用于获取关于ResultSet对象中列的类型和属性信息的对象。
03-JDBC
xinruzhishui_11的博客
06-08 238
JDBC JAVA Database Connectivity java 数据库连接 为什么会出现JDBC SUN公司提供的一种数据库访问规则、规范, 由于数据库种类较多，并且java语言使用比较广泛，sun公司就提供了一种规范，让其他的数据库提供商去实现底层的访问规则。 我们的java程序只要使用sun公司提供的jdbc驱动即可。 使用JDBC的基本步骤 注册...
JDBC超级详细笔记
QilanAllen的博客
09-23 301
一、简介： JDBC(Java Data Base Connectivity)是一种用于执行SQL语句的javaAPI，由一组用java语言编写的类和接口组成。 从结构上看，JDBC是Java语言访问数据库的一套接口集合。从本质上看，JDBC是调用者（开发人员）与执行者（数据库厂商）的一种协议。 二、使用： 1、导包 创建工程后，在工程下创建lib文件夹，导入mysql-connecto...
JDBC-1500行学习笔记，真的超级详细！！！
08-25
### JDBC详解与实践 #### 一、JDBC概述与重要性 JDBC（Java Database Connectivity）是Java平台上的数据库访问技术。它为Java应用程序提供了一种标准的方式来访问各种关系型数据库管理系统（RDBMS），例如MySQL、...
超详细23年软考笔记（本人于北京已过）
最新发布
08-28
《超详细23年软考笔记——信息系统项目管理师》 软考，即全国计算机技术与软件专业技术资格（水平）考试，是一项针对信息技术领域专业人员的国家级考试。本笔记主要涵盖了软考高级的信息系统项目管理师的重点内容，...
Javaweb最新全套项目实战视频教程-JDBC课堂笔记
12-18
是否还在默默的看着学习路线图，寻找适合自己的学习资源，现在不需要如此麻烦了，动力节点全新整理Javaweb阶段全套教程已经上线，内涵网络通信、HTML、CSS、JavaScript、MySQL、JDBC、JSP、Servlet等技术，Javaweb从...
javaweb项目实（含笔记与详细实现步骤）
07-20
JavaWeb项目实（含笔记与详细实现步骤） JavaWeb是一种基于Java技术的Web应用程序开发框架，它涵盖了服务器端编程、数据库交互、用户界面设计等多个方面。对于初学者来说，掌握JavaWeb开发是步入Web开发领域的关键...
马士兵Spring课堂笔记(超级详细版).pdf
02-28
马士兵Spring课堂笔记（超级详细版） 本资源主要讲解了Spring框架的基础概念和应用，涵盖了面向接口编程、IOC/DI、AOP、Spring应用IOC/DI、Spring应用AOP、Struts2.1.6 + Spring2.5.6 + Hibernate3.3.2整合、Spring...
最全的jdbc笔记
weixin_43146162的博客
08-24 198
JDBC概述 数据的持久化 持久化(persistence)：把数据保存到可掉电式存储设备中以供之后使用。 JDBC的理解 JDBC(Java Database Connectivity)是一个独立于特定数据库管理系统、通用的SQL数据库存取和操作的公共接口（一组API） 简单理解为：JDBC，是SUN提供的一套 API，使用这套API可以实现对具体数据库的操作（获取连接、关闭连接、DML、DDL、DCL) JDBC的好处 面向应用的API：Java API，抽象接口，供应用程序开发人员使用（
jdbc笔记
sawelly的博客
02-01 254
通过JDBC查询数据库数据 一般需要以下七个步骤： （1）  加载JDBC驱动 （2）  建立并获取数据库连接 （3）  创建 JDBC Statements 对象 （4）  设置SQL语句的传入参数 （5）  执行SQL语句并获得查询结果 （6）  对查询结果进行转换处理并将处理结果返回 （7）  释放相关资源（关闭Connection，关闭Statement，关闭ResultS
JDBC笔记
晴晴晴的博客
10-09 222
为什么要使用ＪＤＢＣ？JDBC:java database connectivity SUN公司提供的一套操作数据库的标准规范。 java语言操作数据库的一种技术（规范） JDBC与数据库驱动的关系：接口与实现的关系。JDBC规范（掌握四个核心对象）：DriverManager类:用于注册驱动 java.sql.DriverManager Connection接口: 表示与数据库创建的连接 j
JDBC MVC学习笔记：连接、预编译与结果集
"JDBC_MVC个人笔记.md" 这篇个人笔记主要涵盖了JDBC和MVC两种在Java开发中常见的技术。JDBC（Java Database Connectivity）是Java语言与数据库交互的标准接口，而MVC（Model-View-Controller）是一种设计模式，常...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Willing卡卡

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值