一、业务阐述

  在开发中查询的数据库结果集，既要连接数据库、执行数据库操作、关闭数据库，还要把结果集的记录人为的设置到自己封装的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 + “\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]