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

    一、业务阐述

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

    本文主要是想解决：用户只需要得到数据库连接，写sql语句，自己封装dao,其余的操作由封转的小框架解决这些重复的工作，用户得到的只是一个集合List。

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

    DBUtil.executeQuery(con, sql)

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

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

    以下提供源码的叙述

     二、源码解说

     测试类

    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 + " Methods:" + m.getName());  
    251.                 } catch (InvocationTargetException e) {  
    252.                     throw new RuntimeException("InvocationTargetException:" + e + " Methods:" + 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 + " Methods:" + m.getName());  
    285.                 } catch (InvocationTargetException e) {  
    286.                     throw new RuntimeException("InvocationTargetException:" + e + " Methods:" + 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 + " " + 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] 
  • 相关阅读:
    Google Optimize 安装使用教程
    PostgreSQL drop database 显示会话没有关闭 [已解决]
    c#之线程同步--轻量级同步 Interlocked
    CentOS7 'Username' is not in the sudoers file. This incident will be reported
    Mac 如何删除应用、软件
    Oracle的存储过程基本写法
    我的一个PLSQL【我】 循环嵌套、游标使用、变量定义、查询插入表、批量提交事务、字符串截取、动态sql拼接执行
    Oracle定义常量和变量
    ORACLE中%TYPE和%ROWTYPE的使用
    pls_integer类型
  • 原文地址：https://www.cnblogs.com/wangfeng520/p/5457277.html
Copyright © 2020-2023  润新知