1 package com.dsp.core;
  2 
  3 import java.io.IOException;
  4 import java.util.*;
  5 
  6 /**
  7  * 数据库访问操作类
  8  * @author dsp
  9  */
 10 public class DatabaseAccess {
 11     // 数据库辅助帮助类实例
 12     private DatabaseHelper         databaseHelper         = new DatabaseHelper();
 13     // DatabaseAccess类的泛型帮助类实例
 14     private GenericityHelper     genericityHelper     = new GenericityHelper();
 15 
 16     /**
 17      * 向数据库添加object
 18      * @param object    待添加的对象
 19      * @return  若成功向数据库添加object，则返回数据库中object对应记录的id号，否则，返回-1
 20      */
 21     @SuppressWarnings("unchecked")
 22     public synchronized int add(Object object) {
 23         // object为空
 24         if(null == object)
 25             return -1;
 26 
 27         List<String> columns = genericityHelper.getAllFieldNames(object);
 28         Map<String, Object> columnToValues = genericityHelper.getFieldValues(columns, object);
 29 
 30         /*
 31          * 拼接带占位符的SQL语句
 32          */
 33         String className = genericityHelper.getClassName(object).toLowerCase();
 34         String sql_0 = "insert into " + className + "(";
 35         for(int index = 0; index < columns.size(); ++index) {
 36             sql_0 += columns.get(index) + ",";
 37         }
 38         String sql_1 = sql_0.substring(0, sql_0.length() - 1) + ") values(";
 39         // 设置占位符
 40         for(int index = 0; index < columns.size(); ++index) {
 41             sql_1 += "?,";
 42         }
 43         String sql_2 = sql_1.substring(0, sql_1.length() - 1);
 44         sql_2 += ");";
 45 
 46         /*
 47          * 设置相应参数
 48          */
 49         List<Object> params = new LinkedList<Object>();
 50         for(int index = 0; index < columns.size(); ++index) {
 51             String fieldName = columns.get(index);
 52             if("id".equals(fieldName))
 53                 params.add(index, 0);
 54             else
 55                 params.add(index, columnToValues.get(fieldName));
 56         }
 57 
 58         // 执行插入
 59         int result = databaseHelper.singleTableUpdate(sql_2, params, object.getClass());
 60 
 61         // 若插入成功
 62         if(result > 0) {
 63             String tableName = genericityHelper.getClassName(object);
 64             List<Object> targetList = (List<Object>) databaseHelper.getCachedData(tableName, object.getClass());
 65             Object lastObject = targetList.get(targetList.size() - 1);
 66             Object value = genericityHelper.getSpecifiedFieldValue("id", lastObject);
 67             int id = Integer.parseInt(value.toString());
 68             return id;
 69         } else {
 70             return -1;
 71         }
 72     }
 73 
 74     /**
 75      * 从数据库中删除object
 76      * @param object    待删除的对象
 77      * @return  成功删除，返回true；否则返回false
 78      */
 79     public synchronized boolean delete(Object object) {
 80         // 对象为空
 81         if(null == object)
 82             return false;
 83 
 84         /*
 85          * 拼接带占位符的SQL语句
 86          */
 87         String className = genericityHelper.getClassName(object);
 88         List<String> columns = genericityHelper.getAllFieldNames(object);
 89         Map<String, Object> columnToValues = genericityHelper.getFieldValues(columns, object);
 90         String sql = "delete from " + className + " where id = " + columnToValues.get("id") + ";";
 91 
 92         // 执行删除操作
 93         int result = databaseHelper.singleTableUpdate(sql, null, object.getClass());
 94         if(result > 0)
 95             return true;
 96         else
 97             return false;
 98     }
 99 
100     /**
101      * 更新数据库中德object对象
102      * @param object    要更新的对象
103      * @return  成功返回true，否则返回false
104      */
105     public synchronized boolean update(Object object) {
106         // 对象为空
107         if(null == object)
108             return false;
109 
110         String className = genericityHelper.getClassName(object);
111         String sql_0 = "update " + className + " set ";
112 
113         List<Object> params = new ArrayList<Object>();
114         List<String> columns = genericityHelper.getAllFieldNames(object);
115         Map<String, Object> columnToValues = genericityHelper.getFieldValues(columns, object);
116 
117         /*
118          * 拼接带占位符的SQL语句
119          */
120         for(int index = 0; index < columns.size(); ++index) {
121             String field = columns.get(index).toString();
122             if(field.equals("id"))
123                 continue;
124             sql_0 += field + "=?,";
125             params.add(columnToValues.get(field));
126         }
127 
128         String sql_1 = sql_0.substring(0, sql_0.length() - 1) + " where id=?;";
129         params.add(columnToValues.get("id"));
130 
131         // 执行更新操作
132         int result = databaseHelper.singleTableUpdate(sql_1, params, object.getClass());
133         if(result <= 0)
134             return false;
135         else
136             return true;
137     }
138 
139     /**
140      * 从数据库中查询出所有的clazz记录，得到clazz记录的一份副本（深拷贝），使用时要求对应的Java Bean实现Serializable接口
141      * @param clazz 数据库表名映射的Java Bean反射实例
142      * @return  查询到的记录的链表
143      * @throws IOException
144      * @throws ClassNotFoundException
145      */
146     @SuppressWarnings("unchecked")
147     public synchronized List<?> getAll(Class<?> clazz) {
148         List<?> resultsList = null;
149         try {
150             String className = genericityHelper.getClassName(clazz);
151             List<Object> tempResults = (List<Object>) databaseHelper.getCachedData(className, clazz);
152             resultsList = genericityHelper.deepClone(tempResults);
153         } catch (IOException e) {
154             e.printStackTrace();
155         } catch (ClassNotFoundException e) {
156             e.printStackTrace();
157         }
158         return resultsList;
159     }
160 
161 }

  1 package com.dsp.core;
  2 
  3 import java.lang.reflect.Method;
  4 import java.sql.*;
  5 import java.util.ArrayList;
  6 import java.util.HashMap;
  7 import java.util.List;
  8 import java.util.Map;
  9 
 10 import com.dsp.util.Log;
 11 
 12 /**
 13  * 数据库JDBC操作辅助帮助类
 14  * @author dsp
 15  */
 16 public class DatabaseHelper {
 17     // 已缓存了的数据链表
 18     private static Map<String, List<Object>>    cachedData = new HashMap<String, List<Object>>();
 19 
 20     // JDBC连接
 21     private Connection                             connection;
 22     // 预编译对象
 23     private PreparedStatement                     pstmt;
 24 
 25     /**
 26      * 静态块，用来加载驱动
 27      */
 28     static{
 29         try {
 30             Class.forName(LoadDBConfigFile.getInstance().getProperty("driverClassName"));
 31         } catch (ClassNotFoundException e) {
 32             e.printStackTrace();
 33             Log.log.error(e.toString());
 34         }
 35     }
 36 
 37     /**
 38      * 获取连接
 39      */
 40     private Connection getConnection() {
 41         try {
 42             // 手动创建JDBC连接
 43             connection = DriverManager.getConnection(LoadDBConfigFile.getInstance().getProperty("url"), LoadDBConfigFile.getInstance().getProperty("username"), LoadDBConfigFile.getInstance().getProperty("password"));
 44         } catch (Exception e) {
 45             Log.log.error(e.toString());
 46         }
 47         return connection;
 48     }
 49 
 50     /**
 51      * 关闭所有与JDBC相关的连接
 52      * 顺序：先进后出
 53      */
 54     private void closeAllConnections(Connection connection, PreparedStatement pstmt, ResultSet resultSet) {
 55         if(pstmt != null) {
 56             try {
 57                 pstmt.close();
 58             } catch (SQLException e) {
 59                 Log.log.error(e.toString());
 60             }
 61         }
 62         if(connection != null) {
 63             try {
 64                 connection.close();
 65             } catch (SQLException e) {
 66                 Log.log.error(e.toString());
 67             }
 68         }
 69     }
 70 
 71     /**
 72      * 填充PreparedStatement对象的sql语句中的占位符
 73      * @param pstmt        PreparedStatement对象
 74      * @param params    填充PreparedStatement对象中sql语句占位符的参数链表
 75      * #######################################################################
 76      * 参数化查询（Parameterized Query 或 Parameterized Statement）是指在设计与
 77      * 数据库链接并访问数据时，在需要填入数值或数据的地方，使用参数 (Parameter) 来给值，
 78      * 这个方法目前已被视为最有效可预防SQL注入攻击(SQL Injection) 的攻击手法的防御方式。
 79      */
 80     private void replacePlaceholder(PreparedStatement pstmt, List<Object> params) {
 81         if((pstmt != null) && (params != null) && (params.size() > 0)) {
 82             for(int index = 0; index < params.size(); ++index) {
 83                 Object obj = params.get(index);
 84                 try {
 85                     if(obj == null) {
 86                         // 若为null。//待优化处，减少拼接的SQL语句长度
 87                         pstmt.setNull(index + 1, Types.INTEGER);
 88                     } else if("java.util.Date".equals(obj.getClass().getName())) {
 89                         pstmt.setDate(index + 1, new java.sql.Date(((java.util.Date) params.get(index)).getTime()));
 90                     } else if("java.lang.Double".equals(obj.getClass().getName())) {
 91                         pstmt.setDouble(index + 1, (Double) params.get(index));
 92                     } else if("java.lang.Integer".equals(obj.getClass().getName())) {
 93                         pstmt.setInt(index + 1, (Integer) params.get(index));
 94                     } else if("java.lang.Boolean".equals(obj.getClass().getName())) {
 95                         pstmt.setBoolean(index + 1, (Boolean) params.get(index));
 96                     } else if("javax.sql.rowset.serial.SerialBlob".equals(obj.getClass().getName())) {
 97                         pstmt.setBlob(index + 1, (Blob) params.get(index));
 98                     } else {
 99                         pstmt.setString(index+1, (String)params.get(index));
100                     }
101                 } catch (SQLException e) {
102                     Log.log.error(e.toString());
103                 }
104             }
105         }
106     }
107 
108     /**
109      * 打印输出SQL语句。
110      * 若成功，则是刚执行过的SQL语句；
111      * 失败则是致使数据库系统抛出异常的非法语句。
112      * @param pstmt    预编译SQL语句对象
113      */
114     private void printExecutedSQL(PreparedStatement pstmt) {
115         String executedSQL = pstmt.toString();
116         System.out.println("====>" + executedSQL);
117     }
118 
119     /**
120      * 该表的数据是否已缓存
121      * @param tableName 表明
122      * @return  已缓存：true 否则返回 false
123      */
124     private boolean isCached(String tableName) {
125         List<Object> tempList = cachedData.get(tableName);
126         if(tempList == null) {
127             return false;
128         }
129         return true;
130     }
131 
132     /**
133      * 根据键名获取对应已缓存的数据
134      * @param classNameOrTableName    取数据用的键名
135      * @return    缓存的数据链表
136      */
137     public List<?> getCachedData(String classNameOrTableName, Class<?> clazz) {
138         if(isCached(classNameOrTableName)) {
139             return cachedData.get(classNameOrTableName);
140         } else {
141             // 若数据不在缓存中，则向数据库发送查询请求
142             String sql = "select * from " + classNameOrTableName + ";";
143             return this.singleTableQuery(sql, null, clazz);
144         }
145     }
146 
147     /**
148      * 对单表进行更新操作
149      * @param sql        带占位符的SQL语句
150      * @param params    用户填充SQL语句中的占位符的参数
151      * @return    执行结果：>0  成功     <=0  失败
152      */
153     public synchronized int singleTableUpdate(String sql, List<Object> params, Class<?> clazz) {
154         connection = getConnection();
155         int result = 0;
156         try {
157             // 预编译对象
158             pstmt = connection.prepareStatement(sql);
159             replacePlaceholder(pstmt, params);
160             result = pstmt.executeUpdate();
161             // 放在此处是出于打印的语句与数据库实际操作的顺序一致性
162             printExecutedSQL(pstmt);
163 
164             // 更新缓存
165             String className = new GenericityHelper().getClassName(clazz);
166             String querySQL = "select * from " + className + ";";
167             this.singleTableQuery(querySQL, null, clazz);
168         } catch (SQLException e) {
169             try {
170                 // 出错则打印SQL语句并回滚
171                 printExecutedSQL(pstmt);
172                 connection.rollback();
173             } catch (SQLException e1) {
174                 e1.printStackTrace();
175             }
176             // 记录异常
177             e.printStackTrace();
178             Log.log.error(e.toString());
179         } finally {
180             closeAllConnections(connection, pstmt, null);
181         }
182         return result;
183     }
184 
185     /**
186      *
187      * @param sql       查询语句语句，可以含有占位符
188      * @param params    填充占位符的参数集
189      * @param clazz     泛型类型所对应的反射对象
190      * @param <T>       泛型：即你要得到的集合中存的对象的类型
191      * @return    存储查询到的所有对象链表
192      */
193     @SuppressWarnings({ "unchecked" })
194     private synchronized <T> List<Object> singleTableQuery(String sql, List<Object> params, Class<T> clazz) {
195         // 若clazz为空
196         if(null == clazz) {
197             return null;
198         }
199 
200         /*
201          *  最新数据还未缓存，所以执行查询，检出数据库中的数据
202          */
203         List<T> resultList = new ArrayList<T>();
204         connection = getConnection();
205         ResultSet resultSet = null;
206 
207         try {
208             // 预编译SQL语句对象
209             pstmt = connection.prepareStatement(sql);
210             replacePlaceholder(pstmt, params);
211             resultSet = pstmt.executeQuery();
212 
213             ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
214             String[] columnNames = new String[resultSetMetaData.getColumnCount()];
215 
216             for(int index = 0; index < columnNames.length; ++index) {
217                 columnNames[index] = resultSetMetaData.getColumnName(index + 1);
218             }
219 
220             while(resultSet.next()) {
221                 T temp = (T) clazz.newInstance();
222                 for(int index = 0; index < columnNames.length; ++index) {
223                     String targetMethdName = "set" + columnNames[index];
224                     Method[] methods = clazz.getMethods();
225                     if((methods != null) && (methods.length > 0)) {
226                         for(Method method : methods) {
227                             String tempMethodName = method.getName();
228                             if(targetMethdName.equalsIgnoreCase(tempMethodName)) {
229                                 Object tempObject = resultSet.getObject(columnNames[index]);
230                                 if(tempObject != null) {
231                                     String columnTypeName = tempObject.getClass().getName();
232                                     if("java.lang.Integer".equals(columnTypeName)) {
233                                         method.invoke(temp, resultSet.getInt(columnNames[index]));
234                                     } else if("java.sql.Date".equals(columnTypeName)) {
235                                         method.invoke(temp, resultSet.getDate(columnNames[index]));
236                                     } else if("java.lang.Double".equals(columnTypeName)) {
237                                         method.invoke(temp, resultSet.getDouble(columnNames[index]));
238                                     } else if("java.lang.Boolean".equals(columnTypeName)) {
239                                         method.invoke(temp, resultSet.getBoolean(columnNames[index]));
240                                     } else {
241                                         method.invoke(temp, resultSet.getString(columnNames[index]));
242                                     }
243                                 }
244                                 break;
245                             }
246                         }
247                     }
248                 }
249                 resultList.add(temp);
250             }
251         } catch (Exception e) {
252             e.printStackTrace();
253             Log.log.equals(e.toString());
254         } finally {
255             printExecutedSQL(pstmt);
256             closeAllConnections(connection, pstmt, resultSet);
257         }
258 
259         // 缓存最新数据
260         String tableName = new GenericityHelper().getClassName(clazz);
261         cachedData.remove(tableName);
262         cachedData.put(tableName, (List<Object>) resultList);
263 
264         return (List<Object>) resultList;
265     }
266 
267 }

  1 package com.dsp.core;
  2 
  3 import java.io.ByteArrayInputStream;
  4 import java.io.ByteArrayOutputStream;
  5 import java.io.IOException;
  6 import java.io.ObjectInputStream;
  7 import java.io.ObjectOutputStream;
  8 import java.lang.reflect.Field;
  9 import java.lang.reflect.InvocationTargetException;
 10 import java.lang.reflect.Method;
 11 import java.sql.Timestamp;
 12 import java.util.ArrayList;
 13 import java.util.HashMap;
 14 import java.util.List;
 15 import java.util.Map;
 16 
 17 import com.dsp.util.Log;
 18 
 19 /**
 20  * DatabaseAccess类的辅助帮助类
 21  * 声明：
 22  * 本来这个类的所有方法完全可安置到DatabaseAccess类中，从数据耦合
 23  * 这个层面上来讲，DatabaseAccess类有太多的数据处理需要此类中的方法；
 24  * 但考虑到代码都放到一个类中就显得代码有点冗长了，可以适时调整代码位置。
 25  * @author dsp
 26  */
 27 public class GenericityHelper {
 28     /**
 29      * 获取对象object的简短类名
 30      * @param     object    待操作的对象
 31      * @return     object对象所对应的类名
 32      */
 33     public String getClassName(Object object) {
 34         Class<?> clazz = getReflectClass(object);
 35         String classFullName = getClassFullName(clazz);
 36         return classFullName.substring(classFullName.lastIndexOf(".") + 1).toLowerCase();
 37     }
 38 
 39     /**
 40      *  重载方法
 41      *  获取对象object的简短类名
 42      * @param clazz 反射类实例
 43      * @return  反射类实例所对应的类名
 44      */
 45     public String getClassName(Class<?> clazz) {
 46         String classFullName = getClassFullName(clazz);
 47         return classFullName.substring(classFullName.lastIndexOf(".") + 1).toLowerCase();
 48     }
 49 
 50     /**
 51      * 获取对象所有的的字段名
 52      * @param     object 操作的对象
 53      * @return     object所有的字段名
 54      */
 55     public List<String> getAllFieldNames(Object object) {
 56         Class<?> clazz = getReflectClass(object);
 57         Field[] fields = clazz.getDeclaredFields();
 58         List<String> columns = new ArrayList<String>();
 59         for(int index = 0; index < fields.length; ++index) {
 60             columns.add(index, fields[index].getName().toString());
 61         }
 62         return columns;
 63     }
 64 
 65     /**
 66      * 获取所有字段对应的值：键值对
 67      * @param columns    所有的字段名
 68      * @param object    值来源对象
 69      * @return object所有的字段对应的值
 70      */
 71     public Map<String, Object> getFieldValues(List<String> columns, Object object) {
 72         Map<String, Object> columnToValues = new HashMap<String, Object>();
 73         for(int index = 0; index < columns.size(); ++index) {
 74             String fieldName = columns.get(index).toString();
 75             columnToValues.put(fieldName, getSpecifiedFieldValue(fieldName, object));
 76         }
 77         return columnToValues;
 78     }
 79 
 80     /**
 81      * 根据类字段名获取该字段对应的值
 82      * @param fieldName    字段名
 83      * @param object    数据源对象
 84      * @return    object中fieldName字段对应的值
 85      */
 86     public Object getSpecifiedFieldValue(String fieldName, Object object) {
 87         List<String> methodNames = generateMethodNames(fieldName);
 88         Method targetMethod = getExistedMethod(methodNames, getReflectClass(object));
 89         Object value = getValueBySpecifiedMethod(targetMethod, object);
 90         return dataCastType(value);
 91     }
 92 
 93     /**
 94      * 获取对象object的反射类实例
 95      * @param   object  操作对象
 96      * @return     object对象的反射类实例
 97      */
 98     private Class<? extends Object> getReflectClass(Object object) {
 99         return object.getClass();
100     }
101 
102     /**
103      * 获取反射类实例的类全名
104      * @param   clazz   反射类实例
105      * @return     clazz的类全名
106      */
107     private String getClassFullName(Class<?> clazz) {
108         return clazz.getName();
109     }
110 
111     /**
112      * 获取object对象的指定函数返回的值
113      * @param targetMethod  指定的函数
114      * @param object        操作的对象
115      * @return  object对象的targetMethod函数返回的值
116      */
117     private Object getValueBySpecifiedMethod(Method targetMethod, Object object) {
118         Object value = null;
119         try {
120             value = targetMethod.invoke(object, new Object[] {});
121         } catch (IllegalAccessException e) {
122             e.printStackTrace();
123             Log.log.error(e.toString());
124         } catch (InvocationTargetException e) {
125             e.printStackTrace();
126             Log.log.error(e.toString());
127         }
128         return value;
129     }
130 
131     /**
132      * 数据转换
133      * @param value 待转换的值
134      * @return    转换后的值
135      */
136     private Object dataCastType(Object value) {
137         if(value instanceof Timestamp)
138             value = Timestamp.valueOf(value.toString());
139         return value;
140     }
141 
142     /**
143      * 判断methodName是否是对象中存在的函数名
144      * @param methodName    待校验的可能的函数名
145      * @param clazz         反射类实例
146      * @return  若methodName是clazz中的函数名，返回true，否则返回false
147      */
148     private boolean isExistedMethodName(String methodName, Class<?> clazz) {
149         Method[] methods = clazz.getMethods();
150         for(Method method : methods) {
151             if(method.getName().equals(methodName))
152                 return true;
153         }
154         return false;
155     }
156 
157     /**
158      * 根据可能的函数名字检索clazz对象存在的函数
159      * @param methodNames   函数名字链表
160      * @param clazz         反射类实例
161      * @return  在clazz对象中根据函数名字检索到的函数
162      */
163     private Method getExistedMethod(List<String> methodNames, Class<?> clazz) {
164         for(String methodName : methodNames) {
165             if(isExistedMethodName(methodName, clazz)) {
166                 try {
167                     Method targetMethod = clazz.getMethod(methodName, new Class[] {});
168                     if(targetMethod != null) {
169                         return targetMethod;
170                     }
171                 } catch (NoSuchMethodException | SecurityException e) {
172                     e.printStackTrace();
173                     Log.log.error(e.toString());
174                 }
175             }
176         }
177         return null;
178     }
179 
180     /**
181      * 根据字段名生成可能的目标函数名
182      * @param fieldName 字段名
183      * @return    根据fieldName生成的所有可能的目标函数名，将其存放在链表中
184      */
185     private List<String> generateMethodNames(String fieldName) {
186         List<String> methodNames = new ArrayList<String>();
187         String firstLetter = fieldName.substring(0, 1).toUpperCase();
188         String postfix = firstLetter + fieldName.substring(1);
189 
190         /*
191          * IDE自动生成的getter函数前缀不一定都是"get"
192          */
193         // 方法是”getXyz()“
194         String methodPrefixGet = "get" + postfix;
195         methodNames.add(methodPrefixGet);
196         // 方法名是“isXyz()”
197         String methodPrefixIs = "is" + postfix;
198         methodNames.add(methodPrefixIs);
199 
200         return methodNames;
201     }
202 
203     /**
204      * 深拷贝List<Object>，要求Object已实现Serializable接口
205      * @param sourceList    源List
206      * @return    源List的一份副本
207      * @throws IOException
208      * @throws ClassNotFoundException
209      */
210     @SuppressWarnings("unchecked")
211     public List<Object> deepClone(List<Object> sourceList) throws IOException, ClassNotFoundException {
212         ByteArrayOutputStream byteOutStream = new ByteArrayOutputStream();
213         ObjectOutputStream objectOutStream = new ObjectOutputStream(byteOutStream);
214         objectOutStream.writeObject(sourceList);
215 
216         ByteArrayInputStream byteInputStream = new ByteArrayInputStream(byteOutStream.toByteArray());
217         ObjectInputStream objectInputStream =new ObjectInputStream(byteInputStream);
218         List<Object> destList = (List<Object>) objectInputStream.readObject();
219         return destList;
220     }
221 
222 }

 1 package com.dsp.core;
 2 
 3 import java.io.IOException;
 4 import java.io.InputStream;
 5 import java.util.Properties;
 6 
 7 import com.dsp.util.Log;
 8 
 9 /**
10  * 加载数据库配置文件
11  * @author dsp
12  */
13 public class LoadDBConfigFile extends Properties {
14     private static final long serialVersionUID = 1907772550710288554L;
15 
16     private static LoadDBConfigFile instance = null;
17 
18     /**
19      * 对外提供一个工厂方法
20      * @return LoadDBConfigFile的全局唯一实例
21      */
22     public synchronized static LoadDBConfigFile getInstance() {
23         if(instance != null) {
24             return instance;
25         } else {
26             instance = new LoadDBConfigFile();
27             return instance;
28         }
29     }
30 
31     /**
32      * 单例模式的核心：构造方法私有化
33      */
34     private LoadDBConfigFile() {
35         // db.properties文件保存有基本的配置信息
36         // 通过类的反射实例找到并加载classpath路径下的指定资源文件,并将其生成一个输入流;
37         InputStream inputStream = this.getClass().getResourceAsStream("/db.properties");
38         try {
39             // 将输入流中的信息加载到类的当前对象中
40             this.load(inputStream);
41         } catch (IOException e) {
42             Log.log.error(e.toString());
43         } finally {
44             try {
45                 inputStream.close();
46             } catch (IOException e) {
47                 e.printStackTrace();
48                 Log.log.error(e.toString());
49             }
50         }
51     }
52 
53 }

 1 package com.dsp.util;
 2 
 3 import org.apache.log4j.Logger;
 4 import org.apache.log4j.PropertyConfigurator;
 5 
 6 public class Log {
 7     
 8     public static Logger log;
 9 
10     static {
11         PropertyConfigurator.configure("/log4j.properties");
12         log = Logger.getLogger(Log.class);
13         log.debug("debug");
14         log.error("error");
15     }
16     
17 }

 1 import com.dsp.bean.MovieType;
 2 import com.dsp.core.DatabaseAccess;
 3 import java.lang.reflect.InvocationTargetException;
 4 import java.util.Date;
 5 import java.util.List;
 6 
 7 /**
 8  * Created by dsp on 14-3-9.
 9  */
10 public class DataBaseAccessTester {
11     public static void main(String[] args) throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
12 //        MovieType movieType = new MovieType();
13 //        movieType.setId(6);
14 //        movieType.setName("101010");
15 //        new DatabaseAccess().add(movieType);
16 //
17         DatabaseAccess databaseAccess = new DatabaseAccess();
18 //        List<MovieType> movieTypes = (List<MovieType>) databaseAccess.getAll(MovieType.class);
19 //        for(MovieType movieType_ : movieTypes) {
20 //            System.out.println(movieType_);
21 //        }
22 //
23 //        System.out.println("#############################################################");
24 //
25 //        MovieType movieType_1 = new MovieType();
26 //        movieType_1.setId(8);
27 //        movieType_1.setName("888");
28 //        new DatabaseAccess().update(movieType_1);
29 //
30 //        System.out.println("#############################################################");
31 //
32 //        List<MovieType> movieTypes_1 = (List<MovieType>) databaseAccess.getAll(MovieType.class);
33 //        for(MovieType movieType_2 : movieTypes_1) {
34 //            System.out.println(movieType_2);
35 //        }
36 //
37 //        System.out.println("#############################################################");
38 //        System.out.println("#############################################################");
39 //
40 //        MovieType movieType_2 = new MovieType();
41 //        movieType_2.setId(9);
42 //        movieType_2.setName("dsp");
43 //        new DatabaseAccess().update(movieType_2);
44 //
45 //        System.out.println("#############################################################");
46 
47 //        List<MovieType> movieTypes_22 = (List<MovieType>) databaseAccess.getAll(MovieType.class);
48 //        movieTypes_22.remove(0);
49 //        movieTypes_22.remove(3);
50 //        movieTypes_22.add(new MovieType());
51 //        for(MovieType movieType_22 : movieTypes_22) {
52 //            System.out.println(movieType_22);
53 //        }
54 //
55 //        System.out.println("###############################################################");
56 //
57 //        List<MovieType> movieTypeList_23 = (List<MovieType>) new DatabaseHelper().getCachedData("movietype", MovieType.class);
58 //        for(MovieType movieType_22 : movieTypeList_23) {
59 //            System.out.println(movieType_22);
60 //        }
61 //
62 //        System.out.println("#########################");
63 //        System.out.println(movieTypes_22 == movieTypeList_23);
64 
65 // ##################################################################################
66     }
67 
68 }