NemoHero
NemoHero

redission 源代码剖析3 future模式

Redission核心代码流程使用Promise模式。 这归功于netty优秀的架构,是Redission提供异步和同步编程的核心。

   Config config = new Config();
        config.useSingleServer().setAddress("redis://192.168.2.41:6379")
                .setPassword("rabbit123@");
//创建客户端
        RedissonClient redisson = Redisson.create(config);
//创建Bucket对象

        RBucket rBucket = redisson.getBucket("dddd");
        rBucket.set("ffff");
        String ss = rBucket.get();

这篇博客主要详细介绍Redission提供的RBucket 类。

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.redisson.api;

import java.util.concurrent.TimeUnit;

public interface RBucket extends RExpirable, RBucketAsync {
    long size();

    V get();

    V getAndDelete();

    boolean trySet(V var1);

    boolean trySet(V var1, long var2, TimeUnit var4);

    boolean setIfExists(V var1);

    boolean setIfExists(V var1, long var2, TimeUnit var4);

    boolean compareAndSet(V var1, V var2);

    V getAndSet(V var1);

    V getAndSet(V var1, long var2, TimeUnit var4);

    void set(V var1);

    void set(V var1, long var2, TimeUnit var4);

    int addListener(ObjectListener var1);
}

RBucket提供set()和sget()方法用于保存和获取对象。RedissonBucket 是对RBucket对象的实现。RedissonBucket实现set()和get()同步方法和异步方法。

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.redisson;

import java.util.Collections;
import java.util.concurrent.TimeUnit;
import java.util.function.BiConsumer;
import org.redisson.api.ObjectListener;
import org.redisson.api.RBucket;
import org.redisson.api.RFuture;
import org.redisson.api.RPatternTopic;
import org.redisson.api.listener.SetObjectListener;
import org.redisson.client.codec.Codec;
import org.redisson.client.codec.StringCodec;
import org.redisson.client.protocol.RedisCommands;
import org.redisson.command.CommandAsyncExecutor;
import org.redisson.misc.CountableListener;
import org.redisson.misc.RPromise;
import org.redisson.misc.RedissonPromise;

public class RedissonBucket extends RedissonExpirable implements RBucket {
    public RedissonBucket(CommandAsyncExecutor connectionManager, String name) {
        super(connectionManager, name);
    }

    public RedissonBucket(Codec codec, CommandAsyncExecutor connectionManager, String name) {
        super(codec, connectionManager, name);
    }

    public boolean compareAndSet(V expect, V update) {
        return (Boolean)this.get(this.compareAndSetAsync(expect, update));
    }

    public RFuture compareAndSetAsync(V expect, V update) {
        if (expect == null && update == null) {
            return this.trySetAsync((Object)null);
        } else if (expect == null) {
            return this.trySetAsync(update);
        } else {
            return update == null ? this.commandExecutor.evalWriteAsync(this.getName(), this.codec, RedisCommands.EVAL_BOOLEAN, "if redis.call('get', KEYS[1]) == ARGV[1] then redis.call('del', KEYS[1]); return 1 else return 0 end", Collections.singletonList(this.getName()), new Object[]{this.encode(expect)}) : this.commandExecutor.evalWriteAsync(this.getName(), this.codec, RedisCommands.EVAL_BOOLEAN, "if redis.call('get', KEYS[1]) == ARGV[1] then redis.call('set', KEYS[1], ARGV[2]); return 1 else return 0 end", Collections.singletonList(this.getName()), new Object[]{this.encode(expect), this.encode(update)});
        }
    }

    public V getAndSet(V newValue) {
        return this.get(this.getAndSetAsync(newValue));
    }

    public RFuture getAndSetAsync(V newValue) {
        return newValue == null ? this.commandExecutor.evalWriteAsync(this.getName(), this.codec, RedisCommands.EVAL_OBJECT, "local v = redis.call('get', KEYS[1]); redis.call('del', KEYS[1]); return v", Collections.singletonList(this.getName()), new Object[0]) : this.commandExecutor.writeAsync(this.getName(), this.codec, RedisCommands.GETSET, new Object[]{this.getName(), this.encode(newValue)});
    }

    public V get() {
        return this.get(this.getAsync());
    }

    public RFuture getAsync() {
        return this.commandExecutor.readAsync(this.getName(), this.codec, RedisCommands.GET, new Object[]{this.getName()});
    }

    public V getAndDelete() {
        return this.get(this.getAndDeleteAsync());
    }

    public RFuture getAndDeleteAsync() {
        return this.commandExecutor.evalWriteAsync(this.getName(), this.codec, RedisCommands.EVAL_OBJECT, "local currValue = redis.call('get', KEYS[1]); redis.call('del', KEYS[1]); return currValue; ", Collections.singletonList(this.getName()), new Object[0]);
    }

    public long size() {
        return (Long)this.get(this.sizeAsync());
    }

    public RFuture sizeAsync() {
        return this.commandExecutor.readAsync(this.getName(), this.codec, RedisCommands.STRLEN, new Object[]{this.getName()});
    }

    public void set(V value) {
        this.get(this.setAsync(value));
    }

    public RFuture setAsync(V value) {
        return value == null ? this.commandExecutor.writeAsync(this.getName(), RedisCommands.DEL_VOID, new Object[]{this.getName()}) : this.commandExecutor.writeAsync(this.getName(), this.codec, RedisCommands.SET, new Object[]{this.getName(), this.encode(value)});
    }

    public void set(V value, long timeToLive, TimeUnit timeUnit) {
        this.get(this.setAsync(value, timeToLive, timeUnit));
    }

    public RFuture setAsync(V value, long timeToLive, TimeUnit timeUnit) {
        return value == null ? this.commandExecutor.writeAsync(this.getName(), RedisCommands.DEL_VOID, new Object[]{this.getName()}) : this.commandExecutor.writeAsync(this.getName(), this.codec, RedisCommands.PSETEX, new Object[]{this.getName(), timeUnit.toMillis(timeToLive), this.encode(value)});
    }

    public RFuture trySetAsync(V value) {
        return value == null ? this.commandExecutor.readAsync(this.getName(), this.codec, RedisCommands.NOT_EXISTS, new Object[]{this.getName()}) : this.commandExecutor.writeAsync(this.getName(), this.codec, RedisCommands.SETNX, new Object[]{this.getName(), this.encode(value)});
    }

    public RFuture trySetAsync(V value, long timeToLive, TimeUnit timeUnit) {
        if (value == null) {
            throw new IllegalArgumentException("Value can't be null");
        } else {
            return this.commandExecutor.writeAsync(this.getName(), this.codec, RedisCommands.SET_BOOLEAN, new Object[]{this.getName(), this.encode(value), "PX", timeUnit.toMillis(timeToLive), "NX"});
        }
    }

    public boolean trySet(V value, long timeToLive, TimeUnit timeUnit) {
        return (Boolean)this.get(this.trySetAsync(value, timeToLive, timeUnit));
    }

    public boolean trySet(V value) {
        return (Boolean)this.get(this.trySetAsync(value));
    }

    public boolean setIfExists(V value) {
        return (Boolean)this.get(this.setIfExistsAsync(value));
    }

    public RFuture setIfExistsAsync(V value) {
        return value == null ? this.commandExecutor.evalWriteAsync(this.getName(), this.codec, RedisCommands.EVAL_BOOLEAN, "local currValue = redis.call('get', KEYS[1]); if currValue ~= false then redis.call('del', KEYS[1]); return 1;end;return 0; ", Collections.singletonList(this.getName()), new Object[0]) : this.commandExecutor.writeAsync(this.getName(), this.codec, RedisCommands.SET_BOOLEAN, new Object[]{this.getName(), this.encode(value), "XX"});
    }

    public boolean setIfExists(V value, long timeToLive, TimeUnit timeUnit) {
        return (Boolean)this.get(this.setIfExistsAsync(value, timeToLive, timeUnit));
    }

    public RFuture setIfExistsAsync(V value, long timeToLive, TimeUnit timeUnit) {
        if (value == null) {
            throw new IllegalArgumentException("Value can't be null");
        } else {
            return this.commandExecutor.writeAsync(this.getName(), this.codec, RedisCommands.SET_BOOLEAN, new Object[]{this.getName(), this.encode(value), "PX", timeUnit.toMillis(timeToLive), "XX"});
        }
    }

    public RFuture getAndSetAsync(V value, long timeToLive, TimeUnit timeUnit) {
        return this.commandExecutor.evalWriteAsync(this.getName(), this.codec, RedisCommands.EVAL_OBJECT, "local currValue = redis.call('get', KEYS[1]); redis.call('psetex', KEYS[1], ARGV[2], ARGV[1]); return currValue; ", Collections.singletonList(this.getName()), new Object[]{this.encode(value), timeUnit.toMillis(timeToLive)});
    }

    public V getAndSet(V value, long timeToLive, TimeUnit timeUnit) {
        return this.get(this.getAndSetAsync(value, timeToLive, timeUnit));
    }

    public int addListener(ObjectListener listener) {
        return listener instanceof SetObjectListener ? this.addListener("__keyevent@*:set", (SetObjectListener)listener, SetObjectListener::onSet) : super.addListener(listener);
    }

    public RFuture addListenerAsync(ObjectListener listener) {
        return listener instanceof SetObjectListener ? this.addListenerAsync("__keyevent@*:set", (SetObjectListener)listener, SetObjectListener::onSet) : super.addListenerAsync(listener);
    }

    public void removeListener(int listenerId) {
        RPatternTopic expiredTopic = new RedissonPatternTopic(StringCodec.INSTANCE, this.commandExecutor, "__keyevent@*:set");
        expiredTopic.removeListener(listenerId);
        super.removeListener(listenerId);
    }

    public RFuture removeListenerAsync(int listenerId) {
        RPromise result = new RedissonPromise();
        CountableListener listener = new CountableListener(result, (Object)null, 3);
        RPatternTopic setTopic = new RedissonPatternTopic(StringCodec.INSTANCE, this.commandExecutor, "__keyevent@*:set");
        setTopic.removeListenerAsync(listenerId).onComplete(listener);
        this.removeListenersAsync(listenerId, listener);
        return result;
    }
}

 RedissonBucket 对象又继承了基类RedissionObject对象。 在RedissionObject 包含name 作为键,codec 作为编码解码器，commandExecutor 用来执行所以的操作。

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.redisson;

import io.netty.buffer.ByteBuf;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Spliterator;
import java.util.Spliterators;
import java.util.concurrent.TimeUnit;
import java.util.function.BiConsumer;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;
import org.redisson.api.DeletedObjectListener;
import org.redisson.api.ExpiredObjectListener;
import org.redisson.api.ObjectListener;
import org.redisson.api.RFuture;
import org.redisson.api.RObject;
import org.redisson.api.RPatternTopic;
import org.redisson.api.listener.PatternMessageListener;
import org.redisson.client.codec.ByteArrayCodec;
import org.redisson.client.codec.Codec;
import org.redisson.client.codec.StringCodec;
import org.redisson.client.protocol.RedisCommands;
import org.redisson.command.CommandAsyncExecutor;
import org.redisson.misc.CountableListener;
import org.redisson.misc.Hash;
import org.redisson.misc.RPromise;
import org.redisson.misc.RedissonPromise;

public abstract class RedissonObject implements RObject {
    protected final CommandAsyncExecutor commandExecutor;
    protected String name;
    protected final Codec codec;

    public RedissonObject(Codec codec, CommandAsyncExecutor commandExecutor, String name) {
        this.codec = codec;
        this.name = name;
        this.commandExecutor = commandExecutor;
    }

    public RedissonObject(CommandAsyncExecutor commandExecutor, String name) {
        this(commandExecutor.getConnectionManager().getCodec(), commandExecutor, name);
    }

    public static String prefixName(String prefix, String name) {
        return name.contains("{") ? prefix + ":" + name : prefix + ":{" + name + "}";
    }

    public static String suffixName(String name, String suffix) {
        return name.contains("{") ? name + ":" + suffix : "{" + name + "}:" + suffix;
    }

    protected final  Stream toStream(Iterator iterator) {
        Spliterator spliterator = Spliterators.spliteratorUnknownSize(iterator, 256);
        return StreamSupport.stream(spliterator, false);
    }

    protected final  V get(RFuture future) {
        return this.commandExecutor.get(future);
    }

    protected final long toSeconds(long timeout, TimeUnit unit) {
        long seconds = unit.toSeconds(timeout);
        if (timeout != 0L && seconds == 0L) {
            seconds = 1L;
        }

        return seconds;
    }

    public String getName() {
        return this.name;
    }

    protected String getName(Object o) {
        return this.getName();
    }

    public void rename(String newName) {
        this.get(this.renameAsync(newName));
    }

    public RFuture sizeInMemoryAsync() {
        return this.commandExecutor.writeAsync(this.getName(), StringCodec.INSTANCE, RedisCommands.MEMORY_USAGE, new Object[]{this.getName()});
    }

    public final RFuture sizeInMemoryAsync(List keys) {
        return this.commandExecutor.evalWriteAsync((String)keys.get(0), StringCodec.INSTANCE, RedisCommands.EVAL_LONG, "local total = 0;for j = 1, #KEYS, 1 do local size = redis.call('memory', 'usage', KEYS[j]); if size ~= false then total = total + size;end; end; return total; ", keys, new Object[0]);
    }

    public long sizeInMemory() {
        return (Long)this.get(this.sizeInMemoryAsync());
    }

    public RFuture renameAsync(String newName) {
        RFuture f = this.commandExecutor.writeAsync(this.getName(), StringCodec.INSTANCE, RedisCommands.RENAME, new Object[]{this.getName(), newName});
        f.onComplete((r, e) -> {
            if (e == null) {
                this.name = newName;
            }

        });
        return f;
    }

    public void migrate(String host, int port, int database, long timeout) {
        this.get(this.migrateAsync(host, port, database, timeout));
    }

    public RFuture migrateAsync(String host, int port, int database, long timeout) {
        return this.commandExecutor.writeAsync(this.getName(), StringCodec.INSTANCE, RedisCommands.MIGRATE, new Object[]{host, port, this.getName(), database, timeout});
    }

    public void copy(String host, int port, int database, long timeout) {
        this.get(this.copyAsync(host, port, database, timeout));
    }

    public RFuture copyAsync(String host, int port, int database, long timeout) {
        return this.commandExecutor.writeAsync(this.getName(), StringCodec.INSTANCE, RedisCommands.MIGRATE, new Object[]{host, port, this.getName(), database, timeout, "COPY"});
    }

    public boolean move(int database) {
        return (Boolean)this.get(this.moveAsync(database));
    }

    public RFuture moveAsync(int database) {
        return this.commandExecutor.writeAsync(this.getName(), StringCodec.INSTANCE, RedisCommands.MOVE, new Object[]{this.getName(), database});
    }

    public boolean renamenx(String newName) {
        return (Boolean)this.get(this.renamenxAsync(newName));
    }

    public RFuture renamenxAsync(String newName) {
        RFuture f = this.commandExecutor.writeAsync(this.getName(), StringCodec.INSTANCE, RedisCommands.RENAMENX, new Object[]{this.getName(), newName});
        f.onComplete((value, e) -> {
            if (e == null && value) {
                this.name = newName;
            }

        });
        return f;
    }

    public boolean delete() {
        return (Boolean)this.get(this.deleteAsync());
    }

    public RFuture deleteAsync() {
        return this.commandExecutor.writeAsync(this.getName(), StringCodec.INSTANCE, RedisCommands.DEL_BOOL, new Object[]{this.getName()});
    }

    protected RFuture deleteAsync(String... keys) {
        return this.commandExecutor.writeAsync(this.getName(), StringCodec.INSTANCE, RedisCommands.DEL_OBJECTS, keys);
    }

    public boolean unlink() {
        return (Boolean)this.get(this.unlinkAsync());
    }

    public RFuture unlinkAsync() {
        return this.commandExecutor.writeAsync(this.getName(), StringCodec.INSTANCE, RedisCommands.UNLINK_BOOL, new Object[]{this.getName()});
    }

    public boolean touch() {
        return (Boolean)this.get(this.touchAsync());
    }

    public RFuture touchAsync() {
        return this.commandExecutor.writeAsync(this.getName(), StringCodec.INSTANCE, RedisCommands.TOUCH, new Object[]{this.getName()});
    }

    public boolean isExists() {
        return (Boolean)this.get(this.isExistsAsync());
    }

    public RFuture isExistsAsync() {
        return this.commandExecutor.readAsync(this.getName(), StringCodec.INSTANCE, RedisCommands.EXISTS, new Object[]{this.getName()});
    }

    public Codec getCodec() {
        return this.codec;
    }

    protected List encode(Object... values) {
        List result = new ArrayList(values.length);
        Object[] var3 = values;
        int var4 = values.length;

        for(int var5 = 0; var5 < var4; ++var5) {
            Object object = var3[var5];
            result.add(this.encode(object));
        }

        return result;
    }

    protected List encode(Collection values) {
        List result = new ArrayList(values.size());
        Iterator var3 = values.iterator();

        while(var3.hasNext()) {
            Object object = var3.next();
            result.add(this.encode(object));
        }

        return result;
    }

    public void encode(Collection params, Collection values) {
        Iterator var3 = values.iterator();

        while(var3.hasNext()) {
            Object object = var3.next();
            params.add(this.encode(object));
        }

    }

    public String getLockByMapKey(Object key, String suffix) {
        ByteBuf keyState = this.encodeMapKey(key);

        String var4;
        try {
            var4 = suffixName(this.getName(key), Hash.hash128toBase64(keyState) + ":" + suffix);
        } finally {
            keyState.release();
        }

        return var4;
    }

    public String getLockByValue(Object key, String suffix) {
        ByteBuf keyState = this.encode(key);

        String var4;
        try {
            var4 = suffixName(this.getName(key), Hash.hash128toBase64(keyState) + ":" + suffix);
        } finally {
            keyState.release();
        }

        return var4;
    }

    protected void encodeMapKeys(Collection params, Collection values) {
        Iterator var3 = values.iterator();

        while(var3.hasNext()) {
            Object object = var3.next();
            params.add(this.encodeMapKey(object));
        }

    }

    protected void encodeMapValues(Collection params, Collection values) {
        Iterator var3 = values.iterator();

        while(var3.hasNext()) {
            Object object = var3.next();
            params.add(this.encodeMapValue(object));
        }

    }

    public ByteBuf encode(Object value) {
        if (this.commandExecutor.isRedissonReferenceSupportEnabled()) {
            RedissonReference reference = this.commandExecutor.getObjectBuilder().toReference(value);
            if (reference != null) {
                value = reference;
            }
        }

        try {
            return this.codec.getValueEncoder().encode(value);
        } catch (IOException var3) {
            throw new IllegalArgumentException(var3);
        }
    }

    public ByteBuf encodeMapKey(Object value) {
        if (this.commandExecutor.isRedissonReferenceSupportEnabled()) {
            RedissonReference reference = this.commandExecutor.getObjectBuilder().toReference(value);
            if (reference != null) {
                value = reference;
            }
        }

        try {
            return this.codec.getMapKeyEncoder().encode(value);
        } catch (IOException var3) {
            throw new IllegalArgumentException(var3);
        }
    }

    public ByteBuf encodeMapValue(Object value) {
        if (this.commandExecutor.isRedissonReferenceSupportEnabled()) {
            RedissonReference reference = this.commandExecutor.getObjectBuilder().toReference(value);
            if (reference != null) {
                value = reference;
            }
        }

        try {
            return this.codec.getMapValueEncoder().encode(value);
        } catch (IOException var3) {
            throw new IllegalArgumentException(var3);
        }
    }

    public byte[] dump() {
        return (byte[])this.get(this.dumpAsync());
    }

    public RFuture dumpAsync() {
        return this.commandExecutor.readAsync(this.getName(), ByteArrayCodec.INSTANCE, RedisCommands.DUMP, new Object[]{this.getName()});
    }

    public void restore(byte[] state) {
        this.get(this.restoreAsync(state));
    }

    public RFuture restoreAsync(byte[] state) {
        return this.restoreAsync(state, 0L, (TimeUnit)null);
    }

    public void restore(byte[] state, long timeToLive, TimeUnit timeUnit) {
        this.get(this.restoreAsync(state, timeToLive, timeUnit));
    }

    public RFuture restoreAsync(byte[] state, long timeToLive, TimeUnit timeUnit) {
        long ttl = 0L;
        if (timeToLive > 0L) {
            ttl = timeUnit.toMillis(timeToLive);
        }

        return this.commandExecutor.writeAsync(this.getName(), StringCodec.INSTANCE, RedisCommands.RESTORE, new Object[]{this.getName(), ttl, state});
    }

    public void restoreAndReplace(byte[] state, long timeToLive, TimeUnit timeUnit) {
        this.get(this.restoreAndReplaceAsync(state, timeToLive, timeUnit));
    }

    public RFuture restoreAndReplaceAsync(byte[] state, long timeToLive, TimeUnit timeUnit) {
        long ttl = 0L;
        if (timeToLive > 0L) {
            ttl = timeUnit.toMillis(timeToLive);
        }

        return this.commandExecutor.writeAsync(this.getName(), StringCodec.INSTANCE, RedisCommands.RESTORE, new Object[]{this.getName(), ttl, state, "REPLACE"});
    }

    public void restoreAndReplace(byte[] state) {
        this.get(this.restoreAndReplaceAsync(state));
    }

    public RFuture restoreAndReplaceAsync(byte[] state) {
        return this.restoreAndReplaceAsync(state, 0L, (TimeUnit)null);
    }

    protected final  int addListener(String name, T listener, BiConsumer consumer) {
        RPatternTopic topic = new RedissonPatternTopic(StringCodec.INSTANCE, this.commandExecutor, name);
        return topic.addListener(String.class, (pattern, channel, msg) -> {
            if (msg.equals(this.getName())) {
                consumer.accept(listener, msg);
            }

        });
    }

    protected final  RFuture addListenerAsync(String name, T listener, BiConsumer consumer) {
        RPatternTopic topic = new RedissonPatternTopic(StringCodec.INSTANCE, this.commandExecutor, name);
        return topic.addListenerAsync(String.class, (pattern, channel, msg) -> {
            if (msg.equals(this.getName())) {
                consumer.accept(listener, msg);
            }

        });
    }

    public int addListener(ObjectListener listener) {
        if (listener instanceof ExpiredObjectListener) {
            return this.addListener("__keyevent@*:expired", (ExpiredObjectListener)listener, ExpiredObjectListener::onExpired);
        } else if (listener instanceof DeletedObjectListener) {
            return this.addListener("__keyevent@*:del", (DeletedObjectListener)listener, DeletedObjectListener::onDeleted);
        } else {
            throw new IllegalArgumentException();
        }
    }

    public RFuture addListenerAsync(ObjectListener listener) {
        if (listener instanceof ExpiredObjectListener) {
            return this.addListenerAsync("__keyevent@*:expired", (ExpiredObjectListener)listener, ExpiredObjectListener::onExpired);
        } else if (listener instanceof DeletedObjectListener) {
            return this.addListenerAsync("__keyevent@*:del", (DeletedObjectListener)listener, DeletedObjectListener::onDeleted);
        } else {
            throw new IllegalArgumentException();
        }
    }

    public void removeListener(int listenerId) {
        RPatternTopic expiredTopic = new RedissonPatternTopic(StringCodec.INSTANCE, this.commandExecutor, "__keyevent@*:expired");
        expiredTopic.removeListener(listenerId);
        RPatternTopic deletedTopic = new RedissonPatternTopic(StringCodec.INSTANCE, this.commandExecutor, "__keyevent@*:del");
        deletedTopic.removeListener(listenerId);
    }

    public RFuture removeListenerAsync(int listenerId) {
        RPromise result = new RedissonPromise();
        CountableListener listener = new CountableListener(result, (Object)null, 2);
        this.removeListenersAsync(listenerId, listener);
        return result;
    }

    protected final void removeListenersAsync(int listenerId, CountableListener listener) {
        RPatternTopic expiredTopic = new RedissonPatternTopic(StringCodec.INSTANCE, this.commandExecutor, "__keyevent@*:expired");
        expiredTopic.removeListenerAsync(listenerId).onComplete(listener);
        RPatternTopic deletedTopic = new RedissonPatternTopic(StringCodec.INSTANCE, this.commandExecutor, "__keyevent@*:del");
        deletedTopic.removeListenerAsync(listenerId).onComplete(listener);
    }
}


当RedissionBucket执行set()方法时,这将是Redission整个流程的核心。


1 -RedissonBucket 执行set()方法,并通过get()方法获取返回值


  public void set(V value) {
        this.get(this.setAsync(value));
    }


 2 -真正执行set操作,为CommandAsyncExecutor 来完成。主要封装redis的键值，命令以及所需要的参数



    public RFuture setAsync(V value) {
        return value == null ? this.commandExecutor.writeAsync(this.getName(), RedisCommands.DEL_VOID, new Object[]{this.getName()}) : this.commandExecutor.writeAsync(this.getName(), this.codec, RedisCommands.SET, new Object[]{this.getName(), this.encode(value)});
    }



3-CommandAsyncService 首先通过netty框架创建一个promise接口，并且返回。  


  public  RFuture writeAsync(String key, Codec codec, RedisCommand command, Object... params) {
        RPromise mainPromise = this.createPromise();
        NodeSource source = this.getNodeSource(key);
        this.async(false, source, codec, command, params, mainPromise, false);
        return mainPromise;
    }



 在此,RBucket 执行一个set操作,由netty创建一个promise对象，并且RBucket通过get()同步方法获取promise完成时的结果。


 

























你可能感兴趣的:(Redis)






    

  • Redis系列：Geo 类型赋能亿级地图位置计算
Ly768768
redisbootstrap数据库

    1前言我们在篇深刻理解高性能Redis的本质的时候就介绍过Redis的几种基本数据结构，它是基于不同业务场景而设计的：动态字符串(REDIS_STRING)：整数(REDIS_ENCODING_INT)、字符串(REDIS_ENCODING_RAW)双端列表(REDIS_ENCODING_LINKEDLIST)压缩列表(REDIS_ENCODING_ZIPLIST)跳跃表(REDIS_ENCODI
    

    • 

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

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

    • 

  • Redis Key的过期策略
ArchManual
分布式架构分布式Java后端微服务架构redis

    Redis的过期策略主要是指管理和删除那些设定了过期时间的键，以确保内存的有效使用和数据的及时清理。具体来说，Redis有三种主要的过期策略：定期删除（ScheduledDeletion）、惰性删除（LazyDeletion）和内存淘汰策略（EvictionPolicies）。1.定期删除Redis的定期删除策略（ScheduledDeletion）的步骤如下：设置定期任务：Redis会在后台线程
    

    • 

  • Redis:缓存击穿
我的程序快快跑啊
缓存redisjava

    缓存击穿(热点key)：部分key(被高并发访问且缓存重建业务复杂的)失效,无数请求会直接到数据库，造成巨大压力1.互斥锁：可以保证强一致性线程一：未命中之后，获取互斥锁，再查询数据库重建缓存，写入缓存，释放锁线程二：查询未命中，未获得锁(已由线程一获得)，等待一会，缓存命中互斥锁实现方式：redis中setnxkeyvalue:改变对应key的value,仅当value不存在时执行，以此来实现互
    

    • 

  • Redis 有哪些危险命令？如何防范？
花小疯
redis缓存数据库危险命令大数据

    Redis有哪些危险命令？Redis的危险命令主要有以下几个：1.keys客户端可查询出所有存在的键。2.flushdb删除Redis中当前所在数据库中的所有记录，并且此命令从不会执行失败。3.flushall删除Redis中所有数据库中的所有记录，不止是当前所在数据库，并且此命令从不会执行失败。4.config客户端可修改Redis配置。怎么禁用和重命名危险命令？看下redis.conf默认配置
    

    • 

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

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

    • 

  • Cloud Native Weekly | 华为云抢先发布Redis5.0，红帽宣布收购混合云提供商
weixin_34302561
数据库devops大数据

    1——华为云抢先发布Redis5.02——DigitalOceanK8s服务正式上线3——红帽宣布收购混合云提供商NooBaa4——微软发布多项AzureKubernetes服务更新1华为云抢先发布Redis5.012月17日，华为云在DCS2.0的基础上，快人一步，抢先推出了新的Redis5.0产品，这是一个崭新的突破。目前国内在缓存领域的发展普遍停留在Redis4.0阶段，华为云率先发布了Re
    

    • 

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

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

    • 

  • 关于Redis集群同步/持久化/淘汰机制的详解
尾巴尖上的阳光
大数据redis数据库

    Redis是非常常用的KV数据库,使用内存以及HashMap进行存储的特点带来了高效的查询.本文将围绕Redis的常见开发使用场景,阐述在Redis集群中各个节点是如何进行数据同步,每个节点如何进行持久化以及在长期使用中如何对数据进行更新和淘汰.如果对Redis有更多的兴趣,可以查看我的技术博客:https://dingyuqi.com下面是Redis在开发过程中常用的几种使用场景.集群Redis
    

    • 

  • 主流行架构
rainbowcheng
架构架构

    nexus，gitlab,svn,jenkins,sonar,docker，apollo，catteambition，axure，蓝湖，禅道,WCP；redis，kafka，es，zookeeper，dubbo，shardingjdbc，mysql，InfluxDB，Telegraf，Grafana，Nginx，xxl-job，Neo4j,NebulaGraph是一个高性能的,NOSQL图形数据库
    

    • 

  • 网上商城项目总结 续
猫只i
javaweb电子商城结构

    前台1.用户登录注册邮箱验证校验用户名是否存在验证码自动登录2.导航条自定义标签库采用异步读取数据（使用gson将集合转换json数据）Redis服务器3.首页热门商品查询展示4.分类列表分页查询5.商品详情用cookie实现浏览记录6.购物车实现商品添加到购物车商品的查询，添加，修改，删除清空购物车7.提交订单添加订单（订单详情）确认订单（易宝支付）8.我的订单9.Fliter定义权限拦截（提交
    

    • 

  • 常用类库 Guava 简介
豆瑞瑞
java

    简介GoogleGuava是一个由Google开发的Java开源函数库。前身是GoogleCollectionsLibrary，提供了许多简化工具，如缓存、连接器、过滤器、关联数组等仓库代码GitCode-全球开发者的开源社区,开源代码托管平台参考https://github.com/google/guavahttps://github.com/google/guava/wikiRedisStre
    

    • 

  • 2024Mysql And Redis基础与进阶操作系列（8）作者——LJS[含MySQL 创建、修改、跟新、重命名、删除视图等具体详步骤；注意点及常见报错问题所对应的解决方法]
肾透侧视攻城狮
MYSQLREDISAdvanceoperationredismysql数据库linuxsqlbashadb

    目录1MySQL视图1.概念2.作用3.特点4.具体如何操作实现MYSQL视图4.1创建视图语法示例查看表和视图查看视图的结构查看视图属性信息（比如：显示数据表的存储引擎、版本、数据行数和数据大小等）查看视图的详细定义信息4.2修改视图简介格式举例4.3更新视图简介下述结构中不可更新的视图补充说明举例更新视图视图包含聚合函数不可更新视图包含distinct不可更新视图包含goupby、having
    

    • 

  • 自定义布隆过滤器解决缓存穿透
暗金烂狗
缓存

    什么是缓存穿透以及常见解决方案缓存穿透是指客户端请求的数据在缓存中和数据库中都不存在，这样缓存永远不会生效，这些请求都会打到数据库，导致数据库压力提高，造成宕机。缓存穿透就是指用户访问那些在数据库和Redis中都不存在的数据，例如我们知道id采用自增策略，那么就不可能出现负数id，而如果不法分子使用负数id进行查询，那么这些请求都会穿过Redis直接向数据库发送请求，从而导致数据库压力骤增，导致数
    

    • 

  • Redis 为什么这么快？
小海海不怕困难
Redisredis

    决定Redis请求效率的因素主要是三个方面，分别是网络、cpu、内存。在网络层面，Redis采用多路复用的设计，提升了并发处理的连接数，不过这个阶段，Server端的所有IO操作，都是由同一个主线程处理的这个时候IO的瓶颈就会影响到Redis端的整体处理性能。所以从Redis6.0开始，在多路复用及层面增加了多线程的处理，来优化IO处理的能力不过，具体的数据操作仍然是由主线程来处理的，所以我们可以
    

    • 

  • Redis 集群
確定饿的猫
redislinux

    目录Redis主从复制Redis主从复制简介Redis主从复制的作用Redis主从复制流程搭建Redis主从复制master节点slave节点验证哨兵故障转移机制部署哨兵Redis集群作用数据分区高可用Redis集群Redis高可用实现的方式有持久化、主从复制、哨兵、集群，与持久化不同，另外三种方式都是属于集群，之前已经分析了解过两种持久化模式了，现在了解另外几种方式Redis主从复制Redis主
    

    • 

  • Redisson分布式锁实现原理和使用
牧竹子
springboot#redisRedissonredis

    常见的锁内存锁lock,synchronize分布式锁redis，zookeeper实现Redisson基于redis实现了Lock接口的分布式集群锁，是可重入锁，功能强大，源码复杂，比redis单机模式分布式锁可靠，稳定性更高，支持集群模式，支持锁根据业务时长自动延迟释放redis普通分布式锁存在一定的缺陷——它加锁只作用在一个Redis节点上，如果通过sentinel和cluster保证高可用
    

    • 

  • 分布式框架Celery七(Django-Celery-Flower实现异步和定时爬虫及其监控邮件告警)
yjjpp2301
Celery分布式djangopython后端

    Django中集成方式安装模块pipinstallDjango==3.2.22pipinstallcelerypipinstallredispipinstalleventlet#在windows环境下需要安装eventlet包-----------pipinstalldjango-celery-beatpipinstalldjango-celery-resultspipinstalldjango-
    

    • 

  • Redis的持久化和高可用性
小辛学西嘎嘎
redis数据库缓存

    目录一、淘汰策略1、背景2、淘汰策略二、持久化1、背景2、fork进程写时复制机制3、Redis持久化方式1、aof2、rdb三、高可用1、主从复制2、Redis哨兵模式3、Rediscluster集群一、淘汰策略1、背景首先Redis是一个内存数据库，将所有数据存放在内存中，通过对K值进行hash后存储在散列表中。有一个小问题Redis数据库占96G，但为什么最终占满只有48G呢。因为中间有个过
    

    • 

  • 【Redis】Redis缓存
1886i
JavaRedis缓存redis数据库

    目录一、缓存1、概念2、作用3、缺点二、缓存模型三、缓存的更新1、更新策略2、主动更新的三种模式1.cacheasidepattern2.read/writethroughpattern3.writebehindcachingpattern3、线程安全问题1.缓存删除还是更新缓存2.先删除缓存后操作数据库3.先操作数据库后删除缓存4.如何保证缓存与数据库操作同时成功或失败4、最佳选择一、缓存1、概
    

    • 

  • Windows系统下安装Redis
bjzhang75
windowsredis数据库

    文章目录1、下载Redis安装包2、解压压缩包3、运行Redis4、Redis连接检测5、Redis相关设置5.1设置环境变量PATH5.2Redis配置文件修改1、下载Redis安装包Windows版本的Redis可以在Github中下载：下载Redis2、解压压缩包将下载的压缩包解压到某个目录下，比如：C:\redis。3、运行Redis在cmd窗口中运行命令redis-serverredis
    

    • 

  • 实现多级缓存的六种策略方法
Kixuan214
缓存redisrabbitmq

    保证多级缓存数据一致性是一个复杂的任务，尤其是在分布式和高并发环境中。以下是一些常见的方法和策略，可以帮助实现多级缓存的数据一致性1.缓存失效策略1.1主动失效在更新数据库时，主动使相关缓存失效。步骤：更新数据库删除或失效缓存publicclassCacheService{privateLocalCachelocalCache;privateRedisCacheredisCache;private
    

    • 

  • redis-shake v4全量增量同步redis数据
nangonghen
redisredis数据库缓存redis-shake

    1概述RedisShake是一个用于处理和迁移Redis数据的工具，github地址是https://github.com/tair-opensource/RedisShake。它提供以下特性：1）Redis兼容性：RedisShake兼容从2.8到7.2的Redis版本，并支持各种部署方式，包括单机，主从，哨兵和集群。2）云服务兼容性：RedisShake与主流云服务提供商提供的流行Redis-
    

    • 

  • redis,codis,云redis
shuff1e

    redis的分布式解决方式--codis（转）https://www.cnblogs.com/softidea/p/5365640.htmlhttps://help.aliyun.com/document_detail/57797.html?spm=5176.173352.925244.2.bF70Gb
    

    • 

  • Redis总结（八）redis单线程还是多线程问题
卢小记

    redis为什么可以支持高并发和它内部的工作模式有不可分割的关系：绝大部分请求是纯粹的内存操作（非常快速）采用单线程,避免了不必要的上下文切换和竞争条件非阻塞IO-IO多路复用Redis客户端对服务端的每次调用都经历了发送命令，执行命令，返回结果三个过程。其中执行命令阶段，由于Redis是单线程来处理命令的，所有到达服务端的命令都不会立刻执行，所有的命令都会进入一个队列中，然后逐个执行，并且多个客
    

    • 

  • Java 使用 Redis
lly202406
开发语言

    Java使用Redis1.引言Redis是一个开源的高性能键值对数据库。它支持多种类型的数据结构，如字符串、列表、集合、散列表等，适用于多种场景，如缓存、消息队列等。Java是一种广泛使用的编程语言，它在企业级应用中有着广泛的应用。在Java应用中，使用Redis可以提高数据访问速度，减轻数据库的压力。本文将介绍如何在Java应用中使用Redis。2.准备工作在开始使用Redis之前，需要确保已经
    

    • 

  • Redis数据结构—跳跃表 skiplist
马卫斌 前端工程师
skiplist

    跳跃表（Skiplist）是Redis中用于实现有序集合（SortedSet）的一种高效数据结构。以下是关于Redis中跳跃表（Skiplist）的关键特性和工作原理的概览：基本概念层级结构：跳跃表通过多层次的链表组成，每一层都是下一层的稀疏视图，顶层最快地遍历整个链表，而底层则是完全连通所有节点的传统链表结构。这样的设计使得查询操作能够快速跳过大量不需要检查的元素。有序集合：每个节点（或称为元素
    

    • 

  • Redis安装详解（单机安装，sentinel哨兵模式，Cluster模式）
dream21st
中间件学习笔记sentinelredisjava

    文章目录1Redis单机安装1.1windows中安装1.2linux中安装2Redis主从复制安装3Redis哨兵模式安装4Springboot项目操作RedisSentinel集群5官方cluster分区搭建5.1部署架构5.2RedisCluster的优势5.3集群搭建6Springboot项目操作Cluster集群1Redis单机安装Redis安装包可以从官网下载，也可以在redis的官方
    

    • 

  • Redis哨兵模式(Sentinel)详解
水木渔樵
Redisredis

    目录文章目录一、Sentinel1.何为Sentinel2.Sentinel启动流程当一个Sentinel启动时，它需要执行以下步骤：2.1初始化服务器2.2使用Sentinel专用代码2.3初始化Sentinel状态2.4初始化Sentinel状态的masters属性2.5创建连向主服务器的网络连接3.Sentinel获取主服务器信息4.Sentinel获取从服务器信息5.Sentinel与主从
    

    • 

  • Redis Sentinel（哨兵）详解
dlwlrma ⥳
Java八股框架redissentinel数据库

    目录一：什么是Sentinel（哨兵）二：Sentinel有什么用1.监控2.故障转移3通知4.配置提供三：Sentinel如何检测master节点宕机1.主观下线2.客观下线四：Sentinel是如何选举出新的master1.slave的优先级2.复制进度3.runid五：如何在sentinel集群中选择出Leader前言：有关Redis的基础知识可以参照我之前写的文章Redis必知必会的知识在
    

    • 

  • sql统计相同项个数并按名次显示
朱辉辉33
javaoracle

    现在有如下这样一个表：
A表
ID Name time
------------------------------
0001 aaa 2006-11-18
0002 ccc 2006-11-18
0003 eee 2006-11-18
0004 aaa 2006-11-18
0005 eee 2006-11-18
0004 aaa 2006-11-18
0002 ccc 20
    

    • 

  • Android+Jquery Mobile学习系列-目录
白糖_
JQuery Mobile

    最近在研究学习基于Android的移动应用开发，准备给家里人做一个应用程序用用。向公司手机移动团队咨询了下，觉得使用Android的WebView上手最快，因为WebView等于是一个内置浏览器，可以基于html页面开发，不用去学习Android自带的七七八八的控件。然后加上Jquery mobile的样式渲染和事件等，就能非常方便的做动态应用了。
 
从现在起，往后一段时间，我打算
    

    • 

  • 如何给线程池命名
daysinsun
线程池

            在系统运行后，在线程快照里总是看到线程池的名字为pool-xx，这样导致很不好定位，怎么给线程池一个有意义的名字呢。参照ThreadPoolExecutor类的ThreadFactory，自己实现ThreadFactory接口，重写newThread方法即可。参考代码如下：
   
public class Named
    

    • 

  • IE 中"HTML Parsing Error:Unable to modify the parent container element before the
周凡杨
html解析errorreadyState

     
错误： IE 中"HTML Parsing Error:Unable to modify the parent container element before the child element is closed"
 
 
现象： 同事之间几个IE 测试情况下，有的报这个错，有的不报。经查询资料后，可归纳以下原因。
    

    • 

  • java上传
g21121
java

    我们在做web项目中通常会遇到上传文件的情况，用struts等框架的会直接用的自带的标签和组件，今天说的是利用servlet来完成上传。
我们这里利用到commons-fileupload组件，相关jar包可以取apache官网下载：http://commons.apache.org/
下面是servlet的代码：
//定义一个磁盘文件工厂
DiskFileItemFactory fact
    

    • 

  • SpringMVC配置学习
510888780
springmvc

    spring MVC配置详解
现在主流的Web MVC框架除了Struts这个主力 外，其次就是Spring MVC了，因此这也是作为一名程序员需要掌握的主流框架，框架选择多了，应对多变的需求和业务时，可实行的方案自然就多了。不过要想灵活运用Spring MVC来应对大多数的Web开发，就必须要掌握它的配置及原理。
　　一、Spring MVC环境搭建：（Spring 2.5.6 + Hi
    

    • 

  • spring mvc-jfreeChart 柱图(1)
布衣凌宇
jfreechart

    第一步：下载jfreeChart包，注意是jfreeChart文件lib目录下的，jcommon-1.0.23.jar和jfreechart-1.0.19.jar两个包即可；
第二步：配置web.xml;
web.xml代码如下
<servlet>
    <servlet-name>jfreechart</servlet-nam
    

    • 

  • 我的spring学习笔记13-容器扩展点之PropertyPlaceholderConfigurer
aijuans
Spring3

    PropertyPlaceholderConfigurer是个bean工厂后置处理器的实现，也就是BeanFactoryPostProcessor接口的一个实现。关于BeanFactoryPostProcessor和BeanPostProcessor类似。我会在其他地方介绍。PropertyPlaceholderConfigurer可以将上下文（配置文件）中的属性值放在另一个单独的标准java P
    

    • 

  • java 线程池使用 Runnable&Callable&Future
antlove
javathreadRunnablecallablefuture

    1. 创建线程池
ExecutorService executorService = Executors.newCachedThreadPool();
 
2. 执行一次线程，调用Runnable接口实现
Future<?> future = executorService.submit(new DefaultRunnable());
System.out.prin
    

    • 

  • XML语法元素结构的总结
百合不是茶
xml树结构

    1.XML介绍1969年   gml (主要目的是要在不同的机器进行通信的数据规范)1985年   sgml  standard generralized markup language1993年   html(www网)1998年  xml   extensible markup language
    

    • 

  • 改变eclipse编码格式
bijian1013
eclipse编码格式

    1.改变整个工作空间的编码格式
        改变整个工作空间的编码格式，这样以后新建的文件也是新设置的编码格式。
        Eclipse->window->preferences->General->workspace-
    

    • 

  • javascript中return的设计缺陷
bijian1013
JavaScriptAngularJS

    代码1：
<script>
var gisService = (function(window)
{
return
{
name:function ()
{
alert(1);
}
};
})(this);
gisService.name();
&l
    

    • 

  • 【持久化框架MyBatis3八】Spring集成MyBatis3
bit1129
Mybatis3

    pom.xml配置
Maven的pom中主要包括：
MyBatis
MyBatis-Spring
Spring
MySQL-Connector-Java
Druid
applicationContext.xml配置  
<?xml version="1.0" encoding="UTF-8"?>
&
    

    • 

  • java web项目启动时自动加载自定义properties文件
bitray
javaWeb监听器相对路径

    创建一个类
public class ContextInitListener implements ServletContextListener
使得该类成为一个监听器。用于监听整个容器生命周期的，主要是初始化和销毁的。
类创建后要在web.xml配置文件中增加一个简单的监听器配置，即刚才我们定义的类。
<listener>
<des
    

    • 

  • 用nginx区分文件大小做出不同响应
ronin47

    昨晚和前21v的同事聊天，说到我离职后一些技术上的更新。其中有个给某大客户(游戏下载类)的特殊需求设计，因为文件大小差距很大——估计是大版本和补丁的区别——又走的是同一个域名，而squid在响应比较大的文件时，尤其是初次下载的时候，性能比较差，所以拆成两组服务器，squid服务于较小的文件，通过pull方式从peer层获取，nginx服务于较大的文件，通过push方式由peer层分发同步。外部发布
    

    • 

  • java-67-扑克牌的顺子.从扑克牌中随机抽5张牌，判断是不是一个顺子，即这5张牌是不是连续的.2-10为数字本身，A为1，J为11，Q为12，K为13，而大
bylijinnan
java

    package com.ljn.base;
import java.util.Arrays;
import java.util.Random;
public class ContinuousPoker {
/**
* Q67 扑克牌的顺子 从扑克牌中随机抽5张牌，判断是不是一个顺子，即这5张牌是不是连续的。
* 2-10为数字本身，A为1，J为1
    

    • 

  • 翟鸿燊老师语录
ccii
翟鸿燊

    一、国学应用智慧TAT之亮剑精神A
1. 角色就是人格
    就像你一回家的时候，你一进屋里面，你已经是儿子，是姑娘啦，给老爸老妈倒怀水吧，你还觉得你是老总呢？还拿派呢？就像今天一样，你们往这儿一坐，你们之间是什么，同学，是朋友。
    还有下属最忌讳的就是领导向他询问情况的时候，什么我不知道，我不清楚，该你知道的你凭什么不知道
    

    • 

  • [光速与宇宙]进行光速飞行的一些问题
comsci
问题

    
     在人类整体进入宇宙时代，即将开展深空宇宙探索之前，我有几个猜想想告诉大家
    仅仅是猜想。。。未经官方证实
     1：要在宇宙中进行光速飞行，必须首先获得宇宙中的航行通行证，而这个航行通行证并不是我们平常认为的那种带钢印的证书，是什么呢？ 下面我来告诉
    

    • 

  • oracle undo解析
cwqcwqmax9
oracle

    oracle undo解析2012-09-24 09:02:01     我来说两句       作者：虫师收藏    我要投稿
Undo是干嘛用的？         &nb
    

    • 

  • java中各种集合的详细介绍
dashuaifu
java集合

    一，java中各种集合的关系图 Collection       接口的接口     对象的集合  ├ List           子接口   &n
    

    • 

  • 卸载windows服务的方法
dcj3sjt126com
windowsservice

    卸载Windows服务的方法
在Windows中，有一类程序称为服务，在操作系统内核加载完成后就开始加载。这里程序往往运行在操作系统的底层，因此资源占用比较大、执行效率比较高，比较有代表性的就是杀毒软件。但是一旦因为特殊原因不能正确卸载这些程序了，其加载在Windows内的服务就不容易删除了。即便是删除注册表中的相 应项目，虽然不启动了，但是系统中仍然存在此项服务，只是没有加载而已。如果安装其他
    

    • 

  • Warning: The Copy Bundle Resources build phase contains this target's Info.plist
dcj3sjt126com
iosxcode

     
 
http://developer.apple.com/iphone/library/qa/qa2009/qa1649.html
Excerpt:
You are getting this warning because you probably added your Info.plist file to your Copy Bundle 
    

    • 

  • 2014之C++学习笔记（一）
Etwo
C++EtwoEtwoiterator迭代器

            已经有很长一段时间没有写博客了，可能大家已经淡忘了Etwo这个人的存在，这一年多以来，本人从事了AS的相关开发工作，但最近一段时间，AS在天朝的没落，相信有很多码农也都清楚，现在的页游基本上达到饱和，手机上的游戏基本被unity3D与cocos占据，AS基本没有容身之处。so。。。最近我并不打算直接转型
    

    • 

  • js跨越获取数据问题记录
haifengwuch
jsonpjsonAjax

    js的跨越问题，普通的ajax无法获取服务器返回的值。
  第一种解决方案，通过getson，后台配合方式，实现。
Java后台代码：
protected void doPost(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
String ca
    

    • 

  • 蓝色jQuery导航条
ini
JavaScripthtmljqueryWebhtml5

    效果体验：http://keleyi.com/keleyi/phtml/jqtexiao/39.htmHTML文件代码：
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>jQuery鼠标悬停上下滑动导航条 - 柯乐义<
    

    • 

  • linux部署jdk,tomcat,mysql
kerryg
jdktomcatlinuxmysql

    1、安装java环境jdk:
    一般系统都会默认自带的JDK,但是不太好用，都会卸载了，然后重新安装。
   1.1）、卸载：
     （rpm -qa :查询已经安装哪些软件包；
       rmp -q 软件包：查询指定包是否已
    

    • 

  • DOMContentLoaded VS onload VS onreadystatechange
mutongwu
jqueryjs

    1. DOMContentLoaded 在页面html、script、style加载完毕即可触发，无需等待所有资源（image/iframe）加载完毕。（IE9+）
2. onload是最早支持的事件，要求所有资源加载完毕触发。
3. onreadystatechange 开始在IE引入，后来其它浏览器也有一定的实现。涉及以下 document , applet, embed, fra
    

    • 

  • sql批量插入数据
qifeifei
批量插入

    hi，
  自己在做工程的时候，遇到批量插入数据的数据修复场景。我的思路是在插入前准备一个临时表，临时表的整理就看当时的选择条件了，临时表就是要插入的数据集，最后再批量插入到数据库中。
  
WITH tempT AS (
SELECT
item_id AS combo_id,
item_id,
now() AS create_date
FROM
a
    

    • 

  • log4j打印日志文件 如何实现相对路径到 项目工程下
thinkfreer
Weblog4j应用服务器日志

    最近为了实现统计一个网站的访问量，记录用户的登录信息，以方便站长实时了解自己网站的访问情况，选择了Apache 的log4j,但是在选择相对路径那块 卡主了，X度了好多方法(其实大多都是一样的内用，还一个字都不差的)，都没有能解决问题，无奈搞了2天终于解决了，与大家分享一下
需求：
用户登录该网站时，把用户的登录名,ip,时间。统计到一个txt文档里，以方便其他系统调用此txt。项目名
    

    • 

  • linux下mysql-5.6.23.tar.gz安装与配置
笑我痴狂
mysqllinuxunix

    1.卸载系统默认的mysql
[root@localhost ~]# rpm -qa | grep mysql
mysql-libs-5.1.66-2.el6_3.x86_64
mysql-devel-5.1.66-2.el6_3.x86_64
mysql-5.1.66-2.el6_3.x86_64
[root@localhost ~]# rpm -e mysql-libs-5.1
    

    •