JDBC的批量添加-大数据处理-结果集的元数据-Class反射-JDBC查询封装

一、使用JDBC批量添加

​ 知识点复习：

​ JDBC的六大步骤 （导入jar包， 加载驱动类，获取连接对象， 获取sql执行器、执行sql与并返回结果， 关闭数据库连接）

​ 封装了一个DBUtil 类， 通过读取属性文件的方式获取 基础连接信息。

​ 批量添加： 一次性可执行多个添加记录 ，将多个sql语句在当前这次连接中执行完毕。

    // 设置部门集合
        List<Dept> list = new ArrayList<>();
        list.add(new Dept(60,"市场部","武汉市"));
        list.add(new Dept(70,"研发部","武汉市"));
        list.add(new Dept(80,"教学部","武汉市"));

          //通过DBUtil获取数据库连接
        Connection conn = DBUtil.getConn();
        String sql="insert into dept(deptno,dname,loc) values (?,?,?)";
          //获取预编译sql执行器
        PreparedStatement ps = conn.prepareStatement(sql);
        //批量设置该条sql语句的 参数
        for(Dept dept : list){
            //设置参数
            ps.setInt(1,dept.getDeptno());
            ps.setString(2,dept.getDname());
            ps.setString(3,dept.getLoc());
            // 将设置好的参数 先放入批量添加的容器中
            ps.addBatch();
            //  对于完整的sql语句 可以用有参的
           // ps.addBatch(sql);
        }
        // 执行sql语句  返回每一行sql语句影响的行数  ,
        int [] counts = ps.executeBatch();
        System.out.println("结果长度："+ counts.length);
        System.out.println("结果："+ Arrays.toString(counts));
        //关闭sql语句
        DBUtil.closeAll(conn,ps,null);

​

补充知识点： Java使用Excel批量导入数据 到数据库中

1、先将Excel通过Java 的 POI框架 读取数据到内存中（List）

2、将List数据 批量添加到 数据库中。

package com.j2008.jdbc2;


import com.j2008.jdbc.Dept;
import org.apache.poi.hssf.usermodel.hssfDateUtil;
import org.apache.poi.hssf.usermodel.hssfWorkbook;
import org.apache.poi.hssf.util.CellReference;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import org.springframework.expression.Expression;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;

import java.io.*;
import java.net.URLDecoder;
import java.text.DateFormat;
import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.util.*;

//import javax.validation.ConstraintViolation;
//import javax.validation.Validation;
//import javax.validation.Validator;
//import javax.validation.ValidatorFactory;
//import org.springframework.expression.EvaluationException;

/**
 * ClassName: ExcelUtil
 * Description:
 * date: 2020/11/23 9:33
 *
 * @author wuyafeng
 * @version 1.0   softeem.com
 */
public class ExcelUtil {
   // Logger logger = Logger.getLogger(this.getClass());

    private String description = "";// 如果校验失败，将会给出详细提示信息
    private Sheet sheet;// execel 对象
    private List<String> fieldList;//从xml读取到的execel表格信息
    private int rowIndex = 0;//当前操作行
    private Object objectBean;//每一行数据封装
    private Cell cellStart;// 数据的开始单元格
    private Class clazz; //需要封装的类
//    private Validator validator; //hibernate 的校验器
    private String[] fieldVals ; //从execel读到的某一行的数据
    private int fieldSize = 0;  //有效数据的列数
    private DateFormat format = new SimpleDateFormat("yyyy-MM-dd"); // 针对日期的默认转换形式
    private Expression exp ;//EL 解析器
    private ExpressionParser parser;

    private DecimalFormat df = new DecimalFormat("#");

    public String getDescription() {
        return description;
    }

    public Object getobjectBean() {
        return objectBean;
    }

    public ExcelUtil(InputStream execelIS,String xmlFilename,
                     Class clazz,String suffix) throws Exception{
        // 打开execel工作簿
        Workbook wb = null;
        try {
            if(suffix.equals(".xls")){
                wb = new hssfWorkbook(execelIS);
            }else if(suffix.equals(".xlsx")){
                wb = new XSSFWorkbook(execelIS);
            }
            execelIS.close();
        } catch (IOException e) {
            throw new Exception("加载文件失败,请确保是否是Execel表格");
        }
        sheet = wb.getSheetAt(0);// 默认取第一个工作簿
        //读配置文件，获取所有的属性列描述
        fieldList = this.readFieldsFromXML(getAbsolutePath(xmlFilename));
        //个数
        fieldSize = fieldList.size();

        //找到有效数据的开始单元格
        cellStart = this.findStartCell();
        if(cellStart == null){
            throw new Exception(this.description);
        }

        //每次读取一行execel数据，rowIndex每次增1
        rowIndex = cellStart.getRowIndex()+1;

        //需要封装的对象类
        this.clazz = clazz;
        //初始化校验器
//        ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
//        validator = factory.getValidator();
//        //初始化EL解析器
        parser = new SpelExpressionParser();
        exp = parser.parseExpression("values");
    }

    //是否还有数据
    public boolean hasNext(){
        Row row = sheet.getRow(rowIndex++);
        if(row == null)
            return false;
        fieldVals = this.getRowValues(row, cellStart.getColumnIndex());
        if(Arrays.asList(fieldVals).indexOf("") != -1){
            for(String s :fieldVals)//如果每个字段都是空的，则返回false 否则true
                if(!s.equals(""))
                    return true;
            return false;
        }
        return true;
    }
    //校验
    public boolean validate(){
        try {
            objectBean = Class.forName(clazz.getName()).newInstance();
        } catch (Exception e) {
           // logger.error(e);
            e.printstacktrace();
        }


        try{
           exp.setValue(objectBean, fieldVals);// 给objectBean的属性赋值

        }catch( Exception e){//由于所有的数据类型转换都有objectBean里面来处理，故可能有异常，需要进行相应的处理
            e.printstacktrace();
            return false;
        }

        return true;
    }

    private String[] getRowValues(Row row,int columnStartIndex){
        String[] values = new String[fieldSize];
        for(int j = columnStartIndex,t=0;t<fieldSize;j++,t++){
            Cell c = row.getCell(j);
            if(c==null){
                values[t] = "";
                continue;
            }
            switch(c.getCellType()){
                case Cell.CELL_TYPE_BLANK:
                    values[t] = "";
                    break;
                case Cell.CELL_TYPE_BOOLEAN:
                    values[t] = String.valueOf(c.getBooleanCellValue());
                    break;
                case Cell.CELL_TYPE_NUMERIC:

                    if (hssfDateUtil.isCellDateFormatted(c)) {
                        values[t] = format.format(c.getDateCellValue());
                    } else if(c.getCellStyle().getDataFormat() == 58) {
                        // 处理自定义日期格式：m月d日(通过判断单元格的格式id解决，id的值是58)
                        SimpleDateFormat sdf = new SimpleDateFormat("MM/dd");
                        double value = c.getNumericCellValue();
                        Date date = org.apache.poi.ss.usermodel.DateUtil
                                .getJavaDate(value);

                        values[t] = sdf.format(date);
                    }
                    else {
                        values[t] = new DecimalFormat("#").format(c.getNumericCellValue());
                    }
                    break;
                case Cell.CELL_TYPE_STRING:
                    values[t] = String.valueOf(c.getStringCellValue());
                    break;

                default:
                    values[t] = "";
                    break;
            }
        }
        return values;
    }
    // 根据某一个单元格，得到更人性化的显示,例如“A4”
    private String getCellRef(Cell cell) {
        return CellReference.convertNumToColString(cell.getColumnIndex()) + (cell.getRowIndex() + 1);
    }
    private  String getAbsolutePath(String file) throws Exception {
        try {
            file = this.getClass().getClassLoader().getResource(file).getFile();

        } catch (NullPointerException e) {
            throw new Exception("文件不存在");
        }
        try {
            // 解决当出现中文路径时不能解析的bug
            file = URLDecoder.decode(file, "UTF-8");
        } catch (UnsupportedEncodingException e) {
            throw new Exception( "解码失败");
        }
        return file;
    }
    private List<String> readFieldsFromXML(String xmlFilename)throws Exception{
        SAXReader reader = new SAXReader();
        Document document = null;

        try {
            document = reader.read(new File(xmlFilename));// 加载配置文件
        } catch (DocumentException e) {
            e.printstacktrace();
            this.description = "IO 异常，读取配置文件失败";
            throw new Exception("IO 异常，读取配置文件失败");
        }

        Element root = document.getRootElement();
        List<String> fields = new ArrayList<String>();
        for (Iterator iter = root.elementIterator("field"); iter.hasNext();) {
            Element field = (Element) iter.next();
            fields.add(field.getTextTrim());
        }

        return fields;
    }
    /**
     * 从execel表中找到数据开始的单元格
     * @return
     */
    private  Cell findStartCell(){
        String firstFieldDesc = this.fieldList.get(0);
        int endRow = sheet.getLastRowNum()>100?100:sheet.getLastRowNum();
        for(int i = 0;i<=endRow;i++){
            Row r = sheet.getRow(i);
            if (r == null)
                continue;
            for(int j = 0;j < r.getLastCellNum();j++){
                Cell c = r.getCell(j);
                if( c == null)
                    continue;
                if(c.getCellType() == Cell.CELL_TYPE_STRING){
                    if(c.getStringCellValue().trim().equals(firstFieldDesc)){//找到第一个符合要求的字段，接下来判断它相邻的字段是否都符合要求
                        if(fieldList.size()>r.getLastCellNum()-j){
                            this.description = "execel表格与所给配置描述不符，请下载模板文件";
                            return null;
                        }
                        for(int k=j+1,t=1;k<=j+fieldList.size()-1;k++,t++){
                            Cell c2 = r.getCell(k);
                            if(c2 == null){
                                this.description = "请确保单元格"+this.getCellRef(c2)+"内容是\""+fieldList.get(t)+"\"";
                                return null;
                            }
                            if(c2.getCellType() == Cell.CELL_TYPE_STRING){
                                if(c2.getStringCellValue().contains(fieldList.get(t)))
                                    continue;
                                else{
                                    this.description = "请确保单元格"+this.getCellRef(c2)+"内容是\""+fieldList.get(t)+"\"";
                                    return null;
                                }
                            }

                        }
                        return c;
                    }else
                        continue;
                }else
                    continue;
            }
        }
        this.description = "找不到\""+fieldList.get(0)+"\"这一列";
        return null;
    }

    public int getRowIndex() {
        return rowIndex;
    }

    public DateFormat getFormat() {
        return format;
    }


    public String createExcelIncludeFailReason(InputStream execelIS,String path,String newExcelName, HashMap<Integer,String> errHash) {
        FileOutputStream file;
        try {
            file = new FileOutputStream(path+"/"+newExcelName);
            Workbook workbook=this.getWorkbook(execelIS);
            Sheet s=workbook.getSheetAt(0);

            //int endRow = sheet.getLastRowNum()>100?100:sheet.getLastRowNum();
            int endRow = sheet.getLastRowNum();
            for(int i=1;i<=endRow;i++){
                if(errHash.get(i)!=null){
                    Row rowkk = s.getRow(i);
                    Cell error_cell = rowkk.createCell(fieldList.size());
                    error_cell.setCellValue(errHash.get(i));
                }
            }
            workbook.write(file);
            file.close();
        } catch (FileNotFoundException e) {

            e.printstacktrace();
        } catch (IOException e) {

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

            e.printstacktrace();
        }

        return newExcelName;
    }


    public String getFile(InputStream execelIS,String path,String appPath, List<Integer> listF, boolean b) {
        FileOutputStream file;
        try {
            file = new FileOutputStream(path+"/"+appPath);
            Workbook workbook=this.getWorkbook(execelIS);
            Sheet s=workbook.getSheetAt(0);
            Row row=null;
            //int endRow = sheet.getLastRowNum()>100?100:sheet.getLastRowNum();
            int endRow = sheet.getLastRowNum();
            for(int i=1;i<=endRow;i++){

                Row rowkk = s.getRow(i);
                Cell info_cell = rowkk.createCell(fieldList.size());
                info_cell.setCellValue("sss");

                //删除错误行
                if(b&& listF.contains(i)){
                    row=s.getRow(i);
                    if(row!=null)s.removeRow(row);
                }
                //删除正确行
                if(!b && !listF.contains(i)){
                    row=s.getRow(i);
                    if(row!=null)s.removeRow(row);
                }
            }
            workbook.write(file);
            file.close();
        } catch (FileNotFoundException e) {

            e.printstacktrace();
        } catch (IOException e) {
            e.printstacktrace();
        } catch (Exception e) {
            e.printstacktrace();
        }

        return appPath;
    }
    public  Workbook  getWorkbook(InputStream execelIS) throws Exception{
        Workbook wb = null;
        try {
            wb = new hssfWorkbook(execelIS);
        } catch (IOException e) {
            throw new Exception("加载文件失败,请确保是否是Execel表格");
        }
        return wb;
    }


    /**
     * 返回List集合
     * @param filePath
     * @param xmlName
     * @return
     * @throws Exception
     */
    public static List<Dept> getListByExcel(String filePath,String xmlName ) throws Exception {
        InputStream is = new FileInputStream(filePath);
        ExcelUtil eu = new ExcelUtil(is, xmlName, Dept.class,".xls");
        Dept cp = null;
        List<Dept> list = new ArrayList<>();
        while (eu.hasNext()) {
            if (eu.validate()) {
               // System.out.println( eu.getobjectBean());
                cp = (Dept) eu.getobjectBean();
              //  System.out.println(cp.getDeptno()+"/"+cp.getDname()+ "/"+cp.getLoc() );
                list.add(cp);
            }
        }
        return list;

    }

    

    /**
     *
     * @param args
     */
    public static void main(String[] args) throws Exception {

        /**
         *  使用Excel工具的前提
         *   1、定义一个实体类 ， 并提供基本的get set方法 和 setValues方法
         *   2、提供一个 表头的 xml文件。  表头的名字和  xml中的   <field>部门编号</field>  一致
         *   3、 源数据： D:/dept.xls
         */

       List<Dept>  list =   getListByExcel("D:/dept.xls","importTitle.xml");
         for(Dept d : list){
             System.out.println(d);
         }
    }
}

二、JDBC处理大数据类型（Blob ，Text）

​ 将数据库中存储 类似图片，视频，音频，小说等这些大数据类型格式是，JDBC如何操作

分两种情况: 字节数据和字符数据

1、字节数据：

​ 原理： 存数据（添加记录）：使用字节流先 读取到 内存中， 然后在保存数据中，

​ 取数据（根据id查询该结果记录）： 先通过jdbc 从结果集中获取输入字节流，将字节流写出到磁盘中

添加数据：

  /**
     *  添加一个大数据类型
     * @throws Exception
     */
    public static void addImg() throws Exception {
        //获取连接
       Connection conn =  DBUtil.getConn();
       //获取预编译sql执行器
        String sql ="insert into mytest2 values(?,?,?,?,?)";
        PreparedStatement ps = conn.prepareStatement(sql);
        // 设置参数
        ps.setInt(1,1002);
        ps.setString(2,"李四");
        ps.setString(3,"男");
        ps.setString(4,"自我介绍说明");
        // 读取图片的源路径
        File file = new File("e:/12.jpg");
        FileInputStream fis = new FileInputStream(file);
        // 需要一个输入流
       // ps.setBlob(5,fis);
        ps.setBinaryStream(5,fis);
        //执行sql语句
       int count =   ps.executeUpdate();
       if(count>0){
           System.out.println("添加成功");
       }
       //关闭流
        DBUtil.closeAll(conn,ps,null);

    }

查询数据：

 /**
     *  根据id 获取 图片信息
     * @param id
     */
    public static String findById(int id) throws Exception {
            // 获取数据库连接
        Connection conn = DBUtil.getConn();
        //获取预编译sql执行器
        String sql = "select * from mytest2 where id = ?";
        PreparedStatement ps = conn.prepareStatement(sql);
        ps.setInt(1,id);
        ResultSet rs = ps.executeQuery();
        if(rs.next()){
            //获取记录
           String username =  rs.getString(2);
           //获取字节类型 blob
           Blob image = rs.getBlob("image");
           //获取字节流
           InputStream is =  image.getBinaryStream();
            FileOutputStream fos = new FileOutputStream("d:/my.jpg");
            // 文件读写
            byte [] b = new byte[1024];
            int len=0;
            while((len = is.read(b))!=-1){
                fos.write(b,0,len);
            }
            System.out.println("文件保存成功");
            fos.close();
            is.close();

            // 获取字符流 写出到文件中  text字段可直接通过String映射，也可以通过字符流
            Reader reader = rs.getCharacterStream("introduce");
            // 字符输出流 写出
            Writer writer = new FileWriter("d:/introduce.txt");
            char [] c = new char[1024];
            int len2 = 0;
            while( (len2 = reader.read(c)) !=-1){
                writer.write(c, 0 ,len2);
            }
            writer.close();
            reader.close();

            return username;

        }
        DBUtil.closeAll(conn,ps,rs);

        return null;

    }

三、JDBC元数据

​ 数据库的元数据表示数据库信息 和 结果集信息的 基础信息

1、 数据库元数据信息： DataBaseMetaData

​ 方法说明：

         //获取数据库连接
        Connection conn = DBUtil.getConn();
        DatabaseMetaData dbMetaData =  conn.getMetaData();
        System.out.println("数据库产品名称："+ dbMetaData.getDatabaseProductName());
        System.out.println("数据库的主要版本"+dbMetaData.getDatabaseMajorVersion());
        System.out.println("数据库产品信息的版本"+dbMetaData.getDatabaseProductVersion());

        System.out.println("数据库的url："+dbMetaData.getURL());
        System.out.println("驱动类："+dbMetaData.getDriverName());
        System.out.println("用户名："+dbMetaData.getUserName());

2、 结果集的元数据 ResultSetMetaData

用于获取结果集的基础信息（处理数据项以外的信息），例如字段名称，字段个数，字段的数据类型 ，字段值

用途： 可以通过字段信息 与Java实体类做映射关系 ，实现简易的ORM（Object Relation Mapping）框架

API ：

getColumnCount

getColumnCount() : 获取字段的列个数

getColumnLabel（i） ： 获取指定列的字段名

getColumnType(i):获取指定列的 类类型 ： 常用类：

getColumnName() : 获取字段名 与getColumnLabel一样

1：char； 3：BigDecimal 4：int ；12 varchar 91 ：Date

四、反射基础知识

1、为什么需要使用反射

​ 由于之前创建对象的过程 ，是已知这个类，然后对类进行编译，编译通过之后才可以创建对象， 现在可能出现 “未知的类” 只有“包名+类名” ，在运行期间才知道 该类是否存在，并动态创建该类的对象。 这时 创建对象的过程 可以通过反射的方式 完成。

​ 反射机制的定义： 对于任意一个类，都可以在运行期间，动态的创建该类的对象，能知晓该对象的属性和方法，并动态调用属性 和方法 ，这个过程就是Java的反射机制

​ 对于任意类 都存在一个该类的Class类型 ，如何获取类的Classs类型

方式一： Class cls = Class.forName("类的全类名")

方式二： Class cls = 类名.class;

方式三： Class cls = 类的对象名.getClass()

常用API

Construct：

​ cls.getConstructor(int.class , String.class); 根据参数类型和个数 获取cls 对应的 构造器对象

Field ： 属性对应的类型

​ getDeclareFields () : 获取所有声明的属性 （包括 任何修饰符，不包括private修饰）

​ getFields(): 获取所有声明的public修饰的属性

getDeclareFiled（String name）： 根据属性名获取属性对象

getField(String name):根据属性名获取属性对象 （必须是共有的 ）

Method ： 方法对应的类型

​ getDeclaredMethods（） ： 返回当前类的自己声明的方法

​ getmethods（） ：返回所有的方法（包括父类的）

​ invoke（obj，参数值） ：调用该方法

​ getmethod（“方法名” ，参数值）：根据方法名返回Method

            //获取所有的方法   返回当前类的自己声明的方法
            Method [] methods =  cls.getDeclaredMethods();
            System.out.println("当前类自己的方法========");
            for(Method  m : methods){
                //遍历每一个方法
                System.out.println(m.getName()+"------"+ m.getReturnType());
            }

            Method [] methods2 = cls.getmethods();
            System.out.println("它的所有方法=============");
            for(Method m : methods2){
                System.out.println(m.getName()+"---"+m);
            }

            // 调用属性 和 方法
            // 获取指定方法的方法
            Method m = cls.getmethod("sayHello", String.class);
            //调用方法 (参数1 ： 方法所属的对象oibj  ，参数n ： 方法的参数值)
            // retobj ：方法调用的返回值
            Object retobj =  m.invoke(myObj,"商腾辉");
            System.out.println("方法返回值："+retobj);

使用反射完成对象属性的拷贝功能

 /**
     * 对象的属性值拷贝
     * @param fromObj
     * @param toObj
     */
    public static void copy(Object fromObj ,Object toObj) throws NoSuchMethodException, InvocationTargetException, illegalaccessexception {
        //获取这个对象的Class类型
        Class fromCls = fromObj.getClass();
        Class toCls = toObj.getClass();

        // 获取源对象的所有属性名
       Field[] fields = fromCls.getDeclaredFields();
       for(Field f : fields){
           //构建  getXxx的方法
           String methodName = "get"+ f.getName().substring(0,1).toupperCase() +
                            f.getName().substring(1);
           //获取getXxx方法
           Method getmethod =  fromCls.getmethod(methodName,null);
           // 1 调用源对象的get方法，获取返回值， （如何获取get方法呢   id-》getId ）
           Object value = getmethod.invoke(fromObj ,null);
           // 2 调用目标对象的set方法，设置值 ( set方法的参数类型 就是get方法的返回值类型，参数值就是get方法的返回值)
            String methodName2 ="set"+ f.getName().substring(0,1).toupperCase() +
                    f.getName().substring(1);
           Method setMethod =   toCls.getmethod(methodName2,getmethod.getReturnType());
           //调用set方法
           setMethod.invoke(toObj ,value);
           System.out.println("属性赋值成功");
       }



      }

​

     Student stu1 = new Student(1001,"admin",22,"男");
        //目标对象
        Student stu2 = new Student();
        //复制对象的属性
        copy(stu1,stu2);
        System.out.println(stu1);
        System.out.println(stu2);

五、JDBC的添加，查询封装 （反射知识点）

​ 目前我们只对JDBC的 获取连接，关闭进行封装，对于 数据库表的操作 添加，删除修改，查询，根据id查询 ，都需要单独写，这样太麻烦了， 需要将公有的代码 简化。

​ 1、对添加，删除，修改方法写成一个方法

​

/**
     * 对于 添加，删除，修改方法    不同点在于  sql语句不同
     *  参数不同
     * @param sql  sql语句   insert into dept values(?,?,?)
     * @param objs 任意个数任意类型的参数  与sql的？一一对应
     * @return
     */
    public static  int executeUpdate(String sql ,Object ... objs){
        // 获取连接
        Connection conn=null;
        PreparedStatement ps=null;
        // 获取预编译sql执行器
        try {
            conn = DBUtil.getConn();
            ps = conn.prepareStatement(sql);
            //设置参数
            if(objs!=null){
                for(int i=0;i<objs.length;i++){
                    // 参数从1开始，数组objs的下标从0开始
                    ps.setobject(i+1 ,objs[i]);
                }
            }
            //执行sql语句
           int count = ps.executeUpdate();
            return count;
        } catch (sqlException e) {
            e.printstacktrace();
        }finally {
            //关闭连接
            DBUtil.closeAll(conn,ps,null);
        }
        return 0;
    }

查询

  /**
     * 查询所有的公共方法， 可以自动将结果集映射到 实体类上
     * @param sql  sql语句
     * @param cls  实体类的类型
     * @param <T>  实体类的泛型
     * @return
     */
    public static<T> List<T> listAll(String sql ,Class cls ){
        // 存储结果集的集合list
        List<T> list = new ArrayList<T>();
        Connection conn=null;
        PreparedStatement ps = null;
        ResultSet rs=null;
        try {
            //获取连接
            conn = DBUtil.getConn();
            ps = conn.prepareStatement(sql);
            rs  = ps.executeQuery();
            while(rs.next()){
                // 创建这个类型的对象
                Object obj = cls.newInstance();
                // 获取这个类的所有字段个数  获取每一行的元数据
                ResultSetMetaData rsmd = rs.getMetaData();
                int clsCount =rsmd.getColumnCount();
                for(int i=1;i<=clsCount;i++){
                    String columnName = rsmd.getColumnLabel(i);
                    //构建set方法
                    String setMethod =  "set"+columnName.substring(0,1).toupperCase() + columnName.substring(1);
                   // 调用get方法 获取返回值类型
                    String getmethod = "get"+columnName.substring(0,1).toupperCase() + columnName.substring(1);
                    Method m1 = cls.getmethod(getmethod,null);

                    //调用方法  方法的参数类型  是 get方法的返回值类型
                    Method m = cls.getmethod(setMethod, m1.getReturnType());
                    // 调用set方法
                    m.invoke(obj,rs.getobject(columnName));

                }
                // 将obj放入 list中
                list.add((T)obj);

            }
        } catch (sqlException e) {
            e.printstacktrace();
        } catch (illegalaccessexception e) {
            e.printstacktrace();
        } catch (InstantiationException e) {
            e.printstacktrace();
        }  catch (NoSuchMethodException e) {
            e.printstacktrace();
        }catch (Exception e) {
            e.printstacktrace();
        } finally {
            DBUtil.closeAll(conn,ps,rs);
        }

        return list;
    }

/**
     * 根据id查询一行记录
     * @param sql
     * @param cls
     * @param <T>
     * @return
     */
    public static<T> T getById(String sql ,Class cls){
       List<T> list =  listAll(sql,cls)  ;
       //查询一个集合，取第一行记录
       return list.size()>0 ? list.get(0) : null;
    }