IDEA用Maven連接MySQL的jdbc驅動，並操作數據庫

1、在IDEA里創建Maven項目

1.1、點擊Create New Project

 

1.2、選擇Maven，JDK這里用的是1.8，點擊Next

 1.3、填入“組織名”、“項目名”，版本是默認的，點擊Next

 

1.4、選擇創建路徑，點擊Finsh

 

1.5、這是創建完成的界面

 

2、用Maven連接Mysql的JDBC驅動

2.1、打開src下的pom.xml文件， 在里面添加Mysql的jdbc包的引用，代碼如下

<dependencies>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.18</version>
    </dependency>
</dependencies>

2.2、添加完成后，IDEA右下角會出現下圖提示，點擊提示中的Import Changes，Maven就會開始下載資源

 

2.3、下載時頁面左下角出現正在下載的提示

 

2.4、下載完成變成綠勾

 

3、連接數據庫第一種方式：直接注冊驅動，向數據庫插入數據（不推薦使用）

3.1、在src——main——java目錄下，新建一個LinkDatabaseInsert的類

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

public class LinkDatabaseInsert {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        //1.注冊數據庫的驅動
        Class.forName("com.mysql.jdbc.Driver");
        //2.獲取數據庫連接（里面內容依次是："jdbc:mysql://主機名:端口號/數據庫名","用戶名","登錄密碼"）
        Connection connection = DriverManager.getConnection("jdbc:mysql://rm-uf6lgkv4fd9776rxego.mysql.rds.aliyuncs.com:3306/study","root","whmilyY123!");
        //3.需要執行的sql語句（?是占位符，代表一個參數）
        String sql = "insert into stu(id,name,age) values(?,?,?)";
        //4.獲取預處理對象，並依次給參數賦值
        PreparedStatement statement = connection.prepareCall(sql);
        statement.setInt(1,12); //數據庫字段類型是int，就是setInt；1代表第一個參數
        statement.setString(2,"小明");    //數據庫字段類型是String，就是setString；2代表第二個參數
        statement.setInt(3,16); //數據庫字段類型是int，就是setInt；3代表第三個參數
        //5.執行sql語句（執行了幾條記錄，就返回幾）
        int i = statement.executeUpdate();
        System.out.println(i);
        //6.關閉jdbc連接
        statement.close();
        connection.close();
    }
}

3.2、運行程序，返回1，說明插入成功

 

4、連接數據庫第二種方式——新建數據庫配置文件，獲取配置文件信息后，再注冊數據庫驅動

4.1、利用反射獲取新建的數據庫配置文件db.properties里的信息

4.1.1、在src——main——resources目錄下，新建db.properties文件

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://rm-uf6lg6rxego.mysql.rds.aliyuncs.com:3306/study
user=root
password=wY123!

 4.1.2、新建util包，然后在里面創建JdbcUtil類，利用反射獲取db.properties文件信息，最后返回數據庫連接

package util;

import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.util.Properties;

//獲取到db.properties文件中的數據庫信息
public class JdbcUtil {
    //私有變量
    private static String driver;
    private static String url;
    private static String user;
    private static String password;

    //靜態塊
    static{
        try{
            //1.新建屬性集對象
            Properties properties = new Properties();
            //2通過反射，新建字符輸入流，讀取db.properties文件
            InputStream input = JdbcUtil.class.getClassLoader().getResourceAsStream("db.properties");
            //3.將輸入流中讀取到的屬性，加載到properties屬性集對象中
            properties.load(input);
            //4.根據鍵，獲取properties中對應的值
            driver = properties.getProperty("driver");
            url = properties.getProperty("url");
            user = properties.getProperty("user");
            password = properties.getProperty("password");
        }catch(Exception e){
            e.printStackTrace();
        }
    }

    //返回數據庫連接
    public static Connection getConnection(){
        try{
            //注冊數據庫的驅動
            Class.forName(driver);
            //獲取數據庫連接（里面內容依次是：主機名和端口、用戶名、密碼）
            Connection connection = DriverManager.getConnection(url,user,password);
            //返回數據庫連接
            return connection;
        }catch (Exception e){
            e.printStackTrace();
        }
        return null;
    }
}

 4.1.3、在java目錄下創建LinkMysql類，調用JdbcUtil類返回的數據庫連接操作數據庫

import util.JdbcUtil;

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

public class LinkMysql {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        //獲取數據庫連接
        Connection connection = JdbcUtil.getConnection();
        //需要執行的sql語句
        String sql = "insert into stu(id,name,age) values(?,?,?)";
        //獲取預處理對象，並給參數賦值
        PreparedStatement statement = connection.prepareCall(sql);
        statement.setInt(1,14);
        statement.setString(2,"李四");
        statement.setInt(3,16);
        //執行sql語句（插入了幾條記錄，就返回幾）
        int i = statement.executeUpdate();  //executeUpdate：執行並更新
        System.out.println(i);
        //關閉jdbc連接
        statement.close();
        connection.close();
    }
}

 

4.2、通過ResourceBundle類獲取新建的數據庫配置文件db.properties里的信息

4.2.1、在util包里面創建創建JdbcUtil2類，ResourceBundle類獲取db.properties文件信息，最后返回數據庫連接

package util;

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

public class JdbcUtil2 {
    //私有變量
    private static String driver;
    private static String url;
    private static String user;
    private static String password;

    //靜態塊
    static{
        try{
            //2.3通過ResourceBundle類拿到數據庫連接信息
            ResourceBundle resourceBundle = ResourceBundle.getBundle("db");
            driver = resourceBundle.getString("driver");
            url = resourceBundle.getString("url");
            user = resourceBundle.getString("user");
            password = resourceBundle.getString("password");
        }catch(Exception e){
            e.printStackTrace();
        }
    }

    //返回數據庫連接
    public static Connection getConnection(){
        try{
            //注冊數據庫的驅動
            Class.forName(driver);
            //獲取數據庫連接（里面內容依次是：主機名和端口、用戶名、密碼）
            Connection connection = DriverManager.getConnection(url,user,password);
            //返回數據庫連接
            return connection;
        }catch (Exception e){
            e.printStackTrace();
        }
        return null;
    }

    //關閉結果集
    public static void closeResultSet(ResultSet resultSet) {
        if (resultSet != null) {
            try {
                resultSet.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    //關閉預處理對象
    public static void closeStatement(Statement statement) {
        if (statement != null) {
            try {
                statement.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    //關閉數據庫連接
    public static void closeConnection(Connection connection){
        if(connection != null){
            try {
                connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    //一次性關閉上面三個
    public static void closeResource(ResultSet resultSet,Statement statement,Connection connection){
        closeResultSet(resultSet);
        closeStatement(statement);
        closeConnection(connection);
    }
}

 

4.2.2、在java目錄下創建LinkMysql2類，調用JdbcUtil2類返回的數據庫連接操作數據庫

import util.JdbcUtil2;

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

public class LinkMysql2 {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        //獲取數據庫連接
        Connection connection = JdbcUtil2.getConnection();
        //需要執行的sql語句
        String sql = "insert into stu(id,name,age) values(?,?,?)";
        //獲取預處理對象，並給參數賦值
        PreparedStatement statement = connection.prepareCall(sql);
        statement.setInt(1,19);
        statement.setString(2,"王五");
        statement.setInt(3,16);
        //執行sql語句（執行了幾條記錄，就返回幾）
        int i = statement.executeUpdate();  //executeUpdate：執行並更新
        System.out.println(i);
        //關閉jdbc連接
        JdbcUtil2.closeResource(null,statement,connection);
    }
}
import util.JdbcUtil2;

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

public class LinkMysql2 {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        //獲取數據庫連接
        Connection connection = JdbcUtil2.getConnection();
        //需要執行的sql語句
        String sql = "insert into stu(id,name,age) values(?,?,?)";
        //獲取預處理對象，並給參數賦值
        PreparedStatement statement = connection.prepareCall(sql);
        statement.setInt(1,19);
        statement.setString(2,"王五");
        statement.setInt(3,16);
        //執行sql語句（執行了幾條記錄，就返回幾）
        int i = statement.executeUpdate();  //executeUpdate：執行並更新
        System.out.println(i);
        //關閉jdbc連接
        JdbcUtil2.closeResource(null,statement,connection);
    }
}

 

5、連接數據庫的第三種方式：新建數據庫配置文件，獲取配置文件信息后，再通過DButils工具包連接數據庫

5.1、打開src下的pom.xml文件， 在里面添加DButils的引用，代碼如下

<dependency>
    <groupId>commons-dbutils</groupId>
    <artifactId>commons-dbutils</artifactId>
    <version>1.5</version>
</dependency>

 5.2、創建DbutilsInsert類，往數據庫內插入數據，代碼如下

import org.apache.commons.dbutils.QueryRunner;
import util.JdbcUtil2;

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

public class DbutilsInsert {
    public static void main(String[] args) throws SQLException {
        //創建dbUtils里面的QueryRunner對象
        QueryRunner queryRunner = new QueryRunner();
        //sql語句
        String sql = "insert into stu(id,name,age) values(?,?,?)";
        //存參數值的數組
        Object[] objects = {20,"小紅",11};
        //獲取數據庫連接
        Connection connection = JdbcUtil2.getConnection();
        //執行sql語句，並返回影響的行數
        int i = queryRunner.update(connection,sql,objects);
        System.out.println(i);
        //關閉數據庫連接
        connection.close();
    }
}

 5.3、創建DbutiUpdate類，更新數據庫內數據，代碼如下

import org.apache.commons.dbutils.QueryRunner;
import util.JdbcUtil2;

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

public class DbutilsUpdate {
    public static void main(String[] args) throws SQLException {
        //創建dbUtils里面的QueryRunner對象
        QueryRunner queryRunner = new QueryRunner();
        //sql語句
        String sql = "update stu set name=? where id=?";
        //存參數值的數組
        Object[] objects = {"紅紅",21};
        //獲取數據庫連接
        Connection connection = JdbcUtil2.getConnection();
        //執行sql語句，並返回影響的行數
        int i = queryRunner.update(connection,sql,objects);
        System.out.println(i);
        //關閉數據庫連接
        connection.close();
    }
}

 5.4、創建DbutiDelete類，刪除數據庫內數據，代碼如下

import org.apache.commons.dbutils.QueryRunner;
import util.JdbcUtil2;

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

public class DbutilsDelete {
    public static void main(String[] args) throws SQLException {
        //創建dbUtils里面的QueryRunner對象
        QueryRunner queryRunner = new QueryRunner();
        //sql語句
        String sql = "delete from stu where id=?";
        //存參數值的數組
        Object[] objects = {11};
        //獲取數據庫連接
        Connection connection = JdbcUtil2.getConnection();
        //執行sql語句，並返回影響的行數
        int i = queryRunner.update(connection,sql,objects);
        System.out.println(i);
        //關閉數據庫連接
        connection.close();
    }
}

 5.5、創建UtilsSelectArrayHandler類，查詢數據（ArrayHandler()只會返回第一條記錄）

import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.ArrayHandler;
import util.JdbcUtil2;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.Arrays;

public class UtilsSelectArrayHandler {
    public static void main(String[] args) throws SQLException {
        //創建dbUtils里面的QueryRunner對象
        QueryRunner queryRunner = new QueryRunner();
        //sql語句
        String sql = "select * from stu where age>?";
        //獲取數據庫連接
        Connection connection = JdbcUtil2.getConnection();
        //存參數值的數組
        Object[] params = {16};
        //執行查詢，並以數組的形式返回查詢結果（new ArrayHandler()只會返回第一條記錄）
        Object[] objects = queryRunner.query(connection,sql, new ArrayHandler(),params);
        System.out.println(Arrays.toString(objects));
        System.out.println("\n");
        //關閉數據庫連接
        connection.close();
    }
}

 5.6、創建UtilsSelectArrayListHandler類，查詢數據（ArrayListHandler()會返回所有查詢到的記錄）

import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.ArrayListHandler;
import util.JdbcUtil2;

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

public class UtilsSelectArrayListHandler {
    public static void main(String[] args) throws SQLException {
        //創建dbUtils里面的QueryRunner對象
        QueryRunner queryRunner = new QueryRunner();
        //sql語句
        String sql = "select * from stu where age>?";
        //獲取數據庫連接
        Connection connection = JdbcUtil2.getConnection();
        //存參數值的數組
        Object[] params = {16};
        //執行查詢，並以數組的形式返回查詢結果（new ArrayListHandler()返回所有查詢到的記錄）
        List<Object[]> lists = queryRunner.query(connection,sql, new ArrayListHandler(),params);
        for(Object[] item:lists){
            System.out.println(Arrays.toString(item));
        }
        //關閉數據庫連接
        connection.close();
    }
}

 

 5.7、創建UtilsSelectBeanHandler類，查詢數據，並將查詢數據 轉成實際對象（ BeanHandler只會返回 第一條記錄）
先創建student類

public class Student {
    private String id;
    private String name;
    private int age;
    private  String tname;

    public String getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getTname() {
        return tname;
    }

    public void setTname(String tname) {
        this.tname = tname;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", tname='" + tname + '\'' +
                '}';
    }
}

再創建UtilsSelectBeanHandler類

import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import util.JdbcUtil2;

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

public class UtilsSelectBeanHandler {
    public static void main(String[] args) throws SQLException {
        //創建dbUtils里面的QueryRunner對象
        QueryRunner queryRunner = new QueryRunner();
        //sql語句
        String sql = "select * from stu where age>?";
        //獲取數據庫連接
        Connection connection = JdbcUtil2.getConnection();
        //存參數值的數組
        Object[] params = {16};
        //執行查詢，並以數組的形式返回查詢結果（new BeanHandler()只會返回第一條記錄，並轉成對象）
        Student student = queryRunner.query(connection,sql, new BeanHandler<Student>(Student.class),params);
        System.out.println(student);
        System.out.println("\n");
        //關閉數據庫連接
        connection.close();
    }
}

 5.8、創建UtilsSelectBeanListHandler類，查詢數據，並將查詢數據 轉成實際對象（ BeanListHandler會返回查詢到的 所有記錄）

import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import util.JdbcUtil2;

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

public class UtilsSelectBeanListHandler {
    public static void main(String[] args) throws SQLException {
        //創建dbUtils里面的QueryRunner對象
        QueryRunner queryRunner = new QueryRunner();
        //sql語句
        String sql = "select * from stu where age>?";
        //獲取數據庫連接
        Connection connection = JdbcUtil2.getConnection();
        //存參數值的數組
        Object[] params = {16};
        //執行查詢，並以數組的形式返回查詢結果（new BeanListHandler()返回查詢到的所有記錄，並轉成對象）
        List<Student> students = queryRunner.query(connection,sql, new BeanListHandler<Student>(Student.class),params);
        System.out.println(students);
        //關閉數據庫連接
        connection.close();
    }
}

 5.9、創建UtilsSelectColumnListHandler類，查詢數據（ColumnListHandler會返回結果中指定的列）

import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.ColumnListHandler;
import util.JdbcUtil2;

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

public class UtilsSelectColumnListHandler {
    public static void main(String[] args) throws SQLException {
        //創建dbUtils里面的QueryRunner對象
        QueryRunner queryRunner = new QueryRunner();
        //sql語句
        String sql = "select * from stu where age>?";
        //獲取數據庫連接
        Connection connection = JdbcUtil2.getConnection();
        //存參數值的數組
        Object[] params = {16};
        //執行查詢，並以數組的形式返回查詢結果（new ColumnListHandler<>()返回結果中指定的列）
        List<Object> strs = queryRunner.query(connection,sql, new ColumnListHandler<>("name"),params);
        System.out.println(strs);
        for(Object item:strs){
            System.out.println(item);
        }
        //關閉數據庫連接
        connection.close();
    }
}

 5.10、創建UtilsSelectScalarHandler類，查詢單數據（ScalarHandler返回分組函數的值）

import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.ScalarHandler;
import util.JdbcUtil2;

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

public class UtilsSelectScalarHandler {
    public static void main(String[] args) throws SQLException {
        //創建dbUtils里面的QueryRunner對象
        QueryRunner queryRunner = new QueryRunner();
        //sql語句
        String sql = "select max(age) from stu";
        //獲取數據庫連接
        Connection connection = JdbcUtil2.getConnection();
        //存參數值的數組
        Object[] params = {};
        //執行查詢，並以數組的形式返回查詢結果（new ScalarHandler<>()返回分組函數的值）
        int age = queryRunner.query(connection,sql, new ScalarHandler<>(),params);
        System.out.println(age);
        //關閉數據庫連接
        connection.close();
    }
}

6、用c3p0連接池，連接數據庫

6.1、在scr——pom.xml文件里，引入c3p0包

<dependency>
    <groupId>c3p0</groupId>
    <artifactId>c3p0</artifactId>
    <version>0.9.1.2</version>
</dependency>

 6.2、在src——main——resources下增加c3p0-config.mxl文件

<?xml version="1.0" encoding="UTF-8"?>
 
<c3p0-config>
  <default-config>
    <!-- 配置數據庫驅動 -->
    <property name="driverClass">com.mysql.jdbc.Driver</property>
    <!-- 配置數據庫鏈接地址 -->
    <property name="jdbcUrl">jdbc:mysql://rm-uf9776rxego.mysql.rds.aliyuncs.com:3306/study</property>
    <!-- 配置數據庫用戶名 -->
    <property name="user">root</property>
    <!-- 配置數據庫密碼 -->
    <property name="password">whmilyY123!</property>

    <!-- 擴展配置 -->
    <!-- 獲取連接超時設置，默認是一直等待，單位毫秒 -->
    <property name="checkoutTimeout">30000</property>
    <!--每多少秒檢查所有連接池中的空閑連接。Default: 0 -->
    <property name="idleConnectionTestPeriod">30</property>
    <!-- 初始化連接池的連接數 -->
    <property name="initialPoolSize">10</property>
    <!--最大空閑時間,多少秒內未使用則連接被丟棄。若為0則永不丟棄。Default: 0 -->
    <property name="maxIdleTime">30</property>
    <!--連接池中保留的最大連接數。Default: 15 -->
    <property name="maxPoolSize">100</property>
    <!-- 連接池中保留的最小連接數 -->
    <property name="minPoolSize">10</property>
    <!--JDBC的標准參數，用以控制數據源內加載的PreparedStatements數量。但由於預緩存的statements屬於單個connection而不是整個連接池。所以設置這個參數需要考慮到多方面的因素。如果maxStatements與maxStatementsPerConnection均為0，則緩存被關閉。Default:0 -->
    <property name="maxStatements">200</property>
    <!--maxStatementsPerConnection定義了連接池內單個連接所擁有的最大緩存statements數。Default: 0 -->
    <property name="maxStatementsPerConnection">200</property>
    <!--c3p0是異步操作的，緩慢的JDBC操作通過幫助進程完成。擴展這些操作可以有效的提升性能 通過多線程實現多個操作同時被執行。Default:3 -->
    <property name="numHelperThreads">3</property>
  </default-config>
</c3p0-config>

 6.3、在src——main——java——util里添加DataSourceUtils類

package util;

import com.mchange.v2.c3p0.ComboPooledDataSource;

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class DataSourceUtils {
    private static ComboPooledDataSource ds = new ComboPooledDataSource();

    /**
     * 獲取數據源
     *
     * @return 連接池
     */
    public static DataSource getDataSource() {
        return ds;
    }

    /**
     * 釋放資源
     *
     * @param conn
     * @param st
     * @param rs
     */
    public static void CloseResource(Connection conn, Statement st, ResultSet rs) {
        closeResultSet(rs);
        closeStaement(st);
        closeConn(conn);
    }

    /**
     * 獲取連接
     *
     * @return 連接
     * @throws SQLException
     */
    public static Connection getConnection() throws SQLException {
        return ds.getConnection();
    }

    /**
     * 釋放連接
     *
     * @param conn 連接
     */
    public static void closeConn(Connection conn) {
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            } finally {
                conn = null;
            }
        }
    }

    /**
     * 釋放語句執行者
     *
     * @param st 語句執行者
     */
    public static void closeStaement(Statement st) {
        if (st != null) {
            try {
                st.close();
            } catch (SQLException e) {
                e.printStackTrace();
            } finally {
                st = null;
            }
        }
    }

    /**
     * 釋放結果集
     *
     * @param rs 結果集
     */
    public static void closeResultSet(ResultSet rs) {
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            } finally {
                rs = null;
            }
        }
    }
}

 6.4、新建C3p0Select類，用數據庫連接池的方式查詢

import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import util.DataSourceUtils;

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

public class C3p0Select {
    public static void main(String[] args) throws SQLException {
        //創建dbUtils里面的QueryRunner對象,並獲取數據庫連接
        QueryRunner queryRunner = new QueryRunner(DataSourceUtils.getDataSource());
        //sql語句
        String sql = "select * from stu where age>?";
        //存參數值的數組
        Object[] params = {16};
        //執行查詢，並以數組的形式返回查詢結果（new BeanListHandler()返回查詢到的所有記錄，並轉成對象）
        List<Student> students = queryRunner.query(sql, new BeanListHandler<Student>(Student.class),params);
        System.out.println(students);
    }
}