分析图:
数据库连接使用封装的数据库操作。查看上一篇:https://blog.csdn.net/ToBe_Coder/article/details/81916224
User类:
public class User {
private Integer uid;
private String upwd;
private String uname;
public User() {
}
public Integer getUid() {
return uid;
}
public void setUid(Integer uid) {
this.uid = uid;
}
public String getUpwd() {
return upwd;
}
public void setUpwd(String upwd) {
this.upwd = upwd;
}
public String getUname() {
return uname;
}
public void setUname(String uname) {
this.uname = uname;
}
@Override
public String toString() {
return "User [uid=" + uid + ", upwd=" + upwd + ", uname=" + uname + "]";
}
}
BaseDao:
/*
* 将数据库中读入的记录封装成一个对象集合
*/
public class BaseDao {
public static void main(String[] args) {
//测试
//String sql="SELECT ID uid,UNAME uname,PWD upwd FROM USER";
String sql="SELECT TYPEID typeId,BOOKTYPE bookType FROM BOOKTYPE";
try {
System.out.println(queryRows(sql,BookType.class));
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (NoSuchFieldException e) {
e.printStackTrace();
} catch (SecurityException e) {
e.printStackTrace();
}
}
/**
* 查询包装为一个List集合,查询返回多条记录
* @param sql 查询的sql语句
* @param clz 需要的参数
* @param objs 包装之后的集合对象存储的对应的Class对象
* @return
* @throws SecurityException
* @throws NoSuchFieldException
* @throws IllegalAccessException
* @throws InstantiationException
*/
public static <T> List<T> queryRows(String sql,Class<T> clz,Object...objs) throws InstantiationException, IllegalAccessException, NoSuchFieldException, SecurityException{
List<T> resultList=new ArrayList<>();
//获取连接
Connection conn=null;
PreparedStatement pstmt=null;
ResultSet rs=null;
try {
conn=DBUtil.getConnection();
pstmt=conn.prepareStatement(sql);
//设置绑定对象
if(objs!=null){//判断是否传入参数,如果没有,objs为空值,会报空指针异常
for(int i=0;i<objs.length;i++){
pstmt.setObject(i+1, objs[i]);
}
}
//获取结果集合
rs=pstmt.executeQuery();
//将结果集合中的数据封装到一个list集合中
List<Map<String,Object>> ls=transferResultSetToBeans(rs);
//将集合中的map键值对封装成对象
resultList=listToReturnLists(ls,clz);
} catch (SQLException e) {
e.printStackTrace();
}finally{
DBUtil.closeAll(conn, pstmt, rs);
}
return resultList;
}
/**
* 将map中的map键值对转换为对象
* @param ls 传入的列表,
* @param clz 要封装的对象
* @return 存储T类型对象的集合
* @throws InstantiationException
* @throws IllegalAccessException
* @throws NoSuchFieldException
* @throws SecurityException
*/
private static <T> List<T> listToReturnLists(List<Map<String, Object>> ls, Class<T> clz) throws InstantiationException, IllegalAccessException, NoSuchFieldException, SecurityException {
//声明返回
List<T> results=new ArrayList<>();
//遍历结果集合
for(int i=0;i<ls.size();i++){
//组装对象
T t=clz.newInstance();//保证空构造器存在
//获取maps中的所有对象
Map<String,Object> rows=ls.get(i);
//遍历rows
for(Map.Entry<String, Object> entry:rows.entrySet()){
//获取别名,类中的属性名
String columnLable=entry.getKey();
Object value=entry.getValue();
//填充值
parseIntoObject(t,columnLable,value);
//如果类存在父子关系,就不通用
//clz.getDeclaredField(columnLable).set(t, value);
}
results.add(t);
}
return results;
}
/**
* 将列值填充到对象的属性中
* @param t 转换对象
* @param columnLable 属性名
* @param value 对应的属性值
* @throws SecurityException
* @throws NoSuchFieldException
* @throws IllegalAccessException
* @throws IllegalArgumentException
*/
private static <T> void parseIntoObject(T t, String columnLable, Object value) throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
//获取属性
Field f=getFields(t,columnLable);
//属性值可能是私有的,是否需要检查
if(!checkModify(f)){
f.setAccessible(true);
}
f.set(t, value);
}
/**
* 检查属性的修饰符
* @param f 属性
* @return
*/
private static boolean checkModify(Field f) {
if(Modifier.isPublic(f.getModifiers())){
return true;
}
return false;
}
/**
* 获取所有属性
* @param t 要获取的子类对象
* @param columnLable 要获取的属性
* @return 属性对象Field
* @throws NoSuchFieldException
* @throws SecurityException
*/
private static <T> Field getFields(T t,String columnLable) throws NoSuchFieldException, SecurityException {
Field f=null;
for(Class<?> clz=t.getClass();clz!=Object.class;clz=clz.getSuperclass()){
f=clz.getDeclaredField(columnLable);
}
return f;
}
/**
* 将结果集中的结果封装到map集合中
* @param rs 结果集
* @return 数据库查询到的数据封装到list
*/
private static List<Map<String, Object>> transferResultSetToBeans(ResultSet rs) {
List<Map<String, Object>> resultLists=new ArrayList<>();
try {
//遍历结果集,每一次遍历的结果是list集合中的一个元素
while (rs.next()) {
Map<String, Object> map = new HashMap<>();
//获取数据库元数据
ResultSetMetaData rsmd = rs.getMetaData();
//取到数据库表的列数
int colums=rsmd.getColumnCount();
//遍历列,每一列是map集合中的一个元素,元素的键是别名,值是列值
for(int i=1;i<=colums;i++){
String key=rsmd.getColumnLabel(i);
Object obj=rs.getObject(i);
map.put(key, obj);
}
//添加到List
resultLists.add(map);
}
} catch (Exception e) {
}
return resultLists;
}
}