首先需要自己做一个项目，本文是操作数据库的项目Jdbcutil2，主要包括对数据库中数据的增删改查操作，来看一下：
Colume:
package com.xintouyun.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target({ElementType.FIELD}) //注解可以写到属性上面
@Retention(RetentionPolicy.RUNTIME) //注解在运行范围有效
public @interface Colume {
String value() default "";
}Id:
package com.xintouyun.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target({ElementType.FIELD}) //注解可以写到属性上面
@Retention(RetentionPolicy.RUNTIME) //注解在运行范围有效
public @interface Id {
String value();
public boolean isAutoIncrease();
}
Table:
package com.xintouyun.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target(ElementType.TYPE) //注解可以写到类上面
@Retention(RetentionPolicy.RUNTIME) //注解在运行范围有效
public @interface Table {
String value();
}
BaseDao:
package com.xintouyun.dao;
import java.beans.IntrospectionException;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.math.BigDecimal;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import com.xintouyun.annotation.Colume;
import com.xintouyun.annotation.Id;
import com.xintouyun.annotation.Table;
import com.xintouyun.util.JdbcUtil;
public class BaseDao <E> {
private Class<?> cls;
private Map<String,String> columnPropertyMap = new HashMap<>();
public BaseDao() {
//得到父类的泛型
Type sType=getClass().getGenericSuperclass();
//得到实际的类型参数数组
Type[] generics=((ParameterizedType) sType).getActualTypeArguments();
//得到第一个泛型的Class
cls=(Class<?>) (generics[0]);
}
/**
* 传入主键值，删除对应的一条记录
* @param id 主键
* @return 受影响行数
*/
public int delete(Object id) {
/*我们需要将sql语句进行封装
* 1.因为是删除语句所以前面都是delete from+数据库中对应的表的名字+where+主键名+=?
* 2.如何获取表名？表明跟对象名是有联系的，一般实体类跟表明是对应的。但是如果用户在数据库中建表的时候跟实体类不是一一对应的，那我们就需要加上类的注解
* 3.如何获取主键名？首先要获取这个类中所有的属性，然后判断那个是主键，最后获取这个主键名
* 4.将sql语句拼接完之后，可以调用我们底层的update方法来执行操作
* 5.当然，如果这个表中不存在主键的话就没有必要执行下面的操作了，所以我们要先进行一下判断，看主键是否存在
* */
int affectRow=0;
if(scanId()==null) {
throw new IdMistakeException("没有Id设置，请设置Id");
} else {
String sql="delete from "+scanTableName()+" where "+scanId()+"=?";
System.out.println(sql);
affectRow=update(sql,id);
}
return affectRow;
}
/**
* 传入一个对象，根据主键更新这个对象里面其他的值
* @param e 实例对象
* @return 受影响行数，返回值大于零，更新成功，否则更新失败
* @throws IllegalAccessException
* @throws IllegalArgumentException
* @throws InvocationTargetException
* @throws NoSuchMethodException
* @throws SecurityException
* @throws SQLException
* @throws IntrospectionException
*/
public int update(E e) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException, SQLException, IntrospectionException {
//1.先根据传入的对象得到他所有的属性值，然后找到他的主键，调用delete(Object id)将这个对象中的数据删除掉
//2.然后调用save(E e)把新的对象数据存进去
String methodname="get"+scanId().substring(0, 1).toUpperCase()+scanId().substring(1);
System.out.println(methodname);
Method getmethod=e.getClass().getDeclaredMethod(methodname);
Object obj=getmethod.invoke(e);
int i=delete(obj);
System.out.println(i);
int affectedow=save(e);
return affectedow;
}
/**
* 传入一个对象，和要更新的这个对象在数据库中对应属性的列名，只更新这一列的值
* @param e 实体对象
* @param columeName 列名
* @return
* @throws NoSuchMethodException
* @throws SecurityException
* @throws IllegalAccessException
* @throws IllegalArgumentException
* @throws InvocationTargetException
*/
public int update(E e,String columeName) throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
//1.先根据传入的对象得到他所有的属性值，然后找到他的主键
//2.然后根据传入的列名和得到的主键执行更新语句，只更新这一列的值
String methodname="get"+scanId().substring(0, 1).toUpperCase()+scanId().substring(1);
String methodname1="get"+columeName.substring(0, 1).toUpperCase()+columeName.substring(1);
Method getmethod=e.getClass().getDeclaredMethod(methodname);
Method getmethod1=e.getClass().getDeclaredMethod(methodname1);
Object obj=getmethod.invoke(e);
Object obj1=getmethod1.invoke(e);
System.out.println(obj1.getClass().getName());
Connection conn=null;
PreparedStatement st=null;
ResultSet rs=null;
int affectRow=0;
try {
conn=JdbcUtil.getConnection();//加载驱动，创建连接
String sql="update "+scanTableName()+" set "+columeName+"=?"+" where "+scanId()+"="+obj;
System.out.println(sql);
//从传入的对象解析出sql语句
st = conn.prepareStatement(sql);//连接数据库
if(obj1.getClass().getName().equals("java.lang.String")) {
st.setString(1, (String)obj1);
}
if(obj1.getClass().getName().equals("int")) {
st.setString(1, (String)obj1);
}
affectRow=st.executeUpdate();
}catch(Exception i) {
i.printStackTrace();
}finally {
JdbcUtil.closeAll(rs, st, conn);
}
return affectRow;
}
/**
* 拼装字符串的时候根据传入的对象自动生成所对应的属性值
* @return 返回拼装好的sql语句中属性名这一部分
*/
public String fields() {
String result=null;
String field2=null;
List<Object> list2= getField_ColumnName();
StringBuffer sb2=new StringBuffer();
for (int i = 0; i < list2.size(); i++) {
field2=list2.get(i).toString()+",";
sb2.append(field2);
}
result=sb2+"";
String result1=result.substring(0, result.length()-1);
System.out.println("fields拼接后是："+result1);
return result1;
}
/**
* 拼装字符串的时候根据传入的对象自动生成的占位符部分
* @return 返回拼装好的sql语句占位符这一部分
*/
public String placeholder() {
String result=null;
String field=null;
StringBuffer sb=new StringBuffer();
Field[] fields=cls.getDeclaredFields();//获取所有属性放到一个数组中
Object obj=scanId();
for (int i = 0; i < fields.length; i++) {
if(fields[i].equals(obj)) {//判断是不是主键，如果是主键的话就将其的值设置为空，否则就是占位符？
//判断主键是否是自增的，如果是就不需要用户自己设置，如果不是自增的就需要用户自己设置
if(idIsPrimaryKey(fields[i])) {
field=null+",";
System.out.println("主键是自增的");
}else {
field="?,";
System.out.println("主键不是自增的");
}
}else {
field="?,";
}
sb.append(field);
}
result=sb+"";
result=result.substring(0, result.length()-1);
return result;
}
/**
* 传入一个对象并将他的值保存到数据库中
* @param e 实体对象
* @return 受影响行数，保存成功大于零，否则等于零
*/
public int save(E e) {
String sql="insert into "+scanTableName()+"("+fields()+")"+" values("+placeholder()+")";
System.out.println(sql);
Field[] fields = e.getClass().getDeclaredFields();
List<Object> list=new ArrayList<>();
for (Field field : fields) {
PropertyDescriptor pd;
try {
pd = new PropertyDescriptor(field.getName(), e.getClass());
Method getMethod = pd.getReadMethod();
list.add(getMethod.invoke(e));
} catch (Exception ex) {
ex.printStackTrace();
}
}
for (Object object : list) {
System.out.println(object);
}
return update(sql,list.toArray());
}
//根据注解获取列名以及列名
private List<Object> getField_ColumnName(){
Field[] fields = cls.getDeclaredFields();
List<Object> list1=new ArrayList<>();
for (Field field : fields) {
//如果属性上有对应的列注解类型则获取这个注解类型
Colume colume = field.getAnnotation(Colume.class);
if(colume!=null) {
String columename1=colume.value();
list1.add(columename1);
}else {
String fieldname=field.getName();
list1.add(fieldname);
}
}
return list1;
}
//判断主键是否是自增的
public boolean idIsPrimaryKey(Object obj) {
boolean flag=false;
Field[] fileds=cls.getDeclaredFields();
for (Field field : fileds) {
Id id=field.getDeclaredAnnotation(Id.class);
if(id.isAutoIncrease()) {
flag=true;
}else {
flag=false;
}
}
return flag;
}
//根据注解获取主键名
/*private String scanId() {
Field[] fileds=cls.getDeclaredFields();
for (Field field : fileds) {
Id id=field.getDeclaredAnnotation(Id.class);
if(id!=null) {
String columeName=id.value();
columeName=field.getName();
return columeName;
}
}
return null;
}*/
private String scanId() {
//获取所有声明的属性
Field[] fields = cls.getDeclaredFields();
for (Field field : fields) {
//检查这个属性上是否有@Id
Id id = field.getDeclaredAnnotation(Id.class);
if(id != null) {
String columnName = id.value();
if(columnName.trim().equals("")) {
columnName = field.getName();
}
columnPropertyMap.put(columnName, field.getName());
return columnName;
}
}
return null;
}
//根据注解获取对应的表名
private String scanTableName() {
Table table=cls.getAnnotation(Table.class);
String tableName=null;
if(table!=null) {
tableName = table.value();
} else {
tableName = cls.getSimpleName();
}
return tableName;
}
/**
* 通用的增删改操作，传入对应的增加，删除，修改操作的sql语句，以及对应的占位符中的参数，即可执行此操作
* @param sql 通用的增加，删除，修改操作的sql语句
* @param parameters SQL语句中占位符对应的参数
* @return
*/
public int update(String sql,Object...parameters) {
Connection conn=null;
PreparedStatement st=null;
ResultSet rs=null;
int affectedRow=0;
conn=JdbcUtil.getConnection();
try {
st=conn.prepareStatement(sql);
setParameters(st,parameters);
affectedRow=st.executeUpdate();
} catch (SQLException e) {
e.printStackTrace();
}finally {
JdbcUtil.closeAll(rs, st, conn);
}
return affectedRow;
}
/**
*
* @param sql 单条查询语句
* @param parameters sql语句对应的占位符
* @return 返回查询到的这个对象
* @throws InstantiationException
* @throws IllegalAccessException
* @throws NoSuchMethodException
* @throws SecurityException
* @throws IllegalArgumentException
* @throws InvocationTargetException
*/
public E get(String sql,Object...parameters) throws InstantiationException, IllegalAccessException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException {
Connection conn=null;
PreparedStatement st=null;
ResultSet rs=null;
E obj=null;
try {
conn=JdbcUtil.getConnection();
st=conn.prepareStatement(sql);
setParameters(st,parameters);
rs=st.executeQuery();
while(rs.next()) {
obj=oneRowToObject(rs);
}
}catch (SQLException e) {
e.printStackTrace();
}finally {
JdbcUtil.closeAll(rs, st, conn);
}
return obj;
}
/**
* 多表连接查询
* @param sql
* @param rowMapper
* @param parameters
* @return
* @throws InstantiationException
* @throws IllegalAccessException
* @throws NoSuchMethodException
* @throws SecurityException
* @throws IllegalArgumentException
* @throws InvocationTargetException
*/
public List<E> get(String sql,RowMapper<E> rowMapper,Object...parameters) throws InstantiationException, IllegalAccessException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException {
Connection conn=null;
PreparedStatement st=null;
ResultSet rs=null;
List<E> list=new ArrayList<>();
try {
conn=JdbcUtil.getConnection();
st=conn.prepareStatement(sql);
setParameters(st,parameters);
rs=st.executeQuery();
while(rs.next()) {
E obj=rowMapper.moreRowToObject(rs);
list.add(obj);
}
}catch (SQLException e) {
e.printStackTrace();
}finally {
JdbcUtil.closeAll(rs, st, conn);
}
return list;
}
/**
* 单表多条查询，将查询到的多条记录传入一个对象，然后再将这些存入一个集合中，返回这个集合
* @param sql 传入对应的sql查询语句
* @param parameters 传入对应的占位符的值
* @return 返回查询到的记录转化成的对象的集合
*/
public List<E> list(String sql,Object...parameters) {
Connection conn = null;
PreparedStatement st = null;
ResultSet rs = null;
List<E> list = new ArrayList<>();
try {
conn = JdbcUtil.getConnection();
st = conn.prepareStatement(sql);
setParameters(st, parameters);
rs = st.executeQuery();
while(rs.next()) {
E obj = oneRowToObject(rs);
list.add(obj);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
JdbcUtil.closeAll(rs, st, conn);
}
return list;
}
/**
* 统计版块中主贴数
* @param bid
* @return
*/
public int count(int bid) {
return bid;
}
/**
* 把得到的一列数据存入到一个对象中
* @param rs
* @return
* @throws InstantiationException
* @throws IllegalAccessException
* @throws SQLException
* @throws NoSuchMethodException
* @throws SecurityException
* @throws IllegalArgumentException
* @throws InvocationTargetException
*/
@SuppressWarnings("unchecked")
private E oneRowToObject(ResultSet rs) throws InstantiationException, IllegalAccessException, SQLException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException {
E obj;
obj=(E) cls.newInstance();
//获取结果集元数据(获取此 ResultSet 对象的列的编号、类型和属性。)
ResultSetMetaData rd=rs.getMetaData();
for (int i = 0; i < rd.getColumnCount(); i++) {
//获取列名
String columnName=rd.getColumnLabel(i+1);
//组合方法名
String methodName="set"+columnName.substring(0, 1).toUpperCase()+columnName.substring(1);
//获取列类型
int columnType=rd.getColumnType(i+1);
Method method=null;
switch(columnType) {
case java.sql.Types.VARCHAR:
case java.sql.Types.CHAR:
method=cls.getMethod(methodName, String.class);
if(method!=null) {
method.invoke(obj, rs.getString(columnName));
}
break;
case java.sql.Types.INTEGER:
case java.sql.Types.SMALLINT:
method=cls.getMethod(methodName, int.class);
if(method!=null) {
method.invoke(obj, rs.getInt(columnName));
}
break;
case java.sql.Types.BIGINT:
method=cls.getMethod(methodName, long.class);
if(method!=null) {
method.invoke(obj, rs.getLong(columnName));
}
break;
case java.sql.Types.DATE:
case java.sql.Types.TIMESTAMP:
try {
method=cls.getMethod(methodName, Date.class);
if(method!=null) {
method.invoke(obj, rs.getTimestamp(columnName));
}
} catch(Exception e) {
method=cls.getMethod(methodName, String.class);
if(method!=null) {
method.invoke(obj, rs.getString(columnName));
}
}
break;
case java.sql.Types.DECIMAL:
method=cls.getMethod(methodName, BigDecimal.class);
if(method!=null) {
method.invoke(obj, rs.getBigDecimal(columnName));
}
break;
case java.sql.Types.DOUBLE:
case java.sql.Types.NUMERIC:
method=cls.getMethod(methodName, double.class);
if(method!=null) {
method.invoke(obj, rs.getDouble(columnName));
}
break;
case java.sql.Types.BIT:
method=cls.getMethod(methodName, boolean.class);
if(method!=null) {
method.invoke(obj, rs.getBoolean(columnName));
}
break;
default:
break;
}
}
return obj;
}
/**
* 设置占位符
* @param st 预处理
* @param parameters 占位符数组
*/
private void setParameters(PreparedStatement st, Object[] parameters) {
if(parameters!=null&¶meters.length>0) {
for(int i=0;i<parameters.length;i++) {
try {
st.setObject(i+1,parameters[i] );
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
}
IdMistakeException:
package com.xintouyun.dao;
public class IdMistakeException extends RuntimeException {
public IdMistakeException(String message) {
super.setStackTrace(getStackTrace());
}
}
RowMapper:
package com.xintouyun.dao;
import java.sql.ResultSet;
public interface RowMapper<E> {
E moreRowToObject(ResultSet rs);
}
JdbcUtil:
package com.xintouyun.util;
import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;
/*
*
* @author Jianghaoqiang
*
*/
public class JdbcUtil {
private static String DRIVER_CLASS;
private static String URL;
private static String USER;
private static String PASSWORD;
static {
try {
//properties一般放配置信息的,存放的是键值对格式.如userName=root 这样便于管理!
//jdbcUtil.class 得到的是class JdbcUtil ,class对象是java.lang.Class<T>这个类生成的对象,每个类都有一个class对象
//getResourceAsStream(),返回的是InputStream 对象
InputStream is = JdbcUtil.class.getClassLoader().getResourceAsStream("db-config.properties");
//从.properties属性文件对应的文件输入流中，加载属性列表到Properties类对象
Properties properties = new Properties();
//加载属性列表
properties.load(is);
DRIVER_CLASS = properties.getProperty("DRIVER_CLASS");
URL = properties.getProperty("URL");
USER = properties.getProperty("USER");
PASSWORD = properties.getProperty("USERPWD");
//加载jdbc驱动
Class.forName(DRIVER_CLASS);
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
public static Connection getConnection() {
try {
return DriverManager.getConnection(URL,USER,PASSWORD);
} catch (SQLException e) {
e.printStackTrace();
}
return null;
}
public static void closeAll(ResultSet rs,Statement st,Connection conn) {
try {
if(rs != null) {
rs.close();
}
if(st != null) {
st.close();
}
if(conn != null) {
conn.close();
}
} catch (SQLException e) {
e.printStackTrace();
}
}
}
以上就是我写的Jdbcutil2的源码，下面就需要我们把这个工程打成jar包：
步奏：
在工程目录上点击右键--Export..--Java--Jar file--next--将classpath和project,然后选择保存路径，点击finish就可以了
jar包打好后，就需要来用一下，只要是涉及到数据库的增删改查操作都可以。下面找个项目试一下：
我们就找之前做过的学生管理系统试一下：
我们首先将jdbcutil2.jar导入这个项目中，然后写一个StudentDao继承jar包中的BaseDao,这样就可以直接使用BaseDao中直接写好的对数据库增删改查的操作。
StudentDao:
package com.xintouyun.sm.dao;
import com.xintouyun.dao.BaseDao;
import com.xintouyun.sm.entity.Student;
public class StudentDao extends BaseDao<Student>{
}
Student:
package com.xintouyun.sm.entity;
import com.xintouyun.annotation.Id;
public class Student {
@Id(isAutoIncrease = false,value="studentNo")
private String name;
private String studentNo;
private int age;
private String sex;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getStudentNo() {
return studentNo;
}
public void setStudentNo(String studentNo) {
this.studentNo = studentNo;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
}
MangerStore:
package com.xintouyun.sm.service;
import com.xintouyun.sm.entity.Student;
/**
*
* @author Jianghaoqiang
*
*/
public interface MangerStore {
/**
*添加学生方法
* @param student 对象为学生对象
* @return 添加成功返回true，添加失败返回false
*/
boolean addStudent(Student student);
/**
* 查找学生方法
* @param studentNo 根据学生学号查找
* @return 查找成功返回这个学生对象，查找失败返回null
*/
Student findStudent(String studentNo);
/**
* 删除学生方法
* @param studentNo 根据学生学号进行查找，然后删除
* @return 删除成功返回true，删除失败返回false
*/
boolean deleteStudent(String studentNo);
/**
* 修改学生信息方法
* @param studentNo 根据学生学号查找，然后修改信息
* @return 修改成功返回学生对象，修改失败返回null
*/
Student updateStudent(String studentNo,String name,String sex,int age);
/**
* 显示所有学生信息，包括姓名，学号，性别，年龄。
*/
void showAll();
}
impl4:
package com.xintouyun.sm.service.impl;
import java.lang.reflect.InvocationTargetException;
import java.util.Iterator;
import com.xintouyun.sm.dao.StudentDao;
import com.xintouyun.sm.entity.Student;
import com.xintouyun.sm.service.MangerStore;
public class impl4 implements MangerStore{
private StudentDao studentDao = new StudentDao();
public boolean addStudent(Student student) {
return studentDao.save(student) > 0 ;
}
public Student findStudent(String studentNo) {
try {
return studentDao.get("select * from student where studentNo=?", studentNo);
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (SecurityException e) {
e.printStackTrace();
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
return null;
}
public boolean deleteStudent(String studentNo) {
Student existStudent = findStudent(studentNo);
if(existStudent!=null) {
return studentDao.delete(studentNo) > 0;
}
return false;
}
public void showAll() {
Iterator <Student> it = studentDao.list("select * from student").iterator();
System.out.println("学号\t姓名\t年龄\t性别");
while(it.hasNext()) {
Student student = it.next();
System.out.println(student.getStudentNo()+"\t"+student.getName()+"\t"+student.getAge()+"\t"+student.getSex());
}
}
@Override
public Student updateStudent(String studentNo, String name, String sex, int age) {
//Student existStudent=findStudent(studentNo);
//if(existStudent!=null) {
studentDao.update("update student set name=?,sex=?,age=? where studentNo=?", name,sex,age,studentNo);
//studentDao.update(studentNo, name, age, sex);
//}
return null;
}
}
配置文件：db-config-properties:
DRIVER_CLASS=com.mysql.jdbc.Driver
URL=jdbc:mysql:///mangerstore
USER=root
USERPWD=123456我的sm的数据库名字是mangerstore:
客户端Client
package com.xintouyun.sm;
import java.util.Scanner;
import com.xintouyun.sm.entity.Student;
import com.xintouyun.sm.service.impl.impl4;
public class Client {
public static void main(String[] args) {
impl4 data=new impl4();
String nextor="y";
System.out.println("-----------------欢迎使用学生管理系统-------------------");
do {
Scanner sc=new Scanner(System.in);
System.out.println("1.添加2.查找3.删除4.修改5.显示");
int i=0;
try {
i=sc.nextInt();
switch(i) {
case 1:
//Student s=new Student();
System.out.println("请输入学生学号");
String id=sc.next();
System.out.println("请输入学生年龄");
int age=sc.nextInt();
System.out.println("请输入学生姓名");
String name=sc.next();
System.out.println("请输入学生性别");
String sex=sc.next();
Student student=new Student();
student.setAge(age);
student.setName(name);
student.setStudentNo(id);
student.setSex(sex);
boolean result=data.addStudent(student);
if(result) {
System.out.println("添加成功");
data.showAll();
}else {
System.out.println("添加失败");
}
break;
case 2:
System.out.println("请输入要查找的学生学号");
id=sc.next();
Student existStudent=data.findStudent(id);
if(existStudent!=null) {
System.out.println("查找到学生信息如下");
System.out.println(existStudent.getAge()+"\t"+existStudent.getName()+"\t"+existStudent.getStudentNo()+"\t"+existStudent.getSex());
}else {
System.out.println("未查找到相关信息");
}
break;
case 3:
System.out.println("请输入要删除的学生学号");
id=sc.next();
result=data.deleteStudent(id);
if(result) {
System.out.println("删除成功");
data.showAll();
}else {
System.out.println("删除失败");
}
break;
case 4:
System.out.println("请输入要更新的学生学号");
id=sc.next();
System.out.println("请输入要更新的学生姓名");
String name1=sc.next();
System.out.println("请输入要更新的学生年龄");
int age1=sc.nextInt();
System.out.println("请输入要更新的学生性别");
String sex1=sc.next();
data.updateStudent(id, name1, sex1, age1);
break;
case 5:
data.showAll();
break;
}System.out.println("是否继续y/n");
nextor=sc.next();
}catch (Exception e) {
}
}while(nextor.equalsIgnoreCase("y"));
}
}好了，我们测试一下：
添加学生--对应数据库的插入操作
查找学生：
删除操作：
修改操作：
好了：测试成功，当然，这里面还有很多异常没有处理，还有待进一步完善。