• Home
• org.redkale
• redkale
• 1.9.8
• source code
• CacheMemorySource.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

org.redkale.source.CacheMemorySource Maven / Gradle / Ivy

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package org.redkale.source;

import java.io.*;
import java.lang.reflect.Type;
import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicLong;
import java.util.function.*;
import java.util.logging.*;
import javax.annotation.Resource;
import org.redkale.convert.json.*;
import org.redkale.net.sncp.*;
import org.redkale.service.*;
import org.redkale.util.*;

/**
 * CacheSource的默认实现--内存缓存
 *
 * @param  value类型
 * 

 * 详情见: https://redkale.org
 *
 * @author zhangjx
 */
@Local
@AutoLoad(false)
@SuppressWarnings("unchecked")
@ResourceType(CacheSource.class)
public class CacheMemorySource extends AbstractService implements CacheSource, Service, AutoCloseable, Resourcable {

    private static final Type STRING_ENTRY_TYPE = new TypeToken>() {
    }.getType();

    private static final Type LONG_ENTRY_TYPE = new TypeToken>() {
    }.getType();

    private static final Type ATOMIC_ENTRY_TYPE = new TypeToken>() {
    }.getType();

    @Resource(name = "APP_HOME")
    private File home;

    @Resource
    private JsonConvert defaultConvert;

    @Resource(name = "$_convert")
    private JsonConvert convert;

    private boolean needStore;

    private Type objValueType;

    private ScheduledThreadPoolExecutor scheduler;

    private Consumer expireHandler;

    private final Logger logger = Logger.getLogger(this.getClass().getSimpleName());

    protected final ConcurrentHashMap> container = new ConcurrentHashMap<>();

    protected final BiConsumer futureCompleteConsumer = (r, t) -> {
        if (t != null) logger.log(Level.SEVERE, "CompletableFuture complete error", (Throwable) t);
    };

    @RpcRemote
    protected CacheSource remoteSource;

    public CacheMemorySource() {
    }

    @Override
    public final void initValueType(Type valueType) {
        this.objValueType = valueType;
        this.initTransient(this.objValueType == null);
    }

    @Override
    public final void initTransient(boolean flag) {
        this.needStore = !flag;
    }

    @Override
    public final String getType() {
        return "memory";
    }

    @Override
    @SuppressWarnings("unchecked")
    public void init(AnyValue conf) {
        if (this.convert == null) this.convert = this.defaultConvert;
        if (this.convert == null) this.convert = JsonConvert.root();
        final CacheMemorySource self = this;
        AnyValue prop = conf == null ? null : conf.getAnyValue("properties");
        if (prop != null) {
            String storeValueStr = prop.getValue("value-type");
            if (storeValueStr != null) {
                try {
                    this.initValueType(Thread.currentThread().getContextClassLoader().loadClass(storeValueStr));
                } catch (Throwable e) {
                    logger.log(Level.SEVERE, self.getClass().getSimpleName() + " load key & value store class (" + storeValueStr + ") error", e);
                }
            }
            this.initTransient(prop.getBoolValue("store-ignore", false));
        }
        String expireHandlerClass = prop == null ? null : prop.getValue("expirehandler");
        if (expireHandlerClass != null) {
            try {
                this.expireHandler = (Consumer) Thread.currentThread().getContextClassLoader().loadClass(expireHandlerClass).getDeclaredConstructor().newInstance();
            } catch (Throwable e) {
                logger.log(Level.SEVERE, self.getClass().getSimpleName() + " new expirehandler class (" + expireHandlerClass + ") instance error", e);
            }
        }
        if (scheduler == null) {
            this.scheduler = new ScheduledThreadPoolExecutor(1, (Runnable r) -> {
                final Thread t = new Thread(r, self.getClass().getSimpleName() + "-Expirer-Thread");
                t.setDaemon(true);
                return t;
            });
            final List keys = new ArrayList<>();
            scheduler.scheduleWithFixedDelay(() -> {
                try {
                    keys.clear();
                    int now = (int) (System.currentTimeMillis() / 1000);
                    container.forEach((k, x) -> {
                        if (x.expireSeconds > 0 && (now > (x.lastAccessed + x.expireSeconds))) {
                            keys.add(x.key);
                        }
                    });
                    for (String key : keys) {
                        CacheEntry entry = container.remove(key);
                        if (expireHandler != null && entry != null) expireHandler.accept(entry);
                    }
                } catch (Throwable t) {
                    logger.log(Level.SEVERE, "CacheMemorySource schedule(interval=" + 10 + "s) error", t);
                }
            }, 10, 10, TimeUnit.SECONDS);
            if (logger.isLoggable(Level.FINEST)) logger.finest(self.getClass().getSimpleName() + ":" + self.resourceName() + " start schedule expire executor");
        }
        if (Sncp.isRemote(self)) return;

        boolean datasync = false; //是否从远程同步过数据
        //----------同步数据……-----------
        // TODO
        if (this.needStore) {
            try {
                File store = home == null ? new File("cache/" + resourceName()) : new File(home, "cache/" + resourceName());
                if (!store.isFile() || !store.canRead()) return;
                LineNumberReader reader = new LineNumberReader(new FileReader(store));
                if (this.objValueType == null) this.objValueType = Object.class;
                final Type storeObjType = TypeToken.createParameterizedType(null, CacheEntry.class, objValueType);

                String line;
                while ((line = reader.readLine()) != null) {
                    if (line.isEmpty()) continue;
                    Type convertType = storeObjType;
                    if (line.startsWith("{\"cacheType\":\"" + CacheEntryType.LONG)) {
                        convertType = LONG_ENTRY_TYPE;
                    } else if (line.startsWith("{\"cacheType\":\"" + CacheEntryType.STRING)) {
                        convertType = STRING_ENTRY_TYPE;
                    } else if (line.startsWith("{\"cacheType\":\"" + CacheEntryType.ATOMIC)) {
                        convertType = ATOMIC_ENTRY_TYPE;
                    }
                    CacheEntry