Java与JDBC

实验要求:


1. 创建学生类Student

2. 请从抽象类AbstractStudentRepository中继承一个类StudentRepository,实现方法loadStudents()和saveStudents(),要求能够支持对不同编码的文件的操作(提示:参考FileInputStream/FileOutputStream,InputStreamReader/OutputStreamWriter, BufferedReader/BufferedWriter等类的API文档)

3. 请使用接口IStudentDB实现类StudentDBMysql, 用于处理Student类在Mysql数据库的操作,在类中添加方法createStudentTable()用于创建students表格:
数据库类型: mysql
主机地址:210.32.80.105
数据库名:[本人学号]
用户名:[本人学号]
密码:[身份证后6位]
数据库管理地址:http://210.32.80.105/phpmyadmin

4. 创建类TestStudents: 测试从文件中读取学生数据;向文件写入学生数据;连接数据库;创建student表;向student中插入文件中的全部学生数据;在数据库中按自己的学号查询数据;从数据库中删除自己学号的数据。

5. 请仿照已实现的StudentDBMysql使用接口IStudentDB实现类StudentDBAccess,实现Access数据库连接的操作。


内容与要求
1. 学生数据文件中的学生数据格式如下:

尹克平;0012031102;英语(师范);外国语学院
谢惠良;0112023302;市场营销;经贸管理学院
胡康康;0112032306;初等教育(英语方向)(师范);教师教育学院
程双喜;0112033105;外贸英语;外国语学院
何勇;0112041114;数学与应用数学(师范);数学与信息工程学院

即每个学生数据占一行,数据中每个字段以“;”分隔,对应字段为姓名(xm)、学号(xh)、专业(zy)、学院(xy),其中学号是学生的惟一标识,不存在重复学号的两位学生。请按字段要求实现学生类Student。由于学号作为学生的惟一标识,请在Student类中重写方法hashcode()和equals(Object obj)这两个方法。(为了实现的需要,只要学号相同的两个Student实例将会视为相等)

2. 转换学生数据字段,将专业名与是否师范分开,即英语(师范)转换为英语;true, 市场营销转换为市场营销;false

3. 修改学生类Student:增加变量“是否师范(sfsf)”;根据我们实验的要求请实现一个构造方法Student(String str),它可以根据提供的文件中每行学生的数据来创建对应学生实例。(如:"尹克平;0012031102;英语(师范);外国语学院")。

4. 对于saveStudents()方法,需要实现一个Comparator<Student>接口。然后在该方法中对所有学生以学号进行排序。提示:查看Set和Arrays的API文档。将所有学生数据写回文件,内容如下:

尹克平;0003121102;英语;true;外国语学院
谢惠良;0102123302;市场营销;false;经贸管理学院
胡康康;0103122306;初等教育(英语方向);true;教师教育学院
程双喜;0103123105;外贸英语;false;外国语学院
何勇;0104121114;数学与应用数学;true;数学与信息工程学院

5. 在上一步实现的基础上,请修改Student类的构造方法,要求其能根据参数str中的”;”字符的个数来创建正确的Student对象。即:
a. 若str=”尹克平;0012031102;英语(师范);外国语学院”
则Student实例中的xm=”尹克平”, xh=”0012031102”, zy=”英语”, sfsf=true, xy=”外国语学院”

b. 若str=”尹克平;0012031102;英语;false外国语学院”
则Student实例中的xm=”尹克平”, xh=”0012031102”, zy=”英语”, sfsf=true, xy=”外国语学院”

c. 若str=”0012031102”
则Student实例中的xh=”0012031102”, 其它变量全为Java的对应默认值

6. 在数据库中创建一个student表,包含字段:姓名(xm)、学号(xh)、专业(zy)、是否师范(sfsf)、学院(xy),sql语句如下:
CREATE TABLE `student` (`xm` VARCHAR( 24 ),`xh` VARCHAR( 24 ),`zy` VARCHAR( 24 ),`sfsf` TINYINT( 1 ),`xy` VARCHAR( 24 ),PRIMARY KEY ( `xh`)) CHARACTER SET utf8;

7. 在表中查找出学号为自己学号的数据的sql语句:
SELECT * FROM `student` WHERE `xh`=’[学号]’;

8. 将自己学号的数据删除的sql语句:
DELETE FROM ‘student’ WHERE `xh`=’[学号]’;

9. 在数据库中添加的数据的sql语句:
INSERT INTO `student` (`xm`, `xh`, `zy`, `sfsf`, `xy`) VALUES (“尹克平”, “0003121102”, “英语”, “true”, “外国语学院”);

10. 更新学生数据的代码:
UPDATE `student` SET `zy` = '新专业名', `sfsf` = '0或1' WHERE `xh` = '我的学号';

/**
 * Student类,包含姓名(xm)、学号(xh)、专业(zy)、是否师范(sfsf)、学院(xy)字段
 * 其中重写了Object类中hashCode(),equals(),toString()三个方法。
 */
public class Student {
	private String xm, xh, zy, xy;

	private boolean sfsf;

	public Student() {
		super();
	}

	public Student(String xm, String xh, String zy, String xy, boolean sfsf) {
		super();
		this.xm = xm;
		this.xh = xh;
		this.zy = zy;
		this.xy = xy;
		this.sfsf = sfsf;
	}

	public Student(String str) {
		String[] information;
		information = str.split(";");
		if (information.length == 4) {
			xm = information[0];
			xh = information[1];
			if (information[2].endsWith("(师范)")) {
				sfsf = true;
				int endIndex = information[2].indexOf('(');
				zy = information[2].substring(0, endIndex);
			} else {
				sfsf = false;
				zy = information[2];
			}
			xy = information[3];
		} else if (information.length == 5) {
			xm = information[0];
			xh = information[1];
			zy = information[2];
			sfsf = information[3].equals("true") ? true : false;
			xy = information[4];
		} else if (information.length == 1) {
			xh = information[0];
		} else {
			throw new IllegalArgumentException("传入的参数无法构建student");
		}
	}

	public boolean isSfsf() {
		return sfsf;
	}

	public void setSfsf(boolean sfsf) {
		this.sfsf = sfsf;
	}

	public String getXh() {
		return xh;
	}

	public void setXh(String xh) {
		this.xh = xh;
	}

	public String getXm() {
		return xm;
	}

	public void setXm(String xm) {
		this.xm = xm;
	}

	public String getXy() {
		return xy;
	}

	public void setXy(String xy) {
		this.xy = xy;
	}

	public String getZy() {
		return zy;
	}

	public void setZy(String zy) {
		this.zy = zy;
	}

	@Override
	public int hashCode() {
		return xh.hashCode();
	}

	@Override
	public boolean equals(Object obj) {
		if (obj instanceof Student) {
			Student s = (Student) obj;
			return s.xh.equals(xh);
		}
		return false;
	}

	@Override
	public String toString() {
		return xm + ";" + xh + ";" + zy + ";" + sfsf + ";" + xy;
	}
}


import java.util.Set;

/**
 * AbstractStudentRepository抽象类,其中包含loadStudents()方法和saveStudents()方法
 * 分別是从文件中读取学生信息和将学生信息保存
 */
public abstract class AbstractStudentRepository {
	protected Set<Student> set;
	protected String dataFilePath;
	protected String charset;

	public AbstractStudentRepository(String dataFilePath, String charset) {
		super();
		this.dataFilePath = dataFilePath;
		this.charset = charset;
	}

	/**
	 * 从文件dataFilePath中读取所有学生数据到set中
	 */
	public abstract void loadStudents();

	/**
	 * 将set中的学生数据保存到文件dataFilePath中,要求以学号的升序顺序保存
	 */
	public abstract void saveStudents();

	public boolean contains(Student s) {
		if (set == null) {
			loadStudents();
		}
		return set.contains(s);
	}

	public void add(Student s) {
		if (set == null) {
			loadStudents();
		}
		set.add(s);
	}

	public void remove(Student s) {
		if (set == null) {
			loadStudents();
		}
		set.remove(s);
	}

	public int getCount() {
		if (set == null) {
			loadStudents();
		}
		return set.size();
	}

	public Student[] getStudentArray() {
		if (set == null) {
			loadStudents();
		}
		return set.toArray(new Student[0]);
	}
}


import java.sql.Connection;
import java.util.List;

/**
 *Student的数据库操作接口 
 *
 */
public interface IStudentDB {
	/**
	 * 获取数据库连接
	 */
	Connection getConnection();

	/**
	 * 关闭打开的资源,如statement,resultset和数据库连接[视代码实现情况而定]
	 */
	void close();

	/**
	 * 以学号为参数向数据库中查询学生数据,返回Student实例,若库中不存在学生对象返回null
	 * 
	 * @param xh
	 * @return Student实例
	 */
	Student query(String xh);

	/**
	 * 向数据库中添加学生,成功添加返回true, 如果数据库中已经存在相同学号的数据返回false
	 * 
	 * @param s
	 * @return boolean
	 */
	boolean insert(Student s);

	/**
	 * 按学号在数据库中更新学生数据,成功更新返回true, 如果数据库中不存在对应学号的学生数据返回false
	 * 更新的数据项可包括姓名,专业,是否师范,以及学院(需要比较数据库中的数据项值和Student实例的对应变量值来确定是否需要比较)
	 * 
	 * @param s
	 */
	boolean update(Student s);

	/**
	 * 从数据库中删除指定学号的学生数据
	 * 
	 * @param xh
	 */
	void delete(String xh);
	
	/**
	 * 从数据库中查询所有学生数据并返回list
	 * 
	 * @return 学生的list
	 */
	List<Student> loadAll();

	/**
	 * 将studentList中的所有学生插入到数据库
	 * 
	 * @param studentList
	 */
	int insertAll(List<Student> studentList);
}


import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class StudentDBMysql implements IStudentDB {
	Connection conn = null;

	/**
	 * 获取数据库连接
	 */
	@Override
	public Connection getConnection() {
		try {
			Class.forName("org.gjt.mm.mysql.Driver").newInstance();
		} catch (InstantiationException e1) {
			e1.printStackTrace();
		} catch (IllegalAccessException e1) {
			e1.printStackTrace();
		} catch (ClassNotFoundException e1) {
			e1.printStackTrace();
		}
		String url = "jdbc:mysql://210.32.80.105/0929210066?user=0929210066"
				+ "&password=275818"
				+ "&useUnicode=true&characterEncoding=utf8";
		try {
			conn = DriverManager.getConnection(url);
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return conn;
	}

	/**
	 * 关闭打开的资源
	 */
	@Override
	public void close() {
		if (conn != null) {
			try {
				if (!conn.isClosed()) {
					conn.close();
				}
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
	}

	/**
	 * 以学号为参数向数据库中查询学生数据,返回Student实例,若库中不存在学生对象返回null
	 */
	@Override
	public Student query(String xh) {
		conn = getConnection();
		PreparedStatement ps = null;
		ResultSet rs = null;
		Student s = null;

		/**
		 * SQL语句,查询学号为xh的学生信息
		 */
		String sql = "select * from student where xh = ?";
		try {
			ps = conn.prepareStatement(sql);
			ps.setString(1, xh);
			rs = ps.executeQuery();
			if (rs.next()) {
				s = new Student();
				s.setXm(rs.getString("xm"));
				s.setXh(rs.getString("xh"));
				s.setXy(rs.getString("xy"));
				s.setZy(rs.getString("zy"));
				s.setSfsf(rs.getInt("sfsf") == 1 ? true : false);
			}
			rs.close();
			ps.close();
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			close();
		}
		return s;
	}

	/**
	 * 向数据库中添加学生,成功添加返回true, 如果数据库中已经存在相同学号的数据返回false
	 */
	@Override
	public boolean insert(Student s) {
		conn = getConnection();
		PreparedStatement ps = null;
		int count = 0;

		/**
		 * SQL语句,插入一个学生信息
		 */
		String sql = "insert into student(xm, xh, zy, sfsf, xy) values(?,?,?,?,?)";

		try {
			ps = conn.prepareStatement(sql);
			ps.setString(1, s.getXm());
			ps.setString(2, s.getXh());
			ps.setString(3, s.getZy());
			ps.setInt(4, s.isSfsf() ? 1 : 0);
			ps.setString(5, s.getXy());
		} catch (SQLException e1) {
			e1.printStackTrace();
		}
		if (query(s.getXh()) == null) {
			try {
				count = ps.executeUpdate();
				System.out.println(s + " succeed insert into student table");
			} catch (SQLException e) {
				e.printStackTrace();
			}
		} else {
			System.out.println(s + " has exists");
		}
		try {
			ps.close();
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return count != 0 ? true : false;
	}

	/**
	 * 按学号在数据库中更新学生数据,成功更新返回true
	 * 如果数据库中不存在对应学号的学生数据返回false 
	 */
	@Override
	public boolean update(Student s) {
		conn = getConnection();
		PreparedStatement ps = null;
		
		/**
		 * SQL语句,更新一个学生信息
		 */
		String sql = "UPDATE student SET xm = ?, zy = ?, sfsf = ? , xy = ? WHERE xh = ?";
		
		try {
			ps = conn.prepareStatement(sql);
			ps.setString(1, s.getXm());
			ps.setString(2, s.getZy());
			ps.setInt(3, s.isSfsf() ? 1 : 0);
			ps.setString(4, s.getXy());
			ps.setString(5, s.getXh());
			if (query(s.getXh()) == null) {
				System.out.println(s + "update failed");
				return false;
			}
			ps.executeUpdate();
			System.out.println(s + " update succeed");
			ps.close();
			close();
			return true;
		} catch (SQLException e) {
			e.printStackTrace();
		}
		System.out.println(s + "update failed");
		return false;
	}

	/**
	 * 从数据库中删除指定学号的学生数据
	 */
	@Override
	public void delete(String xh) {
		conn = getConnection();
		PreparedStatement ps = null;
		
		/**
		 * SQL语句,删除一个学号为xh的学生信息
		 */
		String sql = "DELETE FROM student WHERE xh = ?";
		try {
			ps = conn.prepareStatement(sql);
			ps.setString(1, xh);
			int count = ps.executeUpdate();
			if (count == 1) {
				System.out.println("Student whose xh is " + xh
						+ " has been deleted");
			} else {
				System.out.println("Student whose xh is " + xh
						+ " failed to be deleted,no such a student");
			}
			ps.close();
			close();
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}

	/**
	 * 从数据库中查询所有学生数据并返回list
	 */
	@Override
	public List<Student> loadAll() {
		conn = getConnection();
		List<Student> stu = new ArrayList<Student>();
		PreparedStatement ps = null;
		ResultSet rs = null;
		
		/**
		 * SQL语句,查询所有学生信息
		 */
		String sql = "SELECT * FROM student";
		try {
			ps = conn.prepareStatement(sql);
			rs = ps.executeQuery();
			while (rs.next()) {
				Student s = new Student();
				s.setXm(rs.getString("xm"));
				s.setXh(rs.getString("xh"));
				s.setXy(rs.getString("xy"));
				s.setZy(rs.getString("zy"));
				s.setSfsf(rs.getInt("sfsf") == 1 ? true : false);
				stu.add(s);
			}
			ps.close();
			rs.close();
			close();
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return stu;
	}

	/**
	 * 将studentList中的所有学生插入到数据库
	 */
	@Override
	public int insertAll(List<Student> studentList) {
		int count = 0;
		Iterator<Student> it = studentList.iterator();
		while (it.hasNext()) {
			if (insert(it.next()) == true) {
				count++;
			}
		}
		System.out.println(count + " students have been added");
		return count;
	}

	/**
	 * 创建学生表
	 */
	public void createStudentTable() {
		conn = getConnection();
		Statement st = null;
		
		/**
		 * SQL语句,创建一个学生信息表
		 */
		String sql = "CREATE TABLE student (xm VARCHAR( 24 ),xh VARCHAR( 24 ),zy VARCHAR( 24 ),"
				+ "sfsf TINYINT( 1 ),xy VARCHAR( 24 ),PRIMARY KEY ( xh)) CHARACTER SET utf8";
		try {
			st = conn.createStatement();
			st.executeUpdate(sql);
			System.out.println("create table 'student' succeed");
			st.close();
			close();
		} catch (SQLException e) {
			System.out.println("create table 'student' failed");
			e.printStackTrace();
		}
	}
}


import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class StudentDBAccess implements IStudentDB {
	Connection conn = null;

	/**
	 * 获取数据库连接
	 */
	@Override
	public Connection getConnection() {
		try {
			Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		String url = "jdbc:odbc:Driver={MicroSoft Access Driver (*.mdb)};DBQ="
				+ "D:/Data/ReportDemo.mdb";
		try {
			conn = DriverManager.getConnection(url, "", "");
			Statement stmtNew = conn.createStatement();
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return conn;
	}

	/**
	 * 关闭打开的资源
	 */
	@Override
	public void close() {
		if (conn != null) {
			try {
				if (!conn.isClosed()) {
					conn.close();
				}
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
	}

	/**
	 * 以学号为参数向数据库中查询学生数据,返回Student实例,若库中不存在学生对象返回null
	 */
	@Override
	public Student query(String xh) {
		conn = getConnection();
		PreparedStatement ps = null;
		ResultSet rs = null;
		Student s = null;

		/**
		 * SQL语句,查询学号为xh的学生信息
		 */
		String sql = "select * from student where xh = ?";
		try {
			ps = conn.prepareStatement(sql);
			ps.setString(1, xh);
			rs = ps.executeQuery();
			if (rs.next()) {
				s = new Student();
				s.setXm(rs.getString("xm"));
				s.setXh(rs.getString("xh"));
				s.setXy(rs.getString("xy"));
				s.setZy(rs.getString("zy"));
				s.setSfsf(rs.getInt("sfsf") == 1 ? true : false);
			}
			rs.close();
			ps.close();
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			close();
		}
		return s;
	}

	/**
	 * 向数据库中添加学生,成功添加返回true, 如果数据库中已经存在相同学号的数据返回false
	 */
	@Override
	public boolean insert(Student s) {
		conn = getConnection();
		PreparedStatement ps = null;
		int count = 0;

		/**
		 * SQL语句,插入一个学生信息
		 */
		String sql = "insert into student(`xm`, `xh`, `zy`, `sfsf`, `xy`) values(?,?,?,?,?)";

		try {
			ps = conn.prepareStatement(sql);
			ps.setString(1, s.getXm());
			ps.setString(2, s.getXh());
			ps.setString(3, s.getZy());
			ps.setInt(4, s.isSfsf() ? 1 : 0);
			ps.setString(5, s.getXy());
		} catch (SQLException e1) {
			e1.printStackTrace();
		}
		if (query(s.getXh()) == null) {
			try {
				count = ps.executeUpdate();
				System.out.println(s + " succeed insert into student table");
			} catch (SQLException e) {
				e.printStackTrace();
			}
		} else {
			System.out.println(s + " has exists");
		}
		try {
			ps.close();
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return count != 0 ? true : false;
	}

	/**
	 * 按学号在数据库中更新学生数据,成功更新返回true 如果数据库中不存在对应学号的学生数据返回false
	 */
	@Override
	public boolean update(Student s) {
		conn = getConnection();
		PreparedStatement ps = null;

		/**
		 * SQL语句,更新一个学生信息
		 */
		String sql = "UPDATE `student` SET `xm` = ?, `zy` = ?, `sfsf` = ? , `xy` = ? WHERE `xh` = ?";

		try {
			ps = conn.prepareStatement(sql);
			ps.setString(1, s.getXm());
			ps.setString(2, s.getZy());
			ps.setInt(3, s.isSfsf() ? 1 : 0);
			ps.setString(4, s.getXy());
			ps.setString(5, s.getXh());
			if (query(s.getXh()) == null) {
				System.out.println(s + "update failed");
				return false;
			}
			ps.executeUpdate();
			System.out.println(s + " update succeed");
			ps.close();
			close();
			return true;
		} catch (SQLException e) {
			e.printStackTrace();
		}
		System.out.println(s + "update failed");
		return false;
	}

	/**
	 * 从数据库中删除指定学号的学生数据
	 */
	@Override
	public void delete(String xh) {
		conn = getConnection();
		PreparedStatement ps = null;

		/**
		 * SQL语句,删除一个学号为xh的学生信息
		 */
		String sql = "DELETE FROM `student` WHERE `xh` = ?";
		try {
			ps = conn.prepareStatement(sql);
			ps.setString(1, xh);
			int count = ps.executeUpdate();
			if (count == 1) {
				System.out.println("Student whose xh is " + xh
						+ " has been deleted");
			} else {
				System.out.println("Student whose xh is " + xh
						+ " failed to be deleted,no such a student");
			}
			ps.close();
			close();
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}

	/**
	 * 从数据库中查询所有学生数据并返回list
	 */
	@Override
	public List<Student> loadAll() {
		conn = getConnection();
		List<Student> stu = new ArrayList<Student>();
		PreparedStatement ps = null;
		ResultSet rs = null;

		/**
		 * SQL语句,查询所有学生信息
		 */
		String sql = "SELECT * FROM `student`";
		try {
			ps = conn.prepareStatement(sql);
			rs = ps.executeQuery();
			while (rs.next()) {
				Student s = new Student();
				s.setXm(rs.getString("xm"));
				s.setXh(rs.getString("xh"));
				s.setXy(rs.getString("xy"));
				s.setZy(rs.getString("zy"));
				s.setSfsf(rs.getInt("sfsf") == 1 ? true : false);
				stu.add(s);
			}
			ps.close();
			rs.close();
			close();
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return stu;
	}

	/**
	 * 将studentList中的所有学生插入到数据库
	 */
	@Override
	public int insertAll(List<Student> studentList) {
		int count = 0;
		Iterator<Student> it = studentList.iterator();
		while (it.hasNext()) {
			if (insert(it.next()) == true) {
				count++;
			}
		}
		System.out.println(count + " students have been added");
		return count;
	}

	/**
	 * 创建学生表
	 */
	public void createStudentTable() {
		conn = getConnection();
		Statement st = null;

		/**
		 * SQL语句,创建一个学生信息表
		 */
		String sql = "CREATE TABLE [student]([xm] VARCHAR(24),[xh] VARCHAR(24),"
				+ "[zy] VARCHAR(24),[sfsf] BIT,[xy] VARCHAR(24),primary key([xh]))";
		try {
			st = conn.createStatement();
			st.executeUpdate(sql);
			System.out.println("create table 'student' succeed");
			st.close();
			close();
		} catch (SQLException e) {
			System.out.println("create table 'student' failed");
			e.printStackTrace();
		}
	}
}

你可能感兴趣的:(java,mysql,jdbc)