数据库增删改查的封装

对于数据库库的添加，删除，修改，查询操作的封装，用到了集合，反射，异常，属相文件，JDBC，数组，连接池等技术。

1.java

package com.softeem.jdbc.utils;

import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Properties;
import java.util.Set;

import com.alibaba.druid.pool.DruidDataSource;


public class DBUtils {
	
	//申明一个连接池对象
	private static DruidDataSource pool;
	//申明一个url对象
	private static String url;
	//申明一个数据库用户名对象
	private static String username;
	//申明一个数据库密码对象
	private static String password;
	//申明一个初始化连接数对象
	private static int InitialSize;
	//申明一个最大连接数对象
	private static int MaxActive;
	//申明一个最小连接数对象
	private static int MinIdle;
	//申明一个最大等待时间对象（即当达到了最大连接数，等待其连接的时间）
	private static long MaxWait;
	//属相文件
	private static String pronName="/jdbc.properties";
	
	static {
		init();
	}
	
	/**
	 * 读取属性文件里面的内容
	 * @param proName
	 */
	private static void loadPro(String proName) {
		pronName=proName;
		InputStream is=DBUtils.class.getResourceAsStream(pronName);
		try {
			Properties p=new Properties();
			p.load(is);
			url=p.getProperty("jdbc.url");
			username=p.getProperty("jdbc.username");
			password=p.getProperty("jdbc.password");
			
			
			InitialSize=Integer.parseInt(p.getProperty("InitialSize"));
			MaxActive=Integer.parseInt(p.getProperty("MaxActive"));
			MinIdle=Integer.parseInt(p.getProperty("MinIdle"));
			MaxWait=Long.parseLong(p.getProperty("MaxWait"));
			
			
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
	/**
	 * 初始化连接池
	 */
	public static void init() {
		pool=new DruidDataSource();
		loadPro(pronName);
		pool.setUrl(url);
		pool.setUsername(username);
		pool.setPassword(password);
		
		pool.setInitialSize(InitialSize);
		pool.setMaxActive(MaxActive);
		pool.setMinIdle(MinIdle);
		pool.setMaxWait(MaxWait);
	}
	
	/**
	 * 连接连接池
	 * @return
	 */
	public static Connection getConn() {
		try {
			if (pool==null||pool.isClosed()) {
				init();
			}
			return pool.getConnection();
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return null;
	}
	
	/**
	 * 关闭资源
	 * @param st
	 * @param coon
	 */
	public static void close(Statement st,Connection coon) {
		try {
			if (st!=null) {
				st.close();
			}
			if (coon!=null) {
				coon.close();
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}

	/**
	 * 封装更新操作(包括添加，修改，删除)
	 */
	public static boolean exeUpdate(String sql,Object...obj) {
		Connection coon=null;
		PreparedStatement ps=null;
		try {
			coon=DBUtils.getConn();
			ps=coon.prepareStatement(sql);
			for (int i = 0; i < obj.length; i++) {
				ps.setObject(i+1, obj[i]);
			}
			return ps.executeUpdate()>0;
		} catch (SQLException e) {
			e.printStackTrace();
		}finally {
			try {
				coon.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		return false;
		
	}
	
	/**
	 * 封装查询操作
	 * @param t
	 * @param sql
	 * @param params
	 * @return
	 */
	public static <T> List<T> queryList(Class<T> t,String sql,Object...params){
		List<T> list=new ArrayList<>();
		T obj=null;
		Connection coon=null;
		PreparedStatement ps=null;
		try {
			coon=getConn();
			ps=coon.prepareStatement(sql);
			for (int i = 0; i < params.length; i++) {
				ps.setObject(i+1, params[i]);
			}
			ResultSet rs=ps.executeQuery();
			//获取表中的原数据（列名，列的类型，列值）
			ResultSetMetaData rsm=ps.getMetaData();
			Map<String,Object> map=new HashMap<>();
			while(rs.next()) {
				//在存储下一行数据之前清空map集合
				map.clear();
				for (int i = 0; i < rsm.getColumnCount(); i++) {
					//获取列名
					String columnNmae=rsm.getColumnName(i+1);
					//通过列名来获取列值
					Object columaValues=rs.getObject(columnNmae);
					//将列名和对应的列值添加到map集合中
					map.put(columnNmae, columaValues);
				}
				if(!map.isEmpty()) {
					//获取键集合
					Set<String> s=map.keySet();
					//创建实例对象
					obj=t.newInstance();
					//遍历键集合获取键值
					for (String str : s) {
						Object values=map.get(s);
						//通过列名获取java属性对象
						Field f=t.getDeclaredField(str);
						//不管是私有的还是共有的都允许对属相设值
						f.setAccessible(true);
						//对属相设值
						f.set(obj, values);
					}
				}
				//将java对象添加到集合当中
				list.add(obj);
				
			}
		} catch (SQLException e) {
			e.printStackTrace();
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		} catch (NoSuchFieldException e) {
			e.printStackTrace();
		} catch (SecurityException e) {
			e.printStackTrace();
		}finally{
			try {
				coon.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
				
		return list;
		
	}
	
	/**
	 * 根据某一个条件来查询
	 * @param t
	 * @param sql
	 * @param params
	 * @return
	 */
	public static <T> T queryOne(Class<T> t,String sql,Object...params){
		T obj=null;
		Connection coon=null;
		PreparedStatement ps=null;
		try {
			coon=getConn();
			ps=coon.prepareStatement(sql);
			for (int i = 0; i < params.length; i++) {
				ps.setObject(i+1, params[i]);
			}
			ResultSet rs=ps.executeQuery();
		    ResultSetMetaData rsmd=ps.getMetaData();
		    if (rs.next()) {
				obj=t.newInstance();
				for (int i = 0; i < rsmd.getColumnCount(); i++) {
					String cname=rsmd.getColumnLabel(i+1);
					Object value=rs.getObject(cname);
					if (Objects.nonNull(value)) {
						Field f=t.getDeclaredField(cname);
						//将字段设置为可访问状态
						f.setAccessible(true);
						f.set(obj, value);
					}
				}
			}
		} catch (SQLException e) {
			e.printStackTrace();
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		} catch (NoSuchFieldException e) {
			e.printStackTrace();
		} catch (SecurityException e) {
			e.printStackTrace();
		}
		return obj;
		
	}
	
	
	

}

2.属性文件

###JDBC-MYSQL
#jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/daily
jdbc.username=root
jdbc.password=

###Connection pool
InitialSize=1
MaxActive=20
MinIdle=1
MaxWait=60000