com.jsj.utils===新闻发布系统（5）

2020-05-14

刚刚我完成了对dao层的业务的定义，定义了我们需要实现的操作的名称

下面我开始介绍工具类，这个就是工具，就是通过提前写好什么类，

然后后面如果你遇到，就直接调用就好了

为什么我要先介绍了？

　　因为，后面daoImpl需要调用方法，害怕等会看不懂

BeanHandler.java

package com.jsj.utils;

import java.sql.ResultSet;

public class BeanHandler extends ResultSetHandler {

    private Class<?> clazz;
    //构造函数：来初始化的
    public BeanHandler(Class<?> clazz){
        this.clazz = clazz;
    }

    @Override
    public Object handle(ResultSet resultSet) throws Exception {
        if (resultSet.next()){
            return buildObject(resultSet, clazz);
        }else {
            return null;
        }
    }

}

BeanListHandler.java

package com.jsj.utils;

import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;

public class BeanListHandler extends ResultSetHandler {
    //无法确定类型的泛型
    private Class<?> clazz;
    //也是初始化变量
    public BeanListHandler(Class<?> clazz){
        this.clazz = clazz;
    }

    @Override
    public List handle(ResultSet resultSet) throws Exception {
        //数组
        List list = new ArrayList();
        //
        while(resultSet.next()) {
            Object bean = buildObject(resultSet, clazz);
            list.add(bean);
        }
        return list;
    }
}

JdbcTemple.java

package com.jsj.utils;

import java.sql.*;

public class JdbcTemplate {

    private JdbcTemplate(){
    }

    /**
     * 更新方法
     */
    public static int update(String sql, Object ...params) throws SQLException {
       //创建连接
        Connection connection = JdbcUtils.getConnection();
        //然后是获取PreparedStatement对象
        //try(语句)这种写法，可以自动调动close（）方法
        try(PreparedStatement preparedStatement = connection.prepareStatement(sql)){
           //这个是赋值，一个问号对应一哥变量，数从1开始
            for (int i = 1; i <= params.length; i++){
                preparedStatement.setObject(i, params [i-1]);
            }
            //返回的是数据库发生改变的行数目，
            //可以用来确定是否执行成功
            return preparedStatement.executeUpdate();
        }finally {
            //释放了申请的资源
            //比如connection
            JdbcUtils.releaseConnection(connection);
        }
    }

    /**
     * 查询方法
     */
    public static Object query(String sql, ResultSetHandler handler, Object... params) throws Exception {
        //创建连接对象
        Connection connection = JdbcUtils.getConnection();
        //执行sql语句
        try(PreparedStatement preparedStatement = connection.prepareStatement(sql)){
            //读出值
            for (int i = 1; i <= params.length; i++){
                preparedStatement.setObject(i, params [i-1]);
            }
            //resultSet就是flag,就是确定是否成功
            try(ResultSet resultSet = preparedStatement.executeQuery()){
                //
                return handler.handle(resultSet);
            }
        }finally {
            //释放connection资源
            JdbcUtils.releaseConnection(connection);
        }
    }

    public static int queryCount(String sql, Object... params) throws Exception{
        //创建数据库连接
        Connection connection = JdbcUtils.getConnection();
        //括号里面是导入sql语句，获取对象
        try(PreparedStatement preparedStatement = connection.prepareStatement(sql)){
            //这个是赋值
            for (int i = 1; i <= params.length; i++){
                preparedStatement.setObject(i, params [i-1]);
            }
            //执行sql语句
            try(ResultSet resultSet = preparedStatement.executeQuery()){
                //读取数据的时候
                if (resultSet.next()){
                    //还有返回1
                    return resultSet.getInt(1);
                }else {
                    //没有数据了，返回-1
                    return -1;
                }
            }
        }finally {
            JdbcUtils.releaseConnection(connection);
        }
    }

}

JdbcUtils.java

package com.jsj.utils;

import com.mchange.v2.c3p0.ComboPooledDataSource;

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

/**
 * jdbc工具类
 */
public class JdbcUtils {

    private static ComboPooledDataSource dataSource = new ComboPooledDataSource();

    private static ThreadLocal<Connection> threadLocal = new ThreadLocal<>();

    public static Connection getConnection() throws SQLException {
        Connection transactionConnection = threadLocal.get();
        if (transactionConnection!=null){
            return transactionConnection;
        }
        return dataSource.getConnection();
    }

    /**
     * 开启事务
     */
    public static void beginTransaction() throws SQLException {
        Connection transactionConnection = threadLocal.get();
        if (transactionConnection!=null){
            throw new SQLException("事务已开启");
        }
        transactionConnection = getConnection();
        transactionConnection.setAutoCommit(false);
        threadLocal.set(transactionConnection);
    }

    /**
     * 提交事务
     */
    public static void commitTransaction() throws SQLException {
        Connection transactionConnection = threadLocal.get();
        if (transactionConnection==null){
            throw new SQLException("事务未开启");
        }
        transactionConnection.commit();
        transactionConnection.close();
        threadLocal.remove();
    }

    /**
     * 回滚事务
     */
    public static void rollbackTransaction() throws SQLException {
        Connection transactionConnection = threadLocal.get();
        if (transactionConnection==null){
            throw new SQLException("事务未开启");
        }
        transactionConnection.rollback();
        transactionConnection.close();
        threadLocal.remove();
    }

    /**
     * 释放连接资源
     */
    public static void releaseConnection(Connection connection) throws SQLException {
        if (threadLocal.get()==null){
            connection.close();
            return;
        }
        if (connection!=threadLocal.get()){
            connection.close();
        }
    }
}

 ResultSetHandler.java

package com.jsj.utils;

import java.lang.reflect.Field;
import java.sql.ResultSet;

abstract class ResultSetHandler {

    abstract Object handle(ResultSet resultSet) throws Exception;

    Object buildObject(ResultSet resultSet, Class<?> clazz) throws Exception {
        Object bean = clazz.newInstance();
        Field[] fields = clazz.getDeclaredFields();
        // 封装数据
        for (int i = 1; i <= resultSet.getMetaData().getColumnCount(); i ++) {
            Object value = resultSet.getObject(i);
            //匹配实体类中对应的属性
            for (Field field : fields) {
                if (resultSet.getMetaData().getColumnName(i).replaceAll("_","").equals(field.getName().toLowerCase())) {
                    boolean flag = field.isAccessible();
                    field.setAccessible(true);
                    field.set(bean, value);
                    field.setAccessible(flag);
                    break;
                }
            }
        }
        return bean;
    }

}