今日内容
  • 基本概念
  • 快速入门
  • 对JDBC中各个接口和类的详解
一、基本概念
1.概念：Java Database Connectivity：Java数据库连接，Java语言操作数据库
2.本质：官方（Sun）定义的一套操作所有关系型数据库的规则，即接口。各个数据库厂商实现这套接口，提供数据库驱动jar包，我们可以使用这套接口（JDBC）编程，真正执行的代码是jar包中的实现类
即：JDBC是接口，真正执行的是jar包中的实现类
SUN公司写的代码，定义了一套操作所有关系型数据库的规则（接口），没有定义实现类，实现类由不同数据库厂商写出对应数据库的实现类（数据库驱动），不同实现类可以操作自己的数据库。
                                                                                            以接口类型调用方法，真正执行的是实现方法
例如 interface Person              class Worker                     Person p=new Work();             p.eat();多态调用
3.快速入门
  • 步骤【创建空项目project，新建模块module，模块module就放到了项目下】
    • 导入驱动jar包mysql-connector-java-5.1.37-bin.jar
      • 复制mysql-connector-java-5.1.37-bin.jar到项目的libs目录下
      • 右键-->add as library
jar包内是一些已经编译好的class字节码文件
src是开源的源码文件
    • 注册驱动
    • 获取数据库的连接对象Connection（java和数据库的桥梁对象）
    • 定义SQL语句
    • 获取执行SQL语句的对象Statement
    • 执行SQL，接收返回的结果
    • 处理结果
    • 释放资源，不释放容易造成内存的泄露问题
  • 使用
    • 创建一个项目Project---itcast
    • 在项目的project structure创建一个新module---day04_jdbc
  1. package cn.itcast.jdbc;
  2. import java.sql.Connection;
  3. import java.sql.DriverManager;
  4. import java.sql.Statement;
  5. /**
  6.  * JDBC快速入门
  7.  */
  8. public class JdbcDemo1 {
  9.     public static void main(String[] args) throws Exception{
  10.         //1.导入驱动jar包mysql-connector-java-5.1.37-bin.jar
  11.         //创建libs文件夹便于管理
  12.         //复制后右键，add as library
  13.         //2.注册驱动
  14.         Class.forName("com.mysql.jdbc.Driver");
  15.         //3.获取数据库的连接对象
  16.         Connection conn= DriverManager.getConnection("jdbc:mysql://localhost:3306/db3","root","root");
  17.         //4.定义一个SQL语句
  18.         String sql="update account set balance = 500 where id=1";//sql语句后不用加分号
  19.         //5.获取SQL的执行对象
  20.         Statement stmt = conn.createStatement();
  21.         //6.执行SQL
  22.         int count = stmt.executeUpdate(sql);
  23.         //7.处理结果，打印
  24.         System.out.println(count);
  25.         //8.释放资源
  26.         stmt.close();
  27.         conn.close();
  28.     }
  29. }
二、各个对象的详解
常见对象
  • DriverManager--驱动管理对象
  • Connection--数据库连接对象
  • Statement--执行SQL的对象

  • ResultSet--结果集对象
  • PreparedStatement--预编译SQL对象
1.JDBC各个类详解_DriverManager_注册驱动
可以实现注册驱动和获取数据库连接
数据库驱动管理类的功能：
  • 注册驱动Class.forName("com.mysql.jdbc.Driver");
    • 代码是这么写的Class.forName("com.mysql.jdbc.Driver");把字节码文件加载进内存【这样简单，实际上还是用了DriverManager】
    • 实际上DriverManager有注册驱动的方法   static void registerDriver(Driver driver) 使用 DriverManager注册给定的驱动程序。
    • 二者的区别：上者中有一些代码会随着类执行（静态代码块）
    • 通过查看源码发现，在mom.mysql.jdbc.Driver中存在静态代码块：
  1.  static {
  2.         try {
  3.             java.sql.DriverManager.registerDriver(new Driver());
  4.         } catch (SQLException E) {
  5.             throw new RuntimeException("Can't register driver!");
  6.         }
  7.     }
注意：
        在mysql5之后的驱动jar包，注册驱动的代码可以省略，注释Class.forName("com.mysql.jdbc.Driver");

MySQL5之后的驱动jar包可以省略注册驱动的步骤
  • 获取数据库连接 Connection conn= DriverManager.getConnection("jdbc:mysql://localhost:3306/db3","root","root");
    • static Connection getConnection(String url, String user, String password) 尝试建立与给定数据库URL的连接。
    • url：指定连接的l路径
      • 语法：（MySQL）-jdbc:mysql:-//ip地址:端口/数据库名
      • 例子：jdbc:mysql://localhost:3306/db3
      • 细节：如果连接的是本机的MySQL服务器，并且默认端口是3306，则可以简写为jdbc:mysql///数据库名
  1. package cn.itcast.jdbc;
  2. import java.sql.Connection;
  3. import java.sql.DriverManager;
  4. import java.sql.Statement;
  5. public class Jdbc_demo1 {
  6.     public static void main(String[] args) throws Exception{
  7.         //1.导入驱动jar包mysql-connector-java-5.1.37-bin.jar
  8.         //创建libs文件夹便于管理
  9.         //复制后右键，add as library
  10.         //2.注册驱动
  11.         //Class.forName("com.mysql.jdbc.Driver");
  12.         //3.获取数据库的连接对象
  13.         Connection conn= DriverManager.getConnection("jdbc:mysql:///db3","root","root");
  14.         //4.定义一个SQL语句
  15.         String sql="update account set balance = 2000 where id=1";//sql语句后不用加分号
  16.         //5.获取SQL的执行对象
  17.         Statement stmt = conn.createStatement();
  18.         //6.执行SQL
  19.         int count = stmt.executeUpdate(sql);
  20.         //7.处理结果，打印
  21.         System.out.println(count);
  22.         //8.释放资源
  23.         stmt.close();
  24.         conn.close();
  25.     }
  26. }
2.JDBC各个类详解_Connection
可以获取执行SQL的对象并可以实现事务的管理
数据库和Java之间的桥梁
2.1功能
  • 获取执行SQL的对象Statement stmt = conn.createStatement();
Statement createStatement() 创建一个 Statement对象，用于将SQL语句发送到数据库。  
PreparedStatement prepareStatement(String sql) 创建一个 PreparedStatement对象，用于将参数化的SQL语句发送到数据库。  
  • 管理事务
    • 事务：多个步骤的业务操作，要么同时成功，要么同时失败
    • 三个方法--开启事务：void setAutoCommit(boolean autoCommit) 调用此方法设置false，即开启事务并不自动提交
    • 三个方法--提交事务：void commit() 提交事务
    • 三个方法--回滚事务：void rollback() 回滚事务
3.JDBC各个类详解_Statement
执行SQL的对象
参数的值是给定的
3.1 常用的方法
  • boolean execute() 可以执行任意的SQL，了解
  • true如果第一个结果是一个ResultSet对象; false如果第一个结果是更新计数或没有结果
  • int executeUpdate() 可以执行DML（insert update delete对表中数据进行修改）语句、DDL（对表和库进行修改，create、alter、drop，不常用，dba用SQL设置好）语句
  • （1）SQL数据操作语言（DML）语句的行计数或（2）0不返回的SQL语句 
    如update account set balance =1000;//返回影响的行数
    可以通过影响的行数判断DML是否执行成功，如果大于0，则执行成功，反之则失败
  • ResultSet executeQuery(String sql) ：执行DQL（select）语句，返回ResultSet
  • 先学习update增删改，再学习select
3.2 Statement--JDBC练习_insert语句执行增删改
之前代码不规范，释放资源应该放入finally内部，不管是否执行成功都要释放资源
练习
  • 为account表添加一条记录
  1. package cn.itcast.jdbc;
  2. import java.sql.Connection;
  3. import java.sql.DriverManager;
  4. import java.sql.SQLException;
  5. import java.sql.Statement;
  6. /**
  7.  * account表，添加一条记录 insert语句
  8.  */
  9. public class Jdbc_demo2 {
  10.     public static void main(String[] args){
  11.         Statement stmt=null;
  12.         Connection conn= null;
  13.         try {
  14.             //1.注册驱动
  15.             Class.forName("com.mysql.jdbc.Driver");
  16.             //定义sql语句
  17.             String sql="insert into account values(null,'wangwu',3000)";
  18.             //3.获取Connection对象
  19.             conn = DriverManager.getConnection("jdbc:mysql:///db3", "root", "root");
  20.             // 有异常 ,alt+enter
  21.             //4.获取执行sql的对象 Statement
  22.             stmt = conn.createStatement();
  23.             //5.执行sql
  24.             int count = stmt.executeUpdate(sql);//影响的行数
  25.             //6.处理结果
  26.             System.out.println(count);
  27.             if (count>0){
  28.                 System.out.println("添加成功");
  29.             }else
  30.                 System.out.println("添加失败");
  31.         } catch (ClassNotFoundException e) {
  32.             e.printStackTrace();
  33.         } catch (SQLException e) {
  34.             e.printStackTrace();
  35.         }finally {
  36.             //7.释放资源
  37.             //先释放Statement对象，是由connection获取的
  38.             //stmt.close();//作用域不同
  39.             //为了避免空指针异常，判断是否为null
  40.             if (stmt!= null){
  41.                 try {
  42.                     stmt.close();
  43.                 } catch (SQLException e) {
  44.                     e.printStackTrace();
  45.                 }
  46.             }
  47.             //释放conn
  48.             if (conn!= null){
  49.                 try {
  50.                     conn.close();
  51.                 } catch (SQLException e) {
  52.                     e.printStackTrace();
  53.                 }
  54.             }
  55.         }
  57.     }
  58. }
  • account表修改记录
  1. package cn.itcast.jdbc;
  3. import java.sql.Connection;
  4. import java.sql.DriverManager;
  5. import java.sql.SQLException;
  6. import java.sql.Statement;
  8. /**
  9.  * account 表 修改记录
  10.  */
  11. public class JDBC_Demo3 {
  12.     public static void main(String[] args) {
  13.         //修改王五的工资为1500
  14.         Statement stmt=null;
  15.         Connection conn=null;
  16.         try {
  17.             //1.注册驱动
  18.             Class.forName("com.mysql.jdbc.Driver");
  19.             //2.获取连接对象
  20.             conn = DriverManager.getConnection("jdbc:mysql:///db3", "root", "root");
  21.             //3.定义sql
  22.             String sql="update account set balance=1500 where name='wangwu'";
  23.             //4.获取执行sql的对象
  24.             stmt = conn.createStatement();
  25.             //5.执行sql
  26.             int count = stmt.executeUpdate(sql);
  27.             //6.处理结果
  28.             System.out.println(count);
  29.             if (count>0){
  30.                 System.out.println("修改成功");
  31.             }else
  32.                 System.out.println("修改失败");
  33.         } catch (ClassNotFoundException e) {
  34.             e.printStackTrace();
  35.         } catch (SQLException e) {
  36.             e.printStackTrace();
  37.         }finally {
  38.             if (stmt!=null){
  39.                 try {
  40.                     stmt.close();
  41.                 } catch (SQLException e) {
  42.                     e.printStackTrace();
  43.                 }
  44.             }
  45.             if (conn!=null){
  46.                 try {
  47.                     conn.close();
  48.                 } catch (SQLException e) {
  49.                     e.printStackTrace();
  50.                 }
  51.             }
  52.         }
  53.     }
  54. }
  • account表删除一条记录
  1. package cn.itcast.jdbc;
  3. import java.sql.Connection;
  4. import java.sql.DriverManager;
  5. import java.sql.SQLException;
  6. import java.sql.Statement;
  8. /**
  9.  * 删除表中的记录
  10.  */
  11. public class JDBCDemo4 {
  12.     public static void main(String[] args) {
  13.         //删除王五
  14.         Statement stmt=null;
  15.         Connection conn=null;
  16.         try {
  17.             //1.注册驱动
  18.             Class.forName("com.mysql.jdbc.Driver");
  19.             //2.获取连接对象
  20.             conn = DriverManager.getConnection("jdbc:mysql:///db3", "root", "root");
  21.             //3.定义sql
  22.             String sql="delete from account where id=3";
  23.             //4.获取执行sql的对象
  24.             stmt = conn.createStatement();
  25.             //5.执行sql
  26.             int count = stmt.executeUpdate(sql);
  27.             //6.处理结果
  28.             System.out.println(count);
  29.             if (count>0){
  30.                 System.out.println("删除成功");
  31.             }else
  32.                 System.out.println("删除失败");
  33.         } catch (ClassNotFoundException e) {
  34.             e.printStackTrace();
  35.         } catch (SQLException e) {
  36.             e.printStackTrace();
  37.         }finally {
  38.             if (stmt!=null){
  39.                 try {
  40.                     stmt.close();
  41.                 } catch (SQLException e) {
  42.                     e.printStackTrace();
  43.                 }
  44.             }
  45.             if (conn!=null){
  46.                 try {
  47.                     conn.close();
  48.                 } catch (SQLException e) {
  49.                     e.printStackTrace();
  50.                 }
  51.             }
  52.         }
  53.     }
  54. }
executeUpdate也可以执行DDL语句
  1. package cn.itcast.jdbc;
  3. import java.sql.Connection;
  4. import java.sql.DriverManager;
  5. import java.sql.SQLException;
  6. import java.sql.Statement;
  8. /**
  9.  * 执行DDL语句
  10.  */
  11. public class JDBCDemo5 {
  12.     public static void main(String[] args) {
  13.         //删除王五
  14.         Statement stmt=null;
  15.         Connection conn=null;
  16.         try {
  17.             //1.注册驱动
  18.             Class.forName("com.mysql.jdbc.Driver");
  19.             //2.获取连接对象
  20.             conn = DriverManager.getConnection("jdbc:mysql:///db3", "root", "root");
  21.             //3.定义sql
  22.             String sql="create TABLE student(id INT, name VARCHAR(20))";
  23.             //4.获取执行sql的对象
  24.             stmt = conn.createStatement();
  25.             //5.执行sql
  26.             int count = stmt.executeUpdate(sql);
  27.             //6.处理结果，DML返回结果，DDL不返回结果
  28.             System.out.println(count);
  29.         } catch (ClassNotFoundException e) {
  30.             e.printStackTrace();
  31.         } catch (SQLException e) {
  32.             e.printStackTrace();
  33.         }finally {
  34.             if (stmt!=null){
  35.                 try {
  36.                     stmt.close();
  37.                 } catch (SQLException e) {
  38.                     e.printStackTrace();
  39.                 }
  40.             }
  41.             if (conn!=null){
  42.                 try {
  43.                     conn.close();
  44.                 } catch (SQLException e) {
  45.                     e.printStackTrace();
  46.                 }
  47.             }
  48.         }
  49.     }
  50. }
DML会返回
DDL不会返回int值，只返回0
4.JDBC各个类详解_ResultSet
4.1 基本使用
Statement可以执行两类方法
  • int executeUpdate() 可以执行DML（insert update delete对表中数据进行修改）语句、DDL（对表和库进行修改，create、alter、drop，不常用，dba用SQL设置好）语句
  • （1）SQL数据操作语言（DML）语句的行计数或（2）0不返回的SQL语句 
    如update account set balance =1000;//返回影响的行数
    可以通过影响的行数判断DML是否执行成功，如果大于0，则执行成功，反之则失败
  • ResultSet executeQuery(String sql) ：执行DQL（select）语句，返回ResultSet
    • ResultSet是一个结果集对象，用于封装查询结果
    • 目的：从resultset中将结果取出来
    • 方法：通过游标，取每一行，需要两类方法
    • next()：游标向下移动一行
    • 获取每一列getXXX()获取数据
      • XXX代表数据类型
      • 如：int getInt(XX) getString(XX)
      • 参数中的值为获取的第几列，两种参数构成了重载
        • int：代表列的编号  如getString(1)   id，从1开始
        • Sting：代表列名，如getString("balance")
  1. package cn.itcast.jdbc;
  3. import java.sql.*;
  5. /**
  6.  * 执行DDL语句
  7.  */
  8. public class JDBCDemo6 {
  9.     public static void main(String[] args) {
  10.         //删除王五
  11.         Statement stmt=null;
  12.         Connection conn=null;
  13.         ResultSet rs=null;
  14.         try {
  15.             //1.注册驱动
  16.             Class.forName("com.mysql.jdbc.Driver");
  17.             //2.获取连接对象
  18.             conn = DriverManager.getConnection("jdbc:mysql:///db3", "root", "root");
  19.             //3.定义sql
  20.             String sql="select * from account";
  21.             //4.获取执行sql的对象
  22.             stmt = conn.createStatement();
  23.             //5.执行sql
  24.             rs = stmt.executeQuery(sql);//资源需要关闭
  25.             //6.处理结果
  26.             // 6.1游标向下移动一行
  27.             rs.next();
  28.             //6.2 获取数据
  29.             int id = rs.getInt(1);
  30.             String name = rs.getString("name");
  31.             double balance = rs.getDouble(3);
  32.             System.out.println(id+"---"+name+"---"+balance);
  33.         } catch (ClassNotFoundException e) {
  34.             e.printStackTrace();
  35.         } catch (SQLException e) {
  36.             e.printStackTrace();
  37.         }finally {
  38.             if (stmt!=null){
  39.                 try {
  40.                     stmt.close();
  41.                 } catch (SQLException e) {
  42.                     e.printStackTrace();
  43.                 }
  44.             }
  45.             if (conn!=null){
  46.                 try {
  47.                     conn.close();
  48.                 } catch (SQLException e) {
  49.                     e.printStackTrace();
  50.                 }
  51.             }
  52.             if (conn!=null){
  53.                 try {
  54.                     conn.close();
  55.                 } catch (SQLException e) {
  56.                     e.printStackTrace();
  57.                 }
  58.             }
  59.             if (rs!=null){
  60.                 try {
  61.                     rs.close();
  62.                 } catch (SQLException e) {
  63.                     e.printStackTrace();
  64.                 }
  65.             }
  66.         }
  67.     }
  68. }
4.2 遍历结果集
注意：
  • 游标向下移动一行，判断当前行是否是最后一行末尾，如果是末尾，返回false，如果有数据返回true
    • boolean next() 将光标从当前位置向前移动一行。
  • 判断是否有数据
  • 获取数据
  1. package cn.itcast.jdbc;
  3. import java.sql.*;
  5. /**
  6.  * 执行DDL语句
  7.  */
  8. public class JDBCDemo7 {
  9.     public static void main(String[] args) {
  10.         //删除王五
  11.         Statement stmt=null;
  12.         Connection conn=null;
  13.         ResultSet rs=null;
  14.         try {
  15.             //1.注册驱动
  16.             Class.forName("com.mysql.jdbc.Driver");
  17.             //2.获取连接对象
  18.             conn = DriverManager.getConnection("jdbc:mysql:///db3", "root", "root");
  19.             //3.定义sql
  20.             String sql="select * from account";
  21.             //4.获取执行sql的对象
  22.             stmt = conn.createStatement();
  23.             //5.执行sql
  24.             rs = stmt.executeQuery(sql);//资源需要关闭
  25.             //6.处理结果
  26.             // 6.1游标向下移动一行
  27.             while (rs.next()){
  28.                 //循环判断结果集是否有下一行
  29.                 //循环判断有标是否是最后一行末尾
  30.                 //6.2 获取数据
  31.                 int id = rs.getInt(1);
  32.                 String name = rs.getString("name");
  33.                 double balance = rs.getDouble(3);
  34.                 System.out.println(id+"---"+name+"---"+balance);
  35.             }
  36.         } catch (ClassNotFoundException e) {
  37.             e.printStackTrace();
  38.         } catch (SQLException e) {
  39.             e.printStackTrace();
  40.         }finally {
  41.             if (stmt!=null){
  42.                 try {
  43.                     stmt.close();
  44.                 } catch (SQLException e) {
  45.                     e.printStackTrace();
  46.                 }
  47.             }
  48.             if (conn!=null){
  49.                 try {
  50.                     conn.close();
  51.                 } catch (SQLException e) {
  52.                     e.printStackTrace();
  53.                 }
  54.             }
  55.             if (conn!=null){
  56.                 try {
  57.                     conn.close();
  58.                 } catch (SQLException e) {
  59.                     e.printStackTrace();
  60.                 }
  61.             }
  62.             if (rs!=null){
  63.                 try {
  64.                     rs.close();
  65.                 } catch (SQLException e) {
  66.                     e.printStackTrace();
  67.                 }
  68.             }
  69.         }
  70.     }
  71. }
4.3 JDBC练习_select语句
要求：查询emp表的数据，将其封装为对象，并打印
解决：通过集合，将对象装载到集合，并打印
    1. 定义Emp类
    2. 定义方法public List<Emp> findAll(){}
    3. 实现方法：select * from emp;
  1. package cn.itcast.domain;
  3. import java.util.Date;
  5. /**
  6.  * 对应封装emp表数据的javabean
  7.  */
  8. public class Emp {
  9.     private int id;
  10.     private String ename;
  11.     private int job_id;
  12.     private int mgr;
  13.     private Date joindate;
  14.     private double salary;
  15.     private double bonus;
  16.     private int dept_id;
  18.     public int getId() {
  19.         return id;
  20.     }
  22.     public void setId(int id) {
  23.         this.id = id;
  24.     }
  26.     public String getEname() {
  27.         return ename;
  28.     }
  30.     public void setEname(String ename) {
  31.         this.ename = ename;
  32.     }
  34.     public int getJob_id() {
  35.         return job_id;
  36.     }
  38.     public void setJob_id(int job_id) {
  39.         this.job_id = job_id;
  40.     }
  42.     public int getMgr() {
  43.         return mgr;
  44.     }
  46.     public void setMgr(int mgr) {
  47.         this.mgr = mgr;
  48.     }
  50.     public Date getJoindate() {
  51.         return joindate;
  52.     }
  54.     public void setJoindate(Date joindate) {
  55.         this.joindate = joindate;
  56.     }
  58.     public double getSalary() {
  59.         return salary;
  60.     }
  62.     public void setSalary(double salary) {
  63.         this.salary = salary;
  64.     }
  66.     public double getBonus() {
  67.         return bonus;
  68.     }
  70.     public void setBonus(double bonus) {
  71.         this.bonus = bonus;
  72.     }
  74.     public int getDept_id() {
  75.         return dept_id;
  76.     }
  78.     public void setDept_id(int dept_id) {
  79.         this.dept_id = dept_id;
  80.     }
  81.     @Override
  82.     public String toString() {
  83.         return "Emp{" +
  84.                 "id=" + id +
  85.                 ", ename='" + ename + '\'' +
  86.                 ", job_id=" + job_id +
  87.                 ", mgr=" + mgr +
  88.                 ", joindate=" + joindate +
  89.                 ", salary=" + salary +
  90.                 ", bonuds=" + bonus +
  91.                 ", dept_id=" + dept_id +
  92.                 '}';
  93.     }
  94. }
  1. package cn.itcast.jdbc;
  2. import cn.itcast.domain.Emp;
  3. import java.sql.*;
  4. import java.util.ArrayList;
  5. import java.util.List;
  6. /**
  7.  * 定义一个方法，查询emp表的数据将其封装为对象，然后装载集合，并返回
  8.  */
  9. public class JDBCDemo8 {
  10.     public static void main(String[] args) {
  11.         //想调用非静态方法，则需要创建对象
  12.         List<Emp> list = new JDBCDemo8().findAll();
  13.         System.out.println(list);
  14.     }
  15.     /**
  16.      * 查询所有emp对象
  17.      * @return
  18.      */
  19.     public List<Emp> findAll(){
  20.         Connection conn=null;
  21.         Statement stmt=null;
  22.         ResultSet rs=null;
  23.         List<Emp> list=null;
  24.         try {
  25.             //1.注册驱动
  26.             Class.forName("com.mysql.jdbc.Driver");//最好写，写上可以向下兼容
  27.             //2.获取连接
  28.             conn = DriverManager.getConnection("jdbc:mysql:///db3", "root", "root");
  29.             //3.定义sql
  30.             String sql="select * from emp";
  31.             //4.获取执行sql的对象
  32.             stmt = conn.createStatement();
  33.             //5.执行sql
  34.             rs = stmt.executeQuery(sql);
  35.             //6.遍历结果集，封装对象，装载集合
  36.             Emp emp=null;
  37.             list = new ArrayList<>();
  38.             while(rs.next()){
  39.                 //获取数据
  40.                 int id = rs.getInt("id");
  41.                 String ename = rs.getString("ename");
  42.                 int job_id = rs.getInt("job_id");
  43.                 int mgr = rs.getInt("mgr");
  44.                 //怎么把光标放上就能显示概述？
  45.                 //Date是sql包下的类，继承了util的date，子类继承父类
  46.                 Date joindate = rs.getDate("joindate");
  47.                 double salary = rs.getDouble("salary");
  48.                 double bonus = rs.getDouble("bonus");
  49.                 int dept_id = rs.getInt("dept_id");
  50.                 //封装对象，对象引用复用
  51.                 emp=new Emp();
  52.                 emp.setId(id);
  53.                 emp.setBonus(bonus);
  54.                 emp.setDept_id(dept_id);
  55.                 emp.setEname(ename);
  56.                 emp.setJoindate(joindate);
  57.                 emp.setMgr(mgr);
  58.                 emp.setSalary(salary);
  59.                 list.add(emp);
  60.             }
  61.         } catch (ClassNotFoundException e) {
  62.             e.printStackTrace();
  63.         } catch (SQLException e) {
  64.             e.printStackTrace();
  65.         }finally {
  66.             if (conn!=null){
  67.                 try {
  68.                     conn.close();
  69.                 } catch (SQLException e) {
  70.                     e.printStackTrace();
  71.                 }
  72.             }
  73.             if (stmt!=null){
  74.                 try {
  75.                     stmt.close();
  76.                 } catch (SQLException e) {
  77.                     e.printStackTrace();
  78.                 }
  79.             }
  80.             if (rs!=null){
  81.                 try {
  82.                     rs.close();
  83.                 } catch (SQLException e) {
  84.                     e.printStackTrace();
  85.                 }
  86.             }
  87.         }
  88.         return list;
  89.     }
  90. }
5.抽取JDBC工具类：JDBCUtils
分析：
上述代码重复度太高，每次都要注册驱动，每次都要获取连接对象
目标：
写工具类，简化代码，简化以后书写的操作
内容：
  • 注册驱动也抽取
  • 抽取一个方法，获取连接对象
    • 需求：不想传递参数（麻烦），还要保证工具类的通用性
    • 解决方案：通过配置文件解决此问题
      • jdbc.properties
        • url=
        • user=
        • password=
  • 抽取一个方法，释放资源
  1. package cn.itcast.utils;
  2. import java.io.FileReader;
  3. import java.io.IOException;
  4. import java.net.URL;
  5. import java.sql.*;
  6. import java.util.Properties;
  8. /**
  9.  * JDBC工具类
  10.  * 一个获取连接的方法
  11.  * 一个释放资源的方法
  12.  */
  13. public class JDBCUtils {
  14.     private static String url;
  15.     private static String user;
  16.     private static String password;
  17.     private static String driver;
  18.     /**
  19.      * 文件的读取，只需要读取一次就可以拿到这些值
  20.      * 方案：通过静态代码块
  21.      */
  22.     static{
  23.         //读取配置资源文件，获取值
  24.         //BufeeredReader。。。麻烦
  25.         try {
  26.             //1.创建Properties集合类
  27.             Properties prop=new Properties();
  28.             //2.加载文件，代码提示
  29.             //prop.load(new FileReader("src/jdbc.properties"));
  30.             //找不到资源文件，最笨的方法---可以写绝对路径D:\IdeaProjects\liujinhui\day04_jdbc_20201220\src\jdbc.properties
  31.             //另外：获取src路径下的文件--->ClassLoader  类加载器：可以 加载字节码文件进内存，同时可以获取src下的资源文件
  32.             ClassLoader classLoader = JDBCUtils.class.getClassLoader();
  33.             //传的是以src相对的文件路径
  34.             //返回统一资源定位符，即文件的绝对路径
  35.             URL res= classLoader.getResource("jdbc.properties");
  36.             String path = res.getPath();
  37.             System.out.println(path);
  38.             prop.load(new FileReader(path));
  39.             //3.获取数据，赋值
  40.             url=prop.getProperty("url");
  41.             user=prop.getProperty("user");
  42.             password=prop.getProperty("password");
  43.             driver=prop.getProperty("driver");
  44.             //4.注册驱动
  45.             Class.forName(driver);
  46.         } catch (IOException e) {
  47.             e.printStackTrace();
  48.         } catch (ClassNotFoundException e) {
  49.             e.printStackTrace();
  50.         }
  51.     }
  52.     //Arrays等都是静态，方便类直接调用
  53.     /**
  54.      * 获取连接的工具方法
  55.      * @return 连接对象
  56.      */
  57.     //String url,String root,String password有参数仍然很麻烦
  58.     //通过私有变量、配置文件及静态代码块解决
  59.     public static Connection getConnection() throws SQLException{
  60.         return DriverManager.getConnection(url,user,password);
  61.     }
  62.     /**
  63.      * 释放资源
  64.      * @param stmt
  65.      * @param conn
  66.      */
  67.     public static void close(Statement stmt,Connection conn){
  68.         if (stmt!=null){
  69.             try {
  70.                 stmt.close();
  71.                 //conn.close();多个语句要放到多个try..catch中
  72.             } catch (SQLException e) {
  73.                 e.printStackTrace();
  74.             }
  75.         }
  76.         if (conn!=null){
  77.             try {
  78.                 conn.close();
  79.             } catch (SQLException e) {
  80.                 e.printStackTrace();
  81.             }
  82.         }
  83.     }
  84.     /**
  85.      * 释放资源
  86.      * @param rs
  87.      * @param stmt
  88.      * @param conn
  89.      */
  90.     public static void close(ResultSet rs, Statement stmt, Connection conn){
  91.         if (stmt!=null){
  92.             try {
  93.                 stmt.close();
  94.                 //conn.close();多个语句要放到多个try..catch中
  95.             } catch (SQLException e) {
  96.                 e.printStackTrace();
  97.             }
  98.         }
  99.         if (conn!=null){
  100.             try {
  101.                 conn.close();
  102.             } catch (SQLException e) {
  103.                 e.printStackTrace();
  104.             }
  105.         }
  106.         if (rs!=null){
  107.             try {
  108.                 rs.close();
  109.             } catch (SQLException e) {
  110.                 e.printStackTrace();
  111.             }
  112.         }
  113.     }
  114. }
  1. package cn.itcast.jdbc;
  2. import cn.itcast.domain.Emp;
  3. import cn.itcast.utils.JDBCUtils;
  5. import java.sql.*;
  6. import java.util.ArrayList;
  7. import java.util.List;
  8. /**
  9.  * 定义一个方法，查询emp表的数据将其封装为对象，然后装载集合，并返回
  10.  */
  11. public class JDBCDemo8 {
  12.     public static void main(String[] args) {
  13.         //想调用非静态方法，则需要创建对象
  14.         List<Emp> list = new JDBCDemo8().findAll2();
  15.         System.out.println(list);
  16.     }
  17.     /**
  18.      * 演示JDBC工具类
  19.      * @return
  20.      */
  21.     public List<Emp> findAll2(){
  22.         Connection conn=null;
  23.         Statement stmt=null;
  24.         ResultSet rs=null;
  25.         List<Emp> list=null;
  26.         try {
  27.             //1.注册驱动
  28.             //Class.forName("com.mysql.jdbc.Driver");//最好写，写上可以向下兼容
  29.             //2.获取连接
  30.             //conn = DriverManager.getConnection("jdbc:mysql:///db3", "root", "root");
  31.             conn=JDBCUtils.getConnection();
  32.             //3.定义sql
  33.             String sql="select * from emp";
  34.             //4.获取执行sql的对象
  35.             stmt = conn.createStatement();
  36.             //5.执行sql
  37.             rs = stmt.executeQuery(sql);
  38.             //6.遍历结果集，封装对象，装载集合
  39.             Emp emp=null;
  40.             list = new ArrayList<>();
  41.             while(rs.next()){
  42.                 //获取数据
  43.                 int id = rs.getInt("id");
  44.                 String ename = rs.getString("ename");
  45.                 int job_id = rs.getInt("job_id");
  46.                 int mgr = rs.getInt("mgr");
  47.                 //怎么把光标放上就能显示概述？
  48.                 //Date是sql包下的类，继承了util的date，子类继承父类
  49.                 Date joindate = rs.getDate("joindate");
  50.                 double salary = rs.getDouble("salary");
  51.                 double bonus = rs.getDouble("bonus");
  52.                 int dept_id = rs.getInt("dept_id");
  53.                 //封装对象，对象引用复用
  54.                 emp=new Emp();
  55.                 emp.setId(id);
  56.                 emp.setBonus(bonus);
  57.                 emp.setDept_id(dept_id);
  58.                 emp.setEname(ename);
  59.                 emp.setJoindate(joindate);
  60.                 emp.setMgr(mgr);
  61.                 emp.setSalary(salary);
  62.                 list.add(emp);
  63.             }
  64.         }catch (SQLException e) {
  65.             e.printStackTrace();
  66.         }finally {
  67.             JDBCUtils.close(rs,stmt,conn);
  68.         }
  69.         return list;
  70.     }
  71.     /**
  72.      * 查询所有emp对象
  73.      * @return
  74.      */
  75.     public List<Emp> findAll(){
  76.         Connection conn=null;
  77.         Statement stmt=null;
  78.         ResultSet rs=null;
  79.         List<Emp> list=null;
  80.         try {
  81.             //1.注册驱动
  82.             Class.forName("com.mysql.jdbc.Driver");//最好写，写上可以向下兼容
  83.             //2.获取连接
  84.             conn = DriverManager.getConnection("jdbc:mysql:///db3", "root", "root");
  85.             //3.定义sql
  86.             String sql="select * from emp";
  87.             //4.获取执行sql的对象
  88.             stmt = conn.createStatement();
  89.             //5.执行sql
  90.             rs = stmt.executeQuery(sql);
  91.             //6.遍历结果集，封装对象，装载集合
  92.             Emp emp=null;
  93.             list = new ArrayList<>();
  94.             while(rs.next()){
  95.                 //获取数据
  96.                 int id = rs.getInt("id");
  97.                 String ename = rs.getString("ename");
  98.                 int job_id = rs.getInt("job_id");
  99.                 int mgr = rs.getInt("mgr");
  100.                 //怎么把光标放上就能显示概述？
  101.                 //Date是sql包下的类，继承了util的date，子类继承父类
  102.                 Date joindate = rs.getDate("joindate");
  103.                 double salary = rs.getDouble("salary");
  104.                 double bonus = rs.getDouble("bonus");
  105.                 int dept_id = rs.getInt("dept_id");
  106.                 //封装对象，对象引用复用
  107.                 emp=new Emp();
  108.                 emp.setId(id);
  109.                 emp.setBonus(bonus);
  110.                 emp.setDept_id(dept_id);
  111.                 emp.setEname(ename);
  112.                 emp.setJoindate(joindate);
  113.                 emp.setMgr(mgr);
  114.                 emp.setSalary(salary);
  115.                 list.add(emp);
  116.             }
  117.         } catch (ClassNotFoundException e) {
  118.             e.printStackTrace();
  119.         } catch (SQLException e) {
  120.             e.printStackTrace();
  121.         }finally {
  122.             if (conn!=null){
  123.                 try {
  124.                     conn.close();
  125.                 } catch (SQLException e) {
  126.                     e.printStackTrace();
  127.                 }
  128.             }
  129.             if (stmt!=null){
  130.                 try {
  131.                     stmt.close();
  132.                 } catch (SQLException e) {
  133.                     e.printStackTrace();
  134.                 }
  135.             }
  136.             if (rs!=null){
  137.                 try {
  138.                     rs.close();
  139.                 } catch (SQLException e) {
  140.                     e.printStackTrace();
  141.                 }
  142.             }
  143.         }
  144.         return list;
  145.     }
  146. }
知识点：自定义工具类、配置文件、静态代码块
6.JDBC练习_登录案例
练习：
  • 通过键盘录入用户名和密码
  • 判断用户名是否登录成功select * from user where username="" and password="";
    • 如果此SQL有查询结果 ，则成功
步骤：
  • 创建一个数据库表user
  1. CREATE TABLE USER(
  2. 	id INT PRIMARY KEY AUTO_INCREMENT,
  3. 	username VARCHAR(32),
  4. 	PASSWORD VARCHAR(32)
  5. );
  6. SELECT * FROM USER;
  7. INSERT INTO USER VALUES(NULL,"zhangsan","123");
  8. INSERT INTO USER VALUES(NULL,"lisi","123");
  • 代码实现--创建登录方法
  1. package cn.itcast.jdbc;
  2. import cn.itcast.utils.JDBCUtils;
  3. import java.sql.Connection;
  4. import java.sql.ResultSet;
  5. import java.sql.SQLException;
  6. import java.sql.Statement;
  7. import java.util.Scanner;
  8. /**
  9.  * 练习：
  10.  通过键盘录入用户名和密码
  11.  判断用户名是否登录成功
  12.  */
  13. public class JDBCDemo9 {
  14.     public static void main(String[] args) {
  15.         //1.键盘录入，接收用户名和密码
  16.         Scanner sc=new Scanner(System.in);
  17.         System.out.println("请输入用户名：");
  18.         String username = sc.nextLine();
  19.         System.out.println("请输入密码：");
  20.         String password = sc.nextLine();
  21.         //2.调用方法
  22.         //静态调用非静态需要声明对象
  23.         boolean flag = new JDBCDemo9().login(username, password);
  24.         //3.判断结果，输出不同语句
  25.         if (flag){
  26.             //登录成功
  27.             System.out.println("登录成功");
  28.         }else{
  29.             System.out.println("用户名或密码错误");
  30.         }
  31.         //2.调用方法
  32.         //3.判断结果，输出不同语句
  33.     }
  34.     /**
  35.      * 登录方法
  36.      */
  37.     public boolean login(String username ,String password){
  38.         if (username==null||password==null){
  39.             return false;
  40.         }
  41.         Connection conn=null;
  42.         Statement stmt=null;
  43.         ResultSet rs=null;
  44.         try {
  45.             //连接数据库判断是否登录成功
  46.             //1.获取连接，更改数据库只需要修改配置文件，可扩展性强
  47.              conn = JDBCUtils.getConnection();
  48.             //2.定义 sql
  49.             String sql="select * from user where username='"+username+"' and password='"+password+"'";
  50.             //3.获取执行SQL的对象
  51.              stmt = conn.createStatement();
  52.             //4.执行查询
  53.              rs = stmt.executeQuery(sql);
  54.             //5.判断
  55.             /*if (rs.next()){
  56.                 return  true;
  57.             }else{
  58.                 return false;
  59.             }*/
  60.             //直接返回
  61.             return rs.next();
  62.         } catch (SQLException e) {
  63.             e.printStackTrace();
  64.         }finally {
  65.             JDBCUtils.close(rs,stmt,conn);
  66.         }
  67.         return false;
  68.     }
  69. }
7.JDBC各个类详解_PreparedStatement
上述方法存在的问题 ：
  • SQL注入问题：在拼接sql时，有一些sql的特殊关键字参与字符串的拼接，会造成安全性问题
    • 输入密码时输入：a' or 'a' = 'a ，可以登录成功
    • 输出的SQL语句：select * from user where username='dsgdf' and password='a' or 'a' = 'a'
    • 在 sqlyog中可以 查到所有记录
  • 解决sql注入问题：使用PreparedStatement对象来解决
    • 是statement的子接口，是 一个预编译的接口
    • 预编译的sql：参数使用？作为占位符
  • 使用步骤
    • 导入驱动jar包
    • 注册驱动
    • 获取数据库的连接对象Connection（java和数据库的桥梁对象）
    • 定义SQL语句
      • 注意：SQL的参数使用？作为占位符
      • 如：select * from user where username=？  and password=?
    • 获取执行SQL语句的对象PreparedStatement   PreparedStatement prepareStatement(String sql)
    • 给？赋值
      • 方法：setXXX(参数1，参数 2)
      • 参数 1：？的位置，从1开始
      • 参数2：？的值
    • 执行SQL，接收返回的结果，不需要传递 SQL语句ResultSet executeQuery()
    • 处理结果
    • 释放资源，不释放容易造成内存的泄露问题
  • 注意：后期都会使用PreparedStatement对象来完成增删改查 操作
    • 可以防止SQL注入
    • 效率更高
  1. package cn.itcast.jdbc;
  3. import cn.itcast.utils.JDBCUtils;
  5. import java.sql.*;
  6. import java.util.Scanner;
  8. /**
  9.  * 使用PrepareStatement实现登录操作
  10.  * 练习：
  11.  通过键盘录入用户名和密码
  12.  判断用户名是否登录成功
  13.  */
  14. public class JDBCDemo10 {
  15.     public static void main(String[] args) {
  16.         //1.键盘录入，接收用户名和密码
  17.         Scanner sc=new Scanner(System.in);
  18.         System.out.println("请输入用户名：");
  19.         String username = sc.nextLine();
  20.         System.out.println("请输入密码：");
  21.         String password = sc.nextLine();
  22.         //2.调用方法
  23.         //静态调用非静态需要声明对象
  24.         boolean flag = new JDBCDemo10().login(username, password);
  25.         //3.判断结果，输出不同语句
  26.         if (flag){
  27.             //登录成功
  28.             System.out.println("登录成功");
  29.         }else{
  30.             System.out.println("用户名或密码错误");
  31.         }
  33.         //2.调用方法
  35.         //3.判断结果，输出不同语句
  36.     }
  37.     /**
  38.      * 登录方法
  39.      */
  40.     public boolean login(String username ,String password){
  41.         if (username==null||password==null){
  42.             return false;
  43.         }
  44.         Connection conn=null;
  45.         PreparedStatement pstmt=null;
  46.         ResultSet rs=null;
  47.         try {
  48.             //连接数据库判断是否登录成功
  49.             //1.获取连接，更改数据库只需要修改配置文件，可扩展性强
  50.              conn = JDBCUtils.getConnection();
  51.             //2.定义 sql
  52.             String sql="select * from user where username= ? and password= ?";
  53.             //System.out.println(sql);
  54.             //3.获取执行SQL的对象
  55.              pstmt = conn.prepareStatement(sql);
  56.              //给 ？赋值
  57.             pstmt.setString(1,username);
  58.             pstmt.setString(2,password);
  59.             //4.执行查询
  60.              rs =pstmt.executeQuery();
  61.             //5.判断
  62.             /*if (rs.next()){
  63.                 return  true;
  64.             }else{
  65.                 return false;
  66.             }*/
  67.             //直接返回
  68.             return rs.next();
  69.         } catch (SQLException e) {
  70.             e.printStackTrace();
  71.         }finally {
  72.             JDBCUtils.close(rs,pstmt,conn);
  73.         }
  74.         return false;
  75.     }
  76. }
三、使用JDBC控制事务
1.事务：包含多个步骤的业务操作，如果这个业务操作被事务管理，则这多个事务要么同时成功，要么同时失败
2.操作
  • 开启事务
  • 提交事务
  • 回滚事务
3.回顾：Connection对象可以进行获取连接和管理事务
使用Connection对象管理事务
  • 三个方法--开启事务：void setAutoCommit(boolean autoCommit) 调用此方法设置false，即开启事务并不自动提交
  • 三个方法--提交事务：void commit() 提交事务
  • 三个方法--回滚事务：void rollback() 回滚事务
4.银行转账案例--JDBC控制事务 
  1. package cn.itcast.jdbc;
  3. import cn.itcast.utils.JDBCUtils;
  5. import java.sql.Connection;
  6. import java.sql.PreparedStatement;
  7. import java.sql.SQLException;
  9. /**
  10.  * 事务操作
  11.  */
  12. public class JDBCDemo11 {
  14.     public static void main(String[] args) {
  15.         Connection conn=null;
  16.         PreparedStatement pstmt1=null;
  17.         PreparedStatement pstmt2=null;
  18.         try {
  19.             //1.获取连接
  20.             conn = JDBCUtils.getConnection();
  21.             //开启事务
  22.             conn.setAutoCommit(false);
  23.             //2,定义SQL
  24.             //2.1 张三-500
  25.             //String sql1="update account set balance=balance-500 where id=1";
  26.             //2.2 李四+500
  27.             //String sql2="update account set balance=balance+500 where id=2";
  28.             //通用写法
  29.             String sql1="update account set balance=balance-? where id=?";
  30.             String sql2="update account set balance=balance+? where id=?";
  31.             //3.获取执行sql对象
  32.             pstmt1 = conn.prepareStatement(sql1);
  33.             pstmt2= conn.prepareStatement(sql2);
  34.             //代码格式化快捷键
  35.             //4.设置参数
  36.             pstmt1.setDouble(1,500);
  37.             pstmt1.setInt(2,1);
  38.             pstmt2.setDouble(1,500);
  39.             pstmt2.setInt(2,2);
  40.             //5.执行SQL
  41.             pstmt1.executeUpdate();
  42.             //手动制造异常
  43.             int i=3/0;
  44.             pstmt2.executeUpdate();
  45.             //提交事务
  46.             conn.commit();
  47.             //使用大异常
  48.         } catch (Exception e) {
  49.             try {
  51.                 //事务回滚，前提不为null
  52.                 if (conn!=null){
  53.                     conn.rollback();
  54.                 }
  55.             } catch (SQLException e1) {
  56.                 e1.printStackTrace();
  57.             }
  58.             e.printStackTrace();
  59.         }finally {
  60.             JDBCUtils.close(pstmt1,conn);
  61.             JDBCUtils.close(pstmt2,null);
  62.         }
  64.     }
  65. }
在执行sql之前开启事务
在当所有sql执行完提交事务
在 catch中回滚事务

JavaEE Day05 JDBC（用Java语言操作数据库）的更多相关文章

  1. Java数据库连接——JDBC基础知识（操作数据库：增删改查）

    一.JDBC简介 JDBC是连接java应用程序和数据库之间的桥梁. 什么是JDBC? Java语言访问数据库的一种规范,是一套API. JDBC (Java Database Connectivit ...

  2. Java程序操作数据库SQLserver详解

    数据库基本操作:增删改查(CRUD) crud介绍(增.删.改.查操作) CRUD是指在做计算处理时的增加(Create).查询(Retrieve)(重新得到数据).更新(Update)和删除(Del ...

  3. 39.C语言操作数据库

    一.准备工作: sqlite3工具集:链接:https://pan.baidu.com/s/1mjufXZa 密码:2ui7 安装步骤: 打开如下文件夹,找到sqlite3.dll,并放入系统目录 2 ...

  4. 借助Java的JDBC自制“DBMS”管理操作数据库

    package jdbc; import java.sql.Connection; import java.sql.Driver; import java.sql.DriverManager; imp ...

  5. JDBC（用Eclipse操作数据库Oracle）的基础操作集合

    JDBC: JDBC(Java Data Base Connectivity,java数据库连接)是一种用于执行SQL语句的Java API,可以为多种关系数据库提供统一访问,它由一组用Java语言编 ...

  6. R语言操作数据库

    以下内容出自http://www.douban.com/note/172387172/ CRAN上有很多R的数据库支持包,使R能够对数据库进行读写操作.这些包有:RODBC.DBI.RMySQL.RO ...

  7. （1）JDBC基础-java链接mysql数据库

    怎么操作数据库: 1,通过客户端(比如mac的终端,或者sql pro等专业工具)登陆数据库服务器(mysql -u root -p) 2,编写sql语句 3,发生sql语句到数据库服务器执行. JD ...

  8. IDEA用Maven连接MySQL的jdbc驱动，并操作数据库

    1.在IDEA里创建Maven项目 1.1.点击Create New Project   1.2.选择Maven,JDK这里用的是1.8,点击Next  1.3.填入“组织名”.“项目名”,版本是默认 ...

  9. IDEA导入MySQL的jdbc驱动，并操作数据库

    将MySQL的jdbc驱动,导入IDEA的方式,虽然也能连接并且操作数据库,但并不推荐这种方式,推荐使用Maven工程的方式:https://www.cnblogs.com/dadian/p/1193 ...

  10. 【JDBC】Java程序的数据库初体验

    JDBC是什么 JDBC是一种能够用来执行SQL语句的Java API[接口]. 它是Java提供的一种规范,让各大数据库厂商遵循此规范完成自己的数据库连接驱动[实现接口]. JDBC的入门程序(这里 ...

随机推荐

  1. 前端实现docx、pdf格式文件在线预览

    theme: vuepress highlight: atelier-heath-light 介绍 在业务中,如果遇到文档管理类的功能,会出现需要在线预览的业务需求,本文主要是通过第三方库来实现文档预 ...

  2. 关于使用kuboard安装其自带的监控应用授权普通用户使用

    官方文档地址:https://www.kuboard.cn/guide/example/monitor-v2.html#授权用户访问套件

  3. CentOS6 配置阿里云 NTP 服务

    本文以Centos 6.5为例介绍如何修改Linux实例时区,以及开启和配置Linux NTP服务,保证实例本地时间精确同步. 前提条件 NTP服务的通信端口为UDP 123,设置NTP服务之前请确保 ...

  4. 关闭You have new mail in /var/spool/mail/root提醒

    echo "unset MAILCHECK">> /etc/profile #以root权限执行 或者用sudo source /etc/profile cat /de ...

  5. PHP全栈开发（八）：CSS Ⅲ background

    设置背景颜色: div { background-color:#b0c4de; } 不仅可以给body标签设置背景颜色,还能给p,div,h标签设置背景颜色 设置背景图片: body { backgr ...

  6. 从源码分析 MGR 的新主选举算法

    MGR 的新主选举算法,在节点版本一致的情况下,其实也挺简单的. 首先比较权重,权重越高,选为新主的优先级越高. 如果权重一致,则会进一步比较节点的 server_uuid.server_uuid 越 ...

  7. 关于javascript:void(0) 在不用的浏览器当中的表现

    原因在于三款浏览器,对三个属性的处理顺序不同. Chrome顺序:onclick -> href -> target IE和Firefox顺序:onclick -> target - ...

  8. Windows活动目录_票据——敬请期待！

    票据:域控&域机子之间的信任密钥 [缺省40天更换一次] 域用户登录过程 域用户的账户密码(用信任密钥加密的)传递至域控: 域控验证账户密码成功后,构造域用户SID和组SID(用信任密钥加密的 ...

  9. Redis5种数据类型

    字符串 @GetMapping("/string") public String stringTest(){ redisTemplate.opsForValue().set(&qu ...

  10. 一天十道Java面试题----第四天（线程池复用的原理------＞spring事务的实现方式原理以及隔离级别）

    这里是参考B站上的大佬做的面试题笔记.大家也可以去看视频讲解!!! 文章目录 31.线程池复用的原理 32.spring是什么? 33.对Aop的理解 34.对IOC的理解 35.BeanFactor ...