基于Hibernate实现Android与MySql的交互

1.1总述
Android客户端与服务器交互时，通过JavaWeb的思想，使用HttpServlet进行数据的响应和处理，在访问数据库方面，使用Hibernate框架进行与数据库的交互并获取数据再传输回请求的客户端。其思想如图1.1所示

图1.1服务端数据架构
1.2数据接收
接收的数据是根据Hibernate所需要的参数设置的数据结构，是数据的核心，无论接收还是回传，都是利用Message类作为媒介。定义数据包Message
类其参数如下：

参数名 类型 作用
cmd Int 判断操作的命令字，如：增、删、改、查
className String 提供需要操作哪个类
json String className类的json数据（以数组进行存储）
数据接受时接受一个Message类，然后将Message传送到数据解析层进行解析。
1.3数据解析
解析时分三个步骤：

1. 获取className并转化为Class类
2. 解析json数据
3. 判断命令字
   在获取到Message类时，先创建其所属的类，然后通过Gson进行json数据的解析并转化为类的数组，最后判断所需要的操作。
   1.4访问数据库
   Hibernate提供的访问数据库的方法简单易用，拿到数据对象数组后，遍历数组，然后调用其相关的方法即可。
   1.5数据回传
   当解析完数组并拿到其结果后就要进行数据回传，开启输出流将Message类传输回请求的客户端。

private ThreadServer server;
    private Gson gson;//json
    public BaseDaoServlet(){
        super();
        server = new ThreadServer();
        gson = new Gson();
    }
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        request.setCharacterEncoding("utf-8");
        String msg = request.getParameter("msg"); //接受msg参数
        System.out.println(msg);
        Message message = gson.fromJson(msg,Message.class);  //利用json转化为Message类

        Analysis.AnalysisDataBase(message);           //对Message类进行解析处理
        msg = gson.toJson(message);                  //处理后将其转化为新的msg作为结果返回
        String finalMsg = msg;
        System.out.println(finalMsg);
        response.getOutputStream().write(finalMsg.getBytes(StandardCharsets.UTF_8));  //向外输出数据

Analysis类
 private static DataBaseDao baseDao ;
    public static Message AnalysisDataBase(Message message){
        Gson gson = new Gson();
        Class classofjs = null;
        try {
            classofjs = Class.forName(message.getClassName());
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        Object[] objects;
        baseDao = new DataBaseDao();
        switch (message.getCmd()) {
            case Cmd.INSERT:
                objects = gson.fromJson(message.getJson(), TypeToken.getArray((Type) classofjs).getType());
                System.out.println(objects);
                if (objects != null) {
                    baseDao.Insert(objects);
                    message.setCmd(Cmd.SUCCESS);
                }
                break;
            case Cmd.SELECT:
                Map wheres = gson.fromJson(message.getJson(), new TypeToken<Map<String, Object>>() {}.getType());
                List objs = baseDao.Select(wheres,classofjs);
                message.setJson(gson.toJson(objs));
                message.setCmd(Cmd.SUCCESS);
                break;
            case Cmd.UAPATE:
                objects = gson.fromJson(message.getJson(), TypeToken.getArray((Type) classofjs).getType());
                System.out.println(objects);
                if (objects != null) {
                    baseDao.UpDate(objects);
                    message.setCmd(Cmd.SUCCESS);
                }
                break;
            case Cmd.DELETE:
                objects = gson.fromJson(message.getJson(), TypeToken.getArray((Type) classofjs).getType());
                System.out.println(objects);
                if (objects != null) {
                    baseDao.Delete(objects);
                    message.setCmd(Cmd.SUCCESS);
                }
                break;
                default:System.out.println("0000");
        }
        return message;
}

DataBaseDao类
private volatile static SessionFactory sf = new Configuration().configure().buildSessionFactory();

//    public DataBaseDao(){
//        sf = new Configuration().configure().buildSessionFactory();
//        Session session = sf.openSession();
//    }

    public void Insert(T[] objs){
        Session session = sf.getCurrentSession();
        session.beginTransaction();
        Arrays.asList(objs).forEach((session::save));
        session.getTransaction().commit();
        session.close();
    }

    public List Select(Map<String,Object> wheres,Class classinfo){
        List objs;
        Session session = sf.openSession();
        session.beginTransaction();
        DetachedCriteria dc = DetachedCriteria.forClass(classinfo);
        wheres.forEach((column,values)->{
            dc.add(Restrictions.eq(column,values));
            System.out.println(column+"  "+values);
        });

        Criteria c = dc.getExecutableCriteria(session);

        session.getTransaction().commit();

        objs = c.list();

        return objs;
    }

    public void UpDate(T[] objs){
        Session session = sf.openSession();
        session.beginTransaction();

        Arrays.asList(objs).forEach(session::update);

        session.getTransaction().commit();
        session.close();
    }
    public void Delete(T[] objs){
        Session session = sf.openSession();
        session.beginTransaction();

        Arrays.asList(objs).forEach(session::delete);

        session.getTransaction().commit();
        session.close();
    }