526互联

java数据库与JDBC

发布时间 2023-10-12 19:04:38作者: BattleofZhongDinghe

java数据库与JDBC

java与MYSQL

1.下载驱动
https://dev.mysql.com/downloads/connector/j/

https://dev.mysql.com/get/Downloads/Connector-J/mysql-connector-j-8.1.0.zip
2.导入mysql-connector-j.*.jar包

3.然后在src目录下新建一个java类

4.写入数据库连接测试代码

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class Conn {
    public static void main(String[] args) {
        Connection con;
        //jdbc驱动
        String driver="com.mysql.cj.jdbc.Driver";
        //数据库地址为localhost:3306,数据库名为security (sqli-labs的数据库)
        String url="jdbc:mysql://localhost:3306/security?useSSL=false&serverTimezone=UTC";
        String user="root";
        String password="root";
        try {
            //注册JDBC驱动程序
            Class.forName(driver);
            //建立连接
            con = DriverManager.getConnection(url, user, password);
            if (!con.isClosed()) {
                System.out.println("数据库连接成功");
            }
            con.close();
        } catch (ClassNotFoundException e) {
            System.out.println("数据库驱动没有安装");

        } catch (SQLException e) {
            e.printStackTrace();
            System.out.println("数据库连接失败");
        }
    }
}


5.然后利用JDBC进行查询

import java.sql.*;

public class Conn{
    public static void main(String[] args){
        Connection con;
        //jdbc驱动
        String driver="com.mysql.cj.jdbc.Driver";
        String url="jdbc:mysql://localhost:3306/security?useSSL=false&serverTimezone=UTC";
        String user="root";
        String password="root";
        try {
            Class.forName(driver);
            con = DriverManager.getConnection(url,user,password);
            if(!con.isClosed()){
                System.out.println("数据库连接成功");
                Statement state = con.createStatement();

                String query = "SELECT * FROM users";
                ResultSet res = state.executeQuery(query);

                while(res.next()){
                    int id = res.getInt("id");
                    String name = res.getString("username");
                    String pass = res.getString("password");
                    System.out.println("ID: "+id+", Username: "+name+", Password: "+pass);
                }
                res.close();
                state.close();
                con.close();
            }
            con.close();
        } catch (ClassNotFoundException e) {
            System.out.println("数据库驱动没有安装");
        } catch (SQLException e) {
            e.printStackTrace();
            System.out.println("数据库连接失败");
        }
    }
}

JDBC_事务特性ACID,隔离级别

JDBC（Java Database Connectivity）是Java程序与数据库进行交互的标准接口。在JDBC中，事务是一组数据库操作，作为一个单元要么全部成功，要么全部失败。JDBC遵循ACID原则和隔离级别来确保事务的可靠性和一致性。
ACID是指：
原子性（Atomicity）：事务是一个原子操作单元，要么全部执行成功，要么全部执行失败。事务中的所有操作要么全部提交，要么全部回滚。
一致性（Consistency）：事务在执行前后，数据库的状态必须保持一致。如果事务执行成功，数据库从一个一致的状态转换到另一个一致的状态。如果事务执行失败，数据库应该回滚到之前的一致状态。
隔离性（Isolation）：事务之间应该是相互隔离的，即一个事务的操作不应该影响其他事务的操作。每个事务应该感觉自己是在独立运行的，即使有其他事务在同时执行。
持久性（Durability）：一旦事务提交成功，其结果应该永久保存在数据库中，即使系统发生故障或重启。
隔离级别是指在多个事务并发执行时，数据库系统如何处理事务之间的相互影响。JDBC定义了四个隔离级别：
读未提交（Read Uncommitted）：最低的隔离级别，事务可以读取其他事务未提交的数据。这种隔离级别可能导致脏读（Dirty Read）问题，即读取到了未提交的数据。
读已提交（Read Committed）：事务只能读取其他事务已经提交的数据。这种隔离级别可以避免脏读问题，但可能导致不可重复读（Non-repeatable Read）问题，即在同一个事务中，多次读取同一数据可能得到不同的结果。
可重复读（Repeatable Read）：事务在执行期间多次读取同一数据时，保证能够读取到一致的数据。这种隔离级别可以避免脏读和不可重复读问题，但可能导致幻读（Phantom Read）问题，即在同一个事务中，多次查询同一范围的数据，结果集合的行数可能不同。
串行化（Serializable）：最高的隔离级别，事务依次执行，相当于将并发执行的事务串行化。这种隔离级别可以避免脏读、不可重复读和幻读问题，但会降低并发性能。
在JDBC中，可以使用Connection对象的setTransactionIsolation()方法设置事务的隔离级别，例如：
connection.setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);
需要注意的是，隔离级别越高，事务的并发性能越低，因为需要加锁和保证事务的一致性。因此，在选择隔离级别时，需要权衡并发性能和数据一致性的需求。

JDBC封装资源文件以及如何存出一到多条记录

JDBC是Java Database Connectivity的缩写，是Java语言访问数据库的标准接口。JDBC封装资源文件可以通过使用Properties类来实现。
1.创建一个名为"db.properties"的资源文件，其中包含数据库连接所需的配置信息

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/security
username=root
password=root

2.创建一个DBconfig.java文件 可以在Java代码中使用Properties类来加载并读取这个资源文件

import java.io.FileInputStream;
import java.io.IOException;
import java.util.Properties;

public class DBConfig {
    private static Properties properties;

    static {
        properties = new Properties();
        try {
            properties.load(new FileInputStream("F:/db.properties"));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static String getProperty(String key) {
        return properties.getProperty(key);
    }
}

3.可以使用JDBC连接数据库并执行SQL语句来存储一到多条记录

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

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

        try {
            // 加载数据库驱动
            Class.forName(DBConfig.getProperty("driver"));

            // 建立数据库连接
            conn = DriverManager.getConnection(DBConfig.getProperty("url"),
                    DBConfig.getProperty("username"), DBConfig.getProperty("password"));

            // 执行SQL语句
            String sql = "INSERT INTO users (username, password) VALUES (?, ?)";
            stmt = conn.prepareStatement(sql);
            stmt.setString(1, "value1");
            stmt.setString(2, "value2");
            stmt.executeUpdate();

            // 存储多条记录
            sql = "INSERT INTO users (username, password) VALUES (?, ?), (?, ?), (?, ?)";
            stmt = conn.prepareStatement(sql);
            stmt.setString(1, "value1");
            stmt.setString(2, "value2");
            stmt.setString(3, "value3");
            stmt.setString(4, "value4");
            stmt.setString(5, "value5");
            stmt.setString(6, "value6");
            stmt.executeUpdate();

            System.out.println("成功插入数据");
        } catch (ClassNotFoundException | SQLException e) {
            e.printStackTrace();
        } finally {
            try {
                if (stmt != null) {
                    stmt.close();
                }
                if (conn != null) {
                    conn.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

然后idea运行Conn2
成功插入数据

总结起来，JDBC封装资源文件可以通过使用Properties类来实现，而存储一到多条记录可以使用PreparedStatement对象执行SQL语句，并通过setString等方法设置参数。

数据库与JDBC手写对象和SQL自动映射框架

手写对象和SQL自动映射框架可以简化数据库操作的代码，提高开发效率和代码可维护性。下面是一个简单的手写对象和SQL自动映射框架的示例：
1.定义一个User类表示数据库中的用户表

public class User {
    private int id;
    private String username;
    private String password;

    public User() {
    }

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

    public int getId() {
        return id;
    }

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

    public String getUsername() {
        return username;
    }

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

    public String getPassword() {
        return password;
    }

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

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

2.创建一个UserDao类来完成数据库操作：

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

public class UserDao {
    private Connection conn;

    public UserDao(Connection conn) {
        this.conn = conn;
    }

    public User findById(int id) throws SQLException {
        String sql = "SELECT * FROM users WHERE id = ?";
        PreparedStatement stmt = conn.prepareStatement(sql);
        stmt.setInt(1, id);
        ResultSet rs = stmt.executeQuery();

        if (rs.next()) {
            User user = new User();
            user.setId(rs.getInt("id"));
            user.setUsername(rs.getString("username"));
            user.setPassword(rs.getString("password"));
            return user;
        }

        return null;
    }

    public List<User> findAll() throws SQLException {
        String sql = "SELECT * FROM users";
        PreparedStatement stmt = conn.prepareStatement(sql);
        ResultSet rs = stmt.executeQuery();

        List<User> userList = new ArrayList<>();
        while (rs.next()) {
            User user = new User();
            user.setId(rs.getInt("id"));
            user.setUsername(rs.getString("username"));
            user.setPassword(rs.getString("password"));
            userList.add(user);
        }

        return userList;
    }

    public void save(User user) throws SQLException {
        String sql = "INSERT INTO users (username, password) VALUES (?, ?)";
        PreparedStatement stmt = conn.prepareStatement(sql);
        stmt.setString(1, user.getUsername());
        stmt.setString(2, user.getPassword());
        stmt.executeUpdate();
    }

    public void update(User user) throws SQLException {
        String sql = "UPDATE users SET username = ?, password = ? WHERE id = ?";
        PreparedStatement stmt = conn.prepareStatement(sql);
        stmt.setString(1, user.getUsername());
        stmt.setString(2, user.getPassword());
        stmt.setInt(3, user.getId());
        stmt.executeUpdate();
    }

    public void delete(int id) throws SQLException {
        String sql = "DELETE FROM users WHERE id = ?";
        PreparedStatement stmt = conn.prepareStatement(sql);
        stmt.setInt(1, id);
        stmt.executeUpdate();
    }
}

在上述代码中，UserDao类封装了数据库的增删改查操作。通过传入Connection对象来进行数据库连接，并使用PreparedStatement对象执行SQL语句。在查询操作中，通过ResultSet对象获取查询结果，并将结果映射到User对象中。
3.使用示例代码来演示如何使用UserDao类进行数据库操作：

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.List;


public class Conn3 {
    public static void main(String[] args) {
        try {
            // 建立数据库连接
            Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/security",
                    "root", "root");

            // 创建UserDao对象
            UserDao userDao = new UserDao(conn);

            // 查询用户
            User user = userDao.findById(1);
            System.out.println(user);

            // 查询所有用户
            List<User> userList = userDao.findAll();
            System.out.println(userList);

            // 新增用户
            User newUser = new User();
            newUser.setUsername("test");
            newUser.setPassword("123456");
            userDao.save(newUser);

            // 更新用户
            user.setUsername("newUsername");
            userDao.update(user);

            // 删除用户
            userDao.delete(user.getId());

            // 关闭数据库连接
            conn.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}


在上述代码中，首先通过DriverManager.getConnection建立数据库连接，然后创建UserDao对象。接下来，可以使用UserDao对象进行数据库操作，例如查询用户、查询所有用户、新增用户、更新用户和删除用户。
总结起来，手写对象和SQL自动映射框架可以通过定义对象类和封装数据库操作的DAO类来实现。通过传入Connection对象来进行数据库连接，并使用PreparedStatement对象执行SQL语句。在查询操作中，通过ResultSet对象获取查询结果，并将结果映射到对象中。