SimplifiedHibernate：简化了的Hibernate

我的目的是实现下Hibernate中增删改查、缓存的核心功能。虽然基本功能实现了，但可能还有好多Bug，欢迎点评拍砖，没准能在一片谩骂声中取得意想不到的进步，：）

// DatabaseAccess.java

package com.dsp.core;

import java.io.IOException;
import java.util.*;

/**
 * 数据库访问操作类
 * @author dsp
 */
public class DatabaseAccess {
    // 数据库辅助帮助类实例
    private DatabaseHelper         databaseHelper         = new DatabaseHelper();
    // DatabaseAccess类的泛型帮助类实例
    private GenericityHelper     genericityHelper     = new GenericityHelper();

    /**
     * 向数据库添加object
     * @param object    待添加的对象
     * @return  若成功向数据库添加object，则返回数据库中object对应记录的id号，否则，返回-1
     */
    @SuppressWarnings("unchecked")
    public synchronized int add(Object object) {
        // object为空
        if(null == object)
            return -1;

        List<String> columns = genericityHelper.getAllFieldNames(object);
        Map<String, Object> columnToValues = genericityHelper.getFieldValues(columns, object);

        /*
         * 拼接带占位符的SQL语句
         */
        String className = genericityHelper.getClassName(object).toLowerCase();
        String sql_0 = "insert into " + className + "(";
        for(int index = 0; index < columns.size(); ++index) {
            sql_0 += columns.get(index) + ",";
        }
        String sql_1 = sql_0.substring(0, sql_0.length() - 1) + ") values(";
        // 设置占位符
        for(int index = 0; index < columns.size(); ++index) {
            sql_1 += "?,";
        }
        String sql_2 = sql_1.substring(0, sql_1.length() - 1);
        sql_2 += ");";

        /*
         * 设置相应参数
         */
        List<Object> params = new LinkedList<Object>();
        for(int index = 0; index < columns.size(); ++index) {
            String fieldName = columns.get(index);
            if("id".equals(fieldName))
                params.add(index, 0);
            else
                params.add(index, columnToValues.get(fieldName));
        }

        // 执行插入
        int result = databaseHelper.singleTableUpdate(sql_2, params, object.getClass());

        // 若插入成功
        if(result > 0) {
            String tableName = genericityHelper.getClassName(object);
            List<Object> targetList = (List<Object>) databaseHelper.getCachedData(tableName, object.getClass());
            Object lastObject = targetList.get(targetList.size() - 1);
            Object value = genericityHelper.getSpecifiedFieldValue("id", lastObject);
            int id = Integer.parseInt(value.toString());
            return id;
        } else {
            return -1;
        }
    }

    /**
     * 从数据库中删除object
     * @param object    待删除的对象
     * @return  成功删除，返回true；否则返回false
     */
    public synchronized boolean delete(Object object) {
        // 对象为空
        if(null == object)
            return false;

        /*
         * 拼接带占位符的SQL语句
         */
        String className = genericityHelper.getClassName(object);
        List<String> columns = genericityHelper.getAllFieldNames(object);
        Map<String, Object> columnToValues = genericityHelper.getFieldValues(columns, object);
        String sql = "delete from " + className + " where id = " + columnToValues.get("id") + ";";

        // 执行删除操作
        int result = databaseHelper.singleTableUpdate(sql, null, object.getClass());
        if(result > 0)
            return true;
        else
            return false;
    }

    /**
     * 更新数据库中德object对象
     * @param object    要更新的对象
     * @return  成功返回true，否则返回false
     */
    public synchronized boolean update(Object object) {
        // 对象为空
        if(null == object)
            return false;

        String className = genericityHelper.getClassName(object);
        String sql_0 = "update " + className + " set ";

        List<Object> params = new ArrayList<Object>();
        List<String> columns = genericityHelper.getAllFieldNames(object);
        Map<String, Object> columnToValues = genericityHelper.getFieldValues(columns, object);

        /*
         * 拼接带占位符的SQL语句
         */
        for(int index = 0; index < columns.size(); ++index) {
            String field = columns.get(index).toString();
            if(field.equals("id"))
                continue;
            sql_0 += field + "=?,";
            params.add(columnToValues.get(field));
        }

        String sql_1 = sql_0.substring(0, sql_0.length() - 1) + " where id=?;";
        params.add(columnToValues.get("id"));

        // 执行更新操作
        int result = databaseHelper.singleTableUpdate(sql_1, params, object.getClass());
        if(result <= 0)
            return false;
        else
            return true;
    }

    /**
     * 从数据库中查询出所有的clazz记录，得到clazz记录的一份副本（深拷贝），使用时要求对应的Java Bean实现Serializable接口
     * @param clazz 数据库表名映射的Java Bean反射实例
     * @return  查询到的记录的链表
     * @throws IOException
     * @throws ClassNotFoundException
     */
    @SuppressWarnings("unchecked")
    public synchronized List<?> getAll(Class<?> clazz) {
        List<?> resultsList = null;
        try {
            String className = genericityHelper.getClassName(clazz);
            List<Object> tempResults = (List<Object>) databaseHelper.getCachedData(className, clazz);
            resultsList = genericityHelper.deepClone(tempResults);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return resultsList;
    }

}

 // DatabaseHelper.java

package com.dsp.core;

import java.lang.reflect.Method;
import java.sql.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.dsp.util.Log;

/**
 * 数据库JDBC操作辅助帮助类
 * @author dsp
 */
public class DatabaseHelper {
    // 已缓存了的数据链表
    private static Map<String, List<Object>>    cachedData = new HashMap<String, List<Object>>();

    // JDBC连接
    private Connection                             connection;
    // 预编译对象
    private PreparedStatement                     pstmt;

    /**
     * 静态块，用来加载驱动
     */
    static{
        try {
            Class.forName(LoadDBConfigFile.getInstance().getProperty("driverClassName"));
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
            Log.log.error(e.toString());
        }
    }

    /**
     * 获取连接
     */
    private Connection getConnection() {
        try {
            // 手动创建JDBC连接
            connection = DriverManager.getConnection(LoadDBConfigFile.getInstance().getProperty("url"), LoadDBConfigFile.getInstance().getProperty("username"), LoadDBConfigFile.getInstance().getProperty("password"));
            if(connection == null) {
                System.out.println("Error!!!Failed to connect database!");
                System.exit(-1);
            }
        } catch (Exception e) {
            Log.log.error(e.toString());
        }
        return connection;
    }

    /**
     * 关闭所有与JDBC相关的连接
     * 顺序：先进后出
     */
    private void closeAllConnections(Connection connection, PreparedStatement pstmt, ResultSet resultSet) {
        if(pstmt != null) {
            try {
                pstmt.close();
            } catch (SQLException e) {
                Log.log.error(e.toString());
            }
        }
        if(connection != null) {
            try {
                connection.close();
            } catch (SQLException e) {
                Log.log.error(e.toString());
            }
        }
    }

    /**
     * 填充PreparedStatement对象的sql语句中的占位符
     * @param pstmt        PreparedStatement对象
     * @param params    填充PreparedStatement对象中sql语句占位符的参数链表
     * #######################################################################
     * 参数化查询（Parameterized Query 或 Parameterized Statement）是指在设计与
     * 数据库链接并访问数据时，在需要填入数值或数据的地方，使用参数 (Parameter) 来给值，
     * 这个方法目前已被视为最有效可预防SQL注入攻击(SQL Injection) 的攻击手法的防御方式。
     */
    private void replacePlaceholder(PreparedStatement pstmt, List<Object> params) {
        if((pstmt != null) && (params != null) && (params.size() > 0)) {
            for(int index = 0; index < params.size(); ++index) {
                Object obj = params.get(index);
                try {
                    if(obj == null) {
                        // 若为null。//待优化处，减少拼接的SQL语句长度
                        pstmt.setNull(index + 1, Types.INTEGER);
                    } else if("java.util.Date".equals(obj.getClass().getName())) {
                        pstmt.setDate(index + 1, new java.sql.Date(((java.util.Date) params.get(index)).getTime()));
                    } else if("java.lang.Double".equals(obj.getClass().getName())) {
                        pstmt.setDouble(index + 1, (Double) params.get(index));
                    } else if("java.lang.Integer".equals(obj.getClass().getName())) {
                        pstmt.setInt(index + 1, (Integer) params.get(index));
                    } else if("java.lang.Boolean".equals(obj.getClass().getName())) {
                        pstmt.setBoolean(index + 1, (Boolean) params.get(index));
                    } else if("javax.sql.rowset.serial.SerialBlob".equals(obj.getClass().getName())) {
                        pstmt.setBlob(index + 1, (Blob) params.get(index));
                    } else {
                        pstmt.setString(index+1, (String)params.get(index));
                    }
                } catch (SQLException e) {
                    Log.log.error(e.toString());
                }
            }
        }
    }

    /**
     * 打印输出SQL语句。
     * 若成功，则是刚执行过的SQL语句；
     * 失败则是致使数据库系统抛出异常的非法语句。
     * @param pstmt    预编译SQL语句对象
     */
    private void printExecutedSQL(PreparedStatement pstmt) {
        String executedSQL = pstmt.toString();
        System.out.println("====>" + executedSQL);
    }

    /**
     * 该表的数据是否已缓存
     * @param tableName 表明
     * @return  已缓存：true 否则返回 false
     */
    private boolean isCached(String tableName) {
        List<Object> tempList = cachedData.get(tableName);
        if(tempList == null) {
            return false;
        }
        return true;
    }

    /**
     * 根据键名获取对应已缓存的数据
     * @param classNameOrTableName    取数据用的键名
     * @return    缓存的数据链表
     */
    public List<?> getCachedData(String classNameOrTableName, Class<?> clazz) {
        if(isCached(classNameOrTableName)) {
            return cachedData.get(classNameOrTableName);
        } else {
            // 若数据不在缓存中，则向数据库发送查询请求
            String sql = "select * from " + classNameOrTableName + ";";
            return this.singleTableQuery(sql, null, clazz);
        }
    }

    /**
     * 对单表进行更新操作
     * @param sql        带占位符的SQL语句
     * @param params    用户填充SQL语句中的占位符的参数
     * @return    执行结果：>0  成功     <=0  失败
     */
    public synchronized int singleTableUpdate(String sql, List<Object> params, Class<?> clazz) {
        connection = getConnection();
        int result = 0;
        try {
            // 预编译对象
            pstmt = connection.prepareStatement(sql);
            replacePlaceholder(pstmt, params);
            result = pstmt.executeUpdate();
            // 放在此处是出于打印的语句与数据库实际操作的顺序一致性
            printExecutedSQL(pstmt);

            // 更新缓存
            String className = new GenericityHelper().getClassName(clazz);
            String querySQL = "select * from " + className + ";";
            this.singleTableQuery(querySQL, null, clazz);
        } catch (SQLException e) {
            try {
                // 出错则打印SQL语句并回滚
                printExecutedSQL(pstmt);
                connection.rollback();
            } catch (SQLException e1) {
                e1.printStackTrace();
            }
            // 记录异常
            e.printStackTrace();
            Log.log.error(e.toString());
        } finally {
            closeAllConnections(connection, pstmt, null);
        }
        return result;
    }

    /**
     *
     * @param sql       查询语句语句，可以含有占位符
     * @param params    填充占位符的参数集
     * @param clazz     泛型类型所对应的反射对象
     * @param <T>       泛型：即你要得到的集合中存的对象的类型
     * @return    存储查询到的所有对象链表
     */
    @SuppressWarnings({ "unchecked" })
    private synchronized <T> List<Object> singleTableQuery(String sql, List<Object> params, Class<T> clazz) {
        // 若clazz为空
        if(null == clazz) {
            return null;
        }

        /*
         *  最新数据还未缓存，所以执行查询，检出数据库中的数据
         */
        List<T> resultList = new ArrayList<T>();
        connection = getConnection();
        ResultSet resultSet = null;

        try {
            // 预编译SQL语句对象
            pstmt = connection.prepareStatement(sql);
            replacePlaceholder(pstmt, params);
            resultSet = pstmt.executeQuery();

            ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
            String[] columnNames = new String[resultSetMetaData.getColumnCount()];

            for(int index = 0; index < columnNames.length; ++index) {
                columnNames[index] = resultSetMetaData.getColumnName(index + 1);
            }

            while(resultSet.next()) {
                T temp = (T) clazz.newInstance();
                for(int index = 0; index < columnNames.length; ++index) {
                    String targetMethdName = "set" + columnNames[index];
                    Method[] methods = clazz.getMethods();
                    if((methods != null) && (methods.length > 0)) {
                        for(Method method : methods) {
                            String tempMethodName = method.getName();
                            if(targetMethdName.equalsIgnoreCase(tempMethodName)) {
                                Object tempObject = resultSet.getObject(columnNames[index]);
                                if(tempObject != null) {
                                    String columnTypeName = tempObject.getClass().getName();
                                    if("java.lang.Integer".equals(columnTypeName)) {
                                        method.invoke(temp, resultSet.getInt(columnNames[index]));
                                    } else if("java.sql.Date".equals(columnTypeName)) {
                                        method.invoke(temp, resultSet.getDate(columnNames[index]));
                                    } else if("java.lang.Double".equals(columnTypeName)) {
                                        method.invoke(temp, resultSet.getDouble(columnNames[index]));
                                    } else if("java.lang.Boolean".equals(columnTypeName)) {
                                        method.invoke(temp, resultSet.getBoolean(columnNames[index]));
                                    } else {
                                        method.invoke(temp, resultSet.getString(columnNames[index]));
                                    }
                                }
                                break;
                            }
                        }
                    }
                }
                resultList.add(temp);
            }
        } catch (Exception e) {
            e.printStackTrace();
            Log.log.equals(e.toString());
        } finally {
            printExecutedSQL(pstmt);
            closeAllConnections(connection, pstmt, resultSet);
        }

        // 缓存最新数据
        String tableName = new GenericityHelper().getClassName(clazz);
        cachedData.remove(tableName);
        cachedData.put(tableName, (List<Object>) resultList);

        return (List<Object>) resultList;
    }

}

 // GenericityHelper.java

package com.dsp.core;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.dsp.util.Log;

/**
 * DatabaseAccess类的辅助帮助类
 * 声明：
 * 本来这个类的所有方法完全可安置到DatabaseAccess类中，从数据耦合
 * 这个层面上来讲，DatabaseAccess类有太多的数据处理需要此类中的方法；
 * 但考虑到代码都放到一个类中就显得代码有点冗长了，可以适时调整代码位置。
 * @author dsp
 */
public class GenericityHelper {
    /**
     * 获取对象object的简短类名
     * @param     object    待操作的对象
     * @return     object对象所对应的类名
     */
    public String getClassName(Object object) {
        Class<?> clazz = getReflectClass(object);
        String classFullName = getClassFullName(clazz);
        return classFullName.substring(classFullName.lastIndexOf(".") + 1).toLowerCase();
    }

    /**
     *  重载方法
     *  获取对象object的简短类名
     * @param clazz 反射类实例
     * @return  反射类实例所对应的类名
     */
    public String getClassName(Class<?> clazz) {
        String classFullName = getClassFullName(clazz);
        return classFullName.substring(classFullName.lastIndexOf(".") + 1).toLowerCase();
    }

    /**
     * 获取对象所有的的字段名
     * @param     object 操作的对象
     * @return     object所有的字段名
     */
    public List<String> getAllFieldNames(Object object) {
        Class<?> clazz = getReflectClass(object);
        Field[] fields = clazz.getDeclaredFields();
        List<String> columns = new ArrayList<String>();
        for(int index = 0; index < fields.length; ++index) {
            columns.add(index, fields[index].getName().toString());
        }
        return columns;
    }

    /**
     * 获取所有字段对应的值：键值对
     * @param columns    所有的字段名
     * @param object    值来源对象
     * @return object所有的字段对应的值
     */
    public Map<String, Object> getFieldValues(List<String> columns, Object object) {
        Map<String, Object> columnToValues = new HashMap<String, Object>();
        for(int index = 0; index < columns.size(); ++index) {
            String fieldName = columns.get(index).toString();
            columnToValues.put(fieldName, getSpecifiedFieldValue(fieldName, object));
        }
        return columnToValues;
    }

    /**
     * 根据类字段名获取该字段对应的值
     * @param fieldName    字段名
     * @param object    数据源对象
     * @return    object中fieldName字段对应的值
     */
    public Object getSpecifiedFieldValue(String fieldName, Object object) {
        List<String> methodNames = generateMethodNames(fieldName);
        Method targetMethod = getExistedMethod(methodNames, getReflectClass(object));
        Object value = getValueBySpecifiedMethod(targetMethod, object);
        return dataCastType(value);
    }

    /**
     * 获取对象object的反射类实例
     * @param   object  操作对象
     * @return     object对象的反射类实例
     */
    private Class<? extends Object> getReflectClass(Object object) {
        return object.getClass();
    }

    /**
     * 获取反射类实例的类全名
     * @param   clazz   反射类实例
     * @return     clazz的类全名
     */
    private String getClassFullName(Class<?> clazz) {
        return clazz.getName();
    }

    /**
     * 获取object对象的指定函数返回的值
     * @param targetMethod  指定的函数
     * @param object        操作的对象
     * @return  object对象的targetMethod函数返回的值
     */
    private Object getValueBySpecifiedMethod(Method targetMethod, Object object) {
        Object value = null;
        try {
            value = targetMethod.invoke(object, new Object[] {});
        } catch (IllegalAccessException e) {
            e.printStackTrace();
            Log.log.error(e.toString());
        } catch (InvocationTargetException e) {
            e.printStackTrace();
            Log.log.error(e.toString());
        }
        return value;
    }

    /**
     * 数据转换
     * @param value 待转换的值
     * @return    转换后的值
     */
    private Object dataCastType(Object value) {
        if(value instanceof Timestamp)
            value = Timestamp.valueOf(value.toString());
        return value;
    }

    /**
     * 判断methodName是否是对象中存在的函数名
     * @param methodName    待校验的可能的函数名
     * @param clazz         反射类实例
     * @return  若methodName是clazz中的函数名，返回true，否则返回false
     */
    private boolean isExistedMethodName(String methodName, Class<?> clazz) {
        Method[] methods = clazz.getMethods();
        for(Method method : methods) {
            if(method.getName().equals(methodName))
                return true;
        }
        return false;
    }

    /**
     * 根据可能的函数名字检索clazz对象存在的函数
     * @param methodNames   函数名字链表
     * @param clazz         反射类实例
     * @return  在clazz对象中根据函数名字检索到的函数
     */
    private Method getExistedMethod(List<String> methodNames, Class<?> clazz) {
        for(String methodName : methodNames) {
            if(isExistedMethodName(methodName, clazz)) {
                try {
                    Method targetMethod = clazz.getMethod(methodName, new Class[] {});
                    if(targetMethod != null) {
                        return targetMethod;
                    }
                } catch (NoSuchMethodException | SecurityException e) {
                    e.printStackTrace();
                    Log.log.error(e.toString());
                }
            }
        }
        return null;
    }

    /**
     * 根据字段名生成可能的目标函数名
     * @param fieldName 字段名
     * @return    根据fieldName生成的所有可能的目标函数名，将其存放在链表中
     */
    private List<String> generateMethodNames(String fieldName) {
        List<String> methodNames = new ArrayList<String>();
        String firstLetter = fieldName.substring(0, 1).toUpperCase();
        String postfix = firstLetter + fieldName.substring(1);

        /*
         * IDE自动生成的getter函数前缀不一定都是"get"
         */
        // 方法是”getXyz()“
        String methodPrefixGet = "get" + postfix;
        methodNames.add(methodPrefixGet);
        // 方法名是“isXyz()”
        String methodPrefixIs = "is" + postfix;
        methodNames.add(methodPrefixIs);

        return methodNames;
    }

    /**
     * 深拷贝List<Object>，要求Object已实现Serializable接口
     * @param sourceList    源List
     * @return    源List的一份副本
     * @throws IOException
     * @throws ClassNotFoundException
     */
    @SuppressWarnings("unchecked")
    public List<Object> deepClone(List<Object> sourceList) throws IOException, ClassNotFoundException {
        ByteArrayOutputStream byteOutStream = new ByteArrayOutputStream();
        ObjectOutputStream objectOutStream = new ObjectOutputStream(byteOutStream);
        objectOutStream.writeObject(sourceList);

        ByteArrayInputStream byteInputStream = new ByteArrayInputStream(byteOutStream.toByteArray());
        ObjectInputStream objectInputStream =new ObjectInputStream(byteInputStream);
        List<Object> destList = (List<Object>) objectInputStream.readObject();
        return destList;
    }

}

 // LoadDBConfigFile.java

package com.dsp.core;

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

import com.dsp.util.Log;

/**
 * 加载数据库配置文件
 * @author dsp
 */
public class LoadDBConfigFile extends Properties {
    private static final long serialVersionUID = 1907772550710288554L;

    private static LoadDBConfigFile instance = null;

    /**
     * 对外提供一个工厂方法
     * @return LoadDBConfigFile的全局唯一实例
     */
    public synchronized static LoadDBConfigFile getInstance() {
        if(instance != null) {
            return instance;
        } else {
            instance = new LoadDBConfigFile();
            return instance;
        }
    }

    /**
     * 单例模式的核心：构造方法私有化
     */
    private LoadDBConfigFile() {
        // db.properties文件保存有基本的配置信息
        // 通过类的反射实例找到并加载classpath路径下的指定资源文件,并将其生成一个输入流;
        InputStream inputStream = this.getClass().getResourceAsStream("/db.properties");
        try {
            // 将输入流中的信息加载到类的当前对象中
            this.load(inputStream);
        } catch (IOException e) {
            Log.log.error(e.toString());
        } finally {
            try {
                inputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
                Log.log.error(e.toString());
            }
        }
    }

}

 // Log.java

package com.dsp.util;

import org.apache.log4j.Logger;
import org.apache.log4j.PropertyConfigurator;

public class Log {
    
    public static Logger log;

    static {
        PropertyConfigurator.configure("/log4j.properties");
        log = Logger.getLogger(Log.class);
        log.debug("debug");
        log.error("error");
    }
    
}

 // db.properties

1. driverClassName=com.mysql.jdbc.Driver
2. url=jdbc:mysql://127.0.0.1:3306/retina
3. username=root
4. password=123456

// log4j.properties

1. log4j.appender.stdout=org.apache.log4j.ConsoleAppender
2. log4j.appender.stdout.Target=System.out
3. log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
4. log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %m%n
6. log4j.appender.file=org.apache.log4j.FileAppender
7. log4j.appender.file.File=retina.log
8. log4j.appender.file.layout=org.apache.log4j.PatternLayout
9. log4j.appender.file.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %l %m%n
11. log4j.rootLogger=WARN,stdout,file

 // DatabaseAccessTester.java    测试代码

import com.dsp.bean.MovieType;
import com.dsp.core.DatabaseAccess;
import java.lang.reflect.InvocationTargetException;
import java.util.Date;
import java.util.List;

/**
 * Created by dsp on 14-3-9.
 */
public class DataBaseAccessTester {
    public static void main(String[] args) throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
//        MovieType movieType = new MovieType();
//        movieType.setId(6);
//        movieType.setName("101010");
//        new DatabaseAccess().add(movieType);
//
        DatabaseAccess databaseAccess = new DatabaseAccess();
//        List<MovieType> movieTypes = (List<MovieType>) databaseAccess.getAll(MovieType.class);
//        for(MovieType movieType_ : movieTypes) {
//            System.out.println(movieType_);
//        }
//
//        System.out.println("#############################################################");
//
//        MovieType movieType_1 = new MovieType();
//        movieType_1.setId(8);
//        movieType_1.setName("888");
//        new DatabaseAccess().update(movieType_1);
//
//        System.out.println("#############################################################");
//
//        List<MovieType> movieTypes_1 = (List<MovieType>) databaseAccess.getAll(MovieType.class);
//        for(MovieType movieType_2 : movieTypes_1) {
//            System.out.println(movieType_2);
//        }
//
//        System.out.println("#############################################################");
//        System.out.println("#############################################################");
//
//        MovieType movieType_2 = new MovieType();
//        movieType_2.setId(9);
//        movieType_2.setName("dsp");
//        new DatabaseAccess().update(movieType_2);
//
//        System.out.println("#############################################################");

//        List<MovieType> movieTypes_22 = (List<MovieType>) databaseAccess.getAll(MovieType.class);
//        movieTypes_22.remove(0);
//        movieTypes_22.remove(3);
//        movieTypes_22.add(new MovieType());
//        for(MovieType movieType_22 : movieTypes_22) {
//            System.out.println(movieType_22);
//        }
//
//        System.out.println("###############################################################");
//
//        List<MovieType> movieTypeList_23 = (List<MovieType>) new DatabaseHelper().getCachedData("movietype", MovieType.class);
//        for(MovieType movieType_22 : movieTypeList_23) {
//            System.out.println(movieType_22);
//        }
//
//        System.out.println("#########################");
//        System.out.println(movieTypes_22 == movieTypeList_23);

// ##################################################################################
    }

}

^_^ ～