java本地缓存实战项目

作者官方网站:http://www.wxl568.cn

import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.apache.log4j.Logger;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;

import com.sf.hrss.clock.cache.ClockDataCache;
import com.sf.hrss.clock.domain.ClockAddress;
import com.sf.hrss.clock.domain.Employee;
import com.sf.hrss.clock.domain.dto.ClockEmpAddressDto;
import com.sf.hrss.clock.domain.dto.ClockOrgAddressDto;
import com.sf.hrss.clock.exception.BizException;
import com.sf.hrss.clock.exception.BusinessException;
import com.sf.hrss.clock.service.ClockAddressService;
import com.sf.hrss.clock.service.ClockEmpAddressService;
import com.sf.hrss.clock.service.ClockEmpGrantService;
import com.sf.hrss.clock.service.ClockOrgAddressService;
import com.sf.hrss.clock.service.EmployeeService;
import com.sf.hrss.clock.service.OrgService;
import com.sf.hrss.clock.util.CronUtil;
import com.sf.hrss.clock.util.DateUtil;

//每十分钟刷新本地缓存数据

public class ClockDataCacheHandler implements InitializingBean {

    private static final Logger logger = Logger.getLogger(ClockDataCacheHandler.class);

    private static  Date nextTime;

    private static boolean clockEmpAddressProducerFinish;

    private static final Long SLEEP_MILLIS = (long) 1000 * 5;

    /**
     *  private static final String CRON = "* * 0/1 * * *";
     *     1小时
     */
    private static final String CRON = "* 0/10 * * * *";

    private Map<Long, List<ClockAddress>> orgClockAddressMap;

    @Autowired
    private EmployeeService employeeServiceImpl;

    @Autowired
    private ClockAddressService clockAddressServiceImpl;

    @Autowired
    private ClockEmpGrantService clockEmpGrantServiceImpl;

    @Autowired
    private ClockEmpAddressService clockEmpAddressServiceImpl;

    @Autowired
    private ClockOrgAddressService clockOrgAddressServiceImpl;
    
    @Autowired
    private  OrgService orgServiceImpl;

    public static void setUpClockEmpAddressProducerFinish() {
        clockEmpAddressProducerFinish = true;
    }

    public static boolean isClockEmpAddressProducerFinish() {
        return clockEmpAddressProducerFinish;
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        // 加载缓存数据
        loadCacheData();
        // 开启任务线程
        init();
    }

    private void loadCacheData() {
        // 外勤打卡权限
        logger.info("[query outside clock emp grant - start]");
        List<String> outsideEmpClockGrant = this.clockEmpGrantServiceImpl.listCanClockEmps();
        logger.info("[query outside clock emp grant - end] size:" + outsideEmpClockGrant.size());

        // 考勤点
        logger.info("[query addresses - start]");
        List<ClockAddress> addresses = this.clockAddressServiceImpl.listCanClockAddressOfToDay();
        Map<Long, ClockAddress> canClockAddress = new HashMap<>();
        for (ClockAddress clockAddress : addresses) {
            canClockAddress.put(clockAddress.getId(), clockAddress);
        }
        logger.info("[query addresses - end] size:" + addresses.size());

        // 获取全部组织的信息（组织id，上级组织id，考勤点权限）
        logger.info("[query orgInfo - start]");
        List<ClockOrgAddressDto> clockOrgAddress = this.clockOrgAddressServiceImpl.listOrgAddreesGrantInfo();
        Map<Long, ClockOrgAddressDto> clockOrgAddressMap = new HashMap<>();
        for (ClockOrgAddressDto clockOrgAddressDto : clockOrgAddress) {
            clockOrgAddressMap.put(clockOrgAddressDto.getOrgId(), clockOrgAddressDto);
        }
        logger.info("[query orgInfo - end] size:" + clockOrgAddress.size());

        // 获取人员信息(工号、人员类型、组织id)
        logger.info("[query employeesInfo - start]");
        List<Employee> employees = this.employeeServiceImpl.listEmpInfo();
        logger.info("[query employeesInfo - end] size:" + employees.size());

        // 获取人员考勤点权限（工号，考勤点权限）
        logger.info("[query clockEmpAddress - start]");
        List<ClockEmpAddressDto> clockEmpAddress = this.clockEmpAddressServiceImpl.listEmpAddreesGrant(null);
        Map<String, ClockEmpAddressDto> clockEmpAddressMap = new HashMap<>();
        for (ClockEmpAddressDto clockEmpAddressDto : clockEmpAddress) {
            clockEmpAddressMap.put(clockEmpAddressDto.getEmpCode(), clockEmpAddressDto);
        }
        logger.info("[query clockEmpAddress - end] size:" + clockEmpAddress.size());

        logger.info("[handler clockEmpAddress - start]");
        List<String> sapEmps = new ArrayList<>();
        List<String> emps = new ArrayList<>();
        List<Employee> employeeInfo =  this.employeeServiceImpl.listEmpInfoAll();//推广人员封装
        Map<String, Set<ClockAddress>> empClockAddressGrant = new HashMap<>();
        orgClockAddressMap = new HashMap<>();
        for (Employee employee : employees) {
           emps.add(employee.getEmpCode());
            // sap 人员
            if (employee.getSystemFlag() == 1) {
                sapEmps.add(employee.getEmpCode());
            }
            // 整理 组织权限（将自身没有权限的设置为上级的权限）
               if (!orgClockAddressMap.containsKey(employee.getOrgId())) {
                    arrangeOrgAddressGrants(canClockAddress, clockOrgAddressMap, employee.getOrgId());
                }
            // 装载组织考勤点
            getFzAddresses(canClockAddress, clockEmpAddressMap,
                    empClockAddressGrant, employee);
        }
        orgClockAddressMap = null;
        logger.info("[handler clockEmpAddress - end]");

        // ORG TREE 缓存数据 clockOrgAddress
        logger.info("[handler orgTreeData - start]");
        Map<Long, List<ClockOrgAddressDto>> orgTreeData = new HashMap<>();
        for (ClockOrgAddressDto clockOrgAddressDto : clockOrgAddress) {
            if (orgTreeData.containsKey(clockOrgAddressDto.getOrgSupId())) {
                orgTreeData.get(clockOrgAddressDto.getOrgSupId()).add(clockOrgAddressDto);
            } else {
                List<ClockOrgAddressDto> list = new ArrayList<>();
                list.add(clockOrgAddressDto);
                orgTreeData.put(clockOrgAddressDto.getOrgSupId(), list);
            }
        }
        logger.info("[handler orgTreeData - end]");

        // 更新缓存数据

        // 考勤点
        ClockDataCache.setClockAddress(canClockAddress);
        // 打卡权限
        ClockDataCache.setEmpClockGrant(emps);
        // 外勤打卡权限
        ClockDataCache.setOutsideEmpClockGrant(outsideEmpClockGrant);
        // 员工打卡权限
        ClockDataCache.setEmpClockAddressGrant(empClockAddressGrant);
        // sap人员
        ClockDataCache.setSapEmp(sapEmps);
        // ORG TREE
        ClockDataCache.setOrgTreeData(orgTreeData);
        //封装个人信息
        ClockDataCache.setEmployeeInfo(employeeInfo);
    }

    private void getFzAddresses(Map<Long, ClockAddress> canClockAddress,
            Map<String, ClockEmpAddressDto> clockEmpAddressMap,
            Map<String, Set<ClockAddress>> empClockAddressGrant,
            Employee employee) {
        Set<ClockAddress> empClockAddresses = new HashSet<>();
        // 装载组织考勤点
        List<ClockAddress> clockAddresses = orgClockAddressMap.get(employee.getOrgId());
        if (clockAddresses != null) {
            empClockAddresses.addAll(clockAddresses);
        }
        // 装载个人
        if (clockEmpAddressMap.containsKey(employee.getEmpCode())) {
            for (String addressId : clockEmpAddressMap.get(employee.getEmpCode()).getClockAddressIds().split(",")) {
                ClockAddress clockAddress = canClockAddress.get(Long.valueOf(addressId));
                if (clockAddress != null) {
                    clockAddress.setSysType("no");
                    empClockAddresses.add(clockAddress);
                }
            }
        }
        empClockAddressGrant.put(employee.getEmpCode(), empClockAddresses);
    }

    private void arrangeOrgAddressGrants(Map<Long, ClockAddress> clockAddressList, Map<Long, ClockOrgAddressDto> clockOrgAddress, Long orgId) {
        List<Long> localOrgIds = new ArrayList<>();
        while (true) {
            localOrgIds.add(orgId);
            if (clockOrgAddress.containsKey(orgId)) {
                String clockAddressIds = clockOrgAddress.get(orgId).getClockAddressIds();
                if (clockAddressIds != null) {
                    List<ClockAddress> clockAddressesGrant = new ArrayList<>();
                    for (String addressId : clockAddressIds.split(",")) {
                        ClockAddress cloadd = clockAddressList.get(Long.valueOf(addressId));
                        if(null!=cloadd){
                             cloadd.setSysType("yes");
                            clockAddressesGrant.add(cloadd);
                        }
                    }
                    for (Long localOrgId : localOrgIds) {
                        orgClockAddressMap.put(localOrgId, clockAddressesGrant);
                    }
                    break;
                }
            } else if (orgId == 0) {
                for (Long localOrgId : localOrgIds) {
                    orgClockAddressMap.put(localOrgId, null);
                }
                break;
            } else {
                for (Long localOrgId : localOrgIds) {
                    orgClockAddressMap.put(localOrgId, null);
                }
                logger.info("orgid:" + orgId + ",不存在");
                break;
            }
            orgId = clockOrgAddress.get(orgId).getOrgSupId();
        }
    }

    public void init() {
        // 设置下次执行时间
        try {
            setUpNextTime(DateUtil.getCurrentDate());
        } catch (BizException e1) {
             logger.error("setUpNextTime", e1);
        }
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    if (nextTime != null && nextTime.getTime() < DateUtil.getCurrentDate().getTime()) {
                        // 重新加载缓存数据
                        loadCacheData();
                        // 设置下次执行时间
                        try {
                            setUpNextTime(nextTime);
                        } catch (BizException e) {
                             logger.error("setUpNextTime01", e);
                        }
                    }
                    try {
                        Thread.sleep(SLEEP_MILLIS);
                    } catch (InterruptedException e) {
                        logger.error("Thread.sleep", e);
                    }
                }
            }
        }).start();
    }

    /**
     * 设置下一次执行时间
     * @throws BizException 
     */
    private void setUpNextTime(Date start) throws BizException {
        try {
            nextTime = CronUtil.resolveGetNextTime(start, CRON);
            logger.info("下次执行时间：" + DateUtil.format(DateUtil.DATE_TIME, nextTime));
        } catch (BusinessException e) {
            logger.error("resolveGetNextTime", e);
        }
    }
}

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.sf.hrss.clock.domain.ClockAddress;
import com.sf.hrss.clock.domain.dto.ClockEmpAddressDto;

public class ClockEmpAddressGrantsResolve implements Callable<Map<String, List<ClockAddress>>> {

    private static final Logger logger = LoggerFactory.getLogger(ClockEmpAddressGrantsResolve.class);

    private BlockingQueue<ClockEmpAddressDto> queue;

    // 考勤点
    private Map<Long, ClockAddress> clockAddress;

    public ClockEmpAddressGrantsResolve(BlockingQueue<ClockEmpAddressDto> queue, Map<Long, ClockAddress> clockAddress) {
        super();
        this.queue = queue;
        this.clockAddress = clockAddress;
    }

    @Override
    public Map<String, List<ClockAddress>> call() throws Exception {
        Map<String, List<ClockAddress>> empClockAddressGrant = new HashMap<>();
        if (queue != null) {
            while (true) {
                ClockEmpAddressDto empAddreesGrants = queue.poll(5, TimeUnit.SECONDS);
                if (empAddreesGrants != null) {
                    List<ClockAddress> clockAddresses = new ArrayList<>();
                    for (String addressId : empAddreesGrants.getClockAddressIds().split(",")) {
                        clockAddresses.add(clockAddress.get(Long.valueOf(addressId)));
                    }
                    empClockAddressGrant.put(empAddreesGrants.getEmpCode(), clockAddresses);
                } else if (ClockDataCacheHandler.isClockEmpAddressProducerFinish()) {
                    logger.info("xiao fei xian cheng" + Thread.currentThread().getName() + "end；number：");
                    return empClockAddressGrant;
                }
            }
        }
        return empClockAddressGrant;
    }

}

ehcache .xml配置

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:noNamespaceSchemaLocation="ehcache.xsd" updateCheck="true"
    monitoring="autodetect" dynamicConfig="true">
    <diskStore path="java.io.tempdir" />
    <defaultCache maxElementsInMemory="10000" eternal="false"
        timeToIdleSeconds="120" timeToLiveSeconds="120" overflowToDisk="true"
        diskSpoolBufferSizeMB="30" maxElementsOnDisk="10000000"
        diskPersistent="false" diskExpiryThreadIntervalSeconds="120"
        memoryStoreEvictionPolicy="LRU" />

    <cache name="USERCACHE" maxElementsInMemory="10000" eternal="false"
        timeToIdleSeconds="120" timeToLiveSeconds="120" overflowToDisk="true"
        diskSpoolBufferSizeMB="30" maxElementsOnDisk="10000000"
        diskPersistent="false" diskExpiryThreadIntervalSeconds="120"
        memoryStoreEvictionPolicy="LRU" />
</ehcache>  

作者官方网站:http://www.wxl568.cn