大数据量下的数据查询方案一

一、只查增量数据
　　初次查询查询所有并将记录存入文件并记录时间点（也可以在数据库新建表，存进数据库），下次查询是依照此时间点进行增量查询（前提是数据库数据有次时间标识字段）。

　　1.存取数据到文件工具类

package com.inspur.utils;

import org.apache.poi.ss.formula.functions.T;

import java.io.*;
import java.lang.reflect.Type;
import java.util.*;

public class IncrementalQueryUtils {
    private static String path = "";
    private static File file ;
    static {
        path = PowerUtils.getPropertyValue("app.prevData.path","constant");//获取配置文件中的路径
        file = new File(path);
        if (!file.exists()){
            try {
                file.mkdirs();
                file = new File(path+File.separator+"dataFile.txt");//创建dataFile也可以创建其他类型的文件
                file.createNewFile();
                file.setWritable(true);
                file.setExecutable(true);
                file.setReadable(true);
                System.out.println("文件创建成功！");
            } catch (IOException e) {
                e.printStackTrace();
                System.out.println(e.getMessage());
            }
        }else {
            file = new File(path+File.separator+"dataFile.txt");
            System.out.println("文件已经创建!");
        }
    }

    /**
     *  放置对象
     * @param index  决定了放置在list中对象的位置
     * @param list
     * @param date
     */
    public synchronized static void setValue(int index, List<Map<String, Object>> list, Date date){
        FileObject fileObject = new FileObject();
        fileObject.setValue(list);
        fileObject.setDate(date);
        fileObject.setProp(T.class.toString());
        setFileObject(index,fileObject);
    }

    public synchronized static T getValue(int index, Type T){
        FileObject fileObject = getFileObject(index);
        return (T)fileObject.getValue();
    }

    /**
     * 取出对象
     * @param index
     * @return
     */
    public synchronized static Map<String,Object> getValue(int index){
        FileObject fileObject = getFileObject(index);
        Map<String,Object> map = new HashMap<>();
        map.put("list",fileObject.getValue());
        map.put("date",fileObject.getDate());
        return map;
    }

    /**
     * 取出对象 FileObject
     * @param index
     * @return
     */
    private synchronized static FileObject getFileObject(int index){
        FileObject result =new FileObject();
        try{
            result = getFileObjectList().get(index);
        }catch (Exception e){
            System.out.println("getFileObjectList error...");
        }
        return result;
    }

    /**
     * 设置对象 FileObject
     * @param index
     * @param resource
     */
    private synchronized static void setFileObject(int index, FileObject resource){
            List<FileObject> list = getFileObjectList();
            list.set(index,resource);
            ObjectOutputStream out = null;
            try{
                out=new ObjectOutputStream(new FileOutputStream(file));
                out.writeObject(list);
                out.flush();
            }catch (IOException err){
                System.out.println("IOException error...");
            }finally {
                if (out!=null){
                    try{
                        out.close();
                    }catch (IOException err){
                        System.out.println(err);
                    }
                }
            }
    }

    /**
     * 获得文件中存储的list
     * @return
     */
    private synchronized static List<FileObject> getFileObjectList(){
        List<FileObject> list = new ArrayList<>(10);
        ObjectInputStream inStream = null;
        try {
            inStream = new ObjectInputStream(new FileInputStream(file));
            Object object = inStream.readObject();
            list = (List<FileObject>) object;
        }catch (IOException err1){
            System.out.println("IOException error...");
        }catch (ClassNotFoundException err2){
            System.out.println("ClassNotFoundException error...");
        }finally {
            try{
                if (inStream!=null){
                    inStream.close();
                }
            }catch (IOException err){
                System.out.println(err);
            }
            return list;
        }
    }

    /**
     * 比较获得数据库中数据最新的时间戳
     * @param list
     * @param lastDate
     * @return
     */
    public static Date getMaxDate(List<Map<String,Object>> list,Date lastDate){
        if (list==null||list.size()==0){
            return lastDate;
        }
        Date tempDate = (Date)list.get(0).get("DATE");
        for(int i=1;i<list.size();i++){
            Map<String,Object> map = list.get(i);
            Date date = (Date)map.get("DATE");
            if (date==null){
                continue;
            }
            if (date.compareTo(tempDate)==1){
                tempDate = date;
            }
        }
        return tempDate;
    }

    /**
     *
     * @param oldList
     * @param newList
     * @param key  根据此key来和并例如CNT，得到最新的结果list用于返回到页面
     * @return
     */
    public static List<Map<String, Object>> getCombineList(List<Map<String, Object>> oldList,List<Map<String, Object>>  newList,String key){
        if(newList==null||newList.size()==0){
            return oldList;
        }else{
           for(int i=0;i<newList.size();i++){
               try{
                   Map<String, Object> mapNew = newList.get(i);
                   if (mapNew.get(key)==null||"0".equals(mapNew.get(key).toString())){
                       continue;
                   }else {
                       Map<String, Object> mapOld = oldList.get(i);
                       mapOld.put(key,Integer.valueOf(mapOld.get(key).toString())+Integer.valueOf(mapNew.get(key).toString()));
                   }
               }catch (Exception e){
                   System.out.println(e);
               }
           }
           return oldList;
        }
    }

}

 

package com.inspur.utils;

import java.io.Serializable;
import java.util.Date;

public class FileObject implements Serializable {
    Date date;
    Object value;
    String prop;


    public Date getDate() {
        return date;
    }

    public void setDate(Date date) {
        this.date = date;
    }

    public Object getValue() {
        return value;
    }

    public void setValue(Object value) {
        this.value = value;
    }

    public String getProp() {
        return prop;
    }

    public void setProp(String prop) {
        this.prop = prop;
    }
}

二、每次查询后都会在dataFile文件中更新对应index的数据，此处默认是以List<Map>形式存储的，FileObject实现了Serializable接口，可以进行反序列化，在使用过程中直接使用FileObject向下转型得到对象后然后通过对象方法getValue()得到此index存储的对象的值，在系列化得到对象的理想值。

(List<Map<String, Object>>)