头歌Educoder——Java高级特性 - JDBC（下）

悠悠 2023-01-16 06:17 191阅读 0赞

### 文章目录 ###

*  第1关：指定类型JDBC封装
 *   *  任务描述
     *  相关知识
     *   *  连接数据库
         *  关闭数据库连接
         *  新增数据
     *  编程要求
     *  测试说明
     *  实现代码
 *  第2关：泛型JDBC封装
 *   *  任务描述
     *  相关知识
     *   *  反射的常用方法
         *  更新数据的泛型封装分析及实现
     *  编程要求
     *  测试说明
     *  实现代码

--------------------

# 第1关：指定类型JDBC封装 #

--------------------

## 任务描述 ##

本关任务：按照要求封装一个`JDBC`工具类。

## 相关知识 ##

为了完成本关任务，你需要掌握`JDBC`的基本使用，可参考上一个实训内容[ Java高级特性 - JDBC（上）][Java_ - JDBC]。

本章节将针对已知数据结构的**某张表**进行`JDBC`的封装。

### 连接数据库 ###

在增删改查的过程中，我们都离不开数据库的连接，因此我们可以将其操作封装成一个方法，方法无需参数，将连接对象作为返回值。

在方法中完成驱动加载和数据库连接即可使用：

private static Connection getConnection() { 
        //1.加载驱动
        //2.连接数据库
        Connection conn=null;
        //返回连接对象
        return conn;
    }

封装完后我们就可直接在增删改查中直接使用该方法了。

### 关闭数据库连接 ###

同样每次连接完数据库我们都需要对相应资源进行释放，我们也将其封装为一个方法，方法参数为经常被使用到的对象，这些对象通常是`ResultSet`, `Statement`和`Connection`，因此我们的关闭连接方法如下：

public static void close(ResultSet rs,PreparedStatement ps,Connection conn){ 
        try { 
            if(rs!=null)  rs.close();
            if(ps!=null)  ps.close();
            if(conn!=null)  conn.close();
        } catch (SQLException e) { 
            e.printStackT\frace();
        }
    }

### 新增数据 ###

现我们数据库中已有的一张新闻表`news`，结构如下：

<table> 
 <thead> 
  <tr> 
   <th>字段名称</th> 
   <th>类型</th> 
   <th>备注</th> 
   <th>约束</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>id</td> 
   <td>int</td> 
   <td>新闻编号</td> 
   <td>主键</td> 
  </tr> 
  <tr> 
   <td>title</td> 
   <td>varchar(60)</td> 
   <td>新闻标题</td> 
   <td>无</td> 
  </tr> 
  <tr> 
   <td>author_name</td> 
   <td>varchar(30)</td> 
   <td>作者名称</td> 
   <td>无</td> 
  </tr> 
 </tbody> 
</table>

根据表结构我们创建一个`News`对象：

public class News { 
        private int id;
        private String title;
        private String anthor_name;
        public News(int id, String title, String anthor_name) { 
            super();
            this.id = id;
            this.title = title;
            this.anthor_name = anthor_name;
        }
        public int getId() { 
            return id;
        }
        public void setId(int id) { 
            this.id = id;
        }
        ......//省略其他属性的get、set方法
    }

日常生活中我们每天都会看到很多新闻，因此我们需要往数据库中不断新增最新新闻，下面我们一起来对新增方法进行封装：

封装前我们先对方法进行构思，该方法需传递一个`News`对象，无需返回值，因此方法的定义和实现思路如下：

public void insert(News news) throws SQLException { 
        Connection conn = getConnection();//拿到连接对象
        PreparedStatement ps = null;
        //编写新增sql语句
        String sql = "";
        try{ 
            ps = conn.prepareStatement(sql);
            //通过传入的news对象对预编译中 ? 进行赋值
            ps.setXXX(1,news.getXXX());
            //执行新增sql语句
            ps.executeUpdate();
        }catch(SQLException e){ 
            e.printStackT\frace();
        }finally{ 
            //关闭连接
            close(null, ps, conn);
        }
    }

## 编程要求 ##

在右侧编辑器补充代码，完成数据库连接、删除、更新以及查找方法。其中删除方法是通过用户传入新闻`id`来进行删除。

注意：连接数据库名为`mysql_db`，数据库用户为`root`，密码为`123123`。

## 测试说明 ##

平台会对你编写的代码进行测试：

测试输入：无

预期输出：

`News [id=1, title=岳云鹏的18岁，贾玲的18岁，沈腾的18岁，网友：不是来搞笑的？, anthor_name=光明网]`

说明：测试文件中会向`news`表中插入二条新闻数据，以便对你编写的方法进行检测，数据如下：

<table> 
 <thead> 
  <tr> 
   <th>id</th> 
   <th>title</th> 
   <th>author_name</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td>岳云鹏的18岁，贾玲的18岁，沈腾的18岁，网友：不是来搞笑的？</td> 
   <td>小明</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>假设飞行器每秒跑1光年，能飞到宇宙边缘吗？科学家说出答案</td> 
   <td>探索宇宙奥妙</td> 
  </tr> 
 </tbody> 
</table>

--------------------

开始你的任务吧，祝你成功！

## 实现代码 ##

【JDBCUtils.java】

package step1;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    import java.util.ArrayList;
    import java.util.List;
    import test.News;
    
    public class JDBCUtils { 
    	/** * 连接数据库 */
    	private static Connection getConnection() { 
    		Connection conn = null;
    		/********** Begin **********/
    		String url = "jdbc:mysql://localhost:3306/mysql_db";
    		try { 
    			Class.forName("com.mysql.jdbc.Driver");
    			conn = DriverManager.getConnection(url, "root", "123123");
    
    		} catch (ClassNotFoundException e) { 
    			e.printStackTrace();
    		} catch (SQLException e) { 
    			e.printStackTrace();
    		}
    		/********** End **********/
    		return conn;
    	}
    
    	/** * 更新数据方法 * * @param news * @throws SQLException */
    	public void update(News news) throws SQLException { 
    		Connection conn = getConnection();
    		PreparedStatement ps = null;
    		/********** Begin **********/
    		String sql = "update news set title = ? ,author_name = ? where id = ? ";
    		try { 
    
    			ps = conn.prepareStatement(sql);
    
    			ps.setObject(1, news.getTitle());
    			ps.setObject(2, news.getAuthor_name());
    			ps.setObject(3, news.getId());
    
    			ps.execute();
    
    		} catch (SQLException e) { 
    			e.printStackTrace();
    			throw new SQLException("更新数据失败");
    		} finally { 
    			close(null, ps, conn);
    		}
    		/********** End **********/
    	}
    
    	/** * 查询所有数据 * * @return * @throws SQLException */
    	public List<News> findAll() throws SQLException { 
    		Connection conn = getConnection();
    		PreparedStatement ps = null;
    		ResultSet rs = null;
    		News news = null;
    		List<News> newsList = new ArrayList<News>();
    		/********** Begin **********/
    		String sql = "select * from news";
    		try { 
    
    			ps = conn.prepareStatement(sql);
    			rs = ps.executeQuery();
    
    			while (rs.next()) { 
    				news = new News(rs.getInt(1), rs.getString(2), rs.getString(3));
    				newsList.add(news);
    			}
    
    		} catch (SQLException e) { 
    			e.printStackTrace();
    			throw new SQLException("查询所有数据失败");
    		} finally { 
    			close(rs, ps, conn);
    		}
    		/********** End **********/
    		return newsList;
    	}
    
    	/** * 删除方法 * * @param id * @throws SQLException */
    	public void delete(int id) throws SQLException { 
    		Connection conn = getConnection();
    		PreparedStatement ps = null;
    		/********** Begin **********/
    		String sql = "delete from news where id=?";
    		try { 
    
    			ps = conn.prepareStatement(sql);
    			ps.setObject(1, id);
    			ps.execute();
    
    		} catch (SQLException e) { 
    			e.printStackTrace();
    			throw new SQLException(" 删除数据失败");
    		} finally { 
    			close(null, ps, conn);
    		}
    		/********** End **********/
    	}
    
    	/** * 增加对象 * * @param news * @throws SQLException */
    	public void insert(News news) throws SQLException { 
    		Connection conn = getConnection();
    		PreparedStatement ps = null;
    		String sql = "insert into news(id,title,author_name)values(?,?,?)";
    		try { 
    			ps = conn.prepareStatement(sql);
    			ps.setInt(1, news.getId());
    			ps.setString(2, news.getTitle());
    			ps.setString(3, news.getAuthor_name());
    			ps.executeUpdate();
    		} catch (SQLException e) { 
    			e.printStackTrace();
    			throw new SQLException("添加数据失败");
    		} finally { 
    			close(null, ps, conn);
    		}
    	}
    
    	/** * 根据id查询对象 * * @param id * @return * @throws SQLException */
    	public News findById(int id) throws SQLException { 
    		Connection conn = getConnection();
    		PreparedStatement ps = null;
    		ResultSet rs = null;
    		News news = null;
    		String sql = "select * from news where id=?";
    		try { 
    			ps = conn.prepareStatement(sql);
    			ps.setInt(1, id);
    			rs = ps.executeQuery();
    			if (rs.next()) { 
    				news = new News();
    				news.setId(id);
    				news.setTitle(rs.getString(2));
    				news.setAuthor_name(rs.getString(3));
    			}
    		} catch (SQLException e) { 
    			e.printStackTrace();
    			throw new SQLException("根据ID查询数据失败");
    		} finally { 
    			close(rs, ps, conn);
    		}
    		return news;
    	}
    
    	/** * 关闭数据库连接 * * @param rs * @param ps * @param conn */
    	public static void close(ResultSet rs, PreparedStatement ps, Connection conn) { 
    		try { 
    			if (rs != null)
    				rs.close();
    			if (ps != null)
    				ps.close();
    			if (conn != null)
    				conn.close();
    		} catch (SQLException e) { 
    			e.printStackTrace();
    		}
    	}
    }

【News.java】

package test;
    
    public class News { 
    	private int id;
    	private String title;
    	private String author_name;
    
    	public News() { 
    		super();
    	}
    
    	public News(int id, String title, String anthor_name) { 
    		super();
    		this.id = id;
    		this.title = title;
    		this.author_name = anthor_name;
    	}
    
    	public int getId() { 
    		return id;
    	}
    
    	public void setId(int id) { 
    		this.id = id;
    	}
    
    	public String getTitle() { 
    		return title;
    	}
    
    	public void setTitle(String title) { 
    		this.title = title;
    	}
    
    	public String getAuthor_name() { 
    		return author_name;
    	}
    
    	public void setAuthor_name(String author_name) { 
    		this.author_name = author_name;
    	}
    
    	@Override
    	public String toString() { 
    		return "News [id=" + id + ", title=" + title + ", author_name=" + author_name + "]";
    	}
    
    }

【Test1.java】

package test;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.SQLException;
    import java.sql.Statement;
    import java.util.List;
    import step1.JDBCUtils;
    
    public class Test1 { 
    	public static void main(String[] args) throws SQLException { 
    		createTable();
    		JDBCUtils jUtils = new JDBCUtils();
    		News news1 = new News(1, "岳云鹏的18岁，贾玲的18岁，沈腾的18岁，网友：不是来搞笑的？", "小明");
    		News news2 = new News(2, "假设飞行器每秒跑1光年，能飞到宇宙边缘吗？科学家说出答案", "探索宇宙奥秘");
    		jUtils.insert(news1);
    		jUtils.insert(news2);
    		// 修改数据
    		news1.setAuthor_name("光明网");
    		jUtils.update(news1);
    		// 删除数据
    		jUtils.delete(2);
    		// 获取表中数据
    		List<News> findAll = jUtils.findAll();
    		for (int i = 0; i < findAll.size(); i++) { 
    			System.out.println(findAll.get(i));
    		}
    
    		// 检测update方法
    		News findById = jUtils.findById(1);
    		if (!findById.toString().equals(news1.toString())) { 
    			System.out.println("数据修改失败,请检查update方法");
    			System.out.println("查询id为1的结果：" + findById);
    		}
    		// 检查delete方法
    		News findById2 = jUtils.findById(2);
    		if (findById2 != null) { 
    			System.out.println("数据删除失败,请检查delete方法");
    			System.out.println("查询id为2的结果：" + findById2);
    		}
    
    	}
    
    	public static void createTable() { 
    		try { 
    			Class.forName("com.mysql.jdbc.Driver");
    		} catch (ClassNotFoundException e) { 
    			e.printStackTrace();
    		}
    		Connection conn = null;
    		Statement statement = null;
    		String url = "jdbc:mysql://localhost:3306/";
    		try { 
    			conn = DriverManager.getConnection(url, "root", "123123");
    			statement = conn.createStatement();
    			statement.executeUpdate("drop database if exists mysql_db");
    			statement.executeUpdate("create database mysql_db");
    			statement.executeUpdate("use mysql_db");
    			String sql = "create table news(" + "id int primary key, " + "title varchar(60), "
    					+ "author_name varchar(30)" + ")";
    			statement.executeUpdate(sql);
    		} catch (SQLException e) { 
    			e.printStackTrace();
    		} finally { 
    			try { 
    				if (statement != null)
    					statement.close();
    				if (conn != null)
    					conn.close();
    			} catch (SQLException e) { 
    				e.printStackTrace();
    			}
    		}
    	}
    }

--------------------

# 第2关：泛型JDBC封装 #

## 任务描述 ##

本关任务：封装一个泛型类的`JDBC`工具类。

## 相关知识 ##

上一章节中我们对具体类（`News`）进行`JDBC`的封装，但是在一个项目中，数据库中的表远不止一个，难道我们需要对每一张表都进行封装吗？显然是不妥的，因此我们可以将`JDBC`工具类封装为一个泛型的。

在学习了反射（ [JAVA的重要机制——反射Reflection][JAVA_Reflection] ）之后,我们都知道反射机制的强大，利用反射可以获取到类的结构信息，动态调用属性和方法等等。因此，本章节我们采用反射对`JDBC`的增删改查进行泛型的封装。

为了完成本关任务，你需要掌握：反射的常用方法。

### 反射的常用方法 ###

*  获取`Class`的实例的三种方法
    
        Class class=类名.class;
        Class class=Class.forName("全类名");
        Class class=对象.getClass();
 *  获取对象的类名
    
        String className=class.getName();//获取结果为全类名
        String className=class.getSimpleName();//获取简单类名
 *  获取`Field`
    
        Field field=class.getField("属性名");//通过属性名获取public的属性
        Field[] fields=class.getFields();//获取所有用public修饰的属性
        Field field=class.getDeclaredField("属性名")；//获取的属性包括public和private
        Field[] field = c.getDeclaredFields();//获取所有属性包括public和private
 *  获取`Field`的信息
    
        String name=field.getName();//获取属性名
        Class<?> type=filed.getType();//获取属性类型
        Object value=field.get(obj);//获取obj对象field属性的值
        field.set(obj,value);//设置obj对象的field属性的值
 *  设置`private`修饰的属性为可访问
    
        field.setAccessible(true);//默认为false只能对public修饰的操作，设置为true可对private修饰的操作

### 更新数据的泛型封装分析及实现 ###

我们可以从`sql`语句来进行分析，更新数据的`sql`，大家都不陌生：`update 表名 set column2=value2,columen3=value3 where column1=value1;`

观察`sql`语句我们可以将该方法设计为让用户传入一个`Object`对象，然后利用反射获取对象中的所有属性对其进行修改，具体实现如下（注意`Object`对象属性名称要求和数据库中表结构字段名以及类型一致）：

public static void update(Object obj) { 
        Connection conn = getConnection();//获取连接对象
        PreparedStatement ps = null;
        Class<?> c = obj.getClass();//获取obj的Class
        StringBuffer sb = new StringBuffer("update "+ c.getSimpleName() +" set ");//利用StringBuffer进行修改SQL语句的构造
        Field[] field = c.getDeclaredFields();//通过反射获取对象的属性数组
        for(int i = 1; i < field.length; i++) { 
            if(i != field.length-1) {     //判断是否为最后一个属性，若不是则后增加逗号
                sb.append(field[i].getName()).append("=?,");
            }else {     //若为最后一个属性则添加 where
                sb.append(field[i].getName()).append("=? where ");
            }
        }
        //默认第一个属性为主键，切更改时通过第一个属性进行更改
        sb.append(field[0].getName() + "=?");
        try { 
            ps = conn.prepareStatement(sb.toString());
            for(int i = 1; i < field.length; i++) { 
                field[i].setAccessible(true);//设置可以访问私有属性
                ps.setObject(i, field[i].get(obj));//对预编译的SQL语句中的 ? 进行赋值
            }
            field[0].setAccessible(true);
            ps.setObject(field.length, field[0].get(obj));
            ps.execute();//执行sql语句
        } catch (Exception e) { 
            e.printStackT\frace();
        }finally { 
            close(null,ps,conn);//关闭连接数据
        }
    }

## 编程要求 ##

根据更新数据的示例，在右侧编辑器补充代码，完成增加数据、删除数据、查询表中所有数据三个方法。

## 测试说明 ##

测试输入：无

预期输出：

`Student [id=2, name=李四, sex=男, age=20]`

`News [id=1, title=岳云鹏的18岁，贾玲的18岁，沈腾的18岁，网友：不是来搞笑的？, author_name=光明网]`

`News [id=2, title=假设飞行器每秒跑1光年，能飞到宇宙边缘吗？科学家说出答案, author_name=探索宇宙奥秘]`

平台将会根据已有的`Student`表和`News`表来调用你所编写的方法，进行数据的增删改查，分别为二张表中插入二条数据载进行修改`News` 表中一条数据，删除`Student`表中一条数据，插入数据如下：

`Student`表

`News`表

<table> 
 <thead> 
  <tr> 
   <th>id</th> 
   <th>title</th> 
   <th>author_name</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td>岳云鹏的18岁，贾玲的18岁，沈腾的18岁，网友：不是来搞笑的？</td> 
   <td>光明网</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>假设飞行器每秒跑1光年，能飞到宇宙边缘吗？科学家说出答案</td> 
   <td>小明</td> 
  </tr> 
 </tbody> 
</table>

注意：本章实训封装的`JDBC`工具类只做参考，你也可根据自己的实际需求进行封装属于自己的工具类。

--------------------

开始你的任务吧，祝你成功！

## 实现代码 ##

【JDBCUtils.java】

package step2;
    
    import java.lang.reflect.Field;
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    import java.util.ArrayList;
    import java.util.List;
    
    public class JDBCUtils { 
    	private static Connection getConnection() { 
    		try { 
    			Class.forName("com.mysql.jdbc.Driver");
    		} catch (ClassNotFoundException e) { 
    			e.printStackTrace();
    		}
    		String url = "jdbc:mysql://localhost:3306/mysql_db";
    		Connection conn = null;
    		try { 
    			conn = DriverManager.getConnection(url, "root", "123123");
    		} catch (SQLException e) { 
    			e.printStackTrace();
    		}
    		return conn;
    	}
    
    	/** * 类名对应表，属性对应字段 * * @param obj 传入的对象 * @return */
    	public void insert(Object obj) { 
    		Connection conn = getConnection(); // 连接数据库
    		PreparedStatement ps = null;
    		/********** Begin **********/
    
    		try { 
    
    			String sql = "insert into ";
    			String sql2 = ") values(";
    
    			// 获取类名当表名
    			String simpleName = obj.getClass().getSimpleName();
    			sql += simpleName + "(";
    
    			// 获取所有属性
    			Field[] declaredFields = obj.getClass().getDeclaredFields();
    
    			// 拼接sql语句
    			for (int i = 0; i < declaredFields.length; i++) { 
    				sql += declaredFields[i].getName();
    				sql2 += "?";
    				if (i + 1 != declaredFields.length) { 
    					sql += ",";
    					sql2 += ",";
    				} else { 
    					sql2 += ")";
    				}
    			}
    			sql += sql2;
    
    			ps = conn.prepareStatement(sql);
    
    			// 填充占位符
    			for (int i = 0; i < declaredFields.length; i++) { 
    				declaredFields[i].setAccessible(true);
    				Object object = null;
    				try { 
    					object = declaredFields[i].get(obj);
    				} catch (Exception e) { 
    					e.printStackTrace();
    				}
    				ps.setObject(i + 1, object);
    			}
    
    			ps.execute();
    
    		}
    
    		/********** End **********/
    
    		catch (SQLException e) { 
    			e.printStackTrace();
    		} finally { 
    			close(null, ps, conn);
    		}
    	}
    
    	/** * 通过对象的Class获取对应表中的所有记录 * * @param c * @return */
    	public <T> List<T> selectAll(Class<T> c) { 
    		Connection conn = getConnection();
    		List<T> list = new ArrayList<T>();
    		PreparedStatement ps = null;
    		ResultSet rs = null;
    		/********** Begin **********/
    
    		try { 
    			// 获取类名当作表名
    			String simpleName = c.getSimpleName();
    
    			// sql查询语句
    			String sql = "select * from " + simpleName;
    			ps = conn.prepareStatement(sql);
    
    			// 获取结果集
    			rs = ps.executeQuery();
    
    			// 获取所有属性，对应结果集的所有列
    			Field[] fields = c.getDeclaredFields();
    
    			while (rs.next()) { 
    
    				// 创建对象
    				T t = c.newInstance();
    
    				// 给对象对应的属性赋值
    				for (Field field : fields) { 
    					field.setAccessible(true);
    					field.set(t, rs.getObject(field.getName()));
    
    				}
    
    				// 对象添加到集合
    				list.add(t);
    
    			}
    
    		}
    
    		/********** End **********/
    
    		catch (Exception e) { 
    			e.printStackTrace();
    		} finally { 
    			close(rs, ps, conn);
    		}
    		return list;
    	}
    
    	/** * 通过主键(默认第一个属性)删除对象 * * @param obj * @return */
    	public void delete(Object obj) { 
    		Connection conn = getConnection();
    		PreparedStatement ps = null;
    		/********** Begin **********/
    
    		try { 
    			// 获取类名当作表明
    			String simpleName = obj.getClass().getSimpleName();
    
    			// 获取第一个属性的信息
    			Field[] declaredFields = obj.getClass().getDeclaredFields();
    			declaredFields[0].setAccessible(true);
    			String name = declaredFields[0].getName();
    
    			// sql删除语句
    			String sql = "delete from " + simpleName + " where " + name + "=?";
    
    			// 填充占位符
    			ps = conn.prepareStatement(sql);
    			ps.setObject(1, declaredFields[0].get(obj));
    			ps.execute();
    
    		}
    
    		/********** End **********/
    
    		catch (Exception e) { 
    			e.printStackTrace();
    		} finally { 
    			close(null, ps, conn);
    		}
    	}
    
    	/** * 模拟jdbc的更新操作，默认第一个属性为主键 * * @param obj * @return */
    	public void update(Object obj) { 
    		Class<?> c = obj.getClass();// 获取obj的Class
    		StringBuffer sb = new StringBuffer("update " + c.getSimpleName() + " set ");// 利用StringBuffer进行修改SQL语句的构造
    		Field[] field = c.getDeclaredFields();// 通过反射获取对象的属性数组
    		for (int i = 1; i < field.length; i++) { 
    			if (i != field.length - 1) {  // 判断是否为最后一个属性，若不是则后增加逗号
    				sb.append(field[i].getName()).append("=?,");
    			} else {  // 若为最后一个属性则添加 where
    				sb.append(field[i].getName()).append("=? where ");
    			}
    		}
    		// 默认第一个属性为主键，切更改时通过第一个属性进行更改
    		sb.append(field[0].getName() + "=?");
    		String sql = sb.toString() + ";";
    		Connection conn = getConnection();// 获取连接对象
    		PreparedStatement ps = null;
    		try { 
    			ps = conn.prepareStatement(sql);
    			for (int i = 1; i < field.length; i++) { 
    				field[i].setAccessible(true);// 设置可以访问私有属性
    				ps.setObject(i, field[i].get(obj));// 对预编译的SQL语句中的 ? 进行赋值
    			}
    			field[0].setAccessible(true);
    			ps.setObject(field.length, field[0].get(obj));
    			ps.execute();// 执行sql语句
    		} catch (Exception e) { 
    			e.printStackTrace();
    		} finally { 
    			close(null, ps, conn);// 关闭连接数据
    		}
    	}
    
    	public static void close(ResultSet rs, PreparedStatement ps, Connection conn) { 
    		try { 
    			if (rs != null)
    				rs.close();
    			if (ps != null)
    				ps.close();
    			if (conn != null)
    				conn.close();
    		} catch (SQLException e) { 
    			e.printStackTrace();
    		}
    	}
    
    	public <T> Object selectById(Class<T> c, int id) { 
    		String sql = "select * from " + c.getSimpleName() + " where id=" + id;
    		Field[] field = c.getDeclaredFields();
    		Connection conn = getConnection();
    		PreparedStatement ps = null;
    		ResultSet rs = null;
    		Object obj = null;
    		try { 
    			ps = conn.prepareStatement(sql);
    			rs = ps.executeQuery();
    			obj = c.newInstance();
    			while (rs.next()) { 
    				for (int i = 0; i < field.length; i++) { 
    					field[i].setAccessible(true);
    					field[i].set(obj, rs.getObject(field[i].getName()));
    				}
    			}
    		} catch (Exception e) { 
    			e.printStackTrace();
    		} finally { 
    			close(rs, ps, conn);
    		}
    		return obj;
    	}
    
    }

【News.java】

【Student.java】

package test;
    
    public class Student { 
        private int id;
        private String name;
        private String sex;
        private int age;
    
        public Student() { 
    		super();
    	}
    
    	public Student(int id, String name, String sex, int age) { 
            this.id = id;
            this.name = name;
            this.sex = sex;
            this.age = age;
        }
    
        public int getId() { 
            return id;
        }
    
        public Student setId(int id) { 
            this.id = id;
            return this;
        }
    
        public String getName() { 
            return name;
        }
    
        public Student setName(String name) { 
            this.name = name;
            return this;
        }
    
        public String getSex() { 
            return sex;
        }
    
        public Student setSex(String sex) { 
            this.sex = sex;
            return this;
        }
    
        public int getAge() { 
            return age;
        }
    
        public Student setAge(int age) { 
            this.age = age;
            return this;
        }
    
    	@Override
    	public String toString() { 
    		return "Student [id=" + id + ", name=" + name + ", sex=" + sex
    				+ ", age=" + age + "]";
    	}
        
    }

【Test2.java】

package test;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.SQLException;
    import java.sql.Statement;
    import java.util.List;
    import step2.JDBCUtils;
    
    public class Test2 { 
    	static JDBCUtils jUtils = new JDBCUtils();
    
    	public static void main(String[] args) { 
    		createTable();
    		Student student1 = new Student(1, "张三", "男", 18);
    		Student student2 = new Student(2, "李四", "女", 20);
    		News news1 = new News(1, "岳云鹏的18岁，贾玲的18岁，沈腾的18岁，网友：不是来搞笑的？", "光明网");
    		News news2 = new News(2, "假设飞行器每秒跑1光年，能飞到宇宙边缘吗？科学家说出答案", "小明");
    		jUtils.insert(student1);
    		jUtils.insert(student2);
    		jUtils.insert(news1);
    		jUtils.insert(news2);
    		isTrue(student1, student2, news1, news2, "新增");
    
    		news2.setAuthor_name("探索宇宙奥秘");
    		jUtils.update(news2);
    		student2.setSex("男");
    		jUtils.update(student2);
    		isTrue(student1, student2, news1, news2, "更新");
    
    		jUtils.delete(student1);
    		List<Student> studentList1 = jUtils.selectAll(Student.class);
    		if (studentList1.size() != 0) { 
    			if (studentList1.size() != 1) { 
    				System.out.println("数据删除失败,请检查delete方法。" + student1.toString() + "未被删除成功");
    			}
    		} else { 
    			System.out.println("请完成查询方法");
    		}
    
    		List<Student> studentList = jUtils.selectAll(Student.class);
    		for (int i = 0; i < studentList.size(); i++) { 
    			System.out.println(studentList.get(i));
    		}
    		List<News> newsList = jUtils.selectAll(News.class);
    		for (int i = 0; i < newsList.size(); i++) { 
    			System.out.println(newsList.get(i));
    		}
    
    	}
    
    	public static void createTable() { 
    		try { 
    			Class.forName("com.mysql.jdbc.Driver");
    		} catch (ClassNotFoundException e) { 
    			e.printStackTrace();
    		}
    		Connection conn = null;
    		Statement statement = null;
    		String url = "jdbc:mysql://localhost:3306/";
    		try { 
    			conn = DriverManager.getConnection(url, "root", "123123");
    			statement = conn.createStatement();
    			statement.executeUpdate("drop database if exists mysql_db");
    			statement.executeUpdate("create database mysql_db");
    			statement.executeUpdate("use mysql_db");
    			String sql = "create table News(" + "id int primary key, " + "title varchar(60), "
    					+ "author_name varchar(30)" + ")";
    			statement.executeUpdate(sql);
    			String sql2 = "create table Student(" + "id int primary key, " + "name varchar(20), " + "sex varchar(4),"
    					+ "age int" + ")";
    			statement.executeUpdate(sql2);
    		} catch (SQLException e) { 
    			e.printStackTrace();
    		} finally { 
    			try { 
    				if (statement != null)
    					statement.close();
    				if (conn != null)
    					conn.close();
    			} catch (SQLException e) { 
    				e.printStackTrace();
    			}
    		}
    	}
    
    	public static void isTrue(Student student1, Student student2, News news1, News news2, String type) { 
    		Student s1 = (Student) jUtils.selectById(Student.class, 1);
    		Student s2 = (Student) jUtils.selectById(Student.class, 2);
    		News n1 = (News) jUtils.selectById(News.class, 1);
    		News n2 = (News) jUtils.selectById(News.class, 2);
    		if (!student1.toString().equals(s1.toString()) || !student2.toString().equals(s2.toString())
    				|| !news1.toString().equals(n1.toString()) || !news2.toString().equals(n2.toString())) { 
    			System.out.println("请按要求完成" + type + "方法");
    		}
    	}
    }

--------------------

如果还有些不了解或者想要进阶操作，可以转战另一篇文章：[学习JDBC这一篇就够了][JDBC]

[Java_ - JDBC]: https://www.educoder.net/shixuns/cgmrq8je/challenges
[JAVA_Reflection]: https://blog.csdn.net/qq_20185737/article/details/114990869
[JDBC]: https://blog.csdn.net/qq_20185737/article/details/115599307