传智博客---JDBC之以面向对象的思想编的添加和循环查询数据库中数据表记录的代码
|
package com.zhou.jdbc;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.Scanner;
import org.junit.Test;
public class JDBC_Test_OPP {
boolean flage = true;
/**
* 获得学生的信息： 分几步呢？在拿到这个事情之前，我们要先想分几步来写，一次想不明白想第二次……总之会把这个事情想明白；
*/
@Test
public void testGetStudent() {
while(this.flage){
// 1.得到查询的类型：
int searchType = getSearchTypeFromConsole();
// 2.我要拿上面的查询类型亲自去做一个查询：具体查询信息
Student student = searchStudent(searchType);
// 3.打印学生信息：打印查询到的这个学生的信息
printStudent(student);
}
}
/**
* 打印学生信息的方法：若学生存在则打印具体信息，若不存在：打印查无此人；
* 打印学生信息的话，应该是这样的，我查完之后有可能有，有可能没有，没有的话返回查无此人，如果有的话就打印出来；
*
* @param student
*/
public void printStudent(Student student) {
if(student != null){
System.out.println(student);
//重写过Student的toString方法的；
}else{
System.out.println("查无此人！");
this.flage = true;
while(this.flage){
// 1.得到查询的类型：
int searchType = getSearchTypeFromConsole();
// 2.我要拿上面的查询类型亲自去做一个查询：具体查询信息
Student student1 = searchStudent(searchType);
// 3.打印学生信息：打印查询到的这个学生的信息
printStudent(student1);
}
}
}
/**
* 具体查询学生信息的方法：返回一个Student类的对象，若不存在，则返回null
*
* @param searchType
* 1或2
* @return
*/
private Student searchStudent(int searchType) {
// 我要写一个SQL语句：
String sql = "SELECT flowId,type,idCard,examCard,studentname,location,grade"
+ " FROM examstudent" + " WHERE ";
// 后面这个WHERE是什么是不是不一定了啊？因为我要根据这个1和2决定着是什么什么等于啥吧？
// 用Scanner类：
Scanner scanner = new Scanner(System.in);
// 1.根据输入的searchType，提示用户输入信息：
// 1.1若searchType为1，提示：请输入身份证号；若为2，提示：请输入准考证号：
// 2.根据searchType确定SQL语句：
if (searchType == 1) {
// 如果查询；类型是1的话，就用身份证号查询；
System.out.print("请输入准考证号：");
String examCard = scanner.next();
sql = sql + "examCard = '"+ examCard +"'";
// 拼成一个完整的sql语句；
System.out.println(sql);
} else {
// 因为到这里了只有1和2
System.out.print("身份证号：");
String idCard = scanner.next();
sql = sql + "idCard = '"+ idCard +"'";
// 拼成一个完整的sql语句；
System.out.println(sql);
}
// 3.执行查询：查询的话我应该是用sql语句去查一个Student：
Student student = getStudent(sql);
// 4.若存在查询结果，把查询结果封装为一个Student类的对象；
return student;
// 然后把这个Student返回就可以了；
}
/**
* 根据传入的SQL语句返回Student类的对象：
*
* @param sql
* @return
*/
private Student getStudent(String sql) {
// 声明一个Student：
Student student = null;
/**
* 这里比较麻烦，我们写了一个通用的update()方法了，那我们这里能不能写一个通用的get方法呢？
*
*/
// 声明Connection：
Connection connection = null;
// 声明Statement：
Statement statement = null;
// 声明ResultSet：
ResultSet resultSet = null;
// 然后有一个大的try……catch……finally
try {
// 获得数据库连接：
connection = JdbcTools.getConnection();
// 获得Statement：
statement = connection.createStatement();
// 发送SQL语句，查询：
resultSet = statement.executeQuery(sql);
if (resultSet.next()) {
// 如果有下一个的话：
student = new Student(resultSet.getInt(1), resultSet.getInt(2),
resultSet.getString(3), resultSet.getString(4),
resultSet.getString(5), resultSet.getString(6),
resultSet.getInt(7));
//这里直接将查到的结果放到Student类的构造器中封装成一个Student类的对象；
}
} catch (Exception e) {
e.printStackTrace();
} finally {
JdbcTools.release_2(resultSet, statement, connection);
}
// 返回一个student：
return student;
}
/**
* 创建一个从控制台上获得查询类型的getSearchTypeFromConsole()方法：
* 从控制台读入一个整数，确定要查询的类型：1.用身份证号查询 2.用准考证号查询 其他的无效，并提示请用户重新输入；
* 也就是只有1或2的话程序才继续，输入其他的就不继续，我在 testGetStudent()方法里面是不是没有写if判断
* 啊，我这块该怎么写？我可以这么写：
*
* @return
*/
private int getSearchTypeFromConsole() {
// 1.提示用户输入查询类型：
System.out.print("请输入查询类型 1.用准考证号查询 2.用身份证号查询 >:");
// 用Scanner类：
Scanner scanner = new Scanner(System.in);
int type = scanner.nextInt();
// 判断type：
if (type != 1 && type != 2) {
// type既不是1也不是2时：
System.out.println("输入有误，请重新输入>:");
// 但是我在
// testGetStudent()方法里面是不是没有判断啊
// 这个时候我需要使整个程序中断：
//throw new RuntimeException();// 这个时候整个程序就结束掉了；
this.flage = true;
while(this.flage){
// 1.得到查询的类型：
int searchType = getSearchTypeFromConsole();
// 2.我要拿上面的查询类型亲自去做一个查询：具体查询信息
Student student1 = searchStudent(searchType);
// 3.打印学生信息：打印查询到的这个学生的信息
printStudent(student1);
}
}
// 这个写完之后，第二个我需要去查询学生：searchStudent(int searchType)
return type;
}
/**
* 写完public void addNewStudent(Student student)之后呢，我们可以来写这样一个测试的方法
*/
@Test
public void testAddNewStudent() {
// 首先获取一个Student对象，从控制台的输入中获取：
Student student = getStudentFromConsole();
// 然后调用addNewStudent(Student student)方法添加一个学生信息：
addNewStudent(student);
}
/**
* 创建用从控制台获取Student对象的方法：getStudentFromConsole()
*
* @return
*/
private Student getStudentFromConsole() {
// 创建一个Scanner类的对象；
Scanner scanner = new Scanner(System.in);
// 然后呢？创建一个Student类的对：
Student student = new Student();
// 然后怎么整啊？一个一个输入啊：
System.out.print("flowId:");
student.setFlowId(scanner.nextInt());
System.out.print("type:");
student.setType(scanner.nextInt());
System.out.print("idCard:");
student.setIdCard(scanner.next());
System.out.print("examCard:");
student.setExamCard(scanner.next());
System.out.print("studentName:");
student.setStudentName(scanner.next());
System.out.print("Location:");
student.setLocation(scanner.next());
System.out.print("Grade:");
student.setGrade(scanner.nextInt());
// 把对象进行返回；
return student;
}
/**
* 第一个我们叫什么呢？叫addNewStudent 这样就写成了一个方法，我要添加一个学生进来，我们当然可以硬写，怎么写呢？
* 就是真的从控制台逐步读入那些信息，然后把这些信息插入到数据库里面；
*/
public void addNewStudent(Student student) {
/**
* 这个方法基本在写流程的时候已经写过了：
*/
// 1.准备一条SQL语句：
// String sql = “INSERT INTO examstudent”+" VALUES(1,4,’’,’’,’’,’’,90)”;
String sql = "INSERT INTO examstudent" + " VALUES("
+ student.getFlowId() + "," + student.getType() + ",'"
+ student.getIdCard() + "','" + student.getExamCard() + "','"
+ student.getStudentName() + "','" + student.getLocation()
+ "'," + student.getGrade() + ")";
// 我打印一下这个SQL语句：
System.out.println(sql);
// 2.调用JdbcTools工具类的update(sql)方法执行插入操作；
JdbcTools.update(sql);
}
}
用到的工具类：
package com.zhou.jdbc;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.Properties;
/**
* 版本1：后面这些方法还可以升级，比方说我们不能每次操作都获取一个数据库连接，比方说后面会学数据库连接池；
*
* 操作JDBC的工具类：其中封装了一些工具方法：
*
* 1.获取连接的方法；
*
* @author Administrator
*
*/
public class JdbcTools {
/**
* 1.获取连接的方法：这个方法在前面已经写过了，只是这个是工具方法，需要加上static： ---通过读取配置文件从数据库服务器获取一个连接；
*
* 用DriverManager来把之前那个通用的方法写一遍：
*
* @throws Exception
*/
public static Connection getConnection() throws Exception {
// 1.准备连接数据库的四个字符串：
// 1).创建Properties对象：
Properties properties = new Properties();
// 2).获取jdbc.properties对应的输入流：
InputStream in = JdbcTools.class.getClassLoader().getResourceAsStream("jdbc.properties");
// 3).加载2) 对应的输入流：
properties.load(in);
// 4).具体决定user、password、jdbcUrl、driverClass四个字符串：
String user = properties.getProperty("user");
String password = properties.getProperty("password");
String jdbcUrl = properties.getProperty("jdbcUrl");
String driverClass = properties.getProperty("dirver");
// 2.加载数据库驱动程序(实际上这一步应该叫：注册驱动，对应的Driver实现类中有注册驱动的静态代码块)：
Class.forName(driverClass);
// 3.获取数据库的连接:
// Connection connection = DriverManager.getConnection(jdbcUrl, user,
// password);
// return connection;
return DriverManager.getConnection(jdbcUrl, user, password);
}
/**
* 2.关闭数据库资源的方法： 它关闭一个Statement，再关闭一个Connection：
*/
public static void release(Statement statement, Connection connection) {
if (statement != null) {
try {
statement.close();
} catch (Exception e1) {
e1.printStackTrace();
}
}
if (connection != null) {
try {
connection.close();
} catch (Exception e2) {
e2.printStackTrace();
}
}
}
/**
* 3.关闭数据库资源的方法： 它关闭三个：ResultSet、Statement、Connection：
*/
public static void release_2(ResultSet resultSet ,Statement statement, Connection connection) {
if (resultSet != null) {
try {
resultSet.close();
} catch (Exception e1) {
e1.printStackTrace();
}
}
if (statement != null) {
try {
statement.close();
} catch (Exception e2) {
e2.printStackTrace();
}
}
if (connection != null) {
try {
connection.close();
} catch (Exception e3) {
e3.printStackTrace();
}
}
}
/**
* 4.执行SQL的方法：
* SQL：INSERT、UPDATE、DELETE,而不包含SELECT;
*/
public static void update(String sql){
Connection connection = null;
Statement statement = null;
try {
connection = getConnection();
statement = connection.createStatement();
statement.executeUpdate(sql);
} catch (Exception e) {
e.printStackTrace();
} finally {
// 关闭连接：这里不再写那个嵌套的try……catch……finally了
release(statement, connection);
}
}
}
Student类：
package com.zhou.jdbc;
public class Student {
/**
* 这些字段都是跟数据库中examstudent数据表示对应的：
*/
// 流水号
private int flowId;
// 考试的类型
private int type;
// 身份证号
private String idCard;
// 准考证号
private String examCard;
// 学生姓名
private String studentName;
// 地址
private String location;
// 考试分数
private int grade;
/**
* 当然会有对应的getter和setter方法：
*/
public int getFlowId() {
return flowId;
}
public void setFlowId(int flowId) {
this.flowId = flowId;
}
public int getType() {
return type;
}
public void setType(int type) {
this.type = type;
}
public String getIdCard() {
return idCard;
}
public void setIdCard(String idCard) {
this.idCard = idCard;
}
public String getExamCard() {
return examCard;
}
public void setExamCard(String examCard) {
this.examCard = examCard;
}
public String getStudentName() {
return studentName;
}
public void setStudentName(String studentName) {
this.studentName = studentName;
}
public String getLocation() {
return location;
}
public void setLocation(String location) {
this.location = location;
}
public int getGrade() {
return grade;
}
public void setGrade(int grade) {
this.grade = grade;
}
/**
* 还会有一个有参数的构造器：
* @param flowId
* @param type
* @param idCard
* @param examCard
* @param studentName
* @param location
* @param grade
*/
public Student(int flowId, int type, String idCard, String examCard,
String studentName, String location, int grade) {
super();
this.flowId = flowId;
this.type = type;
this.idCard = idCard;
this.examCard = examCard;
this.studentName = studentName;
this.location = location;
this.grade = grade;
}
/**
* 还会有一个无参数的构造器：
*/
public Student() {
super();
}
/**
* 还会有一个toString()方法来做测试：
*/
@Override
public String toString() {
return "Student [flowId=" + flowId + ", type=" + type + ", idCard="
+ idCard + ", examCard=" + examCard + ", studentName="
+ studentName + ", location=" + location + ", grade=" + grade
+ "]";
}
}
|
本文出自 “IT技术JAVA” 博客，转载请与作者联系！