• JDBC的初步认识

    JDBC是什么？JDBC英文名为：Java Data Base Connectivity(Java数据库连接)，数据库是由不同生产产商决定的，例如Mysql、Oracle、SQL Server,JAVA JDK不可能提供对不同数据库的实现，因此，它就提供了JDBC的接口API，具体的实现由不同的生产产商决定。这样，数据库生产产商都根据JAVA API去实现各自的应用驱动，这问题就迎刃而解了

    常用接口

    • DriverManager：这个类管理数据库驱动程序的列表，查看加载的驱动是否符合JAVA Driver API的规范

    • Connection：与数据库中的连接对象，通过该对象与数据库进行通信

    • Statement：把创建的SQL对象，转而存储到数据库当中

    • ResultSet：它是一个迭代器，用于检索查询数据

    JDBC的使用步骤

    1. import cn.kgc.jdbc.entity.User;
    2. import com.mysql.jdbc.Driver;
    3.  
    4. import java.sql.*;
    5. import java.util.ArrayList;
    6.  
    7. public class JDBCDemo01 {
    8.  
    9.     /*
    10.        java操作数据库的基本步骤
    11.        1. 引入依赖  注册驱动
    12.        2.获取连接对象    如何获取数据库的连接？
    13.        3.获取发送sql语句的对象  发送sql语句
    14.        4.处理结果集
    15.        5.释放资源
    16.     * */
    17.     public static void main(String[] args) throws SQLException {
    18.         // 创建驱动对象
    19.         Driver driver = new Driver();
    20.         // 注册驱动
    21.         DriverManager.registerDriver(driver);
    22.  
    23.         /**
    24.          *  获取连接  url   user  password    http://www.baidu.com/login.html
    25.          *  url:  数据库的通信地址  jdbc:mysql://localhost:3306/java2216
    26.          *  user：  数据的用户名  root
    27.          *  password：  用户密码  
    28.          */
    29.         String url = "jdbc:mysql://localhost:3306/java2216?useSSL=false";
    30.         String username = "root";
    31.         String password = "***";
    32.         //获取数据库的连接
    33.         Connection connection = DriverManager.getConnection(url, username, password);
    34.         System.out.println("connection = " + connection);
    35.  
    36.         // 通过连接获取发送sql语句的对象  Statement
    37.         Statement statement = connection.createStatement();
    38.         //编写sql
    39.         //String sql = "SELECT  *  FROM  user   WHERE id = 1";
    40.         String sql = "SELECT  *  FROM  user ";
    41.         // 发送sql语句到mysql数据库
    42.         ResultSet resultSet = statement.executeQuery(sql);
    43.         // 处理结果集  resultSet  resultSet.next()  查询数据结果集中是否还有下一条数据
    44.         // 创建集合 存储查询结果中封装的数据
    45.         ArrayList users = new ArrayList<>();
    46.         while (resultSet.next()){
    47.             //获取当前记录中字段值  根据字段值的数据类型获取
    48.             int id = resultSet.getInt("id");  //  通过字段名获取
    49.             String uname = resultSet.getString(2);  //  通过字段的列索引
    50.             String pwd = resultSet.getString("password");
    51.             User user = new User().setId(id).setPassword(pwd).setUsername(uname);
    52.             users.add(user);
    53.             //System.out.println("user = " + user);
    54.         }
    55.  
    56.         // 遍历集合
    57.         //users.forEach(user-> System.out.println("user = " + user));
    58.  
    59.         for (User user : users) {
    60.             System.out.println(user);
    61.         }
    62.  
    63.         // 释放资源
    64.         resultSet.close();
    65.         statement.close();
    66.         connection.close();
    67.  
    68.     }
    69.  
    70. }

     测试JDBC

    1. package cn.kgc.jdbc;
    2.  
    3. import com.mysql.jdbc.Driver;
    4. import org.junit.Test;
    5.  
    6. import java.sql.Connection;
    7. import java.sql.DriverManager;
    8. import java.sql.SQLException;
    9. import java.sql.Statement;
    10.  
    11. public class TestJDBC {
    12.  
    13.     // jdbc 添加操作
    14.     @Test
    15.     public void  addUser(){
    16.         // jdbc 6步
    17.         Connection connection =null;
    18.         Statement statement = null;
    19.         try {
    20.  
    21.             Driver driver = new Driver();
    22.             DriverManager.registerDriver(driver);
    23.  
    24.             String url = "jdbc:mysql://localhost:3306/java2216?useSSL=false";
    25.             String username = "root";
    26.             String password = "***";
    27.  
    28.             connection = DriverManager.getConnection(url, username, password);
    29.  
    30.             statement = connection.createStatement();
    31.             String sql = "insert into user(username,password) values('tom','12345')";
    32.  
    33.             int i = statement.executeUpdate(sql);
    34.             System.out.println(i>0?"ok":"error");
    35.  
    36.  
    37.         } catch (SQLException throwables) {
    38.             throwables.printStackTrace();
    39.         }finally {
    40.             // 释放资源
    41.             try {
    42.                 if (statement!=null){  //  避免空指针异常
    43.                     statement.close();
    44.                 }
    45.  
    46.             } catch (SQLException throwables) {
    47.                 throwables.printStackTrace();
    48.             }
    49.  
    50.             try {
    51.                 if ( connection!=null){  //  避免空指针异常
    52.                     connection.close();
    53.                 }
    54.  
    55.             } catch (SQLException throwables) {
    56.                 throwables.printStackTrace();
    57.             }
    58.  
    59.         }
    60.  
    61.     }
    62.  
    63.     // jdbc 删除操作
    64.     @Test
    65.     public void  deleteUser(){
    66.         // jdbc 6步
    67.         Connection connection =null;
    68.         Statement statement = null;
    69.         try {
    70.  
    71.             Driver driver = new Driver();
    72.             DriverManager.registerDriver(driver);
    73.  
    74.             String url = "jdbc:mysql://localhost:3306/java2216?useSSL=false";
    75.             String username = "root";
    76.             String password = "***";
    77.  
    78.             connection = DriverManager.getConnection(url, username, password);
    79.  
    80.             statement = connection.createStatement();
    81.             String sql = " delete from user where id = 1";
    82.  
    83.             int i = statement.executeUpdate(sql);
    84.             System.out.println(i>0?"ok":"error");
    85.  
    86.  
    87.         } catch (SQLException throwables) {
    88.             throwables.printStackTrace();
    89.         }finally {
    90.             // 释放资源
    91.             try {
    92.                 if (statement!=null){  //  避免空指针异常
    93.                     statement.close();
    94.                 }
    95.  
    96.             } catch (SQLException throwables) {
    97.                 throwables.printStackTrace();
    98.             }
    99.  
    100.             try {
    101.                 if ( connection!=null){  //  避免空指针异常
    102.                     connection.close();
    103.                 }
    104.  
    105.             } catch (SQLException throwables) {
    106.                 throwables.printStackTrace();
    107.             }
    108.  
    109.         }
    110.  
    111.  
    112.     }
    113.  
    114.     // jdbc 修改操作
    115.     @Test
    116.     public void  updateUser(){
    117.         // jdbc 6步
    118.         Connection connection =null;
    119.         Statement statement = null;
    120.         try {
    121.  
    122.             Driver driver = new Driver();
    123.             DriverManager.registerDriver(driver);
    124.  
    125.             String url = "jdbc:mysql://localhost:3306/java2216?useSSL=false";
    126.             String username = "root";
    127.             String password = "***";
    128.  
    129.             connection = DriverManager.getConnection(url, username, password);
    130.  
    131.             statement = connection.createStatement();
    132.             String sql = "update user  set password = '8888' where id = 2";
    133.  
    134.             int i = statement.executeUpdate(sql);
    135.             System.out.println(i>0?"ok":"error");
    136.  
    137.  
    138.         } catch (SQLException throwables) {
    139.             throwables.printStackTrace();
    140.         }finally {
    141.             // 释放资源
    142.             try {
    143.                 if (statement!=null){  //  避免空指针异常
    144.                     statement.close();
    145.                 }
    146.  
    147.             } catch (SQLException throwables) {
    148.                 throwables.printStackTrace();
    149.             }
    150.  
    151.             try {
    152.                 if ( connection!=null){  //  避免空指针异常
    153.                     connection.close();
    154.                 }
    155.  
    156.             } catch (SQLException throwables) {
    157.                 throwables.printStackTrace();
    158.             }
    159.  
    160.         }
    161.     }
    162. }

    JDBC工具类

    在IDEA中建立resource资源建立jdbc.properties文件

    1. driverClassName=com.mysql.jdbc.Driver
    2. url=jdbc:mysql://localhost:3306/java2216?useSSL=false
    3. username=root
    4. password=***

    使用JDBC的步骤中连接数据库和释放资源重复性使用，可以提取出来单独设立JDBCUtil工具类

    1. import com.mysql.jdbc.Driver;
    2.  
    3. import javax.sql.DataSource;
    4. import java.sql.*;
    5. import java.util.ResourceBundle;
    6.  
    7. public class JDBCUtil {
    8.  
    9.     private JDBCUtil(){}
    10.  
    11.     private static String username;
    12.     private static String driverClassName;
    13.     private static String password;
    14.     private static String url;
    15.  
    16.     static {  //  执行一次 类加载时
    17.  
    18.         ResourceBundle file = ResourceBundle.getBundle("jdbc");
    19.         driverClassName = file.getString("driverClassName");
    20.         url = file.getString("url");
    21.         username = file.getString("username");
    22.         password = file.getString("password");
    23.     }
    24.  
    25.     //获取数据库连接的方法
    26.     public  static Connection  getConnection(){
    27.         //通过反射注册驱动
    28.         Connection connection = null;
    29.         try {
    30.             Class.forName(driverClassName);
    31.             connection = DriverManager.getConnection(url, username, password);
    32.         } catch (Exception e) {
    33.             e.printStackTrace();
    34.         }
    35.         return connection;
    36.     }
    37.  
    38.     //释放资源
    39.     public static  void  closeAll(Connection connection, Statement statement, ResultSet resultSet){
    40.  
    41.         if(resultSet!=null){
    42.             try {
    43.                 resultSet.close();
    44.             } catch (SQLException throwables) {
    45.                 throwables.printStackTrace();
    46.             }
    47.         }
    48.  
    49.         if(statement!=null){
    50.  
    51.             try {
    52.                 statement.close();
    53.             } catch (SQLException throwables) {
    54.                 throwables.printStackTrace();
    55.             }
    56.         }
    57.  
    58.         if(connection!=null){
    59.  
    60.             try {
    61.                 connection.close();
    62.             } catch (SQLException throwables) {
    63.                 throwables.printStackTrace();
    64.             }
    65.         }
    66.     }
    67. }
    1. package cn.kgc.jdbc;
    2.  
    3. import cn.kgc.jdbc.util.JDBCUtil;
    4. import org.junit.Test;
    5.  
    6. import java.sql.Connection;
    7. import java.sql.SQLException;
    8.  
    9. public class TestJDBCUtil {
    10.  
    11.     @Test
    12.     public void test1(){  //  测试工具类获取连接的方法
    13.  
    14.         Connection connection = JDBCUtil.getConnection();
    15.         System.out.println("connection = " + connection);
    16.  
    17.     }
    18. }

  • 相关阅读:
    SpringCloud链路追踪SkyWalking-第六章-日志采集
    springboot 导出word模板
    Go for循环中的defer
    显示今天的年、月、日日期、时间的数据处理timetuple()
    C++ 运算符重载详解
    【虚拟化生态平台】虚拟化平台搭建
    一幅长文细学HTML5和CSS3——一幅长文系列
    Linux 系统服务日志查询 journalctl：查询 systemd 日记
    Elasticsearch系列之：Centos7安装部署Elasticsearch详细步骤
    CSS的伪类选择器:nth-child()
  • 原文地址：https://blog.csdn.net/qq_69761234/article/details/126607109