使用JDBC操作MySql进行增删改查学生信息。

一个老生常谈的知识点了，只不过需要做这个实验也没办法，写了一个用JDBC操作Mysql数据库进行一些简单操作，正好记录一下以后需要的时候改一改就行了。

将数据库配置文件放在conf.properties中，建表语句放在createTable.sql中，存在一个自增主键。

学生实体包括：学号，姓名，班级，创建时间。

检查数据库中是否存在student表，如果存在则将其 删除 后重新创建。

支持添加单个学生信息，多个学生信息。

支持根据学号精确查找，根据姓名、班级精确查找和模糊查找。

根据学号进行修改学生信息。

根据学号进行删除。

代码结构如下，需要添加JDBC对应的jar包：



代码如下，注释写的比较清楚：

conf.properties

url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8
driver=com.mysql.jdbc.Driver
username=root
password=123456

createTable.sql

DROP TABLE  IF EXISTS student;
CREATE TABLE student (
id          INTEGER     NOT NULL AUTO_INCREMENT,
NAME        VARCHAR(20) NOT NULL,
SNO         VARCHAR(10) NOT NULL UNIQUE ,
CLASS       VARCHAR(30) NOT NULL,
CREATE_DATE DATE        NOT NULL,
PRIMARY KEY (id)
)

Student.java

package com.leafage.javatest;

import java.sql.Date;

/**
* @Author Leafage
* @Date 2017/12/4 17:27
**/
public class Student {
private String name;
private String sno;
private String class_;
private Date create_date;

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public String getSno() {
return sno;
}

public void setSno(String sno) {
this.sno = sno;
}

public String getClass_() {
return class_;
}

public void setClass_(String class_) {
this.class_ = class_;
}

public Date getCreate_date() {
return create_date;
}

public void setCreate_date(Date create_date) {
this.create_date = create_date;
}

@Override
public String toString() {
return "Sno:" + sno + ",Name:" + name + ",Class:" + class_ + ",CreateDate:" + create_date;
}
}

JDBCTest.java（读取配置文件的路径可能需要修改）

package com.leafage.javatest;
import java.io.*;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;

/**
* @Author Leafage
* @Date 2017/12/4 15:30
**/
public class JDBCTest {

private static Connection conn;//数据库连接
private static PreparedStatement preparedStatement;
private static Statement statement;

public static void main(String[] args) {
init();//初始化操作
Student student = new Student();
student.setName("小红");
student.setClass_("移动一班");
student.setSno("1515925506");
student.setCreate_date(new Date(System.currentTimeMillis()));

Student student1 = new Student();
student1.setName("小白");
student1.setClass_("移动二班");
student1.setSno("1515925501");
student1.setCreate_date(new Date(System.currentTimeMillis()));

List<Student> students = new ArrayList<>();
students.add(student);
students.add(student1);

insert(students);//测试添加多个信息

Student student2 = new Student();
student2.setName("小黑");
student2.setSno("1515925503");
student2.setClass_("移动一班");
student2.setCreate_date(new Date(System.currentTimeMillis()));
insert(student2);//测试添加单个信息

students = findByName("小白",false);//根据姓名精确查找
for (Student s1 : students) {
System.out.println("根据姓名精确查找：" + s1.toString());
}

Student s2 = findBySno("1515925501");//根据学号查找

System.out.println("根据学号查找:" + s2.toString());

students = findByClass("一班",true);//根据班级模糊查找
for (Student s1 : students) {
System.out.println("根据班级模糊查找:" + s1.toString());
}

Student student3 = new Student();
student3.setSno("1515925506");
student3.setClass_("云计算一班");
student3.setName("Leafage");
student3.setCreate_date(new Date(System.currentTimeMillis()));
update(student3);

System.out.println("更新信息之后的数据为：" + findBySno(student3.getSno()));

delete("1515925506");//测试根据学号删除

findBySno("1515925506");

close();//关闭连接
}

/**
* 执行初始化操作，初始化数据连接，创建表
*/
public static void init() {
try {
BufferedReader reader = new BufferedReader(new FileReader("F:\\IDEA\\JavaTest\\resource\\conf.properties"));//加载文件流
Properties prop = new Properties();//创建属性操作对象
prop.load(reader);//加载流

//加载数据库驱动
Class.forName(prop.getProperty("driver"));
//获得哦数据库连接
conn = DriverManager.getConnection(prop.getProperty("url"),prop.getProperty("username"),prop.getProperty("password"));

//获得建表语句
reader = new BufferedReader(new FileReader("F:\\IDEA\\JavaTest\\resource\\createTable.sql"));
StringBuilder createTableSql = new StringBuilder();
String string;
String deleteTable = reader.readLine();//读取第一行的删除表语句
while ((string = reader.readLine()) != null) {
createTableSql.append(string);
}
reader.close();
//System.out.println("sql:" + createTableSql.toString());
//创建表
statement = conn.createStatement();
statement.execute(deleteTable);//先判断表是否存在，存在则删除
statement.execute(createTableSql.toString());//创建表

System.out.println("初始化学生表成功！\n ========================");
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
statement.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}

private static final String insertSql = "INSERT INTO test.student (NAME, SNO, CLASS, CREATE_DATE) VALUES (?, ?, ?, ?);";

/** 对数据表进行单个添加操作
* @param student
*/
public static void insert(Student student) {
try {
preparedStatement = conn.prepareStatement(insertSql);
addStudent(preparedStatement,student);
} catch (SQLException e) {
e.printStackTrace();
} finally {
try {
preparedStatement.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}

/** 进行多个数据的添加
* @param students
*/
public static void insert(List<Student> students) {
try {
preparedStatement = conn.prepareStatement(insertSql);
for (Student student : students) {
addStudent(preparedStatement,student);
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
try {
preparedStatement.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}

/** 抽象出来的添加代码
* @param preparedStatement
* @param student
*/
public static void addStudent(PreparedStatement preparedStatement,Student student) {
try {
preparedStatement.setString(1,student.getName());
preparedStatement.setString(2,student.getSno());
preparedStatement.setString(3,student.getClass_());
preparedStatement.setDate(4,student.getCreate_date());
preparedStatement.execute();
System.out.println("添加学生信息成功：" + student.getSno());
} catch (SQLException e) {
e.printStackTrace();
}
}

/**
* 根据SNO进行查找
* @param sno 查找的学号
* @return
*/
public static Student findBySno(String sno) {
Student student = null;
String sql = "SELECT * FROM student WHERE SNO = ?;";
List<Student> students = findStudent(sql, sno, false);
if (students.size() > 0) {
student = students.get(0);
} else {
System.out.println("没有找到对应的信息！");
}
return student;
}

/** 根据名称查找
* @param name 学生名称
* @param blur 是否模糊查找
* @return
*/
public static List<Student> findByName(String name,boolean blur) {
String sql = "";
if (blur) {//模糊查询
sql = "SELECT * FROM student WHERE NAME LIKE ?";
} else {//详细查询
sql = "SELECT * FROM student WHERE NAME = ?;";
}
List<Student> students = findStudent(sql,name,blur);
return students;
}

/** 根据班级查找
* @param name 班级名称
* @param blur 是否模糊查找
* @return
*/
public static List<Student> findByClass(String name,boolean blur) {
String sql = "";
if (blur) {//模糊查询
sql = "SELECT * FROM student WHERE CLASS LIKE ?";
} else {//详细查询
sql = "SELECT * FROM student WHERE CLASS = ?;";
}
List<Student> students = findStudent(sql,name,blur);
return students;
}

/** 抽象出来的查找方法
* @param sql 需要执行的sql语句
* @param param sql语句中的参数
* @param blur 是否模糊查找
* @return
*/
public static List<Student> findStudent(String sql,String param,boolean blur) {
try {
preparedStatement = conn.prepareStatement(sql);
if (param != null) {//如果参数不为null，设置参数
if (blur) {//如果是模糊查询
preparedStatement.setString(1,"%"+param+"%");
} else {
preparedStatement.setString(1, param);
}
}
} catch (SQLException e) {
e.printStackTrace();
}

List<Student> students = new ArrayList<>();
try {
ResultSet resultSet = preparedStatement.executeQuery();
while (resultSet.next()) {
Student student = new Student();
student.setName(resultSet.getString("NAME"));
student.setSno(resultSet.getString("SNO"));
student.setClass_(resultSet.getString("CLASS"));
student.setCreate_date(resultSet.getDate("CREATE_DATE"));
students.add(student);
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
try {
preparedStatement.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
return students;
}

/**
* 对数据表进行修改操作，根据学号进行修改
* @param student
*/
public static void update(Student student) {
if (findBySno(student.getSno()) == null) {
System.out.println("更新数据时，该学号不存在！");
return;
}

String updateSql = "UPDATE student SET NAME = ?,CLASS = ?,CREATE_DATE=? WHERE SNO = ?;";
try {
preparedStatement = conn.prepareStatement(updateSql);
preparedStatement.setString(1, student.getName());
preparedStatement.setString(2, student.getClass_());
preparedStatement.setDate(3, student.getCreate_date());
preparedStatement.setString(4, student.getSno());
preparedStatement.execute();
System.out.println("更新学生信息成功！");
} catch (SQLException e) {
e.printStackTrace();
} finally {
try {
preparedStatement.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}

/**
* 对数据表进行删除操作，根据学号进行删除
* @param sno 学号
*/
public static void delete(String sno) {
String deleteSql = "DELETE FROM student WHERE SNO = ?;";
if (findBySno(sno) == null) {//如果这个学号不存在
System.out.println("删除学号时，该学号不存在！");
return;
}
try {
preparedStatement = conn.prepareStatement(deleteSql);
preparedStatement.setString(1, sno);
preparedStatement.execute();
System.out.println("删除学生信息成功！");
} catch (SQLException e) {
e.printStackTrace();
} finally {
try {
preparedStatement.close();
} catch (SQLException e) {
e.printStackTrace();
}
}

}

/**
* 关闭数据库的链接
*/
public static void close() {
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}