从数据库获得的结果集存放到List集合中

时间  2019-12-05 标签 数据库 获得 结果 集 存放 list 集合 中

1、业务阐述java

  在开发中查询的数据库结果集，既要链接数据库、执行数据库操做、关闭数据库，还要把结果集的记录人为的设置到本身封装的DAO中等一系列的重复代码。sql

本文主要是想解决：用户只须要获得数据库链接，写sql语句，本身封装dao,其他的操做由封转的小框架解决这些重复的工做，用户获得的只是一个集合List。数据库

List里面的元素有集合Map其中key是数据库中的字段类型，value是字段类型对应的值这个函数oracle

DBUtil.executeQuery(con, sql)框架

List还提供集合元素存放的是dao对象，一条数据库记录对应一个dao对象，此函数是ide

DBUtil.executeQuery(con, sql,Vehicle.class)函数

如下提供源码的叙述post

 2、源码解说测试

 测试类this

Main.java代码   收藏代码
  1. package com.hewen.dao.manage;  
  2.   
  3. import java.sql.Connection;  
  4. import java.sql.PreparedStatement;  
  5. import java.sql.ResultSet;  
  6. import java.sql.SQLException;  
  7. import java.util.List;  
  8.   
  9.   
  10. public class Main   
  11. {  
  12.     public static void main(String[] args)   
  13.     {  
  14.         Connection con;  
  15.         try {  
  16.             con = DBTest.getCon();  
  17.         } catch (SQLException e) {  
  18.             e.printStackTrace();  
  19.             return;  
  20.         }  
  21.         PreparedStatement pst = null;  
  22.         ResultSet rs = null;  
  23.         String sql = "select * from t_vehicle t where t.vehicle_id<4";  
  24.         /**  
  25.          * 该方法用到的技术是经过结果集的列属性的性质获得，没有用到反射机制  
  26.          * 这个测试用例也是把查询的结果集放到List集合  
  27.          * 里面的元素是集合Map,key是数据库中的字段类型，value是  
  28.          * 字段类型对应的值，  
  29.          * 查询的结果如：[{KIND_ID=1, DEF_FLAG=null, CHANNELNO=1, SN=陆震,(822)22911,13771000789,   
  30.          * BUYDATE=2010-02-26, DELETETIME=null, STAMP=2010-02-26, REGDATE=null, ISDELETED=0,   
  31.          * VEHICLE_ID=2, NUMBER_PLATE=苏B10001, VEHICLESTATE=待命状态（对应现场返回）, USEDATE=2010-02-26,   
  32.          * INTERPHONENO=null, NUMBER_PLATE_TYPE_ID=4, TEL2=null, STYLE=null, COLOR=null,   
  33.          * INTERPHONEID=null, LASTMAINTAINTIME=null, INITDISTANCE=0, LAST_UPDATE_TIME=2010-02-26,  
  34.          *  REMARK=null, TEL=null, SUPERVISER=null},   
  35.          *  {KIND_ID=3, DEF_FLAG=null, CHANNELNO=1, SN=陆震,  
  36.          *  (822)22911,13771000789, BUYDATE=2010-02-26, DELETETIME=null, STAMP=2010-02-26,   
  37.          *  REGDATE=null, ISDELETED=0, VEHICLE_ID=3, NUMBER_PLATE=苏B90003,   
  38.          *  VEHICLESTATE=待命状态（对应现场返回）, USEDATE=2010-02-26, INTERPHONENO=null,   
  39.          *  NUMBER_PLATE_TYPE_ID=4, TEL2=13151000793, STYLE=面包车, COLOR=白, INTERPHONEID=null,   
  40.          *  LASTMAINTAINTIME=null, INITDISTANCE=0, LAST_UPDATE_TIME=2010-02-26, REMARK=null,  
  41.          *   TEL=22916, SUPERVISER=杨兴华}]  
  42.          */  
  43.         try {  
  44.             List list=DBUtil.executeQuery(con, sql);  
  45.             System.out.println(list);  
  46.         } catch (SQLException e) {  
  47.             e.printStackTrace();  
  48.         }  
  49.         /**  
  50.          * 这个测试用例只是把查询的结果集中的某一条记录映射到了dao对象中，  
  51.          * 查询的结果如：  
  52.          * vehicle:vehicle_id: 2 numberPlate: 苏B10001 deleteDate: null  
  53.            vehicle:vehicle_id: 3 numberPlate: 苏B90003 deleteDate: null  
  54.          */  
  55.     /*  try {  
  56.             pst = con.prepareStatement(sql);  
  57.             rs = pst.executeQuery();  
  58.             while(rs.next()){  
  59.                 Vehicle r = (Vehicle) DBUtil.getFirstObjectFromRs(rs, Vehicle.class);  
  60.                 System.out.println("vehicle:" + r);  
  61.             }  
  62.         } catch (SQLException e) {  
  63.             e.printStackTrace();  
  64.         }finally{  
  65.             DBUtil.closeRs(rs);  
  66.             DBUtil.closePst(pst);  
  67.             DBUtil.closeCon(con);  
  68.         }*/  
  69.         /**  
  70.          * 方法是用的反射机制  
  71.          * 这个测试用例是测试executeQuery函数，把查询的结果集放到List集合  
  72.          * 而且集合元素存放的是dao对象，一条数据库记录对应一个dao对象，  
  73.          * 打印出来的结果如：  
  74.          * [vehicle_id: 2 numberPlate: 苏B10001 deleteDate: null,   
  75.          * vehicle_id: 3 numberPlate: 苏B90003 deleteDate: null]  
  76.          *   
  77.          */  
  78.     /*  try {  
  79.             List list=DBUtil.executeQuery(con, sql,Vehicle.class);  
  80.             System.out.println(list);  
  81.         } catch (SQLException e) {  
  82.             // TODO Auto-generated catch block  
  83.             e.printStackTrace();  
  84.         }*/  
  85.     }  
  86. }  

 封装dao DBUtil类

Java代码   收藏代码
  1. package com.hewen.dao.manage;  
  2. import java.lang.reflect.InvocationTargetException;  
  3. import java.lang.reflect.Method;  
  4. import java.lang.reflect.Type;  
  5. import java.sql.Connection;  
  6. import java.sql.PreparedStatement;  
  7. import java.sql.ResultSet;  
  8. import java.sql.ResultSetMetaData;  
  9. import java.sql.SQLException;  
  10. import java.sql.Statement;  
  11. import java.sql.Types;  
  12. import java.util.ArrayList;  
  13. import java.util.HashMap;  
  14. import java.util.List;  
  15. import java.util.Map;  
  16. /*** 
  17.  * 注意利用查询出数据库的一条记录映射到相应的dao中，写相应的dao必定要注意字段，必定 
  18.  * 要与数据库的记录字段相对应，大小写能够忽略，可是字段不一致就返回错误的数据 
  19.  *  
  20.  * private static Object getValueFromRs(ResultSet rs, String fieldName, Type t) throws SQLException 
  21.  * 此接口有个小的问题就是若是，获取的字段值是空值或者为null，而你本身的需求就是想要获取的字段为一个 
  22.  * 默认的值，那就只须要客户该写这个方法，进行判断就能够 
  23.  * @author Administrator 
  24.  * 
  25.  */  
  26. public class DBUtil {  
  27.     /** 
  28.      * 对操做的数据库回滚 
  29.      * @param con 对数据库操做所获得的连接 
  30.      */  
  31.     public static void rollBack(Connection con){  
  32.         try {  
  33.             con.rollback();  
  34.         } catch (SQLException e) {  
  35.             e.printStackTrace();  
  36.         }  
  37.     }  
  38.     /*** 
  39.      *  
  40.      * @param con 数据库jdbc连接 
  41.      * @param sql 执行的sql语句 
  42.      * @return 返回查询的记录数，记录存储在集合List里面， 
  43.      * 里面的元素是集合Map,key是数据库中的字段类型，value是 
  44.      * 字段类型对应的值 
  45.      * @throws SQLException 
  46.      */  
  47.     public static List<Map<String, Object>> executeQuery(Connection con, String sql) throws SQLException{  
  48.         PreparedStatement pst = null;  
  49.         ResultSet rs = null;  
  50.         try {  
  51.             pst = con.prepareStatement(sql);  
  52.             rs = pst.executeQuery();  
  53.             return getListFromRsLowerCase(rs);  
  54.         }finally{  
  55.             closeRs(rs);  
  56.             closePst(pst);  
  57.         }  
  58.     }  
  59.     /*** 
  60.      *  执行sql语句,把结果集存放到List集合里，集合的元素是dao对象 
  61.      * @param con 数据库获得的连接 
  62.      * @param sql 执行查询的sql语句 
  63.      * @param c   把一条条记录要映射的dao类中的对象中去 
  64.      * @return 
  65.      * @throws SQLException 
  66.      */  
  67.     public static List<Object> executeQuery(Connection con, String sql, Class<?> c) throws SQLException{  
  68.         PreparedStatement pst = null;  
  69.         ResultSet rs = null;  
  70.         try {  
  71.             pst = con.prepareStatement(sql);  
  72.             rs = pst.executeQuery();  
  73.             return getListFromRs(rs, c);  
  74.         }finally{  
  75.             closeRs(rs);  
  76.             closePst(pst);  
  77.         }  
  78.     }  
  79.     /** 
  80.      * 获得结果集存储到list中 
  81.      * @param rs 查询的结果集 
  82.      * @return  
  83.      * @throws SQLException 
  84.      */  
  85.     public static List<Map<String, Object>> getListFromRs(ResultSet rs) throws SQLException{  
  86.         ResultSetMetaData md = rs.getMetaData();//获得结果集列的属性  
  87.         int columns = md.getColumnCount();//获得记录有多少列  
  88.         int i;  
  89.         List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();  
  90.         while(rs.next()){  
  91.             Map<String, Object> map = new HashMap<String, Object>();  
  92.             for(i = 0; i < columns; i++){  
  93.                 map.put(md.getColumnName(i + 1), getValueByType(rs, md.getColumnType(i + 1), md.getColumnName(i + 1)));  
  94.             }  
  95.             list.add(map);  
  96.         }  
  97.         return list;  
  98.     }  
  99.     /** 
  100.      * 这个与getListFromRs(ResultSet rs)差很少，只是把数据库的字段变成小写 
  101.      *  
  102.      * @param rs 
  103.      * @return 
  104.      * @throws SQLException 
  105.      */  
  106.     public static List<Map<String, Object>> getListFromRsLowerCase(ResultSet rs) throws SQLException{  
  107.         ResultSetMetaData md = rs.getMetaData();  
  108.         int columns = md.getColumnCount();  
  109.         int i;  
  110.         List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();  
  111.         while(rs.next()){  
  112.             Map<String, Object> map = new HashMap<String, Object>();  
  113.             for(i = 0; i < columns; i++){  
  114.                 map.put(md.getColumnName(i + 1).toLowerCase(), getValueByType(rs, md.getColumnType(i + 1), md.getColumnName(i + 1)));  
  115.             }  
  116.             list.add(map);  
  117.         }  
  118.         return list;  
  119.     }  
  120.     /** 
  121.      * 这个与getListFromRs(ResultSet rs)功能同样，只是把数据库的字段变成大写 
  122.      * @param rs 
  123.      * @return 
  124.      * @throws SQLException 
  125.      */  
  126.     public static List<Map<String, Object>> getListFromRsUpperCase(ResultSet rs) throws SQLException{  
  127.         ResultSetMetaData md = rs.getMetaData();  
  128.         int columns = md.getColumnCount();  
  129.         int i;  
  130.         List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();  
  131.         while(rs.next()){  
  132.             Map<String, Object> map = new HashMap<String, Object>();  
  133.             for(i = 0; i < columns; i++){  
  134.                 map.put(md.getColumnName(i + 1).toUpperCase(), getValueByType(rs, md.getColumnType(i + 1), md.getColumnName(i + 1)));  
  135.             }  
  136.             list.add(map);  
  137.         }  
  138.         return list;  
  139.     }  
  140.     /*** 
  141.      *  
  142.      * @param rs 查询的结果集 
  143.      * @param c  集合元素存放的dao对象 
  144.      * @return 
  145.      * @throws SQLException 
  146.      */  
  147.     public static List<Object> getListFromRs(ResultSet rs, Class<?> c) throws SQLException{  
  148.         List<Object> list = new ArrayList<Object>();  
  149.         try {  
  150.             while(rs.next()){  
  151.                 Object o = initObjectFromRsIfExist(rs, c);  
  152.                 list.add(o);  
  153.             }  
  154.         } catch (IllegalAccessException e) {  
  155.             e.printStackTrace();  
  156.         } catch (InstantiationException e) {  
  157.             e.printStackTrace();  
  158.         }  
  159.         return list;  
  160.     }  
  161.     /** 
  162.      *  
  163.      * @param rs 查询的结果集 
  164.      * @param c 结果集一条记录，而一条记录所对应的dao类 
  165.      * @return 
  166.      * @throws SQLException 
  167.      */  
  168.     public static Object getFirstObjectFromRs(ResultSet rs, Class<?> c) throws SQLException{  
  169.         Object o = null;  
  170.         try {  
  171.             o = initObjectFromRsIfExist(rs, c);  
  172.         } catch (InstantiationException e) {  
  173.             e.printStackTrace();  
  174.         } catch (IllegalAccessException e) {  
  175.             e.printStackTrace();  
  176.         }  
  177.         return o;  
  178.     }  
  179.     /*** 
  180.      *  
  181.      * @param rs 查询出来的结果集 
  182.      * @param type SQL type from java.sql.Types 
  183.      * @param name 数据库记录所对应的字段名称 
  184.      * @return 返回一条记录的一个列值 
  185.      * @throws SQLException 
  186.      */  
  187.     private static Object getValueByType(ResultSet rs, int type, String name) throws SQLException{  
  188.         switch(type){  
  189.             case Types.NUMERIC:  
  190.                     return rs.getLong(name);                  
  191.             case Types.VARCHAR:  
  192.                 //if(rs.getString(name)==null){  
  193.                     //return "";  
  194.                 //}  
  195.                 return rs.getString(name);  
  196.             case Types.DATE:  
  197.                 //if(rs.getDate(name)==null){  
  198.                     //return System.currentTimeMillis();  
  199.             //  }  
  200.                 return rs.getDate(name);  
  201.             case Types.TIMESTAMP:  
  202.                 return rs.getTimestamp(name).toString().substring(0,rs.getTimestamp(name).toString().length()-2);  
  203.             case Types.INTEGER:  
  204.                 return rs.getInt(name);  
  205.             case Types.DOUBLE:  
  206.                 return rs.getDouble(name);  
  207.             case Types.FLOAT:  
  208.                 return rs.getFloat(name);  
  209.             case Types.BIGINT:  
  210.                 return rs.getLong(name);  
  211.             default:  
  212.                 return rs.getObject(name);  
  213.         }  
  214.     }  
  215.     /*** 
  216.      * 查询dao映射的字段是否在记录在数据库包含的字段 
  217.      * @param rs 查询的记录集 
  218.      * @param fieldName dao映射的字段 
  219.      * @return 若是包含在数据库记录集里面，返回true，不然false 
  220.      * @throws SQLException 
  221.      */  
  222.     private static boolean rsContainsFields(ResultSet rs, String fieldName) throws SQLException{  
  223.         ResultSetMetaData md = rs.getMetaData();  
  224.         for(int i = 0; i < md.getColumnCount(); i++){  
  225.             if(md.getColumnName(i + 1).equalsIgnoreCase(fieldName)){  
  226.                 return true;  
  227.             }  
  228.         }  
  229.         return false;  
  230.     }  
  231.     /*** 
  232.      * 这个函数与initObjectFromRsIfExist函数实现的功能是同样，只是 
  233.      * 没有判断dao中的字段是否与数据库记录所定义的字段是同样的, 
  234.      * 没有判断时若是本身设置的dao字段与数据库的字段不一致就会报异常 
  235.      * @param rs 
  236.      * @param c 
  237.      * @return 
  238.      * @throws InstantiationException 
  239.      * @throws SQLException 
  240.      * @throws IllegalAccessException 
  241.      */  
  242.     private static Object initObjectFromRs(ResultSet rs, Class<?> c) throws InstantiationException, SQLException, IllegalAccessException{  
  243.         Object o = c.newInstance();  
  244.         Method[] methods = o.getClass().getMethods();  
  245.         for(Method m: methods){  
  246.             if(m.getName().startsWith("set")){  
  247.                 try {                     
  248.                     m.invoke(o, getParamValueFromRs(rs, m));                      
  249.                 } catch (IllegalArgumentException e) {  
  250.                     throw new RuntimeException("IllegalArgumentException:" + e + "\nMethods:" + m.getName());  
  251.                 } catch (InvocationTargetException e) {  
  252.                     throw new RuntimeException("InvocationTargetException:" + e + "\nMethods:" + m.getName());  
  253.                 }  
  254.             }  
  255.         }  
  256.         return o;  
  257.     }  
  258.     /*** 
  259.      *  
  260.      * 把数据库的一条记录映射到相应的dao对象中， 
  261.      * 若是dao中的字段与数据库字段不一致，返回的就是dao数据类型定义的默认值 
  262.      * 如：dao的字段long vehicleID;而数据库的字段是vehicle_id，那么返回的 
  263.      * 就定义的默认值0. 
  264.      * @param rs 查询的结果集 
  265.      * @param c 结果集一条记录，而一条记录所对应的dao类 
  266.      * @return 
  267.      * @throws SQLException 
  268.      * @throws IllegalAccessException 
  269.      * @throws InstantiationException 
  270.      */  
  271.     private static Object initObjectFromRsIfExist(ResultSet rs, Class<?> c) throws SQLException, IllegalAccessException, InstantiationException{  
  272.         Object o = c.newInstance();//一条记录的dao，新建对象  
  273.         Method[] methods = o.getClass().getMethods();//dao对象全部的方法  
  274.         String field;  
  275.         for(Method m: methods){  
  276.             //获得dao字段，如getRegdate,转换成Regdate  
  277.             field = m.getName().substring(3);  
  278.             //查询dao映射的字段是否在记录在数据库包含的字段,dao方法对set开头的方法进行处理  
  279.             //由于要将结果集映射到dao里面  
  280.             if(m.getName().startsWith("set") && rsContainsFields(rs, field)){  
  281.                 try {                     
  282.                     m.invoke(o, getParamValueFromRs(rs, m));                      
  283.                 } catch (IllegalArgumentException e) {  
  284.                     throw new RuntimeException("IllegalArgumentException:" + e + "\nMethods:" + m.getName());  
  285.                 } catch (InvocationTargetException e) {  
  286.                     throw new RuntimeException("InvocationTargetException:" + e + "\nMethods:" + m.getName());  
  287.                 }  
  288.             }  
  289.         }  
  290.         return o;  
  291.     }  
  292.     /*** 
  293.      *  
  294.      * @param rs 查询的结果集 
  295.      * @param m  dao映射字段对应的一个set方法 
  296.      * @return 
  297.      * @throws SQLException 
  298.      */  
  299.     private static Object getParamValueFromRs(ResultSet rs, Method m) throws SQLException  
  300.     {  
  301.         String fieldName = m.getName().substring(3);  
  302.         Type type = m.getGenericParameterTypes()[0];//获取set方法参数的类型        
  303.         return getValueFromRs(rs, fieldName, type);  
  304.     }  
  305.     /** 
  306.      * 获取数据库一条记录的一个列值 
  307.      * @param rs 查询的结果集 
  308.      * @param fieldName dao数据字段，也就是数据库记录的数据字段类型 
  309.      * @param t 参数的数据类型 
  310.      * @return 
  311.      * @throws SQLException 
  312.      */  
  313.     private static Object getValueFromRs(ResultSet rs, String fieldName, Type t) throws SQLException{  
  314.         String type = t.toString();  
  315.         try{  
  316.             if(type.equals("int") || type.equals("class java.lang.Integer")){  
  317.                 return rs.getInt(fieldName);  
  318.             }else if(type.equals("float") || type.equals("class java.lang.Float")){  
  319.                 return rs.getFloat(fieldName);  
  320.             }else if(type.equals("double") || type.equals("class java.lang.Double")){  
  321.                 return rs.getDouble(fieldName);  
  322.             }else if(type.equals("long") || type.equals("class java.lang.Long")){  
  323.                 return rs.getLong(fieldName);  
  324.             }else if(type.equals("class java.lang.String")){  
  325.                 return rs.getString(fieldName);  
  326.             }else if(type.equals("class java.sql.Timestamp")){  
  327.                 return rs.getTimestamp(fieldName);  
  328.             }else if(type.equals("class java.sql.Date")){  
  329.                 return rs.getDate(fieldName);  
  330.             }else if(type.equals("class java.sql.Time")){  
  331.                 return rs.getTime(fieldName);  
  332.             }  
  333.         }catch(SQLException e){  
  334.             throw new SQLException("SQLException when get field:" + fieldName + "\n" + e);  
  335.         }  
  336.         throw new RuntimeException("getValueFromRsByField fail, field type is:" + type + ",field name is:" + fieldName);  
  337.     }  
  338.     /*** 
  339.      * 关闭数据库多个结果集 
  340.      * @param rss 
  341.      */  
  342.     public static void closeRs(ResultSet... rss){  
  343.         for(ResultSet rs: rss){  
  344.             if(rs != null){  
  345.                 try {  
  346.                     rs.close();  
  347.                 } catch (SQLException e) {  
  348.                 }  
  349.             }  
  350.         }  
  351.     }  
  352.     /** 
  353.      * 关闭数据库多个psts 
  354.      * @param psts 
  355.      */  
  356.     public static void closePst(Statement... psts){  
  357.         for(Statement pst: psts){  
  358.             if(pst != null){  
  359.                 try {  
  360.                     pst.close();  
  361.                 } catch (SQLException e) {  
  362.                 }  
  363.             }  
  364.         }  
  365.     }  
  366.     /** 
  367.      * 关闭数据库所获得的多个连接 
  368.      * @param cons 
  369.      */  
  370.     public static void closeCon(Connection... cons){  
  371.         for(Connection con: cons){  
  372.             if(con != null)  
  373.             {  
  374.                 try {  
  375.                     con.close();  
  376.                 } catch (SQLException e) {  
  377.                 }  
  378.             }  
  379.         }  
  380.     }  
  381. }  

 链接Oracle数据库类

Dbtest.java代码   收藏代码
  1. package com.hewen.dao.manage;  
  2.   
  3. import java.sql.Connection;  
  4. import java.sql.DriverManager;  
  5. import java.sql.SQLException;  
  6. /***  
  7.  * 这个是链接Oracle数据库  
  8.  * @author Administrator  
  9.  *  
  10.  */  
  11. public class DBTest {  
  12.     public static Connection getCon() throws SQLException{  
  13.         try {  
  14.             Class.forName("oracle.jdbc.driver.OracleDriver");  
  15.         } catch (ClassNotFoundException e) {  
  16.             e.printStackTrace();  
  17.             return null;  
  18.         }  
  19.         String url = "jdbc:oracle:thin:@127.0.0.1:1521:orcl";  
  20.         String user = "avls";  
  21.         String password = "1";  
  22.           
  23.         return DriverManager.getConnection(url, user, password);      
  24.     }  
  25. }  

 封装的dao类

Vehicle.java代码   收藏代码
  1. package com.hewen.dao.manage;  
  2.   
  3. import java.sql.Date;  
  4. import java.util.ArrayList;  
  5. import java.util.List;  
  6.   
  7.   
  8. public class Vehicle{  
  9.     private long vehicle_Id;//车牌ID   
  10.       
  11.     private String number_plate;//车牌号码  
  12.     private String def_flag;//车牌自定义别名  
  13.     private int number_plate_type_id;//拍照类型id  
  14.     private int kind_id;//车辆类型ID，如物流、出租等  
  15.     private String style;//车辆品牌如：夏利、奔驰、本田等  
  16.     private String color;//车辆颜色  
  17.     private String sn;//序列号  
  18.     private String interphoneid;//对讲机身份码  
  19.     private String interphoneno;//对讲机号  
  20.     private int channelno;//频道号  
  21.     private float initdistance;//初始里程  
  22.     private Date lastmaintaintime;//最后保养时间  
  23.     private String vehiclestate;//车辆状态，如正常使用，做废等  
  24.     private Date buydate;//购买时间  
  25.     private Date usedate;//使用时间  
  26.     private Date regdate;//登记时间  
  27.     private int isdeleted;//是否删除  
  28.     private Date deletedate;//删除时间  
  29.     private Date last_update_time;//最后更新时间  
  30.     private String remark;//备注  
  31.     private Date stamp;//入库时间  
  32.     private String superviser;//责任人姓名  
  33.     private String tel;//责任人电话一  
  34.     private String tel2;//责任人电话2  
  35.       
  36.       
  37.       
  38.     public String getRemark() {  
  39.         return remark;  
  40.     }  
  41.   
  42.     public void setRemark(String remark) {  
  43.         this.remark = remark;  
  44.     }  
  45.     public String toString(){  
  46.         return "vehicle_id: "+this.vehicle_Id+" numberPlate: "+this.number_plate+" deleteDate: "+this.deletedate;  
  47.     }  
  48.     //@Override  
  49.     public String tagetTableName() {  
  50.         return "t_used_vehicle";  
  51.     }  
  52.   
  53.     //@Override  
  54.     public List<String> unEditFields() {  
  55.         List<String> list = new ArrayList<String>();  
  56.         list.add("remark");  
  57.         return list;  
  58.     }  
  59.   
  60.     public String getNumber_plate() {  
  61.         return number_plate;  
  62.     }  
  63.   
  64.     public void setNumber_plate(String number_plate) {  
  65.         this.number_plate = number_plate;  
  66.     }  
  67.   
  68.     public String getDef_flag() {  
  69.         return def_flag;  
  70.     }  
  71.   
  72.     public void setDef_flag(String def_flag) {  
  73.         this.def_flag = def_flag;  
  74.     }  
  75.   
  76.     public int getNumber_plate_type_id() {  
  77.         return number_plate_type_id;  
  78.     }  
  79.   
  80.     public void setNumber_plate_type_id(int number_plate_type_id) {  
  81.         this.number_plate_type_id = number_plate_type_id;  
  82.     }  
  83.   
  84.     public int getKind_id() {  
  85.         return kind_id;  
  86.     }  
  87.   
  88.     public void setKind_id(int kind_id) {  
  89.         this.kind_id = kind_id;  
  90.     }  
  91.   
  92.     public String getStyle() {  
  93.         return style;  
  94.     }  
  95.   
  96.     public void setStyle(String style) {  
  97.         this.style = style;  
  98.     }  
  99.   
  100.     public String getColor() {  
  101.         return color;  
  102.     }  
  103.   
  104.     public void setColor(String color) {  
  105.         this.color = color;  
  106.     }  
  107.   
  108.     public String getSn() {  
  109.         return sn;  
  110.     }  
  111.   
  112.     public void setSn(String sn) {  
  113.         this.sn = sn;  
  114.     }  
  115.   
  116.     public String getInterphoneid() {  
  117.         return interphoneid;  
  118.     }  
  119.   
  120.     public void setInterphoneid(String interphoneid) {  
  121.         this.interphoneid = interphoneid;  
  122.     }  
  123.   
  124.     public String getInterphoneno() {  
  125.         return interphoneno;  
  126.     }  
  127.   
  128.     public void setInterphoneno(String interphoneno) {  
  129.         this.interphoneno = interphoneno;  
  130.     }  
  131.   
  132.     public int getChannelno() {  
  133.         return channelno;  
  134.     }  
  135.   
  136.     public void setChannelno(int channelno) {  
  137.         this.channelno = channelno;  
  138.     }  
  139.   
  140.     public float getInitdistance() {  
  141.         return initdistance;  
  142.     }  
  143.   
  144.     public void setInitdistance(float initdistance) {  
  145.         this.initdistance = initdistance;  
  146.     }  
  147.   
  148.     public Date getLastmaintaintime() {  
  149.         return lastmaintaintime;  
  150.     }  
  151.   
  152.     public void setLastmaintaintime(Date lastmaintaintime) {  
  153.         this.lastmaintaintime = lastmaintaintime;  
  154.     }  
  155.   
  156.     public String getVehiclestate() {  
  157.         return vehiclestate;  
  158.     }  
  159.   
  160.     public void setVehiclestate(String vehiclestate) {  
  161.         this.vehiclestate = vehiclestate;  
  162.     }  
  163.   
  164.     public Date getBuydate() {  
  165.         return buydate;  
  166.     }  
  167.   
  168.     public void setBuydate(Date buydate) {  
  169.         this.buydate = buydate;  
  170.     }  
  171.   
  172.     public Date getUsedate() {  
  173.         return usedate;  
  174.     }  
  175.   
  176.     public void setUsedate(Date usedate) {  
  177.         this.usedate = usedate;  
  178.     }  
  179.   
  180.     public Date getRegdate() {  
  181.         return regdate;  
  182.     }  
  183.   
  184.     public void setRegdate(Date regdate) {  
  185.         this.regdate = regdate;  
  186.     }  
  187.   
  188.     public int getIsdeleted() {  
  189.         return isdeleted;  
  190.     }  
  191.   
  192.     public void setIsdeleted(int isdeleted) {  
  193.         this.isdeleted = isdeleted;  
  194.     }  
  195.   
  196.     public Date getDeletedate() {  
  197.         return deletedate;  
  198.     }  
  199.   
  200.     public void setDeletedate(Date deletedate) {  
  201.         this.deletedate = deletedate;  
  202.     }  
  203.   
  204.     public Date getLast_update_time() {  
  205.         return last_update_time;  
  206.     }  
  207.   
  208.     public void setLast_update_time(Date last_update_time) {  
  209.         this.last_update_time = last_update_time;  
  210.     }  
  211.   
  212.     public Date getStamp() {  
  213.         return stamp;  
  214.     }  
  215.   
  216.     public void setStamp(Date stamp) {  
  217.         this.stamp = stamp;  
  218.     }  
  219.   
  220.     public String getSuperviser() {  
  221.         return superviser;  
  222.     }  
  223.   
  224.     public void setSuperviser(String superviser) {  
  225.         this.superviser = superviser;  
  226.     }  
  227.   
  228.     public String getTel() {  
  229.         return tel;  
  230.     }  
  231.   
  232.     public void setTel(String tel) {  
  233.         this.tel = tel;  
  234.     }  
  235.   
  236.     public String getTel2() {  
  237.         return tel2;  
  238.     }  
  239.   
  240.     public void setTel2(String tel2) {  
  241.         this.tel2 = tel2;  
  242.     }  
  243.   
  244.     public long getVehicle_Id() {  
  245.         return vehicle_Id;  
  246.     }  
  247.   
  248.     public void setVehicle_Id(long vehicle_Id) {  
  249.         this.vehicle_Id = vehicle_Id;  
  250.     }  
  251. }  

 运行的结果

运行的结果代码   收藏代码
  1. [{vehiclestate=待命状态（对应现场返回）, vehicle_id=2, interphoneid=null, deletetime=null, number_plate=苏B10001, regdate=null, initdistance=0, superviser=null, style=null, number_plate_type_id=4, tel=null, buydate=2010-02-26, isdeleted=0, kind_id=1, channelno=1, usedate=2010-02-26, remark=null, sn=陆震,(822)22911,13771000789, last_update_time=2010-02-26, interphoneno=null, color=null, tel2=null, stamp=2010-02-26, lastmaintaintime=null, def_flag=null}, {vehiclestate=待命状态（对应现场返回）, vehicle_id=3, interphoneid=null, deletetime=null, number_plate=苏B90003, regdate=null, initdistance=0, superviser=杨兴华, style=面包车, number_plate_type_id=4, tel=22916, buydate=2010-02-26, isdeleted=0, kind_id=3, channelno=1, usedate=2010-02-26, remark=null, sn=陆震,(822)22911,13771000789, last_update_time=2010-02-26, interphoneno=null, color=白, tel2=13151000793, stamp=2010-02-26, lastmaintaintime=null, def_flag=null}]  
  2.   
  3. vehicle:vehicle_id: 2 numberPlate: 苏B10001 deleteDate: null  
  4.            vehicle:vehicle_id: 3 numberPlate: 苏B90003 deleteDate: null  
  5.   
  6. [vehicle_id: 2 numberPlate: 苏B10001 deleteDate: null,   
  7.         vehicle_id: 3 numberPlate: 苏B90003 deleteDate: null] 
联系我们 沪ICP备2021010478号-7