皮皮皮的代码
皮皮皮的代码

分布式-多级缓存

1. 介绍

1.1 什么是多级缓存

多级缓存，即在整个系统架构的不同系统层级进行数据缓存，以提升访问效率。在SpringBoot项目中多级缓存基本分为本地缓存和远程缓存，本地缓存可以用Caffeine、Guava、HashMap，远程缓存可以用Redis。

1.2 框架

J2Cache包含的功能大于JetCache，但是JetCache属于阿里开源框架，后续维护的可能性高，其它框架就更不敢随意在项目上使用了。不过JetCache需要扩展一些功能，不然本地缓存和远程缓存都要允许一定的延迟性才能使用。本地缓存可以允许，刷新频率比较高，但是远程缓存如果刷新频率也很高的话，就跟本地缓存无异了，有点得不偿失。Spring AOP原生的缓存框架，功能有所欠缺。

1.2.1 JetCache（阿里）

（1）简介

JetCache是一个基于Java的缓存系统封装，提供统一的API和注解来简化缓存的使用。 JetCache提供了比SpringCache更加强大的注解，可以原生的支持TTL、两级缓存、分布式自动刷新，还提供了Cache接口用于手工缓存操作。

（2）特性

  • 支持注解
  • 支持自动刷新（除非设置一直刷新，不然的话一段时间没访问后就不刷新了，然后突然又有大流量那怎么应对呢：Jetcache设置了分布式锁，当缓存过期后，避免全部进到数据库层）
  • 支持本地缓存Caffeine（本地缓存支持Caffeine、Guava，如果仅支持HashMap或者Memcache的话，就需要斟酌了）
  • 不支持模糊删除，只支持KV键存储，不支持HashMap方式存储（我所知的基本上所有人用缓存都是KV键存储，很少用HashMap存储，但是KV键存储的话基本上避免不了模糊删除，而HashMap存书的话主要删除一个键即可，模糊删除如果使用keys的话，会全量扫阻塞其它线程，而且数据量巨大的话，返回的数组能直接裂开。如果使用游标方式，虽然不会太阻塞其它现成，但是数组还是能直接裂开，数组裂开的可能性应该比较小）
  • 不支持Redis集群访问（代码上获取Redis连接方式为单机方式，不是集群方式）

1.2.2 AutoLoadCache

（1）特性

  • 支持注解
  • 支持自动刷新
  • 支持本地缓存HashMap，不支持Caffeine、Guava方式
  • 支持HashMap方式存储，不支持模糊删除（不推荐模糊删除，以HashMap的方式存储是为了方便删除）
  • 支持Redis集群访问

1.2.3 LayeringCache

（1）简介

layering-cache是一个支持分布式环境的多级缓存框架，使用方式和spring-cache类似。使用Caffeine作为一级本地缓存，使用redis作为二级集中式缓存。一级缓存和二级缓存的数据一致性是通过推和拉两种模式相结合的方式来实现的。推主要是基于redis的pub/sub机制，拉主要是基于消息队列和记录消费消息的偏移量来实现的。

（2）特性

  • 支持注解
  • 支持自动刷新，不支持自定义刷新频率
  • 支持本地缓存Caffeine
  • 支持模糊删除（游标方式删除）
  • 支持Redis集群访问

1.2.4 J2Cache

（1）简介

J2Cache 是 OSChina 目前正在使用的两级缓存框架（要求至少 Java 8）。第一级缓存使用内存(同时支持 Ehcache 2.x、Ehcache 3.x 和 Caffeine)，第二级缓存使用 Redis(推荐)/Memcached 。 由于大量的缓存读取会导致 L2 的网络成为整个系统的瓶颈，因此 L1 的目标是降低对 L2 的读取次数。 该缓存框架主要用于集群环境中。单机也可使用，用于避免应用重启导致的缓存冷启动后对后端业务的冲击。

（2）特性

  • 支持注解（Spring Aop原生注解）
  • 支持自动刷新，不能自定义刷新频率（Redis键过期时触发回调，需要Redis版本和手动配置，默认是关闭的；Redis、RabbitMq、RocketMq等消息方式通知本地缓存的更新）
  • 支持本地缓存Caffeine、Ehcache
  • 支持HashMap方式存储
  • 支持模糊删除（游标方式）
  • 支持Redis集群访问

1.2.5 Spring Aop注解

（1）特性

  • 支持注解

2. 源码

2.1 以AOP方式织入方法内进行拦截

只有@Cached上注册过的name名称，才能做其它更新、删除注解的操作，不然都会报异常。

// com.alicp.jetcache.anno.aop.JetCacheInterceptor#invoke 
public Object invoke(final MethodInvocation invocation) throws Throwable {
        // ...
        CacheInvokeContext context = configProvider.getCacheContext().createCacheInvokeContext(cacheConfigMap);
        context.setTargetObject(invocation.getThis());
        context.setInvoker(invocation::proceed);
        context.setMethod(method);
        context.setArgs(invocation.getArguments());
        context.setCacheInvokeConfig(cac);
        context.setHiddenPackages(globalCacheConfig.getHiddenPackages());
        return CacheHandler.invoke(context);
    }

2.2 根据注解方式执行不同的策略

// com.alicp.jetcache.anno.method.CacheHandler#doInvoke
private static Object doInvoke(CacheInvokeContext context) throws Throwable {
        CacheInvokeConfig cic = context.getCacheInvokeConfig();
        CachedAnnoConfig cachedConfig = cic.getCachedAnnoConfig();
        if (cachedConfig != null && (cachedConfig.isEnabled() || CacheContextSupport._isEnabled())) {
            // 执行查询操作
            return invokeWithCached(context);
        } else if (cic.getInvalidateAnnoConfigs() != null || cic.getUpdateAnnoConfig() != null) {
            // 执行删除或者更新操作
            return invokeWithInvalidateOrUpdate(context);
        } else {
            // 执行原生方法
            return invokeOrigin(context);
        }
    }

 2.3 执行查询操作

// com.alicp.jetcache.anno.method.CacheHandler#invokeWithCached
private static Object invokeWithCached(CacheInvokeContext context)
            throws Throwable {
        CacheInvokeConfig cic = context.getCacheInvokeConfig();
        CachedAnnoConfig cac = cic.getCachedAnnoConfig();
        Cache cache = context.getCacheFunction().apply(context, cac);
        if (cache == null) {
            logger.error("no cache with name: " + context.getMethod());
            return invokeOrigin(context);
        }

        // 如果key解析出来是null值，会直接执行原生方法，应避免，key = "'' + #userId"，这种方式解析出来会产生“null”字符串，不再直接进数据库查询。若果是key = "#userId"，解析出来会是null，不会命中缓存
        Object key = ExpressionUtil.evalKey(context, cic.getCachedAnnoConfig());
        if (key == null) {
            return loadAndCount(context, cache, key);
        }

         // 解析Condition表达式，如果出现一些异常则直接进数据库查询
        if (!ExpressionUtil.evalCondition(context, cic.getCachedAnnoConfig())) {
            return loadAndCount(context, cache, key);
        }

        try {
            CacheLoader loader = new CacheLoader() {
                @Override
                public Object load(Object k) throws Throwable {
                    Object result = invokeOrigin(context);
                    context.setResult(result);
                    return result;
                }

                @Override
                public boolean vetoCacheUpdate() {
                    return !ExpressionUtil.evalPostCondition(context, cic.getCachedAnnoConfig());
                }
            };
            Object result = cache.computeIfAbsent(key, loader);
            return result;
        } catch (CacheInvokeException e) {
            throw e.getCause();
        }
    }

 2.4 执行删除操作

// com.alicp.jetcache.anno.method.CacheHandler#doInvalidate(com.alicp.jetcache.anno.method.CacheInvokeContext, com.alicp.jetcache.anno.support.CacheInvalidateAnnoConfig)
private static void doInvalidate(CacheInvokeContext context, CacheInvalidateAnnoConfig annoConfig) {
        Cache cache = context.getCacheFunction().apply(context, annoConfig);
        if (cache == null) {
            return;
        }
        boolean condition = ExpressionUtil.evalCondition(context, annoConfig);
        if (!condition) {
            return;
        }
        Object key = ExpressionUtil.evalKey(context, annoConfig);
        if (key == null) {
            return;
        }
        if (annoConfig.isMulti()) {
            // 如果注解配置这个属性，则转换key为数组形式，进行缓存删除，但是不是模糊删除
            Iterable it = toIterable(key);
            if (it == null) {
                logger.error("jetcache @CacheInvalidate key is not instance of Iterable or array: " + annoConfig.getDefineMethod());
                return;
            }
            Set keys = new HashSet();
            it.forEach(k -> keys.add(k));
            cache.removeAll(keys);
        } else {
            cache.remove(key);
        }
    }

2.5 查询缓存

// com.alicp.jetcache.AbstractCache#computeIfAbsentImpl
static  V computeIfAbsentImpl(K key, Function loader, boolean cacheNullWhenLoaderReturnNull,
                                               long expireAfterWrite, TimeUnit timeUnit, Cache cache) {
        AbstractCache abstractCache = CacheUtil.getAbstractCache(cache);
        CacheLoader newLoader = CacheUtil.createProxyLoader(cache, loader, abstractCache::notify);
        CacheGetResult r;
        if (cache instanceof RefreshCache) {
            RefreshCache refreshCache = ((RefreshCache) cache);
            // 查询缓存后会检查缓存内的对象，对象内有过期时间信息，会判断是否过期
            r = refreshCache.GET(key);
            // 线程池执行更新部分信息，如过期时间，用户的访问并不会增加缓存的过期时间
            refreshCache.addOrUpdateRefreshTask(key, newLoader);
        } else {
            r = cache.GET(key);
        }
        if (r.isSuccess()) {
            return r.getValue();
        } else {
            // 判定缓存过期，进数据库查询数据进行缓存
            Consumer cacheUpdater = (loadedValue) -> {
                if(needUpdate(loadedValue, cacheNullWhenLoaderReturnNull, newLoader)) {
                    // 缓存过期后更新缓存信息
                    if (timeUnit != null) {
                        cache.PUT(key, loadedValue, expireAfterWrite, timeUnit).waitForResult();
                    } else {
                        cache.PUT(key, loadedValue).waitForResult();
                    }
                }
            };

            V loadedValue;
            if (cache.config().isCachePenetrationProtect()) {
                // 如果开启缓存穿透保护，则进行同步加载，避免同一时间大量请求进入数据库查询，另外允许配置穿透保护时间(com.alicp.jetcache.CacheConfig), 用的CountDownLatch，进行单机限制，没必要用Redis分布式锁
                loadedValue = synchronizedLoad(cache.config(), abstractCache, key, newLoader, cacheUpdater);
            } else {
                loadedValue = newLoader.apply(key);
                cacheUpdater.accept(loadedValue);
            }

            return loadedValue;
        }
    }

2.6 为了支持HashMap存储，和模糊删除， 自定义实现RedisSpringDataCache，可以通过配置type按需设置

本来想用装饰模式，但是好像不太好用。

import com.alicp.jetcache.*;
import com.alicp.jetcache.external.ExternalKeyUtil;
import com.alicp.jetcache.redis.springdata.RedisSpringDataCache;
import com.alicp.jetcache.redis.springdata.RedisSpringDataCacheConfig;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisStringCommands;
import org.springframework.data.redis.core.Cursor;
import org.springframework.data.redis.core.ScanOptions;
import org.springframework.data.redis.core.types.Expiration;
import priv.whh.std.common.constant.Constants;

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.function.Function;
import java.util.function.Predicate;


@SuppressWarnings("unchecked")
public class RedisSpringDataExtCache extends RedisSpringDataCache {
    private Logger logger = LoggerFactory.getLogger(RedisSpringDataExtCache.class);

    private RedisConnectionFactory connectionFactory;
    private RedisSpringDataCacheConfig config;

    private Function valueEncoder;
    private Function valueDecoder;

    public RedisSpringDataExtCache(RedisSpringDataCacheConfig config) {
        super(config);
        this.connectionFactory = config.getConnectionFactory();
        if (connectionFactory == null) {
            throw new CacheConfigException("connectionFactory is required");
        }
        this.config = config;
        this.valueEncoder = config.getValueEncoder();
        this.valueDecoder = config.getValueDecoder();
    }

    private void closeConnection(RedisConnection connection) {
        try {
            if (connection != null) {
                connection.close();
            }
        } catch (Exception ex) {
            logger.error("RedisConnection close fail: {}, {}", ex.getMessage(), ex.getClass().getName());
        }
    }


    @Override
    protected CacheGetResult do_GET(K key) {
        RedisConnection con = null;
        try {
            con = connectionFactory.getConnection();
            byte[] newKey = buildKey(key);
            byte[] resultBytes = con.hGet(config.getKeyPrefix().getBytes(StandardCharsets.UTF_8), newKey);
            if (resultBytes != null) {
                CacheValueHolder holder = (CacheValueHolder) valueDecoder.apply(resultBytes);
                if (System.currentTimeMillis() >= holder.getExpireTime()) {
                    return CacheGetResult.EXPIRED_WITHOUT_MSG;
                }
                return new CacheGetResult(CacheResultCode.SUCCESS, null, holder);
            } else {
                return CacheGetResult.NOT_EXISTS_WITHOUT_MSG;
            }
        } catch (Exception ex) {
            logError("GET", key, ex);
            return new CacheGetResult(ex);
        } finally {
            closeConnection(con);
        }
    }

    @Override
    protected MultiGetResult do_GET_ALL(Set keys) {
        RedisConnection con = null;
        try {
            con = connectionFactory.getConnection();
            ArrayList keyList = new ArrayList<>(keys);
            byte[][] newKeys = keyList.stream().map((k) -> buildKey(k)).toArray(byte[][]::new);

            Map> resultMap = new HashMap<>(16);
            if (newKeys.length > 0) {
                List mgetResults = con.hMGet(config.getKeyPrefix().getBytes(StandardCharsets.UTF_8), newKeys);
                for (int i = 0; i < mgetResults.size(); i++) {
                    Object value = mgetResults.get(i);
                    K key = keyList.get(i);
                    if (value != null) {
                        CacheValueHolder holder = (CacheValueHolder) valueDecoder.apply((byte[]) value);
                        if (System.currentTimeMillis() >= holder.getExpireTime()) {
                            resultMap.put(key, CacheGetResult.EXPIRED_WITHOUT_MSG);
                        } else {
                            CacheGetResult r = new CacheGetResult<>(CacheResultCode.SUCCESS, null, holder);
                            resultMap.put(key, r);
                        }
                    } else {
                        resultMap.put(key, CacheGetResult.NOT_EXISTS_WITHOUT_MSG);
                    }
                }
            }
            return new MultiGetResult<>(CacheResultCode.SUCCESS, null, resultMap);
        } catch (Exception ex) {
            logError("GET_ALL", "keys(" + keys.size() + ")", ex);
            return new MultiGetResult<>(ex);
        } finally {
            closeConnection(con);
        }
    }

    @Override
    protected CacheResult do_REMOVE(K key) {


        RedisConnection con = null;
        try {
            con = connectionFactory.getConnection();
            if (key instanceof String && ((String) key).endsWith(Constants.STAR)) {
                // 如果匹配到"*"，则认定模糊删除
                // TODO 集群暂时不考虑
                Set keys = new HashSet<>(16);
                Cursor cursor = con.scan(ScanOptions.scanOptions().count(10000).match(config.getKeyPrefix()
                        + key).build());
                while (cursor.hasNext()) {
                    keys.add(new String(cursor.next(), StandardCharsets.UTF_8));
                }
                byte[][] newKeys = keys.stream().map(s -> s.getBytes(StandardCharsets.UTF_8)).toArray((len) ->
                        new byte[keys.size()][]);
                Long result = con.del(newKeys);
                if (result != null) {
                    return CacheResult.SUCCESS_WITHOUT_MSG;
                } else {
                    return new CacheResult(CacheResultCode.FAIL, "result:" + result);
                }
            } else {
                byte[] keyBytes = buildKey(key);
                Long result = con.hDel(config.getKeyPrefix().getBytes(StandardCharsets.UTF_8), keyBytes);
                if (result == null) {
                    return new CacheResult(CacheResultCode.FAIL, "result:" + result);
                } else if (result == 1) {
                    return CacheResult.SUCCESS_WITHOUT_MSG;
                } else if (result == 0) {
                    return new CacheResult(CacheResultCode.NOT_EXISTS, null);
                } else {
                    return CacheResult.FAIL_WITHOUT_MSG;
                }
            }
        } catch (Exception ex) {
            logError("REMOVE", key, ex);
            return new CacheResult(ex);
        } finally {
            closeConnection(con);
        }
    }

    @Override
    protected CacheResult do_REMOVE_ALL(Set keys) {
        RedisConnection con = null;
        try {
            con = connectionFactory.getConnection();
            boolean judge = keys.stream().allMatch((Predicate) k -> k instanceof String && ((String) k).endsWith(Constants.STAR));
            if (judge) {
                // 如果匹配到"*"，则认定模糊删除
                // TODO 集群暂时不考虑
                Set keySet = new HashSet<>(16);
                for (K k : keys) {
                    Cursor cursor = con.scan(ScanOptions.scanOptions().count(10000).match(config.getKeyPrefix() + k).build());
                    while (cursor.hasNext()) {
                        keySet.add(new String(cursor.next(), StandardCharsets.UTF_8));
                    }
                }
                byte[][] newKeys = keySet.stream().map(s -> s.getBytes(StandardCharsets.UTF_8)).toArray((len) ->
                        new byte[keys.size()][]);
                Long result = con.del(newKeys);
                if (result != null) {
                    return CacheResult.SUCCESS_WITHOUT_MSG;
                } else {
                    return new CacheResult(CacheResultCode.FAIL, "result:" + result);
                }
            } else {
                byte[][] newKeys = keys.stream().map((k) -> buildKey(k)).toArray((len) -> new byte[keys.size()][]);
                Long result = con.hDel(config.getKeyPrefix().getBytes(StandardCharsets.UTF_8), newKeys);
                if (result != null) {
                    return CacheResult.SUCCESS_WITHOUT_MSG;
                } else {
                    return new CacheResult(CacheResultCode.FAIL, "result:" + result);
                }
            }
        } catch (Exception ex) {
            logError("REMOVE_ALL", "keys(" + keys.size() + ")", ex);
            return new CacheResult(ex);
        } finally {
            closeConnection(con);
        }
    }

    @Override
    protected CacheResult do_PUT(K key, V value, long expireAfterWrite, TimeUnit timeUnit) {
        RedisConnection con = null;
        try {
            con = connectionFactory.getConnection();
            CacheValueHolder holder = new CacheValueHolder(value, timeUnit.toMillis(expireAfterWrite));
            byte[] keyBytes = buildKey(key);
            byte[] valueBytes = valueEncoder.apply(holder);
            boolean result = hSet(con, config.getKeyPrefix().getBytes(StandardCharsets.UTF_8), keyBytes,
                    valueBytes, timeUnit.toMillis(expireAfterWrite));
            if (Boolean.TRUE.equals(result)) {
                return CacheResult.SUCCESS_WITHOUT_MSG;
            } else {
                return new CacheResult(CacheResultCode.FAIL, "result:" + result);
            }
        } catch (Exception ex) {
            logError("PUT", key, ex);
            return new CacheResult(ex);
        } finally {
            closeConnection(con);
        }
    }

    @Override
    protected CacheResult do_PUT_ALL(Map map, long expireAfterWrite, TimeUnit timeUnit) {
        RedisConnection con = null;
        try {
            con = connectionFactory.getConnection();
            int failCount = 0;
            for (Map.Entry en : map.entrySet()) {
                CacheValueHolder holder = new CacheValueHolder(en.getValue(), timeUnit.toMillis(expireAfterWrite));
                boolean result = hSet(con, config.getKeyPrefix().getBytes(StandardCharsets.UTF_8),
                        buildKey(en.getKey()), valueEncoder.apply(holder), timeUnit.toMillis(expireAfterWrite));
                if (!Boolean.TRUE.equals(result)) {
                    failCount++;
                }
            }
            return failCount == 0 ? CacheResult.SUCCESS_WITHOUT_MSG :
                    failCount == map.size() ? CacheResult.FAIL_WITHOUT_MSG : CacheResult.PART_SUCCESS_WITHOUT_MSG;
        } catch (Exception ex) {
            logError("PUT_ALL", "map(" + map.size() + ")", ex);
            return new CacheResult(ex);
        } finally {
            closeConnection(con);
        }
    }

    @Override
    protected CacheResult do_PUT_IF_ABSENT(K key, V value, long expireAfterWrite, TimeUnit timeUnit) {
        RedisConnection con = null;
        try {
            con = connectionFactory.getConnection();
            CacheValueHolder holder = new CacheValueHolder(value, timeUnit.toMillis(expireAfterWrite));
            byte[] newKey = buildKey(key);
            Boolean result = con.set(newKey, valueEncoder.apply(holder),
                    Expiration.from(expireAfterWrite, timeUnit), RedisStringCommands.SetOption.ifAbsent());
            if (Boolean.TRUE.equals(result)) {
                return CacheResult.SUCCESS_WITHOUT_MSG;
            }/* else if (result == null) {
                return CacheResult.EXISTS_WITHOUT_MSG;
            } */ else {
                return CacheResult.EXISTS_WITHOUT_MSG;
            }
        } catch (Exception ex) {
            logError("PUT_IF_ABSENT", key, ex);
            return new CacheResult(ex);
        } finally {
            closeConnection(con);
        }
    }

    @Override
    public byte[] buildKey(K key) {
        try {
            Object newKey = key;
            if (key instanceof byte[]) {
                newKey = key;
            } else if (key instanceof String) {
                newKey = key;
            } else {
                if (config.getKeyConvertor() != null) {
                    newKey = config.getKeyConvertor().apply(key);
                }
            }
            return ExternalKeyUtil.buildKeyAfterConvert(newKey, "");
        } catch (IOException e) {
            throw new CacheException(e);
        }
    }

    private boolean hSet(RedisConnection con, byte[] key, byte[] field, byte[] value, long millis) {
        try {
            con.openPipeline();
            con.hashCommands().hSet(key, field, value);
            con.keyCommands().pExpire(key, millis);
            return true;
        } catch (Exception e) {
            logger.error("Failed to hset, cause: {}", e);
            return false;
        } finally {
            con.closePipeline();
        }
    }
}

2.7 value序列化方式采用redis配置的序列化方式 

考虑到fastjson兼容性可能会有坑，官方也不推荐fastjson给使用方，怕有坑，而其它方式的序列化后redis客户端看不了具体的值，没什么具体的性能要求的话就使用jackson了，redis客户端看的方便。但是使用jackson进行配置后，需要配置om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL)。 Jetcache缓存结果会封装一个对象进行缓存（com.alicp.jetcache.CacheValueHolder），但是这个对象final且不是public，因此使用jackson后没有类型信息，反序列化的时候会直接报错，因此只能改源码，仅此一次为了兼容jackson方式一定要修改，fastjson没有次问题。（按道理jackson配置不该有这种限制，但是基本上试了enableDefaultTyping的所有方式，但是没有效果）

import com.alicp.jetcache.anno.support.SpringConfigProvider;
import org.springframework.data.redis.serializer.RedisSerializer;
import priv.whh.std.boot.cache.jetcache.convertor.Md5CacheKeyConvertor;
import priv.whh.std.boot.cache.jetcache.decoder.DefaultValueDecoder;
import priv.whh.std.boot.cache.jetcache.encoder.DefaultValueEncoder;

import java.util.Objects;
import java.util.function.Function;


public class SpringConfigExtProvider extends SpringConfigProvider {
    private static final String DEFAULT = "default";
    private static final String MD5 = "MD5";
    private final RedisSerializer redisSerializer;

    public SpringConfigExtProvider(RedisSerializer redisSerializer) {
        this.redisSerializer = redisSerializer;
    }

    @Override
    public Function parseValueEncoder(String valueEncoder) {
        if (Objects.equals(valueEncoder, DEFAULT)) {
            return new DefaultValueEncoder(redisSerializer);
        }
        return super.parseValueEncoder(valueEncoder);
    }

    @Override
    public Function parseValueDecoder(String valueDecoder) {
        if (Objects.equals(valueDecoder, DEFAULT)) {
            return new DefaultValueDecoder(redisSerializer);
        }
        return super.parseValueDecoder(valueDecoder);
    }

    @Override
    public Function parseKeyConvertor(String convertor) {
        if (Objects.equals(convertor, MD5)) {
            return new Md5CacheKeyConvertor();
        }
        return super.parseKeyConvertor(convertor);
    }
}


3. 实战


4. FAQ


4.1 什么时候适合使用远程缓存，什么时候适合使用本地缓存


本身Redis的访问速度是不慢的，但是如果访问的数量上去后，Redis的连接数会打满，所以增加本地缓存我认为主要还是为了防止突发的流量。本地缓存过期时间设置大概率是要短的，过期时间一到自动刷新去Redis加载最新的数据。Redis缓存过期时如果没加分布式锁的话会直接访问数据库，本地缓存(Caffeine、Guava)一旦时间过期了，并且此时有访问的话，Caffeine、Guava会按照过期的数据返回(还没验证)。


4.2 是否需要保证强一致性


多级缓存基本上用的应该是查询和删除操作，基本应该不会使用更新操作，因为改数据库再改缓存存在的风险大于改数据库删除缓存。本地缓存因为是在服务器内部，删除缓存的时候也只是删除当前服务器的本地缓存。本地缓存过期时间设置的比较短，一定延迟性基本上是可以接受的，我觉得不一定非要强一致性。多级缓存如果没有特别的手段都会有一定风险导致不一致性（短时间的），有过期时间的限制可以保证最终一致性。Redis可以作为消息中心，可以通知更新到各服务器的本地缓存，但是有点大材小用。除非本地缓存设置的过期时间比较长，如果设置的过期时间比较短的话，感觉没有必要。


5. 参考资料


【JetCache官网】


【AutoLoadCache官网】


【LayeringCache官网】


【J2Cache官网】

























你可能感兴趣的:(分布式)






    

  • GitHub上克隆项目
bigbig猩猩
github

    从GitHub上克隆项目是一个简单且直接的过程，它允许你将远程仓库中的项目复制到你的本地计算机上，以便进行进一步的开发、测试或学习。以下是一个详细的步骤指南，帮助你从GitHub上克隆项目。一、准备工作1.安装Git在克隆GitHub项目之前，你需要在你的计算机上安装Git工具。Git是一个开源的分布式版本控制系统，用于跟踪和管理代码变更。你可以从Git的官方网站（https://git-scm.
    

    • 

  • 01-Git初识
Meereen
Gitgit

    01-Git初识概念：一个免费开源，分布式的代码版本控制系统，帮助开发团队维护代码作用：记录代码内容。切换代码版本，多人开发时高效合并代码内容如何学：个人本机使用：Git基础命令和概念多人共享使用：团队开发同一个项目的代码版本管理Git配置用户信息配置：用户名和邮箱，应用在每次提交代码版本时表明自己的身份命令：查看git版本号git-v配置用户名gitconfig--globaluser.name
    

    • 

  • Kafka是如何保证数据的安全性、可靠性和分区的
喜欢猪猪
kafka分布式

    Kafka作为一个高性能、可扩展的分布式流处理平台，通过多种机制来确保数据的安全性、可靠性和分区的有效管理。以下是关于Kafka如何保证数据安全性、可靠性和分区的详细解析：一、数据安全性SSL/TLS加密：Kafka支持SSL/TLS协议，通过配置SSL证书和密钥来加密数据传输，确保数据在传输过程中不会被窃取或篡改。这一机制有效防止了中间人攻击，保护了数据的安全性。SASL认证：Kafka支持多种
    

    • 

  • WebMagic：强大的Java爬虫框架解析与实战
Aaron_945
Javajava爬虫开发语言

    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
    

    • 

  • 华为云分布式缓存服务DCS 8月新特性发布
华为云PaaS服务小智
华为云分布式缓存

    分布式缓存服务（DistributedCacheService，简称DCS）是华为云提供的一款兼容Redis的高速内存数据处理引擎，为您提供即开即用、安全可靠、弹性扩容、便捷管理的在线分布式缓存能力，满足用户高并发及数据快速访问的业务诉求。此次为大家带来DCS8月的特性更新内容，一起来看看吧！
    

    • 

  • 浅谈MapReduce
Android路上的人
Hadoop分布式计算mapreduce分布式框架hadoop

    从今天开始，本人将会开始对另一项技术的学习，就是当下炙手可热的Hadoop分布式就算技术。目前国内外的诸多公司因为业务发展的需要，都纷纷用了此平台。国内的比如BAT啦，国外的在这方面走的更加的前面，就不一一列举了。但是Hadoop作为Apache的一个开源项目，在下面有非常多的子项目，比如HDFS，HBase,Hive，Pig,等等，要先彻底学习整个Hadoop，仅仅凭借一个的力量，是远远不够的。
    

    • 

  • KVM+GFS分布式存储系统构建KVM高可用
henan程序媛
分布式GFS高可用KVM

    一、案列分析1.1案列概述本章案例主要使用之前章节所学的KVM及GlusterFs技术,结合起来从而实现KVM高可用。利用GlusterFs分布式复制卷，对KVM虚拟机文件进行分布存储和冗余。分布式复制卷主要用于需要冗余的情况下把一个文件存放在两个或两个以上的节点,当其中一个节点数据丢失或者损坏之后，KVM仍然能够通过卷组找到另一节点上存储的虚拟机文件，以保证虚拟机正常运行。当节点修复之后，Glu
    

    • 

  • Hadoop
傲雪凌霜，松柏长青
后端大数据hadoop大数据分布式

    ApacheHadoop是一个开源的分布式计算框架，主要用于处理海量数据集。它具有高度的可扩展性、容错性和高效的分布式存储与计算能力。Hadoop核心由四个主要模块组成，分别是HDFS（分布式文件系统）、MapReduce（分布式计算框架）、YARN（资源管理）和HadoopCommon（公共工具和库）。1.HDFS（HadoopDistributedFileSystem）HDFS是Hadoop生
    

    • 

  • 大模型训练数据库Common Crawl
WindyChanChan
数据集语言模型数据库

    CommonCrawl介绍‌‌CommonCrawl是一个非营利组织，致力于通过大规模分布式爬虫系统定期抓取整个Web并将其存储在一个可公开访问的数据库中。CommonCrawl的数据收集和处理过程包括使用Python开源爬虫工具收集全球范围内的网站数据，并将其上传到‌CommonCrawl基金会的数据仓库中。该项目从2008年开始，至今已经积累了大量的原始网页数据、元数据和文本提取数据。这些数据
    

    • 

  • 慢速连接攻击是什么？慢速连接攻击怎么防护？
快快小毛毛
网络ddos服务器

    慢速连接攻击（SlowConnectionAttack），又称慢速攻击（SlowlorisAttack），是一种网络攻击技术，旨在通过占用服务器上的所有可用连接资源来使其无法响应正常请求。与传统的拒绝服务（DoS）和分布式拒绝服务（DDoS）攻击不同，慢速攻击并不依赖于发送大量数据包来消耗带宽，而是利用HTTP、TCP或SSL等协议的特性，通过发送大量不完整的请求或缓慢发送数据来占用服务器资源，使
    

    • 

  • 分布式锁和spring事务管理
暴躁的鱼
锁及事务分布式springjava

    最近开发一个小程序遇到一个需求需要实现分布式事务管理业务需求用户在使用小程序的过程中可以查看景点，对景点地区或者城市标记是否想去，那么需要统计一个地点被标记的人数，以及记录某个用户对某个地点是否标记为想去，用两个表存储数据，一个地点表记录改地点被标记的次数，一个用户意向表记录某个用户对某个地点是否标记为想去。由于可能有多个用户同时标记一个地点，每个用户在前端点击想去按钮之后，后台接收到请求，从数据
    

    • 

  • Gobelieve 架构
weixin_34099526
数据库golangjson

    Gobelievegithub地址声明:转简书JackieF的文章,为了自己方便copy了一份,加一些自己的东西.链接：https://www.jianshu.com/p/8121d6e85282IMCore主要分三大块:im客户连接服务器（可分布式部署，暂无负载均衡模块)imr路由查询服务器（主要解决im分布式部署的问题）ims存储服务器(主从部署)基础模块1.数据包协议包：header(12)
    

    • 

  • Kafka详细解析与应用分析
芊言芊语
kafka分布式

    Kafka是一个开源的分布式事件流平台（EventStreamingPlatform），由LinkedIn公司最初采用Scala语言开发，并基于ZooKeeper协调管理。如今，Kafka已经被Apache基金会纳入其项目体系，广泛应用于大数据实时处理领域。Kafka凭借其高吞吐量、持久化、分布式和可靠性的特点，成为构建实时流数据管道和流处理应用程序的重要工具。Kafka架构Kafka的架构主要由
    

    • 

  • linux挂载文件夹
小码快撩
linux

    1.使用NFS（NetworkFileSystem）NFS是一种分布式文件系统协议，允许一个系统将其文件系统的一部分共享给其他系统。检查是否安装NFSrpm-qa|grepnfs2.启动和启用NFS服务假设服务名称为nfs-server.service，你可以使用以下命令启动和启用它：sudosystemctlstartnfs-server.servicesudosystemctlenablenf
    

    • 

  • Kafka 基础与架构理解
StaticKing
KAFKAkafka

    目录前言Kafka基础概念消息队列简介：Kafka与传统消息队列（如RabbitMQ、ActiveMQ）的对比Kafka的组件Kafka的工作原理：消息的生产、分发、消费流程Kafka系统架构Kafka的分布式架构设计Leader-Follower机制与数据复制Log-basedStorage和持久化Broker间通信协议Zookeeper在Kafka中的角色总结前言Kafka是一个分布式的消息系
    

    • 

  • Rides实现分布式锁，保障数据一致性,Redisson分布式事务处理
朱杰jjj
缓存分布式

    分布式环境下分布式锁有三种方式：基于数据库分布式锁基于Redis分布式锁基于zk分布式锁本帖只介绍Redis分布式锁为什么需要用到分布式锁？在单机环境下一个服务中多个线程对同一个事物或数据资源进行操作时，可以通过添加加锁方式（synchronized和lock）来解决数据一致性的问题。但是如果出现多个服务的情况下，这时候我们在通过synchronized和lock的方式来加锁会出现问题，因为多个服
    

    • 

  • 机电综合管理系统架构
小熊coder
机载系统系统架构

    文章目录一、机电综合管理系统架构1.系统概述2.架构层次3.核心组件二、余度管理1.余度概述2.硬件冗余3.软件冗余4.通信冗余三、总线架构1.MIL-STD-1553B总线2.ARINC429总线3.ARINC629总线4.AFDX/ARINC664总线四、未来发展趋势1.分布式架构2.高速网络3.智能化与自动化结语机电综合管理系统（ElectromechanicalManagementSyst
    

    • 

  • 华为云分布式缓存服务DCS与开源服务差异对比
hcinfo_18
redis使用华为云Redis5.0分布式缓存服务Redis客户端

    分布式缓存服务DCS提供单机、主备、集群等丰富的实例类型，满足用户高读写性能及快速数据访问的业务诉求。支持丰富的实例管理操作，帮助用户省去运维烦恼。用户可以聚焦于业务逻辑本身，而无需过多考虑部署、监控、扩容、安全、故障恢复等方面的问题。DCS基于开源Redis、Memcached向用户提供一定程度定制化的缓存服务，因此，除了拥有开源服务缓存数据库的优秀特性，DCS提供更多实用功能。一、与开源Red
    

    • 

  • Dubbo架构概览：服务注册与发现、远程调用、监控与管理
木南曌
dubbo架构

    Dubbo是一个成熟的、高性能的、基于Java的微服务开发框架，它主要用于解决分布式系统中的服务治理问题，包括服务的注册与发现、远程过程调用（RPC）、服务监控与管理等多个关键环节。以下是Dubbo架构概览的详细介绍：服务注册与发现Dubbo的服务注册与发现机制是其核心功能之一，它依赖于注册中心来管理服务的生命周期和定位服务提供者。1.服务提供者（Provider）服务提供者是实际提供服务的节点，
    

    • 

  • nfs服务搭建
GHope

    nfs是什么？基哥度娘网络文件系统(NFS)是sun微系统最初开发的分布式文件系统协议,[1]允许客户端计算机上的用户通过计算机网络访问文件很像本地存储被访问。NFS与许多其他协议一样,在开放网络计算远程过程调用(很久以前RPC)系统上建立。NFS是在请求注释(RFC)中定义的开放标准,允许任何人实现协议。NFSNFS优势：节省本地存储空间，将常用的数据存放在一台NFS服务器上且可以通过网络访问，
    

    • 

  • hbase介绍
CrazyL-
云计算+大数据hbase

    hbase是一个分布式的、多版本的、面向列的开源数据库hbase利用hadoophdfs作为其文件存储系统，提供高可靠性、高性能、列存储、可伸缩、实时读写、适用于非结构化数据存储的数据库系统hbase利用hadoopmapreduce来处理hbase、中的海量数据hbase利用zookeeper作为分布式系统服务特点：数据量大：一个表可以有上亿行，上百万列（列多时，插入变慢）面向列：面向列（族）的
    

    • 

  • Flume：大规模日志收集与数据传输的利器
傲雪凌霜，松柏长青
后端大数据flume大数据

    Flume：大规模日志收集与数据传输的利器在大数据时代，随着各类应用的不断增长，产生了海量的日志和数据。这些数据不仅对业务的健康监控至关重要，还可以通过深入分析，帮助企业做出更好的决策。那么，如何高效地收集、传输和存储这些海量数据，成为了一项重要的挑战。今天我们将深入探讨ApacheFlume，它是如何帮助我们应对这些挑战的。一、Flume概述ApacheFlume是一个分布式、可靠、可扩展的日志
    

    • 

  • 探索未来，大规模分布式深度强化学习——深入解析IMPALA架构
汤萌妮Margaret

    探索未来，大规模分布式深度强化学习——深入解析IMPALA架构scalable_agent项目地址:https://gitcode.com/gh_mirrors/sc/scalable_agent在当今的人工智能研究前沿，深度强化学习（DRL）因其在复杂任务中的卓越表现而备受瞩目。本文要介绍的是一个开源于GitHub的重量级项目：“ScalableDistributedDeep-RLwithImp
    

    • 

  • 等保测评中的关键技术挑战与应对策略
亿林数据
网络安全等保测评

    在信息安全领域，等保测评（信息安全等级保护测评）作为确保信息系统安全性的重要手段，其过程中不可避免地会遇到一系列技术挑战。这些挑战不仅考验着企业的技术实力，也对其安全管理水平提出了更高要求。本文将深入探讨等保测评中的关键技术挑战，并提出相应的应对策略。一、等保测评中的关键技术挑战1.复杂系统架构的评估难度随着信息技术的快速发展，企业信息系统的架构日益复杂，包括分布式系统、微服务架构、云计算环境等。
    

    • 

  • 系统架构师软考历年论文题目（2009-2024年）及分析
pccai-vip
系统架构师系统架构

    时间题目20091.论基于DSSA的软件架构设计与应用；2.论信息系统建模方法；3.论基于REST服务的Web应用系统设计；4.论软件可靠性设计与应用20101.论软件的静态演化和动态演化及其应用；2.论数据挖掘技术的应用；3.论大规模分布式系统缓存设计策略；4.论软件可靠性评价20111.论模型驱动架构在系统开发中的应用；2.论企业集成平台的架构设计；3.论企业架构管理与应用；4.论软件需求获取
    

    • 

  • 深入解析 Dubbo 的 attachments 机制及其应用场景
molashaonian
dubboattachments隐式传参

    背景在分布式系统中，服务之间的调用（RPC调用）是非常常见的。而在这种服务调用过程中，常常需要在不同服务之间传递一些上下文信息，比如用户身份信息、请求追踪ID、客户端IP等。Dubbo提供的attachments机制，能够帮助开发者在RPC调用时隐式传递这些数据，而不需要修改接口方法签名。通过分析架构图，我们可以看到，在服务调用链路中，使用Dubbo的attachments机制可以简化上下文信息的
    

    • 

  • 座舱交互的下一个时代
高工智能汽车
交互物联网人工智能

    为了满足座舱信息娱乐的更高性能要求，几乎所有的一线品牌都在准备“换芯”。去年开始，不少车型开始推动传统的分布式座舱仪表和中控电子架构进入域控制器时代，高通成为大赢家。今年6月，特斯拉也正式官宣，即将推出的新款ModelS将配备能够运行PS5游戏机性能的AMD芯片，包括专门定制的AMDRyzenCPU和独立的Navi23图形处理器。最新消息，特斯拉将率先在中国市场生产的ModelY高性能版车型换装A
    

    • 

  • 软件架构，一切尽在权衡
元闰子
架构

    荐语本文要介绍的是2021年O’Reilly出版的书籍SoftwareArchitecture:TheHardParts（后文简称SAHP），某种程度上，它是FundamentalsofSoftwareArchitecture（后文简称FSA）的延续，两本书的主要作者相同。FSA是基础篇，重点介绍了常见的8种架构模式；SAHP是进阶篇，重点介绍了如何从单体架构演进到分布式架构。软件架构，特别是分布
    

    • 

  • Nacos 与 Eureka 的区别
litGrey
微服务eureka

    随着微服务架构的流行，服务发现成为了构建分布式系统的关键技术之一。在众多服务发现工具中，Nacos和Eureka是两个非常受欢迎的选择。本文将深入探讨这两者的区别，帮助你在选择适合自己的服务发现解决方案时做出明智的决策。如果你不懂得怎么选择，请记得看最后一点小建议！1.基础对比1.1.架构设计：集中式vs分布式Eureka采用的是客户端-服务器（Client-Server,CS）架构。Eureka
    

    • 

  • Web3入门指南：从基础概念到实际应用
dingzd95
去中心化web3区块链人工智能智能合约

    Web3，即“去中心化的第三代互联网”，正在逐步改变我们对互联网的传统认知。从最初的静态网页（Web1.0）到互动平台和社交媒体为主的互联网（Web2.0），Web3的目标是让用户重新掌握对数据和数字资产的控制权。什么是Web3？Web3被视为互联网的下一代发展阶段，其核心是去中心化。与以往依赖中心化服务器和大公司控制的数据模式不同，Web3通过区块链技术实现了数据的分布式存储和处理。这一去中心化
    

    • 

  • 统一思想认识
永夜-极光
思想

    1.统一思想认识的基础,才能有的放矢
 原因:
   总有一种描述事物的方式最贴近本质,最容易让人理解.
   如何让教育更轻松,在于找到最适合学生的方式.
         难点在于,如何模拟对方的思维基础选择合适的方式.   &
    

    • 

  • Joda Time使用笔记
bylijinnan
javajoda time

    Joda Time的介绍可以参考这篇文章：
http://www.ibm.com/developerworks/cn/java/j-jodatime.html
工作中也常常用到Joda Time，为了避免每次使用都查API，记录一下常用的用法：
   
/**
* DateTime变化（增减）
*/
@Tes
    

    • 

  • FileUtils API
eksliang
FileUtilsFileUtils API

    转载请出自出处：http://eksliang.iteye.com/blog/2217374 一、概述
这是一个Java操作文件的常用库，是Apache对java的IO包的封装，这里面有两个非常核心的类FilenameUtils跟FileUtils，其中FilenameUtils是对文件名操作的封装;FileUtils是文件封装，开发中对文件的操作，几乎都可以在这个框架里面找到。 非常的好用。 
    

    • 

  • 各种新兴技术
不懂事的小屁孩
技术

    1:gradle Gradle 是以 Groovy 语言为基础，面向Java应用为主。基于DSL（领域特定语言）语法的自动化构建工具。
现在构建系统常用到maven工具，现在有更容易上手的gradle，
搭建java环境:
http://www.ibm.com/developerworks/cn/opensource/os-cn-gradle/
搭建android环境：
http://m
    

    • 

  • tomcat6的https双向认证
酷的飞上天空
tomcat6

    1.生成服务器端证书
keytool -genkey -keyalg RSA -dname "cn=localhost,ou=sango,o=none,l=china,st=beijing,c=cn" -alias server -keypass password -keystore server.jks -storepass password -validity 36
    

    • 

  • 托管虚拟桌面市场势不可挡
蓝儿唯美

    用户还需要冗余的数据中心，dinCloud的高级副总裁兼首席营销官Ali Din指出。该公司转售一个MSP可以让用户登录并管理和提供服务的用于DaaS的云自动化控制台，提供服务或者MSP也可以自己来控制。
在某些情况下，MSP会在dinCloud的云服务上进行服务分层，如监控和补丁管理。
MSP的利润空间将根据其参与的程度而有所不同，Din说。
“我们有一些合作伙伴负责将我们推荐给客户作为个
    

    • 

  • spring学习——xml文件的配置
a-john
spring

    在Spring的学习中，对于其xml文件的配置是必不可少的。在Spring的多种装配Bean的方式中，采用XML配置也是最常见的。以下是一个简单的XML配置文件：
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.or
    

    • 

  • HDU 4342 History repeat itself 模拟
aijuans
模拟

    来源：http://acm.hdu.edu.cn/showproblem.php?pid=4342
题意：首先让求第几个非平方数，然后求从1到该数之间的每个sqrt(i)的下取整的和。
思路：一个简单的模拟题目，但是由于数据范围大，需要用__int64。我们可以首先把平方数筛选出来，假如让求第n个非平方数的话，看n前面有多少个平方数，假设有x个，则第n个非平方数就是n+x。注意两种特殊情况，即
    

    • 

  • java中最常用jar包的用途
asia007
java

    java中最常用jar包的用途
jar包用途axis.jarSOAP引擎包commons-discovery-0.2.jar用来发现、查找和实现可插入式接口，提供一些一般类实例化、单件的生命周期管理的常用方法.jaxrpc.jarAxis运行所需要的组件包saaj.jar创建到端点的点到点连接的方法、创建并处理SOAP消息和附件的方法，以及接收和处理SOAP错误的方法.  w
    

    • 

  • ajax获取Struts框架中的json编码异常和Struts中的主控制器异常的解决办法
百合不是茶
jsjson编码返回异常

    一:ajax获取自定义Struts框架中的json编码  出现以下 问题:    
 
1,强制flush输出  json编码打印在首页
2, 不强制flush js会解析json 打印出来的是错误的jsp页面   却没有跳转到错误页面
3,  ajax中的dataType的json 改为text 会
    

    • 

  • JUnit使用的设计模式
bijian1013
java设计模式JUnit

    JUnit源代码涉及使用了大量设计模式
1、模板方法模式（Template Method）
        定义一个操作中的算法骨架，而将一些步骤延伸到子类中去，使得子类可以不改变一个算法的结构，即可重新定义该算法的某些特定步骤。这里需要复用的是算法的结构，也就是步骤，而步骤的实现可以在子类中完成。
  
    

    • 

  • Linux常用命令（摘录）
sunjing
crondchkconfig

    chkconfig --list   查看linux所有服务
chkconfig --add servicename 添加linux服务
netstat -apn | grep 8080  查看端口占用
env 查看所有环境变量
echo $JAVA_HOME 查看JAVA_HOME环境变量
 
安装编译器
yum install -y gcc
    

    • 

  • 【Hadoop一】Hadoop伪集群环境搭建
bit1129
hadoop

     结合网上多份文档，不断反复的修正hadoop启动和运行过程中出现的问题，终于把Hadoop2.5.2伪分布式安装起来，跑通了wordcount例子。Hadoop的安装复杂性的体现之一是，Hadoop的安装文档非常多，但是能一个文档走下来的少之又少，尤其是Hadoop不同版本的配置差异非常的大。Hadoop2.5.2于前两天发布，但是它的配置跟2.5.0，2.5.1没有分别。 &nb
    

    • 

  • Anychart图表系列五之事件监听
白糖_
chart

    创建图表事件监听非常简单：首先是通过addEventListener('监听类型',js监听方法)添加事件监听，然后在js监听方法中定义具体监听逻辑。
以钻取操作为例，当用户点击图表某一个point的时候弹出point的name和value，代码如下：
<script>
//创建AnyChart
var chart = new AnyChart();
//添加钻取操作&quo
    

    • 

  • Web前端相关段子
braveCS
web前端

    Web标准：结构、样式和行为分离
 
使用语义化标签
0）标签的语义：使用有良好语义的标签，能够很好地实现自我解释，方便搜索引擎理解网页结构，抓取重要内容。去样式后也会根据浏览器的默认样式很好的组织网页内容，具有很好的可读性，从而实现对特殊终端的兼容。
1）div和span是没有语义的：只是分别用作块级元素和行内元素的区域分隔符。当页面内标签无法满足设计需求时，才会适当添加div
    

    • 

  • 编程之美-24点游戏
bylijinnan
编程之美

    
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Random;
import java.util.Set;
public class PointGame {
/**编程之美 
    

    • 

  • 主页面子页面传值总结
chengxuyuancsdn
总结

    1、showModalDialog
returnValue是javascript中html的window对象的属性,目的是返回窗口值,当用window.showModalDialog函数打开一个IE的模式窗口时,用于返回窗口的值
主界面
var sonValue=window.showModalDialog("son.jsp");
子界面
window.retu
    

    • 

  • [网络与经济]互联网+的含义
comsci
互联网+

    
      互联网+后面是一个人的名字 = 网络控制系统
      互联网+你的名字 =  网络个人数据库
      每日提示:如果人觉得不舒服,千万不要外出到处走动,就呆在床上,玩玩手游,更不能够去开车,现在交通状况不
    

    • 

  • oracle 创建视图 with check option
daizj
视图vieworalce

    我们来看下面的例子：
create or replace view testview
as
select empno,ename from emp where ename like ‘M%’
with check option;
这里我们创建了一个视图，并使用了with check option来限制了视图。 然后我们来看一下视图包含的结果：
select * from testv
    

    • 

  • ToastPlugin插件在cordova3.3下使用
dibov
Cordova

        自己开发的Todos应用，想实现“
再按一次返回键退出程序 ”的功能，采用网上的ToastPlugins插件，发现代码或文章基本都是老版本，运行问题比较多。折腾了好久才弄好。下面吧基于cordova3.3下的ToastPlugins相关代码共享。  
    ToastPlugin.java
package&nbs
    

    • 

  • C语言22个系统函数
dcj3sjt126com
cfunction

    C语言系统函数一、数学函数下列函数存放在math.h头文件中Double floor(double num) 求出不大于num的最大数。Double fmod(x, y) 求整数x/y的余数。Double frexp(num, exp); double num; int *exp; 将num分为数字部分（尾数）x和 以2位的指数部分n，即num=x*2n，指数n存放在exp指向的变量中，返回x。D
    

    • 

  • 开发一个类的流程
dcj3sjt126com
开发

    本人近日根据自己的开发经验总结了一个类的开发流程。这个流程适用于单独开发的构件，并不适用于对一个项目中的系统对象开发。开发出的类可以存入私人类库，供以后复用。
 
以下是开发流程：
1. 明确类的功能，抽象出类的大概结构
2. 初步设想类的接口
3. 类名设计（驼峰式命名）
4. 属性设置(权限设置)
判断某些变量是否有必要作为成员属
    

    • 

  • java 并发
shuizhaosi888
java 并发

    能够写出高伸缩性的并发是一门艺术
 
在JAVA SE5中新增了3个包
java.util.concurrent
java.util.concurrent.atomic
java.util.concurrent.locks
在java的内存模型中，类的实例字段、静态字段和构成数组的对象元素都会被多个线程所共享，局部变量与方法参数都是线程私有的，不会被共享。 
    

    • 

  • Spring Security（11）——匿名认证
234390216
Spring SecurityROLE_ANNOYMOUS匿名

    匿名认证
目录
1.1     配置
1.2     AuthenticationTrustResolver
 
       对于匿名访问的用户，Spring Security支持为其建立一个匿名的AnonymousAuthenticat
    

    • 

  • NODEJS项目实践0.2[ express,ajax通信...]
逐行分析JS源代码
Ajaxnodejsexpress

     
一、前言
        通过上节学习，我们已经        ubuntu系统搭建了一个可以访问的nodejs系统，并做了nginx转发。本节原要做web端服务 及 mongodb的存取，但写着写着，web端就
    

    • 

  • 在Struts2 的Action中怎样获取表单提交上来的多个checkbox的值
lhbthanks
javahtmlstrutscheckbox

    第一种方法：获取结果String类型
在 Action 中获得的是一个 String 型数据，每一个被选中的 checkbox 的 value 被拼接在一起，每个值之间以逗号隔开(,)。
所以在 Action 中定义一个跟 checkbox 的 name 同名的属性来接收这些被选中的 checkbox 的 value 即可。
以下是实现的代码：
前台 HTML 代码：

    

    • 

  • 003.Kafka基本概念
nweiren
hadoopkafka

    Kafka基本概念：Topic、Partition、Message、Producer、Broker、Consumer。 Topic：             消息源（Message）的分类。 Partition：             Topic物理上的分组，一
    

    • 

  • Linux环境下安装JDK
roadrunners
jdklinux

    1、准备工作
创建JDK的安装目录：
mkdir -p /usr/java/
 
下载JDK，找到适合自己系统的JDK版本进行下载：
http://www.oracle.com/technetwork/java/javase/downloads/index.html
 
把JDK安装包下载到/usr/java/目录，然后进行解压：
tar -zxvf jre-7
    

    • 

  • Linux忘记root密码的解决思路
tomcat_oracle
linux

    1：使用同版本的linux启动系统，chroot到忘记密码的根分区passwd改密码 　　2：grub启动菜单中加入init=/bin/bash进入系统，不过这时挂载的是只读分区。根据系统的分区情况进一步判断. 　　3: grub启动菜单中加入 single以单用户进入系统. 　　4:用以上方法mount到根分区把/etc/passwd中的root密码去除 　　例如: 　　ro
    

    • 

  • 跨浏览器 HTML5 postMessage 方法以及 message 事件模拟实现
xueyou
jsonpjquery框架UIhtml5

    postMessage 是 HTML5 新方法，它可以实现跨域窗口之间通讯。到目前为止，只有 IE8+, Firefox 3, Opera 9, Chrome 3和 Safari 4 支持，而本篇文章主要讲述 postMessage 方法与 message 事件跨浏览器实现。postMessage 方法 JSONP 技术不一样，前者是前端擅长跨域文档数据即时通讯，后者擅长针对跨域服务端数据通讯，p
    

    •