com.iih5.smartorm.cache.Redis Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of smart-orm Show documentation
这是一个ORM模型组件，可快速实现SQL操作,目前支持mysql,NoSQL库目前支持Redis
There is a newer version: 3.1
package com.iih5.smartorm.cache;

import redis.clients.jedis.*;
import redis.clients.jedis.params.geo.GeoRadiusParam;
import redis.clients.jedis.params.sortedset.ZAddParams;
import redis.clients.jedis.params.sortedset.ZIncrByParams;

import java.util.List;
import java.util.Map;
import java.util.Set;

public class Redis {
    private static RedisExecutor defaultExecutor = null;
    static {
        defaultExecutor = RedisExecutor.use();
    }
     public static RedisExecutor use(String jedisPool){
        return RedisExecutor.use(jedisPool);
    }

    public static int getNumActivePool() {
        return defaultExecutor.getNumActivePool();
    }

    public static int getNumIdlePool() {
        return defaultExecutor.getNumIdlePool();
    }

    public static int getNumWaitersPool() {
        return defaultExecutor.getNumWaitersPool();
    }
    public static String set(String key, String value) {
        return defaultExecutor.set(key, value);
    }

     public static String set(String key, String value, String nxxx, String expx, long time) {
        return defaultExecutor.set(key, value, nxxx, expx, time);
    }

     public static String set(String key, String value, String nxxx) {
        return defaultExecutor.set(key, value, nxxx);
    }

     public static String get(String key) {
        return defaultExecutor.get(key);
    }

     public static Boolean exists(String key) {
        return defaultExecutor.exists(key);
    }

     public static Long persist(String key) {
        return   defaultExecutor.persist(key);
    }

     public static String type(String key) {
        return  defaultExecutor.type(key);
    }

     public static Long expire(String key, int seconds) {
        return  defaultExecutor.expire(key, seconds);
    }

     public static Long pexpire(String key, long milliseconds) {
        return  defaultExecutor.pexpire(key, milliseconds);
    }

     public static Long expireAt(String key, long unixTime) {
        return  defaultExecutor.expireAt(key, unixTime);
    }

     public static Long pexpireAt(String key, long millisecondsTimestamp) {
        return defaultExecutor.pexpireAt(key,millisecondsTimestamp);
    }

     public static Long ttl(String key) {
        return defaultExecutor.ttl(key);
    }

     public static Long pttl(String key) {
        return defaultExecutor.pttl(key);
    }

     public static Boolean setbit(String key, long offset, boolean value) {
        return defaultExecutor.setbit(key,offset,value);
    }

     public static Boolean setbit(String key, long offset, String value) {
        return defaultExecutor.setbit(key, offset, value);
    }

     public static Boolean getbit(String key, long offset) {
        return defaultExecutor.getbit(key, offset);
    }

     public static Long setrange(String key, long offset, String value) {
        return defaultExecutor.setrange(key, offset, value);
    }

     public static String getrange(String key, long startOffset, long endOffset) {
        return defaultExecutor.getrange(key, startOffset, endOffset);
    }

     public static String getSet(String key, String value) {
        return defaultExecutor.getSet(key,value);
    }

     public static Long setnx(String key, String value) {
        return defaultExecutor.setnx(key,value);
    }

     public static String setex(String key, int seconds, String value) {
        return defaultExecutor.setex(key, seconds, value);
    }

     public static String psetex(String key, long milliseconds, String value) {
        return defaultExecutor.psetex(key,milliseconds,value);
    }

     public static Long decrBy(String key, long integer) {
        return defaultExecutor.decrBy(key, integer);
    }

     public static Long decr(String key) {
        return defaultExecutor.decr(key);
    }

     public static Long incrBy(String key, long integer) {
        return defaultExecutor.incrBy(key, integer);
    }

     public static Double incrByFloat(String key, double value) {
        return defaultExecutor.incrByFloat(key, value);
    }

     public static Long incr(String key) {
        return defaultExecutor.incr(key);
    }

     public static Long append(String key, String value) {
        return defaultExecutor.append(key, value);
    }

     public static String substr(String key, int start, int end) {
        return defaultExecutor.substr(key,start,end);
    }

     public static Long hset(String key, String field, String value) {
        return defaultExecutor.hset(key,field,value);
    }

     public static String hget(String key, String field) {
        return defaultExecutor.hget(key, field);
    }

     public static Long hsetnx(String key, String field, String value) {
        return defaultExecutor.hsetnx(key, field, value);
    }

     public static String hmset(String key, Map hash) {
        return defaultExecutor.hmset(key, hash);
    }

     public static List hmget(String key, String... fields) {
        return defaultExecutor.hmget(key, fields);
    }

     public static Long hincrBy(String key, String field, long value) {
        return defaultExecutor.hincrBy(key, field, value);
    }

     public static Double hincrByFloat(String key, String field, double value) {
        return defaultExecutor.hincrByFloat(key, field, value);
    }

     public static Boolean hexists(String key, String field) {
        return defaultExecutor.hexists(key,field);
    }

     public static Long hdel(String key, String... field) {
        return defaultExecutor.hdel(key,field);
    }

     public static Long hlen(String key) {
        return defaultExecutor.hlen(key);
    }

     public static Set hkeys(String key) {
        return defaultExecutor.hkeys(key);
    }

     public static List hvals(String key) {
        return defaultExecutor.hvals(key);
    }

     public static Map hgetAll(String key) {
        return defaultExecutor.hgetAll(key);
    }

     public static Long rpush(String key, String... string) {
        return defaultExecutor.rpush(key, string);
    }

     public static Long lpush(String key, String... string) {
        return defaultExecutor.lpush(key, string);
    }

     public static Long llen(String key) {
        return defaultExecutor.llen(key);
    }

     public static List lrange(String key, long start, long end) {
        return defaultExecutor.lrange(key, start, end);
    }

     public static String ltrim(String key, long start, long end) {
        return defaultExecutor.ltrim(key, start, end);
    }

     public static String lindex(String key, long index) {
        return defaultExecutor.lindex(key, index);
    }

     public static String lset(String key, long index, String value) {
        return defaultExecutor.lset(key, index, value);
    }

     public static Long lrem(String key, long count, String value) {
        return defaultExecutor.lrem(key, count, value);
    }

     public static String lpop(String key) {
        return defaultExecutor.lpop(key);
    }

     public static String rpop(String key) {
        return defaultExecutor.rpop(key);
    }

     public static Long sadd(String key, String... member) {
        return defaultExecutor.sadd(key, member);
    }

     public static Set smembers(String key) {
        return defaultExecutor.smembers(key);
    }

     public static Long srem(String key, String... member) {
        return defaultExecutor.srem(key, member);
    }

     public static String spop(String key) {
        return defaultExecutor.spop(key);
    }

     public static Set spop(String key, long count) {
        return defaultExecutor.spop(key, count);
    }

     public static Long scard(String key) {
        return defaultExecutor.scard(key);
    }

     public static Boolean sismember(String key, String member) {
        return defaultExecutor.sismember(key, member);
    }

     public static String srandmember(String key) {
        return defaultExecutor.srandmember(key);
    }

     public static List srandmember(String key, int count) {
        return defaultExecutor.srandmember(key, count);
    }

     public static Long strlen(String key) {
        return defaultExecutor.strlen(key);
    }

     public static Long zadd(String key, double score, String member) {
        return defaultExecutor.zadd(key, score, member);
    }

     public static Long zadd(String key, double score, String member, ZAddParams params) {
        return defaultExecutor.zadd(key, score, member, params);
    }

     public static Long zadd(String key, Map scoreMembers) {
        return defaultExecutor.zadd(key, scoreMembers);
    }

     public static Long zadd(String key, Map scoreMembers, ZAddParams params) {
        return defaultExecutor.zadd(key, scoreMembers, params);
    }

     public static Set zrange(String key, long start, long end) {
        return defaultExecutor.zrange(key, start, end);
    }

     public static Long zrem(String key, String... member) {
        return defaultExecutor.zrem(key, member);
    }

     public static Double zincrby(String key, double score, String member) {
        return defaultExecutor.zincrby(key, score, member);
    }

     public static Double zincrby(String key, double score, String member, ZIncrByParams params) {
        return defaultExecutor.zincrby(key, score, member, params);
    }

     public static Long zrank(String key, String member) {
        return defaultExecutor.zrank(key, member);
    }

     public static Long zrevrank(String key, String member) {
        return defaultExecutor.zrevrank(key, member);
    }

     public static Set zrevrange(String key, long start, long end) {
        return defaultExecutor.zrevrange(key, start, end);
    }

     public static Set zrangeWithScores(String key, long start, long end) {
        return defaultExecutor.zrangeWithScores(key, start, end);
    }

     public static Set zrevrangeWithScores(String key, long start, long end) {
        return defaultExecutor.zrevrangeWithScores(key, start, end);
    }

     public static Long zcard(String key) {
        return defaultExecutor.zcard(key);
    }

     public static Double zscore(String key, String member) {
        return defaultExecutor.zscore(key, member);
    }

     public static List sort(String key) {
        return defaultExecutor.sort(key);
    }

     public static List sort(String key, SortingParams sortingParameters) {
        return defaultExecutor.sort(key, sortingParameters);
    }

     public static Long zcount(String key, double min, double max) {
        return defaultExecutor.zcount(key, min, max);
    }

     public static Long zcount(String key, String min, String max) {
        return defaultExecutor.zcount(key, min, max);
    }

     public static Set zrangeByScore(String key, double min, double max) {
        return defaultExecutor.zrangeByScore(key, min, max);
    }

     public static Set zrangeByScore(String key, String min, String max) {
        return defaultExecutor.zrangeByScore(key, min, max);
    }

     public static Set zrevrangeByScore(String key, double max, double min) {
        return defaultExecutor.zrevrangeByScore(key, max, min);
    }

     public static Set zrangeByScore(String key, double min, double max, int offset, int count) {
        return defaultExecutor.zrangeByScore(key, min, max, offset, count);
    }

     public static Set zrevrangeByScore(String key, String max, String min) {
        return defaultExecutor.zrevrangeByScore(key, max, min);
    }

     public static Set zrangeByScore(String key, String min, String max, int offset, int count) {
        return defaultExecutor.zrangeByScore(key, min, max, offset, count);
    }

     public static Set zrevrangeByScore(String key, double max, double min, int offset, int count) {
        return defaultExecutor.zrevrangeByScore(key, max, min, offset, count);
    }


     public static Long zremrangeByScore(String key, double start, double end) {
        return defaultExecutor.zremrangeByScore(key, start, end);
    }

     public static Long zremrangeByScore(String key, String start, String end) {
        return defaultExecutor.zremrangeByScore(key, start, end);
    }

     public static Long zlexcount(String key, String min, String max) {
        return defaultExecutor.zlexcount(key, min, max);
    }

     public static Set zrangeByLex(String key, String min, String max) {
        return defaultExecutor.zrangeByLex(key, min, max);
    }

     public static Set zrangeByLex(String key, String min, String max, int offset, int count) {
        return defaultExecutor.zrangeByLex(key, min, max, offset, count);
    }

     public static Set zrevrangeByLex(String key, String max, String min) {
        return defaultExecutor.zrevrangeByLex(key, max, min);
    }

     public static Set zrevrangeByLex(String key, String max, String min, int offset, int count) {
        return defaultExecutor.zrevrangeByLex(key, max, min, offset, count);
    }

     public static Long zremrangeByLex(String key, String min, String max) {
        return defaultExecutor.zremrangeByLex(key, min, max);
    }

     public static Long linsert(String key, BinaryClient.LIST_POSITION where, String pivot, String value) {
        return defaultExecutor.linsert(key, where, pivot, value);
    }

     public static Long lpushx(String key, String... string) {
        return defaultExecutor.lpushx(key, string);
    }

     public static Long rpushx(String key, String... string) {
        return defaultExecutor.rpushx(key, string);
    }

     public static List blpop(int timeout, String key) {
        return defaultExecutor.blpop(timeout, key);
    }


     public static List brpop(int timeout, String key) {
        return defaultExecutor.brpop(timeout,key);
    }

     public static Long del(String key) {
        return defaultExecutor.del(key);
    }

     public static String echo(String string) {
        return defaultExecutor.echo(string);
    }

     public static Long move(String key, int dbIndex) {
        return defaultExecutor.move(key, dbIndex);
    }

     public static Long bitcount(String key) {
        return defaultExecutor.bitcount(key);
    }

     public static Long bitcount(String key, long start, long end) {
        return defaultExecutor.bitcount(key, start, end);
    }

     public static Long bitpos(String key, boolean value) {
        return defaultExecutor.bitpos(key, value);
    }

     public static Long bitpos(String key, boolean value, BitPosParams params) {
        return defaultExecutor.bitpos(key, value, params);
    }

     public static Long geoadd(String key, double longitude, double latitude, String member) {
        return defaultExecutor.geoadd(key, longitude, latitude, member);
    }

     public static Long geoadd(String key, Map memberCoordinateMap) {
        return defaultExecutor.geoadd(key, memberCoordinateMap);
    }

     public static Double geodist(String key, String member1, String member2) {
        return defaultExecutor.geodist(key, member1, member2);
    }

     public static Double geodist(String key, String member1, String member2, GeoUnit unit) {
        return defaultExecutor.geodist(key, member1, member2, unit);
    }

     public static List geohash(String key, String... members) {
        return defaultExecutor.geohash(key, members);
    }

     public static List geopos(String key, String... members) {
        return defaultExecutor.geopos(key, members);
    }

     public static List georadius(String key, double longitude, double latitude, double radius, GeoUnit unit) {
        return defaultExecutor.georadius(key, longitude, latitude, radius, unit);
    }

     public static List georadius(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param) {
        return defaultExecutor.georadius(key, longitude, latitude, radius, unit, param);
    }

     public static List georadiusByMember(String key, String member, double radius, GeoUnit unit) {
        return defaultExecutor.georadiusByMember(key, member, radius, unit);
    }

     public static List georadiusByMember(String key, String member, double radius, GeoUnit unit, GeoRadiusParam param) {
        return defaultExecutor.georadiusByMember(key, member, radius, unit, param);
    }

     public static Long del(String... keys) {
        return defaultExecutor.del(keys);
    }

     public static Long exists(String... keys) {
        return defaultExecutor.exists(keys);
    }

     public static List blpop(int timeout, String... keys) {
        return defaultExecutor.blpop(timeout, keys);
    }

     public static List brpop(int timeout, String... keys) {
        return defaultExecutor.brpop(timeout, keys);
    }

     public static List blpop(String... args) {
        return defaultExecutor.blpop(args);
    }

     public static List brpop(String... args) {
        return defaultExecutor.brpop(args);
    }

     public static Set keys(String pattern) {
        return defaultExecutor.keys(pattern);
    }

     public static List mget(String... keys) {
        return defaultExecutor.mget(keys);
    }

     public static String mset(String... keysvalues) {
        return defaultExecutor.mset(keysvalues);
    }

     public static Long msetnx(String... keysvalues) {
        return defaultExecutor.msetnx(keysvalues);
    }

     public static String rename(String oldkey, String newkey) {
        return defaultExecutor.rename(oldkey, newkey);
    }

     public static Long renamenx(String oldkey, String newkey) {
        return defaultExecutor.renamenx(oldkey, newkey);
    }

     public static String rpoplpush(String srckey, String dstkey) {
        return defaultExecutor.rpoplpush(srckey, dstkey);
    }

     public static Set sdiff(String... keys) {
        return defaultExecutor.sdiff(keys);
    }

     public static Long sdiffstore(String dstkey, String... keys) {
        return defaultExecutor.sdiffstore(dstkey, keys);
    }

     public static Set sinter(String... keys) {
        return defaultExecutor.sinter(keys);
    }

     public static Long sinterstore(String dstkey, String... keys) {
        return defaultExecutor.sinterstore(dstkey, keys);
    }

     public static Long smove(String srckey, String dstkey, String member) {
        return defaultExecutor.smove(srckey, dstkey, member);
    }

     public static Long sort(String key, SortingParams sortingParameters, String dstkey) {
        return defaultExecutor.sort(key, dstkey);
    }

     public static Long sort(String key, String dstkey) {
        return defaultExecutor.sort(key, dstkey);
    }

     public static Set sunion(String... keys) {
        return defaultExecutor.sunion(keys);
    }

     public static Long sunionstore(String dstkey, String... keys) {
        return defaultExecutor.sunionstore(dstkey, keys);
    }

     public static String watch(String... keys) {
        return defaultExecutor.watch(keys);
    }

     public static String unwatch() {
        return defaultExecutor.unwatch();
    }

     public static Long zinterstore(String dstkey, String... sets) {
        return defaultExecutor.zinterstore(dstkey, sets);
    }

     public static Long zinterstore(String dstkey, ZParams params, String... sets) {
        return defaultExecutor.zinterstore(dstkey, params, sets);
    }

     public static Long zunionstore(String dstkey, String... sets) {
        return defaultExecutor.zunionstore(dstkey, sets);
    }

     public static Long zunionstore(String dstkey, ZParams params, String... sets) {
        return defaultExecutor.zunionstore(dstkey, params, sets);
    }

     public static String brpoplpush(String source, String destination, int timeout) {
        return defaultExecutor.brpoplpush(source, destination, timeout);
    }

     public static Long publish(String channel, String message) {
        return defaultExecutor.publish(channel, message);
    }

     public static void subscribe(final JedisPubSub jedisPubSub, final String... channels) {
         Thread thread=new Thread(new Runnable() {
             public void run() {
                 while (true) {
                     try {
                         defaultExecutor.subscribe(jedisPubSub, channels);
                     } catch (Exception e) {
                         try {
                             Thread.sleep(1000);
                         } catch (InterruptedException e1) {
                             e1.printStackTrace();
                         }
                     }
                 }
             }
         });
         thread.start();
    }

     public static void psubscribe(final JedisPubSub jedisPubSub, final String... patterns) {

         Thread thread=new Thread(new Runnable() {
             public void run() {
                 while (true) {
                     try {
                         defaultExecutor.psubscribe(jedisPubSub, patterns);
                     } catch (Exception e) {
                         try {
                             Thread.sleep(1200);
                         } catch (InterruptedException e1) {
                             e1.printStackTrace();
                         }
                     }
                 }
             }
         });
         thread.start();
    }

     public static String randomKey() {
        return defaultExecutor.randomKey();
    }

     public static Long bitop(BitOP op, String destKey, String... srcKeys) {
        return defaultExecutor.bitop(op, destKey, srcKeys);
    }


    //-----------------------------二进制----------------------------------------
    public static String set(byte[] key, byte[] value) {
        return defaultExecutor.set(key, value);
    }

    public static String set(byte[] key, byte[] value, byte[] nxxx, byte[] expx, long time) {
        return defaultExecutor.set(key, value, nxxx, expx, time);
    }

    public static byte[] get(byte[] key) {
        return defaultExecutor.get(key);
    }

    public static Long exists(byte[]... keys) {
        return defaultExecutor.exists(keys);
    }

    public static Boolean exists(byte[] key) {
        return defaultExecutor.exists(key);
    }

    public static Long del(byte[]... keys) {
        return defaultExecutor.del(keys);
    }

    public static Long del(byte[] key) {
        return defaultExecutor.del(key);
    }

    public static Set keys(byte[] pattern) {
        return defaultExecutor.keys(pattern);
    }

    public static Long expire(byte[] key, int seconds) {
        return defaultExecutor.expire(key, seconds);
    }

    public static Long ttl(byte[] key) {
        return defaultExecutor.ttl(key);
    }

    public static byte[] getSet(byte[] key, byte[] value) {
        return defaultExecutor.getSet(key, value);
    }

    public static List mget(byte[]... keys) {
        return defaultExecutor.mget(keys);
    }

    public static Long append(byte[] key, byte[] value) {
        return defaultExecutor.append(key, value);
    }

    public static byte[] substr(byte[] key, int start, int end) {
        return defaultExecutor.substr(key, start, end);
    }

    public static Long hset(byte[] key, byte[] field, byte[] value) {
        return defaultExecutor.hset(key, field, value);
    }

    public static byte[] hget(byte[] key, byte[] field) {
        return defaultExecutor.hget(key, field);
    }
    public static Boolean hexists(byte[] key, byte[] field) {
        return defaultExecutor.hexists(key, field);
    }

    public static Long hdel(byte[] key, byte[]... fields) {
        return defaultExecutor.hdel(key, fields);
    }

    public static Long hlen(byte[] key) {
        return defaultExecutor.hlen(key);
    }

    public static Set hkeys(byte[] key) {
        return defaultExecutor.hkeys(key);
    }

    public static List hvals(byte[] key) {
        return defaultExecutor.hvals(key);
    }

    public static Map hgetAll(byte[] key) {
        return defaultExecutor.hgetAll(key);
    }

}