使用Druid連接mysql數據

1.先導入maven

<dependency>
	<groupId>mysql</groupId>
	<artifactId>mysql-connector-java</artifactId>
	<version>5.1.47</version>
</dependency>
<dependency>
	<groupId>com.alibaba</groupId>
	<artifactId>druid</artifactId>
	<version>1.1.9</version>
</dependency>
<dependency>
	<groupId>commons-dbutils</groupId>
	<artifactId>commons-dbutils</artifactId>
	<version>1.6</version>
</dependency>

2.創建加載ProPerties配置文件工具類

public class ProPertiesUtil {

    /**
     * @param fileName 文件名稱
     */
    public static Properties getProperties(String fileName) {
        Properties properties = new Properties();
        // 使用ClassLoader加載properties配置文件生成對應的輸入流
        InputStream in = ProPertiesUtil.class.getClassLoader().getResourceAsStream(fileName);
        // 使用properties對象加載輸入流
        try {
            properties.load(in);
        } catch (IOException e) {
            e.printStackTrace();
        }
        //返回Properties對象
        return properties;
    }
}

3.創建mysql.properties

driverClassName=com.mysql.jdbc.Driver
username=root
password=******
url=jdbc:mysql://localhost:3306/test
initialSiz=5
maxActive=15
minIdle=5

4.創建連接數據庫的工具類

public class JDBCUtil {
    private static DruidDataSource dataSource;

    static {
        Properties properties = ProPertiesUtil.getProperties("mysql.properties");
        // 使用德魯伊數據庫連接池工廠類
        try {
            dataSource = (DruidDataSource) DruidDataSourceFactory.createDataSource(properties);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 獲取連接對象（從數據庫連接池中獲取）
     *
     * @return 連接對象
     */
    public static Connection getConnection() {
        Connection connection = null;
        try {
            connection = dataSource.getConnection();
        } catch (Exception e) {
            return null;
        }
        return connection;
    }

    /**
     * 關閉jdbc資源對象
     *
     * @param connection 連接對象
     */
    public static void close(Connection connection) {
        if (connection != null) {
            try {
                connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

5.scala操作數據庫工具類

import java.sql.{Connection, PreparedStatement, ResultSet, ResultSetMetaData, Statement}

import scala.collection.mutable
import scala.collection.mutable.ListBuffer

object SqlProxy {

    /**
      * 查詢結果並返回
      *
      * @param connection 連接對象
      * @param sql        sql語句
      * @param objects    參數
      */
    def executeSelectByBack(connection: Connection, sql: String, back: (ResultSet) => Unit, objects: Any*): Unit = {
        val statement: PreparedStatement = connection.prepareStatement(sql)
        //判斷參數是否爲空
        if (objects != null && objects.nonEmpty) {
            //將參數設置進去
            for (i <- objects.indices) {
                //參數索引從1開始
                statement.setObject(i + 1, objects(i))
            }
        }
        //執行查詢
        val resultSet: ResultSet = statement.executeQuery()
        back(resultSet)
        //關閉資源
        resultSet.close()
        statement.close()
    }

    /**
      * 查詢一條結果，返回map集合
      *
      * @param connection 連接對象
      * @param sql        sql語句
      * @param objects    參數
      * @return 返回map
      */
    def executeSelectOne(connection: Connection, sql: String, objects: Any*): mutable.HashMap[String, Any] = {
        //設置sql語句
        val preparedStatement: PreparedStatement = connection.prepareStatement(sql)
        //判斷參數是否爲空
        if (objects != null && objects.nonEmpty) {
            //將參數設置進去
            for (i <- objects.indices) {
                //參數索引從1開始
                preparedStatement.setObject(i + 1, objects(i))
            }
        }
        //執行查詢
        val resultSet: ResultSet = preparedStatement.executeQuery()
        //定義一個hashMap
        val resultMap = new mutable.HashMap[String, Any]()
        //獲取列名信息
        val metaData: ResultSetMetaData = resultSet.getMetaData
        //獲取一共有幾列
        val rowCount: Int = metaData.getColumnCount
        if (resultSet.next()) {
            for (i <- 1 to rowCount) {
                resultMap.put(metaData.getColumnName(i), resultSet.getObject(i))
            }
        }
        //關閉資源
        resultSet.close()
        preparedStatement.close()
        //返回
        resultMap
    }

    /**
      * 返回多條結果
      *
      * @param connection 連接對象
      * @param sql        sql語句
      * @param objects    參數
      * @return List[Map]
      */
    def executeSelectAll(connection: Connection, sql: String, objects: Any*): ListBuffer[mutable.HashMap[String, Any]] = {
        //設置sql語句
        val preparedStatement: PreparedStatement = connection.prepareStatement(sql)
        //判斷參數是否爲空
        if (objects != null && objects.nonEmpty) {
            //將參數設置進去
            for (i <- objects.indices) {
                //參數索引從1開始
                preparedStatement.setObject(i + 1, objects(i))
            }
        }
        //執行查詢
        val resultSet: ResultSet = preparedStatement.executeQuery()
        //定義一個hashMap
        val resultList = new ListBuffer[mutable.HashMap[String, Any]]()
        //獲取列名信息
        val metaData: ResultSetMetaData = resultSet.getMetaData
        //獲取一共有幾列
        val rowCount: Int = metaData.getColumnCount
        while (resultSet.next()) {
            val hashMap = new mutable.HashMap[String, Any]()
            for (i <- 1 to rowCount) {
                hashMap.put(metaData.getColumnName(i), resultSet.getObject(i))
            }
            resultList.append(hashMap)
        }
        //關閉資源
        resultSet.close()
        preparedStatement.close()
        //返回
        resultList
    }

    /**
      * 添加或者修改信息
      *
      * @param connection 連接對象
      * @param sql        sql語句
      * @param objects    參數
      */
    def executeUpdateOne(connection: Connection, sql: String, objects: Any*): Int = {
        //設置sql語句
        val preparedStatement: PreparedStatement = connection.prepareStatement(sql)
        //判斷參數是否爲空
        if (objects != null && objects.nonEmpty) {
            //將參數設置進去
            for (i <- objects.indices) {
                //參數索引從1開始
                preparedStatement.setObject(i + 1, objects(i))
            }
        }
        //執行
        val resultCount: Int = preparedStatement.executeUpdate()
        //關閉
        preparedStatement.close()
        //返回
        resultCount
    }

    /**
      * 批量添加或者修改信息
      *
      * @param connection 連接對象
      * @param sql        sql語句
      * @param objectList 參數數組
      */
    def executeUpdateAll(connection: Connection, sql: String, objectList: List[Array[Any]]): Array[Int] = {
        //設置sql語句
        val preparedStatement: PreparedStatement = connection.prepareStatement(sql)
        //判斷參數是否爲空
        if (objectList != null && objectList.nonEmpty) {
            //將參數設置進去
            objectList.foreach(arr => {
                for (i <- arr.indices) {
                    //參數索引從1開始
                    preparedStatement.setObject(i + 1, arr(i))
                }
                preparedStatement.addBatch()
            })
        }
        //執行
        val resultCountList: Array[Int] = preparedStatement.executeBatch()
        //關閉
        preparedStatement.close()
        //返回
        resultCountList
    }

    /**
      * 添加信息並返回主鍵
      *
      * @param connection 連接對象
      * @param sql        sql語句
      * @param objects    參數
      */
    def executeInsertOne(connection: Connection, sql: String, objects: Any*): Option[Long] = {
        //設置sql語句
        val preparedStatement: PreparedStatement = connection.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS)
        //判斷參數是否爲空
        if (objects != null && objects.nonEmpty) {
            //將參數設置進去
            for (i <- objects.indices) {
                //參數索引從1開始
                preparedStatement.setObject(i + 1, objects(i))
            }
        }
        //執行
        preparedStatement.executeUpdate()
        //獲取自增結果集
        val generatedKeys: ResultSet = preparedStatement.getGeneratedKeys
        var keyNum: Option[Long] = None
        //判斷是否有數據
        if (generatedKeys.next()) {
            keyNum = Some(generatedKeys.getLong(1))
        }
        //關閉
        generatedKeys.close()
        preparedStatement.close()
        //返回
        keyNum
    }

    /**
      * 批量添加信息,並返回主鍵
      *
      * @param connection 連接對象
      * @param sql        sql語句
      * @param objectList 參數數組
      */
    def executeInsertAll(connection: Connection, sql: String, objectList: List[Array[Any]]): ListBuffer[Long] = {
        //設置sql語句
        val preparedStatement: PreparedStatement = connection.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS)
        //判斷參數是否爲空
        if (objectList != null && objectList.nonEmpty) {
            //將參數設置進去
            objectList.foreach(arr => {
                for (i <- arr.indices) {
                    //參數索引從1開始
                    preparedStatement.setObject(i + 1, arr(i))
                }
                preparedStatement.addBatch()
            })
        }
        //執行
        preparedStatement.executeBatch()
        //獲取自增結果集
        val generatedKeys: ResultSet = preparedStatement.getGeneratedKeys
        var keyNumList = new ListBuffer[Long]()
        //判斷是否有數據
        while (generatedKeys.next()) {
            keyNumList.append(generatedKeys.getLong(1))
        }
        //關閉
        generatedKeys.close()
        preparedStatement.close()
        //返回
        keyNumList
    }
}

6.使用dbutils進行增刪改查

	/**
     * 查詢一條記錄
     */
    public static void selectOne() {
        //創建QueryRunner 對象
        QueryRunner queryRunner = new QueryRunner();
        //獲取Connection連接
        Connection connection = JDBCUtil.getConnection();
        //定義sql語句
        String sql = "select * from user where id=?";
        try {
            assert connection != null;
            //這條記錄返回Map集合
            Map<String, Object> objectMap = queryRunner.query(connection, sql, new MapHandler(), 2);
            System.out.println(objectMap);
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtil.close(connection);
        }
    }

    /**
     * 查詢多條記錄
     */
    public static void selectList() {
        //創建QueryRunner 對象
        QueryRunner queryRunner = new QueryRunner();
        //獲取Connection連接
        Connection connection = JDBCUtil.getConnection();
        //定義sql語句
        String sql = "select * from user";
        try {
            assert connection != null;
            //這條記錄返回Map集合
            List<Map<String, Object>> mapList = queryRunner.query(connection, sql, new MapListHandler());
            System.out.println(mapList);
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtil.close(connection);
        }
    }

    /**
     * 修改數據
     */
    public static void update() {
        //創建QueryRunner 對象
        QueryRunner queryRunner = new QueryRunner();
        //獲取Connection連接
        Connection connection = JDBCUtil.getConnection();
        //定義sql語句
        String sql = "update user set name=?,age=? where id=?";
        try {
            assert connection != null;
            queryRunner.update(connection, sql, "zhangsan", 30, 1);
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtil.close(connection);
        }
    }

    /**
     * 刪除記錄
     */
    public static void delete() {
        //創建QueryRunner 對象
        QueryRunner queryRunner = new QueryRunner();
        //獲取Connection連接
        Connection connection = JDBCUtil.getConnection();
        //定義sql語句
        String sql = "delete from user where id=?";
        try {
            assert connection != null;
            queryRunner.update(connection, sql, 1);
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtil.close(connection);
        }
    }

    /**
     * 添加一條記錄
     */
    public static void insertOne() {
        //創建QueryRunner 對象
        QueryRunner queryRunner = new QueryRunner();
        //獲取Connection連接
        Connection connection = JDBCUtil.getConnection();
        //定義sql語句
        String sql = "insert into user(name,age) values(?,?)";
        try {
            assert connection != null;
            int update = queryRunner.update(connection, sql, "zhangsan", 20);
            System.out.println(update);
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtil.close(connection);
        }
    }

    /**
     * 添加多條記錄
     */
    public static void insertBach() {
        //創建QueryRunner 對象
        QueryRunner queryRunner = new QueryRunner();
        //獲取Connection連接
        Connection connection = JDBCUtil.getConnection();
        //定義sql語句
        String sql = "insert into user(name,age) values(?,?)";
        try {
            assert connection != null;
            Object[][] list = new Object[5][2];
            list[0] = new Object[]{"zhangsan", 20};
            list[1] = new Object[]{"zhangsan", 21};
            list[2] = new Object[]{"zhangsan", 22};
            list[3] = new Object[]{"zhangsan", 23};
            list[4] = new Object[]{"zhangsan", 24};
            queryRunner.batch(connection, sql, list);
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtil.close(connection);
        }
    }

    /**
     * 添加一條記錄，返回自增主鍵
     */
    public static void insetOne() {
        //創建QueryRunner 對象
        QueryRunner queryRunner = new QueryRunner();
        //獲取Connection連接
        Connection connection = JDBCUtil.getConnection();
        //定義sql語句
        String sql = "insert into user(name,age) values(?,?)";
        try {
            assert connection != null;
            Long id = queryRunner.insert(connection, sql, new ScalarHandler<Long>(), "zhangsan", 20);
            System.out.println(id);
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtil.close(connection);
        }
    }

小知識點：(數據庫插入數據時存在則替換)

create table `user_info`(
   `uid` int(11) not null auto_increment primary key,
   `last_name` char(20) not null,
   `first_name` char(20) not null,
   unique key `uid_unique` (`uid`)
)ENGINE=INNODB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8

1.當數據存在時，不插入數據

insert ignore into user_info(uid,last_name,first_name) values (1,'x','y');

2.當數據存在時，更新數據

insert into user_info(uid,last_name,first_name) values(1,'x','y') on duplicate key update last_name='x',first_name='x';

replace into user_info(uid,last_name,first_name) values (1,'x','y');