初学者，跟着做的数据库的更新和查找操作

import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.sql.Connection;
import java.sql.DriverManager;
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;

/**
 * 通用的数据库工具类，基于Druid连接池实现
 * 包含一下功能：
 * 1.获取链接
 * 2.关闭资源
 * 3.执行通用的更新操作
 * 4.执行通用的查询列表操作
 * 5.执行通用的查询单条记录的操作
 * @author 83413
 *
 */
public class DBUtils {
	
	//声明一个druid连接池对象
		private static DruidDataSource  pool;
		/**数据库链接地址**/
		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 fileName ="jdbc.properties";
		static {
			init();
		}
		/**
		 * 加载属性文件并读取属性文件中的内容将其设置给链接信息
		 * @param propName
		 */
		private static void loadProp() {
			try {
				InputStream is = DBUtils.class.getClassLoader().getResourceAsStream(fileName);
				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").trim());
				maxActive=Integer.parseInt(p.getProperty("maxActive").trim());
				minIdle=Integer.parseInt(p.getProperty("minIdle").trim());
				maxWait = Long.parseLong(p.getProperty("maxWait").trim());
			} catch (IOException e) {
				e.printStackTrace();
			}
			
		}
		
		private static void init() {
			pool = new DruidDataSource();
			loadProp();
			pool.setUrl(url);
			pool.setUsername(username);
			pool.setPassword(password);
			
			//设置连接池初始连接数
			pool.setInitialSize(initialSize);
			//设置最大的连接数
			pool.setMaxActive(maxActive);
			//设置最小的闲置连接数
			pool.setMinIdle(minIdle);
			//设置最大的等待时间（等待获取时间）
			pool.setMaxWait(maxWait);
		}
		
		
		public static Connection getConn() {
			
			try {
				 if(pool == null || pool.isClosed()) {
					 init();
				 }
				 return pool.getConnection();
			} catch (SQLException e) {
				e.printStackTrace();
			}
			return null;
		}

	/**
	 * 关闭连接
	 * 
	 * @param s
	 * @param conn
	 */
	public static void close(Statement stmt, Connection conn) {
		try {
			if (stmt != null) {
				stmt.close();
			}
			if (conn != null) {
				conn.close();
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}
	
	/**
	 * 更新操作
	 * @param sql
	 * @param obj
	 * @return
	 */
	public static boolean exeUpdate(Connection conn,String sql, Object... obj) {

		PreparedStatement ps = null;
		try {
			ps = conn.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 {
			close(ps,null);
		}
		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 conn = null;
		PreparedStatement ps = null;
		try {
			conn = getConn();
			ps = conn.prepareStatement(sql);
			for (int i = 0; i < params.length; i++) {
				ps.setObject(i + 1, params[i]);
			}
			ResultSet rs = ps.executeQuery();
			// 获取插叙结果集中的元数据(获取列类型，数量以及长度等信息)
			ResultSetMetaData rsmd = rs.getMetaData();
			// 声明一个map集合，用于临时存储查询到的一条数据（key：列名；value：列值）
			Map<String, Object> map = new HashMap<>();
			// 遍历结果集
			// if (rs.next()){   查询一行
			while (rs.next()) {
				// 防止缓存上一条数据
				map.clear();
				// 遍历所有的列
				for (int i = 0; i < rsmd.getColumnCount(); i++) {
					// 获取列名
					String cname = rsmd.getColumnLabel(i + 1);
					// 获取列值
					Object value = rs.getObject(cname);
					// 将列明与列值存储到map中
					map.put(cname, value);
				}
				// 利用反射将map中的数据注入到Java对象中，并将对象存入集合
				if (!map.isEmpty()) {
					// 获取map集合键集(列名集合)
					Set<String> columnNames = map.keySet();
					// 创建对象
					obj = t.newInstance();
					for (String column : columnNames) {
						// 根据键获取值
						Object value = map.get(column);
						// 获取属性对象
						if (Objects.nonNull(value)) {
							
							Field f = t.getDeclaredField(column);
							// 设置属性为可访问状态
							f.setAccessible(true);
							// 为属性设置
							f.set(obj, value);
						}
					}
					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();
		}
		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 conn = null;
		PreparedStatement ps = null;
		try {
			conn = getConn();
			ps = conn.prepareStatement(sql);
			for (int i = 0;i<params.length;i++) {
				ps.setObject(i+1, params[i]);
			}
			ResultSet rs = ps.executeQuery();
			ResultSetMetaData rsmd= rs.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)) {
						 //根据列名称获取java类的属性名（要求表中的列名称必须与类中的属性名保持一致）
						 Field field = t.getDeclaredField(cname);
						 //将字段设置未可访问状态
						 field.setAccessible(true);
						 //未字段设置属性
						 field.set(obj, value);
					 }
				}
			}
			return 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();
		}
		return null;
	}
}

在根目录下面创建一个配置文件，使项目移植性更强。

###JDBC_MySQL
#jdbc.driver = com.mysql.jdbc.Driver
jdbc.url =jdbc:mysql://127.0.0.1:3306/test
jdbc.username =root
jdbc.password =123456

###Connection
#初始连接数
initialSize =1   
#最大连接数
maxActive =20
#最小闲置数
minIdle =1
#最大等待时间
maxWait =6000

使用到的j ar包有druid，mysql连接包

装成jar包后，使用该包直接更改配置文件即可。

简介绍一下这个包：

1几个私有的静态属性，用于接收配置文件里的属性，和设置连接池的属性

2.static静态代码块：创建连接和连接池。调用该方法使，执行static代码块-> init()->loadProp()

3.getConn()方法：方法返回值是Connection ，里面需要注意的是，如果连接池创建失败，还是会生成一个连接，避免出现bug

4.close()：关闭连接。

5. exeUpdate(Connection conn,String sql, Object... obj)：更新操作(增删改),调用该方式需要传入参数有：连接，sql语句，sql语句中‘？’要替换的对象。调用后需要关闭连接，使连接返回到连接池中。

6.queryList(Class<T> t, String sql, Object... params) ：查询所有，参数：表的DTO类，sql语句，sql语句中‘？’要替换的对象。

返回值是list集合，

7.queryOne(Class<T> t,String sql,Object...params)，返回值是一个类实例，但不清楚是哪个类，所有用泛型<T>