JDBC原理实现详解

最新推荐文章于 2025-04-21 15:22:45 发布
最新推荐文章于 2025-04-21 15:22:45 发布
阅读量3.4k 收藏 21
点赞数 6
分类专栏： jdbc 文章标签： mysql 数据库 jdbc java 事务
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_44766232/article/details/121377242
版权

看目录

JDBC

一、JDBC是什么？

​ Java DataBase Connectivity（Java语言连接数据库）

二、JDBC的本质是什么？

JDBC是SUN公司制定的一套接口（interface）
​ java.sql.*; (这个软件包下有很多接口。)

接口都有调用者和实现者。
面向接口调用、面向接口写实现类，这都属于面向接 口编程。

为什么要面向接口编程？
解耦合：降低程序的耦合度，提高程序的扩展力，程序更灵活，高内聚，低耦合
多态机制就是非常典型的：面向抽象编程。（不要面向具体编程）
建议：

Animal a = new Cat();
		Animal a = new Dog();
		// 喂养的方法
		public void feed(Animal a){ // 面向父类型编程。
	}

不建议：

	Dog d = new Dog();
	Cat c = new Cat();

JDBC的本质：一套接口

三、JDBC的意义

​ 每一个数据库的底层实现原理都不一样。
​ Oracle数据库有自己的原理。
​ MySQL数据库也有自己的原理。
​ MS SqlServer数据库也有自己的原理。
​ …
​ 每一个数据库产品都有自己独特的实现原理。
​ 如果没有接口，当java要连接不同数据库就需要多套对应的实现程序
​ 实现方是数据库厂家，负责编写JDBC接口的实现类，每个公司的jar包就是驱动，MySQL公司的就是MySQL驱动，Oracle公司的是Oracle驱动，所有的数据库驱动都是以jar包的形式存在，jar包当中有很多.class文件，这些文件就是对JDBC接口的实现，驱动不是SUM公司提供的，是各大数据库厂家负责提供，下载驱动jar包需要去数据库官网下载x
​ 接口由SUM提供，只有一个，
​ 最后程序员调用接口，面向JDBC编程
​ jdk文档中javasql里的接口就是JDBC

3、JDBC开发前的准备工作，先从官网下载对应的驱动jar包，然后将其配置到环境变量classpath当中。

classpath=.;D:\course\06-JDBC\resources\MySql Connector Java 5.1.23\mysql-connector-java-5.1.23-bin.jar

请添加图片描述

配置classpath的本质是我作为程序员,想要调用JDBC实现类(驱动),就先得给类加载器打招呼,让类加载器去指定路径下找(环境变量),这里这个过程由应用类加载器去找

以上的配置是针对于文本编辑器的方式开发，使用IDEA工具的时候，不需要配置以上的环境变量。
IDEA有自己的配置方式。

四、JDBC编程六步

第一步：注册驱动（告诉Java程序即将连接的是哪个数据库）

第二部：获取连接（表示jvm的进程和数据库进程之间的通道打开了，属于进程间通讯，是重量级的，使用完之后一定要关闭通道）

第三步：获取数据库操作对象（专门执行sql语句的对象）

第四步：执行sql语句（DQL、DML…）

第五步：处理查询结果集（只有第四步执行的是select语句的时候才有第五步，如果不是select语句直接到第六步）

第六步：释放资源、关闭连接（使用完资源之后一定要关闭资源，Java和数据库之间属于进程间的通信，开启之后一定要关闭）

//导包

import java.sql.Dirver;
import java.sql.Manager;
import java.sql.SQLException;
import java.sql.Connection; 
import java.sql.Statement;

 public class JDBCTest01{
​	public static void main(String[] args){
		Connection conn = null;
    	Statement stmt = null;

​		try{
    ​		//1.注册驱动
​			Dirver dirver = new com.mysql.Dirver(); ————MySQL
    		Dirver dirver = new oracle.jdbc.driver.OracleDriver(); ————Oracle
​			//多态，父类型引用指向子类型对象，等号前面是接口，等号后面是实现类
​			DirverManager.registerDirver(dirver);

​			//2.获取连接
​			//连接其他地方的数据库必须知道该数据库的IP、端口、数据库名、用户名、密码...
​			//getConnection()方法，返回连接对象，连接对象Connection也是一个接口，参数：url、user、password
    		String url = "jdbc:mysql://127.0.0.1：3306/bjpowernode";
    			/*
    				url: 统一资源定位符，网络中某个资源的绝对路径
    				http://www.baidu.com：这就是URL
    				URL包括：协议、IP、PORT、资源名
    				
    				http://182.61.200.7:80/index.html
    					http:// 通讯协议
    					182.61.200.7 服务器IP地址
    					80 服务器上软件的端口
    					index.heml 是服务器上某个资源名
    					
    				String url = "jdbc:mysql://127.0.0.1：3306/bjpowernode";
    					jdbc:mysql:// 协议
    					127.0.0.1 IP地址
    					3306 mysql数据库端口号
    					bjpowernode 具体的数据库实例名
    				
    				localhost 和 127.0.0.1都是本机IP地址
    				什么是通信协议：是通信之前就提前设定好的数据传输格式，表明数据包具体怎么传递数据，格式提前订好
    				
    				Oracle的URL：
    					jdbc:oracle:thin:@localhost:1521:orcl
    					协议(jdbc)
    					子协议(oracle:thin)
    					数据源标识(@localhost:1521:orcl)
    					IP地址(localhost)
    					端口号(1521)
    					具体数据库实例名（orcl）
    			*/
    		String user = "root";
    		String password = "333";
    		conn = DriverManager.getConnection(url,uesr,password);
    		//返回一个连接对象给conn, conn就可以调用接口的方法
    		System.out.println("数据库连接对象 = " + conn );
    		//结果：conn = com.mysql.jdbc.JDBC4Connection@41cf53f9
    
    ​		//3.获取数据库操作对象(Statement专门执行sql语句)
    		stamt = conn.createStatement();

    ​		//4.执行sql语句
        	String sql = "insert into dept(deptno,dname,loc) values(50,"人事部","北京")";
    		//以下executeUpdate专门执行DML语句的（insert delete update）
    		//返回值count是“影响底层数据库中的记录条数”
    		//插入两条数据返回2，删除三条数据返回3，更新五条数据返回5
    		int count = stmt.executeUpdate(sql);
    		System.out.println(count == 1 ? "执行成功" : "执行失败！");
    		
    ​		//5.执行查询结果集
    
        
​		}catch(SQLException){
​				e.printStackTrace();

​		}finally{
    		//1. 为了保证资源一定释放，释放语句放在finally代码块中
    		//2. 并且关闭遵循从小到大原则，通过connection对象开启的statement,就得先关闭statement再关闭connection
    		//3. 关闭语句要分别对其try..catch
    		try{
                if(stmt != null){
                    stmt.close();
                }catch(SQLException e){
                    e.printStackTrace();
                }
            }
    		try{
                if(conn != null){
                    conn.close();
                }catch(SQLException e){
                    e.printStackTrace();
                }
            }
    		
		}

​	}

}

请添加图片描述
请添加图片描述

JDBC+DML

import java.sql.*;

public class JDBCTest02{
	puclic static void main(String[] args){
        Connection conn = null;
        Statrment stmt = null;
        try{
            //1.注册驱动
            Dirver dirver = new com.mysql.jdbc.Dirver
            DriverManager.registerDriver(dirver);
            //2.获取连接
            conn = DirverManager.geConnection(
                "jdbc:mysql://localhost:3306/bjpowernode","root","333");
            //3.获取数据库操作对象
			stmt = conn.createStatement();
            //4.执行sql语句
            String sql = "update dept set dname = "销售部", loc = "天津" where deptno = 20";
            int count = stmt.executeUpdate(sql);
            System.out.println(count = 1 ? "删除成功" : "删除失败");
            //5.执行查询结果集
        }catch(SQLException e){
            e.printStackTrace();
        }finally{
            //6.释放资源，关闭通道
            if(stmt != null){
                try{
                    stmt.close();
                }catch(SQLException e){
                    e.printStackTrace();
                }
            }
            if(conn != null){
                try{
                    conn.close();
                }catch(SQLException e){
                    e.printStackTrace();
                }
            }
        }
    }


}

五、JDBC注册驱动常用方式

如何让一个类的静态代码块执行：只需要加载这个类就好，
所以直接反射这个class文件，这个类就会被加载进JVM，静态代码块在类加载时执行，所以就注册了
就是利用反射来加载Driver类，使类利用类中的静态代码块实现对驱动的注册

利用类加载机制，让类的静态代码块执行，在静态代码块中发现其完成了驱动的注册
发射机制：Class.forname(); 完成类加载

优势：
双引号里面参数是字符串，字符串可以写到配置文件当中，字符串可以写到xxx.properties文件中

import java.sql.*;

public static JDBCTest03{
	public static void main(String[] args){
        Connection conn = null;
        Statement stmt = null;
		try{
            
            //1. 注册驱动
			Class.forName("com.mysql.jdbc.Driver");	//参数为驱动的类名，类加载
            
            //2. 获取链接conn
			Connection conn = DriverManager.getConnection
			("jdbc:mysql://localhost:3306/bjpowernode","root","333");
			System.out.println(conn);
            //3. 获取数据库操作对象stmt
            Statement stmt = conn.createStatement();
            //4. 执行SQL语句
            String sql = "delate from dept where deptno = 20";
            int count = stmt.executeUpdate(sql);
            System.out,println(count = 1 ? "删除成功" : "删除失败");
            //5. 执行查询结果集
		}catch（SQLException e）{
			e.printStackTrace();
		}finally{
            //6. 关闭连接，释放资源
            if(stmt != null){
                stmt.close();
            }catch(SQLException e){
                e.printStackTrace();
            }
            if(conn != null){
                try{
                    conn.close();
                }catch(SQLException e){
                    e.printStackTrace();
                }
            }
        }

	}
}

六、从属性资源文件中读取连接数据库资源

将接数据库的所有信息配置到配置文件jdbc.propertier中

创建配置文件 jdbc.propertier：

driver = com.mysql.jdbc.Driver

url = jdbc:mysql://localhost:3306/bjpowernode

user = root

pssword = 333

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

public static JDBCTest04{
	public static void main(String[] args){
        
        //使用资源绑定器绑定属性配置文件
        ResoutceBundle bundle = ResourceBundle.getBundle("jdbc");
        String driver = bundle.getString("driver");
        String url = bundle.getString("url");
        String user = bundleString("user");
        String password = bundleString("password");
        
        Connection conn = null;
        Statement stmt = null;
		try{
            //1. 注册驱动
            Class.forName(driver);
            //2. 获取链接
            conn = DriverManager.getConnectiion(url,user,password);
            //3. 获取数据库操作对象
            stmt = conn.createrStatement();
            //4. 执行SQL语句
            String sql = "update dept set dname = '销售部',loc = '天津' where deptno = 20";
            int count = stmt.executeUpdate(sql);
            System.out.println(count = 1 ? "修改成功" : "修改失败");
            //5. 执行查询结果集
        }catch(SQLException e){
            e.printStackTrace();
        }finally{
            
            //6.关闭通道，脂肪资源 
            if(stmt != null){
                try{
                    stmt.close();
                }catch(SQLException e){
                    e.printSackTrace();
                }
            }
            if(conn != null){
                try{
                	conn.cloce();
                }catch(SQLException e){
                	e.printStackTrace();
            }
        }

	}

}

七、处理查询结果集

请添加图片描述

查询出来的数据结果集就是ResultSet rs

import java.sql.*;

public class JDBCTest05{
    public static void main(String[] args){
        Connection conn = null;
        Statement stmt = null;
        ResultSet rs = null;
        
        try{
        	//1.注册驱动
        	Class.forName("com.mysql.jdbc.Dirver");
        	//2. 获取连接
        	conn = DirverManager.getConnection("jdbc:mysql://localhost:3306/bjpowernode","root","333");
        	//3. 获取数据操作对象
        	stmt = conn.createStatement();
        	//4. 执行SQL
        	String sql = "select empno as a,ename,sal from emp";
        	rs = stmt.executeQuery(sql);
        	//5. 处理查询结果集
        	boolean flag1 = rs.next();
        	//System.out.println(flag1);	//true
        
        
        	flag1 = rs.next();
        	if(flag1){
        		//以下程序的1、2、3 说的是第几列
        		String empno = rs.getString(1);
        		String ename = rs.getString(2);
        		String sal = rs.getString(3);
        		System.out.println(empno + "," + ename + "," + sal);
        	}
        	
        	while(rs.next()){
        		String empno = rs.getString(1);
        		String ename = rs.getString(2);
        		String sal = rs.getString(3);
        		System.out.println(empno + "," + ename + "," + sal);
        		
        		//不以表中列的下表获取，通过列的名字获取
        		String empno = rs.getString("empno");
        		String ename = rs.getString("ename");
        		String sal = rs.getString("sal");
        		System.out.println(empno + "," + ename + "," + sal);
        		
        		//除了可以String类型获取数据外，还可以通过特定的类型取出
        		int empno = rs.getInt("empno");
        		String ename = rs.getString("ename");
        		double sal = rs.getDouble("sal");
        		System.out.println(empno + "," + ename + "," + sal);
        		
        	}
        }catch(SQLException e){
            e.printStackTrace();
        }finally{
        	//6. 释放资源
        	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();
        		}
        	}
        }
    }

}

八、使用IDEA开发JDBC代码配置驱动

新建一个java空项目，在模块上点击右键 --> Open Module Settings

请添加图片描述

打开模块设置后，点击Libraries(库) --> “+” -->选择Java

请添加图片描述
请添加图片描述

点击OK后选择模块，最后apply --> OK就可以了
请添加图片描述

九、JDBC实现用户登录业务

实现功能：

  1. 需求：模拟用户登录功能的实现

  2. 业务描述：

    程序运行的时候提供一个数据的入口，可以让用户输入用户名和密码，用户数据用户名和米啊后，提交信息，Java程序收集到用户信息 Java程序连接数据库验证用户名是否合法

    合法：显示登录成功

    不合法：显示登录失败

  3. 数据准备

    在实际开发中，表的设计会使用专业的建模工具，我用的使PoerDesigner，使用PD工具进行数据库表的设计

package com.hyqwsq.jdbc;

import java.sql.*;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

/*
实现功能：
    1. 需求：模拟用户登录功能的实现
    2. 业务描述：
        程序运行的时候提供一个数据的入口，可以让用户输入用户名和密码，
        用户数据用户名和米啊后，提交信息，Java程序收集到用户信息
        Java程序连接数据库验证用户名是否合法
        合法：显示登录成功
        不合法：显示登录失败
    3. 数据准备
        在实际开发中，表的设计会使用专业的建模工具，我用的使PoerDesigner，
        使用PD工具进行数据库表的设计，（附件user-login.sql脚本）；
 */
public class jdbcTest06 {
    public static void main(String[] args) {
        // 初始化一个界面,创建一个可以初始化界面的方法，
        // 接收的返回值是用户名和密码，放到一个MAP容器中
        Map<String,String> userLoginInfo = initUI();

        // 验证用户和密码并登录,创建登录方法，传进用户信息，userLoginInfo为参数
        // 登录失败或者成功只有两种结果，所以方法返回一个布尔类型就好
        boolean loginSuccess = login(userLoginInfo);
        // 最后输出结果
        System.out.println(loginSuccess ? "登录成功" : "登录失败");
    }

    /**
     * 用户登录
     * @param userLoginInfo 用户登录信息
     * @return false 表示失败，true 表示成功
     */
    private static boolean login(Map<String, String> userLoginInfo) {
        // 打标记
        boolean loginSuccessornot = false;

        // 单独定义变量
        String loginName = userLoginInfo.get("loginName");
        String loginPwd = userLoginInfo.get("loginPwd");

        //JDBC代码
        Connection conn = null;
        Statement stmt = null;
        ResultSet rs = null;

        try {
            // 1.注册驱动
            Class.forName("com.mysql.jdbc.Driver");
            // 2.获取连接
            conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/hyqwsq","root","13903014064");
            // 3.获取数据库操作对象
            stmt = conn.createStatement();
            // 4.执行SQL
            //把用户数据的用户名的用户密码的字符串拼到字符串中：双引号中间加两个加号
            //String sql = "select * from t_user where loginName = '"+userLoginInfo.get("loginName")+"' and loginPwd = '"+userLoginInfo.get("loginPwd")+"'";

            //单独应以变量后
            String sql = "select * from t_user where loginName = '"+loginName+"' and loginPwd = '"+loginPwd+"'";
            rs = stmt.executeQuery(sql);

            // 5.处理结果集
//            while(rs.next()){}
            //不需要循环查看结果集，因为返回值为布尔类型，只需要看有没有结果集就好
            if(rs.next()){
                //登录成功
                loginSuccessornot = true;
            }


        } catch (ClassNotFoundException | SQLException e) {
            e.printStackTrace();
        }finally {
            // 6.关闭通道，释放资源
            if(rs != null){
                try {
                    rs.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
            if(stmt != null){
                try {
                    stmt.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
            if(conn != null){
                try {
                    conn.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
        }

        return loginSuccessornot;
    }

    /**
     * 初始化用户界面
     * @return 返回用户输入的用户名和密码等登录信息
     */
    private static Map<String, String> initUI() {
        Scanner s = new Scanner(System.in);
        //输入用户名
        System.out.println("用户名：");
        String loginName = s.nextLine();
        // 输入密码
        System.out.println("密码：");
        String loginPwd = s.nextLine();

        //将数据组装到嘛Map中
        Map<String,String> userLoginInfo = new HashMap<>();
        userLoginInfo.put("loginName","loginName");
        userLoginInfo.put("loginPwd","loginPwd");
        return userLoginInfo;
    }


}

​

复习：

public class jdbcTest06{
    public static void main(String[] args){
		Map<String,String> userLoginInfo = initUI(); 
        boolean loginSuccess = login(userLoginInfo);
        System.out.println(loginSuccess ? "登录成功" : "登录失败");
    }
    private static boolean login(Map<String,String> userLoginInfo){
        boolean loginSuccessornot = false;
        
        String loginName = userLoginInfo.get("loginName");
        String loginPwd = userLoginInfo.get("loginPwd");
        
        Connection conn = null;
        Statement stmt = null;
        ResultSet rs = null;
        try{
            // 1. 注册驱动
            Class.forName("com.mysql.jdbc.Driver");
            // 2. 获取连接
            conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/bjpowernode","root","333");
            // 3. 获取数据库操作对象
            stmt = conn.creatStatement();
            // 4. 执行SQL语句
            String sql = "select * from t_user where loginName = '"+loginName+"' and loginPwd = '"+loginPwd+"'";
            rs = stmt.executeQuery(sql);
            // 5. 处理结果集
            if(rs.next()){
                loginSuccessornot = true;
            }else{
                loginSuccessornot = false;
            }
        }catch(SQLException e){
            e.printStackTrace();
        }finally{
            //释放资源
            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();
                }
            }
        }
        return loginSuccessornot;
    }
    private static Map<String,String> iniUT(){
        Scanner s = new Scanner(System.in);
        System.out.println("用户名：");
        String loginName = s.nextLine();
        System.out.println("密码：");
        String loginPwd = s.nextLine();
        
        Map<String,String> userLoginInfo = new HaspMap<>();
        userLoginInfo.put("loginName","loginName");
        userLoginInfo.put("loginPwd","loginPwd");
        return userLoginInfo;
    }
}

十、解决SQL注入：

当前程序存在问题：
用户名：fdsa
密码：fdsa’ or ‘1’ = ‘1
登录成功
这种现象被成为SQL注入

问题代码块：

jade,mysql

        Statement stmt = null;

		// 3. 获取数据库操作对象
        stmt = conn.creatStatement();
        // 4. 执行SQL语句
        String sql = "select * from t_user where loginName = '"+loginName+"' and loginPwd = '"+loginPwd+"'";
        rs = stmt.executeQuery(sql);

以上代码块内：

​ 获取数据库操作对象 stmt 后执行SQL语句将传了loginName 和 loginPwd 两个参数后把SQL语句作为参数传给了executeQuery()方法，executeQuery()方法进行编译，就会把 fdsa’ or ‘1’ = ‘1 作为sql语句一起编译了，

编译后的sql语句：

 sql: "select * from t_user where loginName = 'fdsa' and loginPwd = 'fdsa' or '1' = '1'"

可以看到查询语句的where条件变成了 loginName = 'fdsa' and loginPwd = 'fdsa' or '1' = '1'"，意思就是 where(loginName = 'fdsa' and loginPwd = 'fdsa') 或者 ('1' = '1')，而'1' = '1'恒成立，所以无论怎么查询都能查到结果，甚至是将所有的用户账号密码都查了出来，最后完成登录

所以出现SQL注入的关键是：

用户输入的非法信息被数据库操作系统编译了，例如用户输入了含有SQL语句的关键字，并且这些关键字参与了SQL语句的编译过程

解决SQL注入：

​ 只要用户提供的信息不参与SQL编译过程
​ 即使提供的信息含有关键字等非法信息，但是只要不参加数据库操作系统的编译九不会形成注入
​ 要想用户信息不参与SQL语句的编译，那必须适合用java.sql.PreparedStatement
​ PreparedStatement 接口集成了java.sql.Statement
​ PreparedStatement 是属于预编译的数据库操作对象
​ PreparedStatement 的原理是预先对SQL语句的框架进行编译，然后再给SQL语句传值

解决SQL注入的关键是：
用户提供的信息中即使含有sql语句的关键字，但是这些关键字并没有参与编译，不起作用

解决注入代码：

package com.hyqwsq.jdbc;

import java.sql.*;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

/*
实现功能：
    1. 需求：模拟用户登录功能的实现
    2. 业务描述：
        程序运行的时候提供一个数据的入口，可以让用户输入用户名和密码，
        用户数据用户名和米啊后，提交信息，Java程序收集到用户信息
        Java程序连接数据库验证用户名是否合法
        合法：显示登录成功
        不合法：显示登录失败
    3. 数据准备
        在实际开发中，表的设计会使用专业的建模工具，我用的使PoerDesigner，
        使用PD工具进行数据库表的设计，（附件user-login.sql脚本）；
    4. 当前程序存在问题：
        用户名：fdsa
        密码：fdsa' or '1' = ‘1
        登录成功
        这种现象被成为SQL注入
    5. 导致SQL注入的根本原因：
        将密码：fdsa' or '1' = ‘1传进去后的SQL语句：
            sql: "select * from t_user where loginName = 'fdsa' and loginPwd = 'fdsa' or '1' = '1'"
            查询条件变成了：where(loginName = 'fdsa' and loginPwd = 'fdsa')  or  ('1' = '1')
            前面的用户名和用户密码不用对，后面的’1‘ = ’1‘恒成立，导致这条SQL语句一定能查到数据，所以一定可以登录成功
        原因：用户输入的非法信息被数据库操作系统编译了，例如用户输入了含有SQL语句的关键字，并且这些关键字参与了SQL语句的编译过程
        导致SQL语句的原意被扭曲，进而形成SQL注入
    6. 解决SQL注入：
        只要用户提供的信息不参与SQL编译过程
        即使提供的信息含有关键字等非法信息，但是只要不参加数据库操作系统的编译九不会形成注入
        要想用户信息不参与SQL语句的编译，那必须适合用java.sql.PreparedStatement
        PreparedStatement 接口集成了java.sql.Statement
        PreparedStatement 是属于预编译的数据库操作对象
        PreparedStatement 的原理是预先对SQL语句的框架进行编译，然后再给SQL语句传值
    7. 解决SQL注入的关键是：
        用户提供的信息中即使含有sql语句的关键字，但是这些关键字并没有参与编译，不起作用
    8. 对比一下Statement 和 PreparedStatement 的不同
    	Statement存在SQL注入的问题，PreparedStatement解决了SQL注入问题
    	Statement 是编译一次执行一次，PreparedStatement 是编译一次，可执行N次，PreparedStatement效率较高
    	PreparedStatement 会在编译阶段做类型的安全检查
  	9. 必须使用Statement的情况
  		业务方面要求必须支持SQL注入的时候
  		Statement支持SQL注入，凡是业务方面要求是需要进行SQL语句拼接的，必须使用过Statement
 */
public class jdbcTest06 {
    public static void main(String[] args) {
        // 初始化一个界面,创建一个可以初始化界面的方法，
        // 接收的返回值是用户名和密码，放到一个MAP容器中
        Map<String,String> userLoginInfo = initUI();

        // 验证用户和密码并登录,创建登录方法，传进用户信息，userLoginInfo为参数
        // 登录失败或者成功只有两种结果，所以方法返回一个布尔类型就好
        boolean loginSuccess = login(userLoginInfo);
        // 最后输出结果
        System.out.println(loginSuccess ? "登录成功" : "登录失败");
    }

    /**
     * 用户登录
     * @param userLoginInfo 用户登录信息
     * @return false 表示失败，true 表示成功
     */
    private static boolean login(Map<String, String> userLoginInfo) {
        // 打标记
        boolean loginSuccessornot = false;

        // 单独定义变量
        String loginName = userLoginInfo.get("loginName");
        String loginPwd = userLoginInfo.get("loginPwd");

        //JDBC代码
        Connection conn = null;
        // Statement stmt = null;
        // 换成预编译的数据库操作对象 PrepareSratement
        PreparedStatement ps = null;
        ResultSet rs = null;

        try {
            // 1.注册驱动
            Class.forName("com.mysql.jdbc.Driver");
            // 2.获取连接
            conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/hyqwsq","root","13903014064");
            // 3.获取编译的数据库操作对象
            // 将原来的值换成占位符 ？
            // 这样sql语句变成了框架，？ 表示占位符，一个占位符将接收一个值，占位符不能使用单引号括起来
            String sql = "select * from t_user where loginName = ? and loginPwd = ?";
            // 程序执行到这里，会发送SQL语句框架给DBMS，然后DBMS进行SQL语句的预先编译
            ps = conn.prepareStatement(sql);
            // 给占位符 ？ 传值（第一个占位符的下标是1， 第二个占位符的下标是2，JDBC中所有下标从1开始）
            ps.setString(1,loginName);
            ps.setString(2,loginPwd);
            // getString()方法传进去字符串后会自动加上单引号，如果是其getInt()就不会

            // 4.执行SQL
            //把用户数据的用户名的用户密码的字符串拼到字符串中：双引号中间加两个加号
            //String sql = "select * from t_user where loginName = '"+userLoginInfo.get("loginName")+"' and loginPwd = '"+userLoginInfo.get("loginPwd")+"'";

            //单独定义变量后
            // String sql = "select * from t_user where loginName = '"+loginName+"' and '"+loginPwd+"'";
            // 以上正好完成了SQL语句的拼接，以下代码的含义是：发送SQL语句给DBMS，DBMS进行编译
            // 正好将用户提供的非法信息编译减去，导致了原来的SQL语句含义被扭曲了
            rs = ps.executeQuery(sql);

            // 5.处理结果集
//            while(rs.next()){}
            //不需要循环查看结果集，因为返回值为布尔类型，只需要看有没有结果集就好
            if(rs.next()){
                //登录成功
                loginSuccessornot = true;
            }


        } catch (ClassNotFoundException | SQLException e) {
            e.printStackTrace();
        }finally {
            // 6.关闭通道，释放资源
            if(rs != null){
                try {rs.close();} catch (SQLException throwables) {throwables.printStackTrace();}}
            if(ps != null){
                try {ps.close();} catch (SQLException throwables) {throwables.printStackTrace();}}
            if(conn != null){
                try {conn.close();} catch (SQLException throwables) {throwables.printStackTrace();}}
        }

        return loginSuccessornot;
    }

    /**
     * 初始化用户界面
     * @return 返回用户输入的用户名和密码等登录信息
     */
    private static Map<String, String> initUI() {
        Scanner s = new Scanner(System.in);
        //输入用户名
        System.out.println("用户名：");
        String loginName = s.nextLine();
        // 输入密码
        System.out.println("密码：");
        String loginPwd = s.nextLine();

        //将数据组装到嘛Map中
        Map<String,String> userLoginInfo = new HashMap<>();
        userLoginInfo.put("loginName","loginName");
        userLoginInfo.put("loginPwd","loginPwd");
        return userLoginInfo;
    }


}

十一、Statement 和 PreparedStatement 对比

  1. Statement存在SQL注入的问题，PreparedStatement解决了SQL注入问题

  2. Statement 是编译一次执行一次，PreparedStatement 是编译一次，可执行N次，PreparedStatement效率较高

    1. 在数据库中前后两句SQL语句如果完全一样，那么第二次输入的SQL语句不会进行编译，而是直接执行

    2. 所以如果yongStatement执行语句，每次输入的用户名和用户密码都会和不一样，导致每次的SQL语句都不一样，所以每次都需要编译再执行

      String sql = "select * from t_user where loginName = '"+loginName+"' and loginPwd = '"+loginPwd+"'";

    3. 如果是用PreparedStatement执行语句，，只需要执行一次SQL语句框架，之后无论输入什么用户名用户密码都是编译后传值的事了，所以不需要多次编译，提高了效率

      String sql = "select * from t_user where loginName = ? and loginPwd = ?";

  3. PreparedStatement 会在编译阶段做类型的安全检查

    例子：

    loginName 的数据类型是 String

    当使用Statement的时候，如果传进去的值不是String ，例如是 int 类型，编译器不会报错

在这里插入图片描述

而使用PreparedStatement的时候，传值是通过getString()方法来拿到loginName的值，所以一旦不是String类型就会报错

在这里插入图片描述

十二、演示 Statement 用途

业务：

  用户在控制台输入desc就是降序，输入asc就是升序

先用PreparedStatement编写程序：

package com.hyqwsq.jdbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.Scanner;

public class jdbcTest09 {
    public static void main(String[] args) {
        //用户在控制台输入desc就是降序，输入asc就是升序
        Scanner s = new Scanner(System.in);
        System.out.println("输入desc或asc，desc表示降序，asc表示升序");
        System.out.println("请输入");
        String keyWord = s.nextLine();

        //执行SQL
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try{
            //注册驱动
            Class.forName("com.mysql.jdbc.Driver");
            //获取连接
            conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/hyqwsq","root","333");
            //获取预编译的数据库操作对象
            String sql = "select ename from emp order by ename ?";//先写框架
            ps = conn.prepareStatement(sql);//再进行编译
            ps.setString(1,keyWord);//最后传值
            //执行SQL
            rs = ps.executeQuery();
            //处理结果集，遍历
            System.out.println(rs.getString("ename"));
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            if(rs != null){
                try{
                    rs.close();
                }catch(Exception e){
                    e.printStackTrace();
                }
            }
            if(ps != null){
                try{
                    ps.close();
                }catch(Exception e){
                    e.printStackTrace();
                }
            }
            if(conn != null){
                try{
                    conn.close();
                }catch(Exception e){
                    e.printStackTrace();
                }
            }
        }
    }
}

经过getString()方法将 desc 或者 asc 传给编译后的SQL语句后 SQL语句如下：

select ename from emp order by ename 'desc'

正是因为getString()会给传进去的值加上 ’ '，所以报错

在这里插入图片描述

使用Statemen:

        //用户在控制台输入desc就是降序，输入asc就是升序
        Scanner s = new Scanner(System.in);
        System.out.println("输入desc或asc，desc表示降序，asc表示升序");
        System.out.println("请输入");
        String keyWord = s.nextLine();

        //执行SQL
        Connection conn = null;
        Statement stmt = null;
        ResultSet rs = null;
        try{
            //注册驱动
            Class.forName("com.mysql.jdbc.Driver");
            //获取连接
            conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/hyqwsq","root","333");
//              //获取预编译的数据库操作对象
//              String sql = "select ename from emp order by ename ?";//先写框架
//              ps = conn.prepareStatement(sql);//再进行编译
//              ps.setString(1,keyWord);//最后传值
//              //执行SQL
//              rs = ps.executeQuery();
//              //处理结果集，遍历
//              System.out.println(rs.getString("ename"));
            //获取数据库操作对象
            stmt = conn.createStatement();
            //执行SQL
            String sql = "select ename from emp order by ename " + keyWord;
            rs = stmt.executeQuery(sql);
            //处理结果集,遍历
            while(rs.next()){
                System.out.println(rs.getString("ename"));
            }
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            if(rs != null){
                try{
                    rs.close();
                }catch(Exception e){
                    e.printStackTrace();
                }
            }
            if(stmt != null){
                try{
                    stmt.close();
                }catch(Exception e){
                    e.printStackTrace();
                }
            }
            if(conn != null){
                try{
                    conn.close();
                }catch(Exception e){
                    e.printStackTrace();
                }
            }
        }

输出：

在这里插入图片描述

十三、PrepareStatement完成增删改查

package com.hyqwsq.jdbc;

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

public class jdbcTest10 {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement ps = null;
        try {
            //注册驱动
            Class.forName("com.mysql.jdbc.Driver");
            //获取连接
            conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/hyqwsq","root","333");
            // 获取预编译数据库操作对象

            //增
            String sql = "insert into dept(deptno,dname,loc) values(?,?,?)";    // 先写框架
            ps = conn.prepareStatement(sql);    // 第二部编译
            ps.setInt(1,60);    // 最后传值
            ps.setString(2,"销售部");
            ps.setString(3,"上海");

            //删
            String sql3 = "delete from dept where deptno = ?";
            ps = conn.prepareStatement(sql3);
            ps.setInt(1,60);

            //改
            String sql2 = "update dept set dname = ?,loc = ? where deptno = ?";
            ps = conn.prepareStatement(sql2);
            ps.setString(1,"研发一部");
            ps.setString(2,"北京");
            ps.setInt(3,60);

            //执行SQL语句
            int count = ps.executeUpdate();
            System.out.println(count);
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            if(ps != null){
                try {
                    ps.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            if(conn != null){
                try {
                    conn.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }

        }
    }
}

十四、JDBC的事务自动提交机制演示

package com.hyqwsq.jdbc;

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

/**
 * JDBC事务机制：
 *      1. JDBC中的事务是自动提交，只要执行一条DML语句，则自动提交一次，这也是JDBC默认的事务行为
 *              但是在实际的业务中，通常都是N条DML语句公共联合才能完成一件事务，
 *              必须保证他们这些DML语句在他同一个事务中同时成功或者同时失败
 */
public class jdbcTest11 {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement ps = null;

        try {
            // 1. 注册驱动
            Class.forName("com.mysql.jdbc.Dirver");
            // 2. 获取连接
            conn = DriverManager.getConnection("jdbc:mysql://localhost/hyqwsq","root","333");
            // 3. 获取预编译的数据库操作对象
            String sql = "update dept set dname = ? where deptno = ? ";     // 先写框架
            ps = conn.prepareStatement(sql);    // 预编译

            // 第一次给占位符传值，作为事务的第一次行为
            ps.setString(1,"X部门");    // 最后传值
            ps.setInt(2,20);
            int count = ps.executeUpdate();
            System.out.println(count);

            // 第二次给占位符传值，作为事务的第二次行为
            ps.setString(1,"Y部门");
            ps.setInt(2,20);
            count += ps.executeUpdate();
            System.out.println(count);
            // 4. 执行SQL
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            if(ps != null){
                try {
                    ps.close();
                } catch (Exception throwables) {
                    throwables.printStackTrace();
                }
            }
            if(conn != null){
                try {
                    conn.close();
                } catch (Exception throwables) {
                    throwables.printStackTrace();
                }
            }
        }
    }
}

十五、账户转账业务演示事务

package com.hyqwsq.jdbc;

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

/**
 * sql脚本：
 *      drop table if exists t_act;
 *      create table t_act(
 *          actno int;
 *          balance double(7,2) // 注意：7表示有效数字的个数，2表示小数位的个数
 *      )；
 *      insert into t_act(acton,balance) values(111,20000);
 *      insert into t_act(actno,balance) values(222,0);
 *      commit;
 *      select * from t_act;
 *
 *      重点三行代码：
 *          conn.setAutoCommit(false);
 *          conn.commit();
 *          conn.rollback();
 */

public class jdbcTest12 {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement ps = null;

        try {
            // 1.注册驱动
            Class.forName("com.mysql.jdbc.Driver");
            // 2. 获取连接
            conn = DriverManager.getConnection("jdbc:mysql://localhost/hyqwsq","root","333");
            // 6. 将自动提交机制修改为手动提交 -- setAutoCommit()
            conn.setAutoCommit(false);

            // 3. 获取预编译数据库操作对象
            String sql = "update t_act set balance = ? where actno = ?";
            ps = conn.prepareStatement(sql);

            // 4. 事务动作一：111用户转账 ---》 账户余额减少一万
            ps.setDouble(1,10000);
            ps.setInt(2,111);
            int count = ps.executeUpdate();

            // 7. 添加空指针异常
            String s = null;
            s.toString();

            // 5. 事务动作二：222用户收到转账 ---》 账户余额增加一万
            ps.setDouble(1,10000);
            ps.setInt(2,222);
            count += ps.executeUpdate();

            System.out.println(count  == 2 ? "转账事务成功" : "转账事务失败");

            // 8. 程序能够走到这里说明以上程序没有异常，事务结束，手动提交数据
            conn.commit();  //事务提交

        } catch (Exception e) {
            // 9. 事务过程如果失败异常，进行回滚,保证数据安全性
            try {
                conn.rollback();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
            e.printStackTrace();
        }finally{
            if(ps != null){
                try {
                    ps.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
            if(conn != null){
                try {
                    conn.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
        }
    }
}

十六、JDBC工具类封装

工具类：

package com.hyqwsq.jdbc.utils;

import java.sql.*;

/**
 * JDBC工具类，简化JDBC编程
 */

public class DBUtil {
    /**
     * 工具类中的构造方法都是私有的
     * 因为工具类中的方法都是静态的，不需要new对象，直接采用类名调用
     */
    private DBUtil(){
    }

    // 静态代码块在类加载时执行，并且只执行一次
    static{
        try {
            Class.forName("com.mysql.jdbc.Driver");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取数据库连接对象封装方法
     * 异常不能try{}catch{}，要抛出去，因为外面有抓
     * @return  返回连接对象
     * @throws SQLException
     */
    public static Connection geConnection() throws SQLException {
        /*
        try {
            //因为可能一个程序调用两次getConnection()方法获取两个数据库连接对象，但是注册驱动只需要注册一次就好，所以使用静态代码块
            Class.forName("com.mysql.jdbc.Driver");
            Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/hyqwsq","root","333");
        } catch (Exception e) {
            e.printStackTrace();
        }
        */
        return DriverManager.getConnection("jdbc:mysql://localhost:3306/hyqwsq","root","333");
    }

    /**
     * 关闭资源
     * @param conn 连接对象
     * @param ps 数据库操作对象
     * @param rs 结果集
     */
    public static void close(Connection conn, Statement ps, ResultSet rs){
        if(rs != null){
            try {
                rs.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        if(ps != null){
            try {
                ps.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        if(conn != null){
            try {
                conn.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }

    }
}

实现类：

package com.hyqwsq.jdbc;

import com.hyqwsq.jdbc.utils.DBUtil;

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

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

        try {
            // 1. 获取连接
            conn = DBUtil.geConnection();
            // 2. 获取预编译数据库错做对象
            // 3. 获取结果集
            // 4. 处理结果集
        } catch (Exception throwables) {
            throwables.printStackTrace();
        }finally{
            // 5. 释放资源
            DBUtil.close(conn,ps,rs);
        }
    }
}

十七、JDBC结合工具类实现模糊查询

package com.hyqwsq.jdbc;

import com.hyqwsq.jdbc.utils.DBUtil;

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

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

        try {
            // 1. 获取连接
            conn = DBUtil.geConnection();
            // 2. 获取预编译数据库错做对象
            String sql = "select ename from emp where ename like ?";
            ps = conn.prepareStatement(sql);
            ps.setString(1,"_A%");

            // 3. 获取结果集
            rs = ps.executeQuery();
            // 4. 处理结果集
            while(rs.next()){
                System.out.println(rs.getString("ename"));
            }
        } catch (Exception throwables) {
            throwables.printStackTrace();
        }finally{
            // 5. 释放资源
            DBUtil.close(conn,ps,rs);
        }
    }
}

十八、悲观锁和行级锁

在这里插入图片描述

+-------+---------+---------+				   +---------+
| ENAME | JOB     | MGR     |				   | version |
+-------+---------+---------+				   +---------+
| BLAKE | MANAGER | 2850.00 |			       |     1.1 |

事务1–>读取到版本号1.1

事务2–>读取到版本号1.1
 
其中事务1先修改了，修改之后看了版本是1.1，于是提交修改的数据，将版本号修改为1.2

其中事务2后修改的，修改之后准备提交的时候，发现版本号是1.2，和它最初读取的版本号不一致。回滚。
 
悲观锁：事务必须排队执行，数据锁住了，不允许并发。（行级锁：select后面添加for update）

乐观锁：支持并发，事务也不需要排队，只不过需要一个版本号。

十九、演示行级锁机制

事务1：

package com.hyqwsq.jdbc;

import com.hyqwsq.jdbc.utils.DBUtil;

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

public class jdbcTest14 {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            // 获取连接
            conn = DBUtil.geConnection();
            // 开启事务
            conn.setAutoCommit(false);
            String sql = "select ename,job,sal from emp where job = ? for update";
            ps = conn.prepareStatement(sql);
            ps.setString(1,"Manager");

            // 处理结果集
            rs = ps.executeQuery();
            while (rs.next()){
                System.out.println(rs.getString("ename") + "," + rs.getString("job") + "," + rs.getDouble("sal"));
            }

            // 提交事务（事务结束）
            conn.commit();
        } catch (Exception throwables) {
            throwables.printStackTrace();
        }finally{
            DBUtil.close(conn,ps,rs);
        }
    }
}

事务2：

package com.hyqwsq.jdbc;

import com.hyqwsq.jdbc.utils.DBUtil;

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

public class jdbcTest14_15 {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement ps = null;
        try {
            conn = DBUtil.geConnection();

            String sql = "update emp set sal = sal *  1.1 where job = ?";
            ps = conn.prepareStatement(sql);
            ps.setString(1,"Manager");
            int count = ps.executeUpdate();
            System.out.println(count);

            conn.commit();
        } catch (SQLException throwables) {
            if(conn != null){
                try {
                    conn.rollback();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            throwables.printStackTrace();
        }finally{
            DBUtil.close(conn,ps,null);
        }
    }
}
JDBC原理详解
weixin_42178281的博客
11-23 538
JDBC中用到的几个对象： 1.DriverManager:驱动管理对象（为什么不说是类呢，因为其中大部分是接口） 功能： (1).注册驱动 在原码中注册驱动的方法是static void registerDriver(Driver driver)，当然也有deregisterDriver用来删除驱动，而实际的代码使用是Class.forName(“com.mysql.jdbc.Driver”)，Class.forName方法的作用是初始化给定的类，从JDBC jar包中顺着这个路径可以看到Driver类的
Java中JDBC实现动态查询的实例详解
08-30
JDBC 实现动态查询的实例详解 概述 动态查询是指从多个查询条件中随机选择若干个组合成一个 DQL 语句进行查询的过程。动态查询的难点在于可供选择的查询条件多，组合情况多，难以一一列举。 基本原理 1. SQL ...
JDBC数据库连接池实现原理
11-26
java实现JDBC数据库连接池的原理，里面有oracle驱动jar包，以及代码的阅读步骤
JavaWeb JDBC
qq_63093843的博客
12-05 1535
在MySQL中创建一个名称为jdbc的数据库，然后在该数据库中创建一个users表，创建数据库和表的SQL语句如下所示。执行结果如图在项目chapter09的src目录下，新建一个名称为chapter02.jdbc.example的包，在该包中创建类Example01，该类用于读取数据库中的users表，并将结果输出到控制台代码解释:1.需要导入mysql的jar包,并导入到Java库内,基本上都是这个路径;2.连接数据库;3.用户名;4.用户密码;结果如图。
JDBC:数据库访问的原始接口
最新发布
2301_79902294的博客
04-21 758
JDBC 是数据库访问的基础技能，虽然在项目中被框架封装，但面试时经常会问底层细节；记住六步流程，尤其是连接获取、预编译 SQL、防止注入；JDBC 是学习 Spring JDBC、MyBatis 的前提。好的，下面是第二章的正文内容，继续坚持“原理 + 实战 + 面试”的思路，帮助 Java 学习者全面掌握 JDBC 核心接口。连接池是 JDBC 性能优化的第一要素项目小就用 HikariCP（默认、快），项目复杂就用 Druid（功能强）永远不要每次操作都新建一个Connection。
JDBC实现原理与过程分析
ILFFQ的博客
09-04 658
JDBC实现原理与过程分析
jdbc 原理
生亦何欢,死亦何求
06-01 233
一.JDBC原理概述   1，JDBC是一套协议，是JAVA开发人员和数据库厂商达成的协议，也就是由Sun定义一组接口，由数据库厂商来实现，并规定了JAVA开发人员访问数据库所使用的方法的调用规范。   2，JDBC的实现是由数据库厂商提供，以驱动程序形式提供。   3，JDBC在使用前要先加载驱动。  JDBC对于使用者要有一致性，对不同的数据库其使用方法都是相同的。   ...
JDBC原理
qq_30260307的博客
04-28 655
【JDBC】jdbc原理总结 1 什么是JDBC JDBC（Java DataBase Connectivity）就是Java数据库连接，说白了就是用Java语言来操作数据库。原来我们操作数据库是在控制台使用SQL语句来操作数据库，JDBC是用Java语言向数据库发送SQL语句。 2 JDBC原理 　　早期SUN公司的天才们想编写一套可以连接天下所有数据库的API，但是当他们刚刚开始时就发现这是不可完成的任务，因为各个厂商的数据库服务器差异太大了。后来SUN开始与数据库厂商们讨论，最终得出的结论是.
Socket+JDBC+IO实现Java文件上传下载器DEMO详解
08-30
Socket+JDBC+IO实现Java文件上传下载器DEMO详解 本资源详解了使用Socket+JDBC+IO实现Java文件上传下载器的DEMO，涵盖了用户注册、用户登录、文件上传、文件下载、文件更新、文件删除、查看数据库所有文件、查看文件...
传智播客JDBC源码详解及驱动实现原理
JDBC（Java Database Connectivity）是Java语言中用于执行SQL语句的API，它定义了Java应用程序如何与...传智播客可能是一个提供IT培训的教育机构，通过提供这些源代码和教学资料帮助学员理解JDBC的工作原理和实际应用。
JDBC原理详解与应用教程：接口、驱动与操作步骤
JDBC (Java Database Connectivity) 是一套标准的Java API，它使得...JDBC是Java语言与数据库交互的核心工具，理解并掌握它的原理和使用流程对于Java开发者来说至关重要，能够有效地提升应用程序的可移植性和兼容性。
【JDBC】jdbc原理总结
weixin_34190136的博客
01-07 258
1 什么是JDBC  JDBC（Java DataBase Connectivity）就是Java数据库连接，说白了就是用Java语言来操作数据库。原来我们操作数据库是在控制台使用SQL语句来操作数据库，JDBC是用Java语言向数据库发送SQL语句。 2 JDBC原理 　　早期SUN公司的天才们想编写一套可以连接天下所有数据库的API，但是当他们刚刚开始时就发现这是不可完成的任务，因为各个...
JDBC原理,JDBC基础编程
热门推荐
SwmIsMe的博客
12-13 1万+
JDBCWHAT IS JDBC Java Database Connectivity：Java访问数据库的解决方案。 JDBC是Java应用程序访问数据库的里程碑式解决方案。Java研发者希望用相同的方式访问不同的数据库，以实现与具体数据库无关的Java操作界面。 JDBC定义了一套标准接口，即访问数据库的通用API，不同的数据库厂商根据各自数据库的特点去实现这些接口。 JDBC接
JDBC实现原理
VIX500的博客
02-24 500
1.新建一个工程 2.创建一个lib包 3.复制进去 4.编译成jar工具 右键这个，然后找到Add to library package cn.tedu.test; import java.sql.*; import java.util.Scanner; public class TestJdbc5 { public static void main(String[] args) throws Exception { // method(); me..
【Java工程师之路】[2-4.1]JDBC的工作原理
Yang Yawen的计算机生涯日志……
10-24 744
工作原理流程：装载驱动程序---->获得数据库连接---->使用Statement或PreparedStatement执行SQL语句---->               返回执行的结果---->关闭相关的连接 JDBC 原理浅析 一.本节目的: 了解JDBC的概念及工作原理 写在详解前 对JAVA基础知识的回顾: JAVA接口: 是一系列方法的声明，是一些方法特征的集合，
JDBC的工作原理
weixin_50518344的博客
11-09 325
在JDBC技术中可以通过Connection对象中的commit()方法执行提交事务的操作；通过Connection对象中的rollback()执行事务的回滚操作，该回滚操作通过cacth()区域中进行设置。在关系型数据库（例如：SQL Server，MySQL）中，事务就是一条或者一组保存、更新数据库记录的SQL语句。在MYSQL数据库，创建一个数据库，并且在该数据库下创建学生信息表，含有学生的基本信息，并通过JDBC实现对该数据表内容实现添加、修改、删除和查询的操作。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值