头歌Educoder——Java高级特性 - JDBC（下）
2021/4/24 12:28:02
本文主要是介绍头歌Educoder——Java高级特性 - JDBC（下），对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！
文章目录
- 第1关：指定类型JDBC封装
- 任务描述
- 相关知识
- 连接数据库
- 关闭数据库连接
- 新增数据
- 编程要求
- 测试说明
- 实现代码
- 第2关：泛型JDBC封装
- 任务描述
- 相关知识
- 反射的常用方法
- 更新数据的泛型封装分析及实现
- 编程要求
- 测试说明
- 实现代码
第1关：指定类型JDBC封装
任务描述
本关任务：按照要求封装一个JDBC工具类。
相关知识
为了完成本关任务，你需要掌握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，结构如下：
| 字段名称 | 类型 | 备注 | 约束 |
|---|---|---|---|
| id | int | 新闻编号 | 主键 |
| title | varchar(60) | 新闻标题 | 无 |
| author_name | varchar(30) | 作者名称 | 无 |
根据表结构我们创建一个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表中插入二条新闻数据，以便对你编写的方法进行检测，数据如下：
| id | title | author_name |
|---|---|---|
| 1 | 岳云鹏的18岁，贾玲的18岁，沈腾的18岁，网友：不是来搞笑的？ | 小明 |
| 2 | 假设飞行器每秒跑1光年，能飞到宇宙边缘吗？科学家说出答案 | 探索宇宙奥妙 |
开始你的任务吧，祝你成功！
实现代码
【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 ）之后,我们都知道反射机制的强大，利用反射可以获取到类的结构信息，动态调用属性和方法等等。因此，本章节我们采用反射对JDBC的增删改查进行泛型的封装。
为了完成本关任务，你需要掌握：反射的常用方法。
反射的常用方法
-
获取
Class的实例的三种方法Class class=类名.class; Class class=Class.forName("全类名"); Class class=对象.getClass(); -
获取对象的类名
String className=class.getName();//获取结果为全类名 String className=class.getSimpleName();//获取简单类名
-
获取
FieldField 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表
| id | name | sex | age |
|---|---|---|---|
| 1 | 张三 | 男 | 18 |
| 2 | 李四 | 女 | 20 |
News表
| id | title | author_name |
|---|---|---|
| 1 | 岳云鹏的18岁，贾玲的18岁，沈腾的18岁，网友：不是来搞笑的？ | 光明网 |
| 2 | 假设飞行器每秒跑1光年，能飞到宇宙边缘吗？科学家说出答案 | 小明 |
注意：本章实训封装的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】
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 + "]";
}
}
【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这一篇就够了
这篇关于头歌Educoder——Java高级特性 - JDBC（下）的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！
- 2024-11-23Springboot应用的多环境打包入门
- 2024-11-23Springboot应用的生产发布入门教程
- 2024-11-23Python编程入门指南
- 2024-11-23Java创业入门：从零开始的编程之旅
- 2024-11-23Java创业入门：新手必读的Java编程与创业指南
- 2024-11-23Java对接阿里云智能语音服务入门详解
- 2024-11-23Java对接阿里云智能语音服务入门教程
- 2024-11-23JAVA对接阿里云智能语音服务入门教程
- 2024-11-23Java副业入门：初学者的简单教程
- 2024-11-23JAVA副业入门：初学者的实战指南
