03.DML与DQL完整封装

需要导入两个依赖包

mysql 版本5.*的建议使用5.*的依赖包

<!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.21</version>
</dependency>
<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.45</version>
</dependency>

druid.properties配置文件

#驱动
driverClassName=com.mysql.jdbc.Driver

#连接url
url=jdbc:mysql://127.0.0.1:3306/qian_feng_cl?useUnicode=true&characterEncoding=UTF-8&rewriteBatchedStatements=true&useSSL=false&serverTimezone=UTC

#数据库用户名
username=root

#密码
password=123456

#初始化的时候，连接池中放多少个连接
initialSize=10

# 最大存货的连接数量
maxActive=50

#最小空闲数量
minIdle=5

# 最大的等待时间
maxWait=10000

#验证连接池中的连接是否有效的sql语句
validationQuery='select 1'

#在获取连接的时候，验证拿到连接是否为有效连接
testOnBorrow=false

#在归还连接的时候，验证是否为有效连接
test-on-return=false

#空闲的时候验证是否有效
test-while-idle=true

静态工具类DBUtil

package com.qf.cl.utils;

import com.alibaba.druid.pool.DruidDataSourceFactory;

import javax.sql.DataSource;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Method;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;

/**
 * ClassName: DBUtils
 * Description:
 *
 * @author CL
 * @version 1.0
 * @date: 2020/4/7
 */
public class DBUtils {

    private static DataSource dataSource;

    static{
        //获取输入流
        InputStream inputStream = DBUtils.class.getClassLoader().getResourceAsStream("druid.properties");
        //创建properties对象
        Properties properties = new Properties();

        try {
            //加载配置文件
            properties.load(inputStream);
            //获取数据源
            dataSource = DruidDataSourceFactory.createDataSource(properties);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    //获取连接
    public static Connection getConnection(){
        Connection connection = null;
        try {
            connection = dataSource.getConnection();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return connection;
    }

    /**
     * 返回所有数据
     */
    public static <T> List<T> getAll(Class<T> clazz, ResultSet resultSet) throws Exception {
    
        List<T> list = new ArrayList<>();

        // while循环是遍历每一行的数据
        while(resultSet.next()) {
        
            // 生成一个实例， 数据的一行对应着一个对象
            T t = clazz.newInstance();
            
            // 返回数据库的元数据信息, 元数据信息中包含列明，列的类型， 列的数量
            ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
            
            //获取列的数量
            int colums = resultSetMetaData.getColumnCount();
            
            // 遍历每一列，取出对应列的数据，然后赋值给对应的属性
            for(int i = 1; i <= colums; i++) {
            
                //获取字段名，或者别名
                String lable= resultSetMetaData.getColumnLabel(i);

                // 取每列对应的数据
                Object obj = resultSet.getObject(i);

                //获取属性的类型，因为通过反射获取 set方法的时候, 需要使用类型，set方法的参数类型和属性的类型是一致的
                Class<?> filedType = clazz.getDeclaredField(lable).getType();

                /**
                 * 拼接set的方法名: setName
                 * lable.substring(0,1).toUpperCase() 将首字母大写： name -> N
                 */
                String setMethodName = "set" + lable.substring(0,1).toUpperCase() + lable.substring(1);

                // 获取set方法
                Method setMethod = clazz.getMethod(setMethodName, filedType); // 获取 set方法
                
                // 给对应的属性设置值
                setMethod.invoke(t, obj);
            }
            list.add(t);
        }
        return list;
    }

    //释放连接
    public static void close(ResultSet resultSet, Statement statement,Connection connection){
        try{
            if(null != resultSet){
                resultSet.close();
            }
            if(null != statement){
                statement.close();
            }
            if(null != connection){
                connection.close();
            }
        }catch(Exception e){
            e.printStackTrace();
        }
    }


}

jdbc增删查改封装

IBaseDao接口基本的增删查改

package com.qf.cl.dao;

import java.util.List;
/**
 * 
 * @Title IBaseDao.java
 * @Package com.qianfeng.cl.dao
 * @Description 增删查改
 * @author CL 
 * @date 2020年3月27日
 * @version 1.0
 */
public interface IBaseDao {

	//添加，修改，删除数据
	boolean executeUpdate(String sql,Object... params);
	
	//查询一条数据
	<T> T executeQueryOne(Class<T> cls,String sql,Object... params);
	
	
	//查询多条数据
	<T> List<T> executeQuery(Class<T> cls,String sql,Object... params);
	
}

接口实现使用到了反射的知识和泛型

package com.qf.cl.dao.impl;

import com.qf.cl.dao.BaseDao;
import com.qf.cl.utils.DBUtils;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;

/**
 * 
 * @Title BaseDaoImpl.java
 * @Package com.qianfeng.cl.dao.impl
 * @Description 实现增删查改操作
 * @author CL 
 * @date 2020年3月27日
 * @version 1.0
 */
public class BaseDaoImpl implements IBaseDao{

	/**
	 * 对数据的增删改
	 * @param sql	sql语句
	 * @param params	预处理sql中的参数
	 * @return true/false	执行成功或失败
	 */
	@Override
	public boolean executeUpdate(String sql, Object... params) {
		
		//获取数据库连接
		Connection connection = DBUtils.getConnection();
		
		//操作数据对象
		PreparedStatement statement = null;
		
		try {
			//获取PreparedStatement对象
			statement = connection.prepareStatement(sql);
			
			//给sql添加参树
			setParams(statement,params);
			
			//执行sql语句获取影响的行数
			int result = statement.executeUpdate();
			
			//释放连接
			DBUtils.closeAll(null, statement, connection);
			
			//影响行数大于0,表示执行成功
			if(result > 0) {
				return true;
			}
			
		} catch (SQLException e) {
			e.printStackTrace();
		}
		//执行失败
		return false;
	}

	/**
	 * 查询一条数据
	 * @param <T>   泛型
	 * @param cls	Class对象
	 * @param sql	sql语句
	 * @param params 预处理sql中的参数
	 * @return
	 */
	@Override
	public <T> T executeQueryOne(Class<T> cls, String sql, Object... params) {
		
		//调用查询多条数据方法
		List<T> list = executeQuery(cls,sql,params);
		
		//获取第一条数据
		if(null != list && list.size() > 0) {
			return list.get(0);
		}
		return null;
	}

	/**
	 * 
	 * @param <T>  泛型
	 * @param cls	Class对象
	 * @param sql	sql语句
	 * @param params	预处理sql中的参数
	 * @return	list	List集合
	 */
	@Override
	public <T> List<T> executeQuery(Class<T> cls, String sql, Object... params) {
		//获取数据库连接
		Connection connection = DBUtils.getConnection();
		
		//操作对象
		PreparedStatement statement = null;
		
		//结果集
		ResultSet result = null;
		
		//返回值
		List<T> list = new ArrayList<T>();
		
		//value
		T obj;
		
		try {
			//获取PreparedStatement
			statement = connection.prepareStatement(sql);
			
			//为预处理sql添加参数
			setParams(statement,params);
			
			//获取结果集
			result = statement.executeQuery();
			
			//获取字段信息
			ResultSetMetaData info = result.getMetaData();
			
			//字段别名
			String name;
			
			//数值
			Object value;
			
			//将结果集添加到集合
			while(result.next()) {
				
				//list集中的value
				obj = cls.newInstance();
				
				//循环加反射添加数据
				for(int i = 0;i < info.getColumnCount();i++) {
					
					//获取字段别名
					name = info.getColumnLabel(i+1);
					
					//可能出现找不到该成员属性
					try {
						
						//获取属性
						Field field = cls.getDeclaredField(name);

						//获取参数类型
						Class<?> type = field.getType();

						//获取属性公共set方法名
						String methodname = "set"+name.substring(0,1).toUpperCase()+name.substring(1,name.length());

						//获取方法
						Method method = cls.getMethod(methodname,type);

						//获取数据
						value = result.getObject(name);
						

						if(null == value) {

							continue;
						}

						//执行方法
						method.invoke(obj,value);
						
					}catch(Exception e) {
						//该成员属性不存在不进行任何操作
					}
					
				}
				//将数据添加到集合
				list.add(obj);	
			}	
		} catch (Exception e) {
			e.printStackTrace();
		}
		return list;
	}

	/**
	 * 给预处理sql添加参数
	 * @param statement
	 * @param params
	 */
	private void setParams(PreparedStatement statement,Object... params) {
		for(int i = 0; i < params.length;i++) {
			try {
				//添加参数
				statement.setObject(i+1, params[i]);
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		
	}
}