DAO全部的实现代码

第一步：DAO中的实现方法

package com.example.dao;

import java.lang.reflect.InvocationTargetException;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;


import org.apache.commons.beanutils.BeanUtils;


import com.atguigu.jdbc.tools.JDBCTools;
import com.atguigu.jdbc.tools.ReflectionUtils;
import com.mysql.jdbc.PreparedStatement;
import com.mysql.jdbc.ResultSetMetaData;


public class DAO {
//insert,update,delete操作都可以包含在其中
public void update(String sql,Object ... args){
Connection connection=null;
PreparedStatement preparedStatement=null;
try {
connection=JDBCTools.getconnection();
preparedStatement=(PreparedStatement) connection.prepareStatement(sql);
   for(int i=0;i<args.length;++i){
    preparedStatement.setObject(i+1, args[i]);
   }
   preparedStatement.executeUpdate();
} catch (Exception e) {
e.printStackTrace();
}finally{
JDBCTools.release(connection, preparedStatement, null);
}
}
//查询一条记录，返回对应的对象
//加入是多条记录，但是也只是返回一条记录。

public <T>T get(Class<T>clazz,String sql,Object ...args){
List<T>result=getForList(clazz, sql, args);
if(result.size()>0){
return result.get(0);
}
return null;
// /*1、获取connection
// * 2、获取preparedstatement
// * 3、填充占位符
// * 4、进行查询，得到resultset
// * 5、若resultset中有记录，准备一个map<String ,object>
// * 键：存放列的别名 值：存放列的值
// * 6、得到resultsetmetadata对象
// * 7、处理resultset，把之中呢向下移动一个单位
// * 8、由resultsetmdtadata对象得到结果集中有多少列
// * 9、由resultsetmetadata得到每一类的别名，由resultset得到具体
// * 10、填充Map对象
// * 11、用反射创建class对应对象。
// * 12、遍历map对象，用反射填充对象的属性值
// * 属性名为map中的key，属性值为map中value
// */
// T entity=null;
// Connection connection=null;
// PreparedStatement preparedStatement=null;
// ResultSet resultSet=null;
// try {
// //1、获取connection
// connection=JDBCTools.getconnection();
// //2、获取preparedstatement
// preparedStatement=(PreparedStatement) connection.prepareStatement(sql);
//    //3、填充占位符
// for(int i=0;i<args.length;++i){
// preparedStatement.setObject(i+1, args[i]);
// }
// //4、进行查询，得到resultset
// resultSet=preparedStatement.executeQuery();
// //5、若resultset中有记录，准备一个map<String ,object>
// // 键：存放列的别名 值：存放列的值
// //如果有记录 
// //7、处理resultset，把之中呢向下移动一个单位
// if(resultSet.next()){
// Map<String, Object> values=new HashMap<String,Object>();
//    //6、得到resultsetmetadata对象
// ResultSetMetaData rsmd=(ResultSetMetaData) resultSet.getMetaData();
//   
// //8、由resultsetmdtadata对象得到结果集中有多少列
// int columnCount=rsmd.getColumnCount();
// //9、由resultsetmetadata得到每一类的别名，由resultset得到具体
// for(int i=0;i<columnCount;++i){
// String columnLabel=rsmd.getColumnLabel(i+1);
// Object columnValue=resultSet.getObject(i+1);
//    //10、填充Map对象
// values.put(columnLabel, columnValue);
// }
// // 11、用反射创建class对应对象。
// entity=clazz.newInstance();
// //12、遍历map对象，用反射填充对象的属性值
// //属性名为map中的key，属性值为map中value
// for(Map.Entry<String, Object> entry: values.entrySet()){
// String propertyName=entry.getKey();
// Object value=entry.getValue();
//
// //ReflectionUtils.setFieldValue(entity, propertyName, value);
// BeanUtils.setProperty(entity, propertyName, value);
// }
// }
// } catch (Exception e) {
// }finally{
// JDBCTools.release(connection, preparedStatement, resultSet);
// }
//
// return entity;
}
//查询多条记录，返回对应的对象的集合
//当得到多条记录，多条记录将会被打印出来。
public <T>List<T>getForList(Class<T>clazz,String sql,Object ...args){
List<T>list=new ArrayList<>();
Connection connection=null;
PreparedStatement preparedStatement=null;
ResultSet resultSet=null;

try {

//--------1、得到结果集-----------


//1、获取connection
connection=JDBCTools.getconnection();
//2、获取preparedstatement
preparedStatement=(PreparedStatement) connection.prepareStatement(sql);
   //3、填充占位符
for(int i=0;i<args.length;++i){
preparedStatement.setObject(i+1, args[i]);
}
//4、进行查询，得到resultset
resultSet=preparedStatement.executeQuery();
//--------2、处理结果集，得到map的list，其中一个map对象
//就是一个条记录，map的key为resultset中列的别名，map的valuew
//为列的值-----------


//5、准备一个List<Map<String,Object>>:
//键：存放列的别名，值：存放列的值，其中一个map对象对应着一条记录
//多个map对象就放在list集合中

List<Map<String, Object>> values = handleResultsetSetToMapList(resultSet);

//12、判断list是否为空集合，若不为空
//则遍历list，得到一个一个map对象，再
//把一个map对象转换成一个class

//参数对应的object对象


//3、------------把map的list转为clazz对应的list
//其中map的key即为clazz对应的对象的propertyName
//而map的valuew即为clazz对应的对系那个的propertyValue
list=transferMapListToBeanList(clazz, values);
} catch (Exception e) {
}finally{
JDBCTools.release(connection, preparedStatement, resultSet);
}
return list;
}
private <T> List<T> transferMapListToBeanList(Class<T> clazz,
List<Map<String, Object>> values) throws InstantiationException,
IllegalAccessException, InvocationTargetException {
List<T> result=new ArrayList<>();

T bean=null;

if(values.size()>0){
for(Map<String, Object> m:values){
bean=clazz.newInstance();
for(Map.Entry<String, Object>entry: m.entrySet()){
String propertyName=entry.getKey();
Object value=entry.getValue();

BeanUtils.setProperty(bean, propertyName, value);
}
//13、把object对象放入到list中。
result.add(bean);
}
}
return result;
}


/**
*处理结果集，得到Map的一个List，其中一个Map对象对应一条记录，
* @param resultSet
* @return
* @throws SQLException
*/
private List<Map<String, Object>> handleResultsetSetToMapList(
ResultSet resultSet) throws SQLException {
List<Map<String,Object>>  values=new ArrayList<>();

List<String>columnLabels=getColumnLabels(resultSet);



Map<String, Object> map=null;
//优化的思想：由结果集，得到一个map list

//7、处理ResulSet，使用while循环
while(resultSet.next()){
//一个map记录了一条数据库表中记录，也就是一个对象。
map=new HashMap<>();

for(String columnLabel:columnLabels){
Object value=resultSet.getObject(columnLabel);
map.put(columnLabel, value);
}
//11、把填充好的Map对象，放在准备好的list集合中
//将map对象放在list集合中
values.add(map);
}
return values;
}
//获取所有的别名
    /**
     * 获取结果集ColumnLabel对应的List
     * @param resultSet
     * @return
     * @throws SQLException
     */
private List<String>getColumnLabels(ResultSet resultSet) throws SQLException{
List<String>labels=new ArrayList<>();
ResultSetMetaData rsmd=(ResultSetMetaData) resultSet.getMetaData();
for(int i=0;i<rsmd.getColumnCount();++i){
labels.add(rsmd.getColumnLabel(i+1));
}
return labels;
}
//返回某条记录的某一个字段的值或一个统计的值（一共有多少条记录）
public <E>E getForValue(String sql,Object...args){


Connection connection=null;
PreparedStatement preparedStatement=null;
ResultSet resultSet=null;
try {
connection=JDBCTools.getconnection();
preparedStatement=(PreparedStatement) connection.prepareStatement(sql);
   for(int i=0;i<args.length;++i){
    preparedStatement.setObject(i+1, args[i]);
   }
   //preparedStatement.executeUpdate();
   resultSet=preparedStatement.executeQuery(); 
   if(resultSet.next()){
    return (E) resultSet.getObject(1);
   }
} catch (Exception e) {
e.printStackTrace();
}finally{
JDBCTools.release(connection, preparedStatement,resultSet);
}

return null;
}

}

第二部：测试方法

package com.example.dao;


import static org.junit.Assert.*;


import java.util.List;


import org.junit.Test;


import com.atguigu.jdbc.reviewtest.Student;


public class DAOTest {
DAO dao=new DAO();


    //只要是insert,update,delete语句都能放进来
@Test
public void testUpdate() {
String sql="INSERT INTO customers(customers_name,customers_email,customers_birth) VALUES(?,?,?)";
   dao.update(sql, "xiaoming","xinlang@com","2016-05-9");
}


@Test
public void testGet() {
//前面的字段名，后面的是别名

String sql="SELECT flow_Id flowId,TYPE TYPE,id_Card idCard,exam_Card examCard,student_Name studentname,location location,grade grade FROM examstudents where flow_Id=?";
   Student student=dao.get(Student.class, sql, 1);
   System.out.println(student);
}


@Test
public void testGetForList() {
String sql="SELECT flow_Id flowId,TYPE TYPE,id_Card idCard,exam_Card examCard,student_Name studentname,location location,grade grade FROM examstudents where flow_Id=?";
   List<Student> students=dao.getForList(Student.class, sql,1);
   System.out.println(students);
}


@Test
public void testGetForValue() {
String sql="SELECT exam_Card FROM examstudents WHERE flow_Id=?";
String examCard=dao.getForValue(sql, 22);
System.out.println(examCard);
}


}