Java的数据库操作

Java的数据库操作，上学期末的课设是用到的，然而老师把JDBC连接mysql数据库的代码和配置文件已经给好了，那时对它可以说是只有一点点印象。

今天跟着书走一边敲一边，总算是有所进步。

数据库表的创建和初始数据的操作，都是在数据库的前端管理工具Navicat里进行的，创建的表如下：


主要注意点就是id设置成主键之后，一定要选择红色箭头的三个选项，需要哪个点哪个。不然只有那个key钥匙，不仅在表里面输入数据时你会迷茫，而且JDBC里面也会出现问题。

接下来就是：

package Java的数据库操作;

import java.sql.Statement;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

import javax.print.attribute.standard.PDLOverrideSupported;

/*
* 上学期最后课程设计用了这个，然后当时是老师给好的
* 今天来自己动手过一遍，看一遍，练习一遍
* 这个是数据库连接操作时，需要的类，并且注意，这是父类
* 所以说后面需要使用到关于数据库操作的类，都是要继承此父类的
* 这个父类负责打开数据库连接，关闭数据库操作对象*/

public class DBConnection {
//连接属性定义区，言下之意就是这些属性都是和数据库有关咯
private final static String CLS="com.mysql.jdbc.Driver";
private final static String URL="jdbc:mysql://localhost:3306/amis";
private final static String UESR="root";
private final static String PWD="y888888";

//公共数据库操作对象，这些是Java里面的功能吗？进一步说是java的jdbc中的功能
public static Connection conn=null;			//连接对象
public static Statement stmt=null;			//命令集对象
public static PreparedStatement pStmt=null;	//预编译命令集对象
public static ResultSet rs=null;			//结果集对象

//打开连接的方法
public static void getConnection() {
try {
Class.forName(CLS);											//加载驱动类
conn=DriverManager.getConnection(URL, UESR, PWD);			//打开连接
} catch (Exception e) {
System.out.println("连接失败");
e.printStackTrace();
}
}

//关闭所有的数据库操作对象的方法
public static void closeAll() {
try {
if (rs!=null){
rs.close();
rs=null;
}
if (stmt!=null){
stmt.close();
stmt=null;
}
if (pStmt!=null){
pStmt.close();
pStmt=null;
}
if (conn!=null){
conn.close();
conn=null;
}
} catch (Exception e) {
e.printStackTrace();
}
}

}

注释里面已经说了说，这里我来说说四个公共数据库操作对象，

Connection是每次需要开始操作连接对象而使用的

Statement和PreparedStatement，现在就我来说，这两个就是需要获取数据库内容，对内容进行操作所，而诞生的，是两个功能类。
http://www.jb51.net/article/76950.htm 这里对这俩进行了较详细的讲解，如果想深入了解的可以看看。

ResultSet，数据中查询结果返回的一种对象，可以说结果集是一个存储查询结果的对象，但是结果集并不仅仅具有存储的功能，他同时还具有操纵数据的功能，可能完成对数据的更新等。http://blog.csdn.net/ustcxjt/article/details/7289345

在数据库连接父类建立完成之后，就开始对对象类进行创建，这样才知道在具体数据库操作的时候要干什么

package Java的数据库操作;
/*
* 此类就是一个对象类：会员*/
public class Academician {
private int id;
private String stuName;
private String stuDept;
private String stuClass;
private String inDt;
private String outDt;
private String tell;
private boolean BLeave;

public Academician(){

}

public Academician(int i,String n,String d,String c,String in,String o,String t,boolean b){
this.id=i;
this.stuName=n;
this.stuDept=d;
this.stuClass=c;
this.inDt=in;
this.outDt=o;
this.tell=t;
this.BLeave=b;
}

public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

public String getStuName() {
return stuName;
}

public void setStuName(String stuName) {
this.stuName = stuName;
}

public String getStuDept() {
return stuDept;
}

public void setStuDept(String stuDept) {
this.stuDept = stuDept;
}

public String getStuClass() {
return stuClass;
}

public void setStuClass(String stuClass) {
this.stuClass = stuClass;
}

public String getInDt() {
return inDt;
}

public void setInDt(String inDt) {
this.inDt = inDt;
}

public String getOutDt() {
return outDt;
}

public void setOutDt(String outDt) {
this.outDt = outDt;
}

public String getTell() {
return tell;
}

public void setTell(String tell) {
this.tell = tell;
}

public boolean isBLeave() {
return BLeave;
}

public void setBLeave(boolean bLeave) {
BLeave = bLeave;
}

}

然而今天get了一个方法，就是不在繁琐的自己创建set、get方法，eclipse里面是会有多的小功能。

在类文件编辑界面中右击-》选择Source-》选择Generate Getters and Setters，之后你就会明白了。

然后就对你的需要进行的操作，创建以下

package Java的数据库操作;

import java.beans.Statement;
import java.security.GeneralSecurityException;
import java.util.ArrayList;
import java.util.List;

/*
* 这个就是继承了数据库操作的父类
* 对数据库中的会员信息进行操作，代码中也就是对会员信息类进行一系列配合sql语句的操作*/
public class AcademicianDao extends DBConnection{

//使用命令集获取所有会员信息的方法
public List<Academician> getAllAcademician() {
List<Academician> list=new ArrayList<Academician>();
try {
getConnection();
stmt=conn.createStatement();
String sql="select * from Academician";
rs=stmt.executeQuery(sql);
while (rs.next()){
Academician item=new Academician();
item.setId(rs.getInt("id"));
item.setStuName(rs.getString("stuName"));
item.setStuDept(rs.getString("stuDept"));
item.setStuClass(rs.getString("stuClass"));
item.setInDt(rs.getString("inDt"));
item.setOutDt(rs.getString("outDt"));
item.setTell(rs.getString("tell"));
item.setBLeave(rs.getBoolean("bleave"));

list.add(item);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
closeAll();
}
return list;
}

//添加会员信息的方法
public int addAcademician(Academician item) {
int iRow=0;
try {
getConnection();
String sql="insert into Academician(id,stuName,stuDept,stuClass,inDt,outDt,tell,bleave) values(?,?,?,?,?,?,?,?)";
pStmt=conn.prepareStatement(sql);
pStmt.setInt(1, item.getId());
pStmt.setString(2, item.getStuName());
pStmt.setString(3, item.getStuDept());
pStmt.setString(4, item.getStuClass());
pStmt.setString(5, item.getInDt());
pStmt.setString(6, item.getOutDt());
pStmt.setString(7, item.getTell());
pStmt.setBoolean(8, item.isBLeave());

iRow=pStmt.executeUpdate();				//更新数据库
} catch (Exception e) {
e.printStackTrace();
}finally {
closeAll();
}
return iRow;
}

//修改会员信息的方法
public int editAcademician(Academician item) {
int iRow=0;
try {
getConnection();
String sql="update Academician set stuName=?,stuDept=?,stuClass=?,inDt=?,outDt=?,"+"tell=?,bleave=? where id=?";
pStmt=conn.prepareStatement(sql);
pStmt.setString(1, item.getStuName());
pStmt.setString(2, item.getStuDept());
pStmt.setString(3, item.getStuClass());
pStmt.setString(4, item.getInDt());
pStmt.setString(5, item.getOutDt());
pStmt.setString(6, item.getTell());
pStmt.setBoolean(7, item.isBLeave());
pStmt.setInt(8, item.getId());

iRow=pStmt.executeUpdate();				//更新数据库
} catch (Exception e) {
e.printStackTrace();
}finally {
closeAll();
}
return iRow;
}

//删除会员信息的方法
public int delAcademician(int id) {
int iRow=0;
try {
getConnection();
String sql="delete from Academician where id=?";
pStmt=conn.prepareStatement(sql);
pStmt.setInt(1, id);

iRow=pStmt.executeUpdate();
} catch (Exception e) {
e.printStackTrace();
}finally {
closeAll();
}
return iRow;
}
}

在这里，你将看到父类中四个公共操作对象的使用，同样也可以看到sql语句和java的结合之处在哪里。

当然，这里学习的只是一种方法，上学期末的课设里面今天一看，他喵的还是另外一种。部分例子如下：

package xupt.se.ttms.dao;

import java.util.LinkedList;
import java.util.List;
import java.sql.ResultSet;
import java.sql.SQLException;
import xupt.se.ttms.idao.iStudioDAO;
import xupt.se.ttms.model.Studio;
import xupt.se.util.DBUtil;

public class StudioDAO implements iStudioDAO {
@Override
public int insert(Studio stu) {
try {
String sql = "insert into studio(studio_name, studio_row_count, studio_col_count, studio_introduction )"
+ " values('"
+ stu.getName()
+ "', "
+ stu.getRowCount()
+ ", " + stu.getColCount()
+ ", '" + stu.getIntroduction()
+ "' )";
DBUtil db = new DBUtil();
db.openConnection();
ResultSet rst = db.getInsertObjectIDs(sql);
if (rst!=null && rst.first()) {
stu.setID(rst.getInt(1));
}
db.close(rst);
db.close();
return 1;

} catch (Exception e) {
e.printStackTrace();
}

return 0;
}

@Override
public int update(Studio stu) {
int rtn=0;
try {
String sql = "update studio set " + " studio_name ='"
+ stu.getName() + "', " + " studio_row_count = "
+ stu.getRowCount() + ", " + " studio_col_count = "
+ stu.getColCount() + ", " + " studio_introduction = '"
+ stu.getIntroduction() + "' ";

sql += " where studio_id = " + stu.getID();
DBUtil db = new DBUtil();
db.openConnection();
rtn =db.execCommand(sql);
db.close();
} catch (Exception e) {
e.printStackTrace();
}
return rtn;
}

@Override
public int delete(int ID) {
int rtn=0;
try{
String sql = "delete from  studio ";
sql += " where studio_id = " + ID;
DBUtil db = new DBUtil();
db.openConnection();
rtn=db.execCommand(sql);
db.close();
} catch (Exception e) {
e.printStackTrace();
}
return rtn;
}

@Override
public List<Studio> select(String condt) {
List<Studio> stuList = null;
stuList=new LinkedList<Studio>();
try {
String sql = "select studio_id, studio_name, studio_row_count, studio_col_count, studio_introduction from studio ";
condt.trim();
if(!condt.isEmpty())
sql+= " where " + condt;
DBUtil db = new DBUtil();
if(!db.openConnection()){
System.out.print("fail to connect database");
return null;
}
ResultSet rst = db.execQuery(sql);
if (rst!=null) {
while(rst.next()){
Studio stu=new Studio();
stu.setID(rst.getInt("studio_id"));
stu.setName(rst.getString("studio_name"));
stu.setRowCount(rst.getInt("studio_row_count"));
stu.setColCount(rst.getInt("studio_col_count"));
stu.setIntroduction(rst.getString("studio_introduction"));
stuList.add(stu);
}
}
db.close(rst);
db.close();
} catch (Exception e) {
e.printStackTrace();
}
finally{

}

return stuList;
}
}

所以说还有其它方法来完成数据库和java的连接和具体实现功能，但是总得思路不要错。

最后，就是测试用例的main和运行结果

package Java的数据库操作;

import java.util.List;

public class testAMis {

public static void main(String[] args) {
AcademicianDao dao=new AcademicianDao();

System.out.println("会员列表信息如下");
showAcademician(dao.getAllAcademician());

Academician item=new Academician(2, "c", "c1", "c2", "2016-01-01 00:00:00", null, "18991237658", false);
dao.addAcademician(item);
item=new Academician(3, "d", "d1", "d2", "2016-02-01 00:00:00", null, "15698123546", false);
dao.addAcademician(item);

System.out.println("添加后会员列表信息如下");
showAcademician(dao.getAllAcademician());

item.setId(3);
item.setOutDt("2018-01-01 00:00:00");
item.setBLeave(true);
dao.editAcademician(item);
System.out.println("修改后会员列表信息如下");
showAcademician(dao.getAllAcademician());

dao.delAcademician(2);
System.out.println("删除后会员列表信息如下");
showAcademician(dao.getAllAcademician());

}

private static void showAcademician(List<Academician> allAcademician) {
System.out.println("id\t会员名\t所在院系\t所在班级\t入会时间\t离会时间\t联系电话\t是否在会");
for (Academician item:allAcademician){
System.out.println(item.getId()+"\t"+item.getStuName()+"\t"+item.getStuDept()+"\t"+item.getStuClass()+"\t"+item.getInDt()+"\t"+item.getOutDt()+"\t"+item.getTell()+"\t"+get_str_from_bleave(item.isBLeave()));
}
}

public static String get_str_from_bleave(boolean bleave) {
String s="在会中";
if (bleave){
s="离会";
}
return s;
}

}

总之今天就是对JDBC有了进一步认识，我认为就是我们现在需要多认识，多见面，首先要知道有哪些功能，都是干什么，怎么用，java里面的优势和劣势可以说同时出现在这里，优势就是确实只要知道怎么用，以后随时可以用，但劣势就是要掌握的好多。

因为，积累，沉淀，学习乃当前之道。