文档章节

RedisSingleUtils 工具类

spinachgit
 spinachgit
发布于 2017/07/20 16:53
字数 2316
阅读 2
收藏 0
点赞 0
评论 0

RedisSingleUtils.java 

package com.common.utils;

import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.ResourceBundle;
import java.util.Set;

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

import com.ch.fm.system.dictionary.entity.DictionaryDetailEntity;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

/**
 * <p>
 *  redis工具类
 * </p>
 * @author why
 * @date 2016-7-20上午11:12:28
 */
public class RedisSingleUtils {
    public static Logger  logger = LoggerFactory.getLogger(RedisSingleUtils.class);
    private static JedisPool jedisPool = null;

    static {
        //从属性文件读取配置
        ResourceBundle bundle = ResourceBundle.getBundle("conf.system.system",Locale.CHINESE);
        String host = bundle.getString("redis.host");
        String port = bundle.getString("redis.port");
        int index = StrUtil.isNullOrBlank(bundle.getString("redis.index"))?Integer.valueOf(bundle.getString("redis.index")):0;
        String auth = null; //bundle.getString("redis.auth");

        try {
            JedisPoolConfig config = new JedisPoolConfig();
            //config.setMaxTotal(500);
            config.setMaxIdle(50);
            //config.setMaxWaitMillis(1000);
            config.setMaxWait(1000);
            config.setTestOnBorrow(true);
            // 在还回给pool时,是否提前进行validate操作
            config.setTestOnReturn(true);
            //连接池设置
            jedisPool = new JedisPool(config, host, Integer.parseInt(port), 1800000, auth, index);

        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        }
    }
    
    /**
     * <p>
     *  获得REDIS客户端
     * </p>
     * @author wanghuihui
     * @date 2017-7-20下午1:40:08
     * @return
     */
    public synchronized static Jedis getJedis() {
        try {
            if (jedisPool != null) {
                Jedis resource = jedisPool.getResource();
                return resource;
            } else {
                return null;
            }
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
            return null;
        }
    }

    /**
     * 释放jedis资源
     * 
     * @param jedis
     */
    public static void closeJedis(final Jedis jedis) {
        if (jedis != null) {
            jedisPool.returnResource(jedis);
            //jedis.close();
        }
    }
    
    /**
     * <p>
     *  获得KEY所指定的对象。
     * </p>
     * @author wanghuihui
     * @date 2017-7-14下午4:21:14
     * @param key
     */
    public static Object getObjectByKey(String key){
        Jedis jedis = null;
        // 从池中获取一个jedis实例
        try {
            jedis = getJedis();
            String type = jedis.type(key);
            if("string".equalsIgnoreCase(type)){
                return jedis.get(key);
            }else if("hash".equalsIgnoreCase(type) || "map".equalsIgnoreCase(type)){
                //map对应的类型 相当于 redis中的hash
                return jedis.hgetAll(key);
            }else if("list".equalsIgnoreCase(type)){
                Long size = jedis.llen(key);
                return jedis.lrange(key, 0, size);
            }else if("set".equalsIgnoreCase(type)){
                return jedis.smembers(key);
            }else if("zset".equalsIgnoreCase(type)){
                //有序结果集和无序结果集是一样的,都是SET
                //Long size = jedis.zrank(key, member)(key);
                 return jedis.zrange(key, 0, 10);
            }else{
                return null;
            }
        } catch (Exception e) {
            // 销毁对象
            jedisPool.returnBrokenResource(jedis);
            logger.error(e.getMessage(), e);
        } finally {
            // 还回到连接池
            closeJedis(jedis);
        }
        return null;
    }
    
    /**
     * <p>
     *  获得KEY所指定的对象。
     * </p>
     * @author wanghuihui
     * @date 2017-7-20下午3:09:13
     * @param key 键
     * @param value 值
     * @param isCover 如果已经存在KEY:是否覆盖
     * @return
     */
    public static  Object setObjectByKey(String key,Object value,boolean isCover){
        if(null == key || "".equals(key) || key.isEmpty()){
            logger.info("key不能空!");
            return false;
        }
        if(null == value || "".equals(value)){
            logger.info("value不能空!");
            return false;
        }
        Jedis jedis = null;
        // 从池中获取一个jedis实例
        try {
            jedis = getJedis();
            boolean isExists = jedis.exists(key);
            if(isExists && isCover){
                jedis.del(key);
            }
            String type = jedis.type(key);
            
            if(value instanceof String){//字符串处理
                if(isExists && !isCover && !"string".equals(type)){
                    throw new RuntimeException("类型不匹配!不能添加");
                }else{
                    jedis.set(key, value.toString());
                    return true;
                }
            }else if(value instanceof List){//LIST处理
                if(isExists && !isCover && !"list".equals(type)){
                    throw new RuntimeException("类型不匹配!不能添加");
                }else{
                    List<Object> list = (List)value;
                    if(null == list || list.size()==0){
                        throw new RuntimeException("对象集合为空!");
                    }
                    for(Object obj:list){
                        String temp = JsonUtil.getJSONString(obj);
                        jedis.lpush(key,temp);
                    }
                    return true;
                }
            }else if(value instanceof Map){//MAP处理
                if(isExists && !isCover && !"hash".equals(type)){
                    throw new RuntimeException("类型不匹配!不能添加");
                }
                Map map = (Map)value;
                if(null == map || map.size()==0){
                    throw new RuntimeException("对象集合为空!");
                }
                jedis.hmset(key, map);
                return true;
            }else if(value instanceof Set){//set处理
                if(isExists && !isCover && !"set".equals(type)){
                    throw new RuntimeException("类型不匹配!不能添加");
                }
                Set set = (Set)value;
                if(null == set || set.size()==0){
                    throw new RuntimeException("对象集合为空!");
                }
                Iterator iterator = set.iterator();
                if(iterator.hasNext()){
                    Object obj = iterator.next();
                    jedis.sadd(key, JsonUtil.getJSONString(obj));
                }
                return true;
            }else{
                jedis.set(key, JsonUtil.getJSONString(value));
                return true;
            }
        } catch (Exception e) {
            // 销毁对象
            jedisPool.returnBrokenResource(jedis);
            logger.error(e.getMessage(), e);
        } finally {
            // 还回到连接池
            closeJedis(jedis);
        }
        return null;
    }
    
    /**
     * <p>
     *  获得KEY所指定的对象。
     * </p>
     * @author wanghuihui
     * @date 2017-7-20下午3:09:13
     * @param key 键
     * @param value 值
     * @param isCover 如果已经存在KEY:是否覆盖
     * @return
     */
    public static  Object setObjectToStrByKey(String key,Object value,boolean isCover){
        if(null == key || "".equals(key) || key.isEmpty()){
            logger.info("key不能空!");
            return false;
        }
        if(null == value || "".equals(value)){
            logger.info("value不能空!");
            return false;
        }
        Jedis jedis = null;
        // 从池中获取一个jedis实例
        try {
            jedis = getJedis();
            boolean isExists = jedis.exists(key);
            if(isExists && isCover){
                jedis.del(key);
            }
            jedis.set(key, JsonUtil.getJSONString(value));
            return true;
        } catch (Exception e) {
            // 销毁对象
            jedisPool.returnBrokenResource(jedis);
            logger.error(e.getMessage(), e);
        } finally {
            // 还回到连接池
            closeJedis(jedis);
        }
        return null;
    }
    
    /**
     * <p>
     *  str put
     * </p>
     * @author wanghuihui
     * @date 2017-7-14下午2:43:58
     * @param key
     * @param value
     */
    public static void strPut(String key, String value) {
        Jedis jedis = null;
        // 从池中获取一个jedis实例
        try {
            jedis = getJedis();
            jedis.set(key, value);
        } catch (Exception e) {
            // 销毁对象
            jedisPool.returnBrokenResource(jedis);
            logger.error(e.getMessage(), e);
        } finally {
            // 还回到连接池
            closeJedis(jedis);
        }
    }
    
    /**
     * <p>
     *  获得KEY对应的字符串
     * </p>
     * @author wanghuihui
     * @date 2017-7-20下午1:40:50
     * @param key
     * @return
     */
    public static String strGet(String key) {
        String value = "";
        Jedis jedis = null;
        // 从池中获取一个jedis实例
        try {
            jedis = getJedis();
            value = jedis.get(key);
        } catch (Exception e) {
            // 销毁对象
            jedisPool.returnBrokenResource(jedis);
            logger.error(e.getMessage(), e);
        } finally {
            // 还回到连接池
            closeJedis(jedis);
        }
        return value;
    }
    
    /**
     * <p>
     *  删除KEY对应的字符串
     * </p>
     * @author wanghuihui
     * @date 2017-7-20下午1:40:50
     * @param key
     * @return
     */
    public static Long strDel(String... key) {
        Long value = 0L;
        Jedis jedis = null;
        // 从池中获取一个jedis实例
        try {
            jedis = getJedis();
            value = jedis.del(key);
        } catch (Exception e) {
            // 销毁对象
            jedisPool.returnBrokenResource(jedis);
            logger.error(e.getMessage(), e);
        } finally {
            // 还回到连接池
            closeJedis(jedis);
        }
        return value;
    }
    
    /**
     * <p>
     *  发布订阅
     * </p>
     * @author wanghuihui
     * @date 2017-7-20下午1:41:38
     * @param theme
     * @param message
     */
    public static void publish(String theme, String message) {
        Jedis jedis = null;
        // 从池中获取一个jedis实例
        try {
            jedis = getJedis();
            jedis.publish(theme, message);
        } catch (Exception e) {
            // 销毁对象
            jedisPool.returnBrokenResource(jedis);
            logger.error(e.getMessage(), e);
        } finally {
            // 还回到连接池
            closeJedis(jedis);
        }
    }
    
    /**
     * <p>
     *  设置过期时间
     * </p>
     * @author wanghuihui
     * @date 2017-7-20下午1:41:54
     * @param key
     * @param seconds
     */
    public static void keyExpire(String key, int seconds) {
        Jedis jedis = null;
        // 从池中获取一个jedis实例
        try {
            jedis = getJedis();
            jedis.expire(key, seconds);
        } catch (Exception e) {
            // 销毁对象
            jedisPool.returnBrokenResource(jedis);
            logger.error(e.getMessage(), e);
        } finally {
            // 还回到连接池
            closeJedis(jedis);
        }
    }
    
    /**
     * <p>
     *  判断是否存在
     * </p>
     * @author wanghuihui
     * @date 2017-7-20下午1:42:10
     * @param key
     * @return
     */
    public static boolean keyExists(String key) {
        boolean bool = false;
        Jedis jedis = null;
        // 从池中获取一个jedis实例
        try {
            jedis = getJedis();
            bool = jedis.exists(key);
        } catch (Exception e) {
            // 销毁对象
            jedisPool.returnBrokenResource(jedis);
            logger.error(e.getMessage(), e);
        } finally {
            // 还回到连接池
            closeJedis(jedis);
        }
        return bool;
    }
    
    /**
     * <p>
     *  key对应的VALUE增加 integer.
     * </p>
     * @author wanghuihui
     * @date 2017-7-20下午1:42:26
     * @param key
     * @param integer
     */
    public static void valueIncr(String key,long integer) {
        Jedis jedis = null;
        // 从池中获取一个jedis实例
        try {
            jedis = getJedis();
            jedis.incrBy(key,integer);
        } catch (Exception e) {
            // 销毁对象
            jedisPool.returnBrokenResource(jedis);
            logger.error(e.getMessage(), e);
        } finally {
            // 还回到连接池
            closeJedis(jedis);
        }
    }

    /**
     * <p>
     * set集合增加。
     * </p>
     * @author wanghuihui
     * @date 2017-7-14下午2:13:39
     * @param key
     * @param members
     */
    public static void setAdd(String key, String... members) {
        Jedis jedis = null;
        // 从池中获取一个jedis实例
        try {
            jedis = getJedis();
            jedis.sadd(key, members);
        } catch (Exception e) {
            // 销毁对象
            jedisPool.returnBrokenResource(jedis);
            //jedisPool.destroy();
            logger.error(e.getMessage(), e);
        } finally {
            // 还回到连接池
            closeJedis(jedis);
        }
    }
    
    /**
     * <p>
     * 如果成员是存储在键中的集合的成员,则返回1,否则返回0。
     * </p>
     * @author wanghuihui
     * @date 2017-7-14下午2:04:54
     * @param key
     * @param members
     * @return
     */
    public static boolean setExists(String key, String members) {
        Jedis jedis = null;
        boolean bool = false;
        // 从池中获取一个jedis实例
        try {
            jedis = getJedis();
            bool = jedis.sismember(key, members);
        } catch (Exception e) {
            // 销毁对象
            jedisPool.returnBrokenResource(jedis);
            logger.error(e.getMessage(), e);
        } finally {
            // 还回到连接池
            closeJedis(jedis);
        }
        return bool;
    }
    /**
     * <p>
     *  有序集合
     * </p>
     * @author wanghuihui
     * @date 2017-7-14下午3:05:13
     * @param key:键
     * @param score:排序依据,SCORE越小越前。
     * @param members :成员
     */
    public static void zSetAdd(String key, double  score , String member) {
        Jedis jedis = null;
        // 从池中获取一个jedis实例
        try {
            jedis = getJedis();
            jedis.zadd(key, score,member);
        } catch (Exception e) {
            // 销毁对象
            jedisPool.returnBrokenResource(jedis);
            logger.error(e.getMessage(), e);
        } finally {
            // 还回到连接池
            closeJedis(jedis);
        }
    }
    /**
     * <p>
     * 有序集合查询:相当于排序分页查询。
     * </p>
     * @author wanghuihui
     * @date 2017-7-14下午3:24:58
     * @param key:
     * @param start 开始
     * @param limit 结束
     */
    public static void zSetQuery(String key, int  start , int limit) {
        Jedis jedis = null;
        // 从池中获取一个jedis实例
        try {
            jedis = getJedis();
            jedis.zrange(key, start,limit);
        } catch (Exception e) {
            // 销毁对象
            jedisPool.returnBrokenResource(jedis);
            logger.error(e.getMessage(), e);
        } finally {
            // 还回到连接池
            closeJedis(jedis);
        }
    }
    /**
     * <p>
     *  清空当前数据库
     * </p>
     * @author wanghuihui
     * @date 2017-7-14下午4:04:08
     */
    public static  void flushDBAll(){
        Jedis jedis = null;
        // 从池中获取一个jedis实例
        try {
            jedis = getJedis();
            jedis.flushDB();
        } catch (Exception e) {
            // 销毁对象
            jedisPool.returnBrokenResource(jedis);
            logger.error(e.getMessage(), e);
        } finally {
            // 还回到连接池
            closeJedis(jedis);
        }
    }
    
    public static void main(String[] args) {
        RedisSingleUtils jedisUtil = new RedisSingleUtils();
        //jedisUtil.testAll();
        //jedisUtil.testSet();
        List<DictionaryDetailEntity> list = (List<DictionaryDetailEntity>) RedisSingleUtils.getObjectByKey("list_dic_detail");
        System.out.println(11);
        JsonUtil.getObjectArrayFromJson(list.toString());
        System.out.println(list.size());
        for(DictionaryDetailEntity dic : list){
            System.out.println(dic.getLabel());
        }
    }
    /**
     * <p>
     *  測試
     * </p>
     * @author wanghuihui
     * @date 2017-7-14下午2:33:49
     */
    private void testAll(){
        Jedis jedis = RedisSingleUtils.getJedis();
        // 设置字符串数据
        jedis.set("runoobkey", "Redis");
        jedis.set("str_01", "10");
        this.valueIncr("str_01",1);
        System.out.println(this.strGet("str_01"));
        // 获取存储的数据并输出
        System.out.println("Stored string in redis: " + jedis.get("runoobkey"));
        

        /**
         * Redis Java Hash(哈希)实例
         */
        // 设置哈希数据
        Map<String, String> map = new HashMap<String, String>();
        map.put("1", "name1");
        map.put("2", "name2");
        map.put("3", "name3");
        jedis.hmset("redisHash", map);
        // 获取存储的数据并输出
        System.out.println("Stored Hash in redis: " + jedis.hgetAll("redisHash"));

        /**
         * Redis Java List(列表)实例
         */
        // 存储数据到列表中
        jedis.lpush("redisList", "1");
        jedis.lpush("redisList", "2");
        jedis.lpush("redisList", "3");
        // 获取存储数据并输出
        List<String> redisList = jedis.lrange("redisList", 0, 10);
        for (String redis : redisList) {
            System.out.println("Stored List in redis: " + redis);
        }

        /**
         * Redis Java Set(集合)实例
         */
        // 存储数据到集合中
        jedis.sadd("redisSet", "1", "2", "3", "3");
        jedis.sadd("redisSet", "22", "43");
        //测试程序会覆盖原来的SET。
        jedis.set("redisSet", "1");
        // 获取存储数据并输出
        System.out.println("Stored Set in redis: " + jedis.smembers("redisSet"));
        
        /**
         * Redis Java ZSet(有序集合)实例
         */
        // 存储数据到有序集合中
        jedis.zadd("redisZSet", 10, "3");
        jedis.zadd("redisZSet", 20, "4");
        jedis.zadd("redisZSet", 5, "2");
        jedis.zadd("redisZSet", 3, "1");
        String ty = jedis.type("redisZSet");
        // 获取存储数据并输出
        System.out.println("Stored ZSet in redis: " + jedis.zrange("redisZSet", 0, 10));

        /**
         * 获取Reids所有的KEY
         */
        // 获取数据并输出
        Set<String> keys = jedis.keys("*");
        Set<String> keys2 = jedis.keys("*nach*");
        for (String key : keys) {
            System.out.println("Set of stored key: " + key);
            String type = jedis.type(key);
            Object value = this.getObjectByKey(key);
            if(null == value){
                System.out.println("类型为空!请检查~");
            }else if(value instanceof String){
                System.out.println("value="+value);
            }else if(value instanceof List){
                List list = (List) value;
                System.out.println(list.size());
            }else if(value instanceof Map){
                Map map2 = (Map)value;
                System.out.println(11);
            }else if(value instanceof Set){
                Set set = (Set)value;
                System.out.println(11);
            }else {
                System.out.println(value.getClass());
            }
        }
        this.flushDBAll();  //清空当前数据库
    }
    private void testSet() {
        Jedis jedis = RedisSingleUtils.getJedis();
        /**
         * SET 集合
         */
        setAdd("spinach", "mem1", "mem2", "mem3", "mem4");
        Boolean isExist = setExists("spinach","mem2");
        zSetAdd("spinachZet", 20, "mem20");
        zSetAdd("spinachZet", 2, "mem2");
        zSetAdd("spinachZet", 01, "mem01");
        zSetAdd("spinachZet", 5, "mem5");
        zSetAdd("spinachZet", 2, "mem02");
        zSetAdd("spinachZet", 6, "mem6");
        zSetAdd("spinachZet", 3, "mem3");
        zSetAdd("spinachZet", 14, "mem14");
        zSetAdd("spinachZet", 10, "mem10");
        Set<String> result = jedis.zrange("spinachZet", 0, 5);
        System.out.println(result);
        Boolean isExist2 = jedis.sismember("spinachZet","mem14");
        System.out.println(jedis.exists("spinachZet"));
        /*
        Long start = System.currentTimeMillis();
        for(int i=0;i<100000;i++){
            jedis.set("key"+i,"value # Warning: since Redis is pretty fast an outside user can try up to aaaaaaaa"+i);
        }
        Long end = System.currentTimeMillis();
        for(int i=0;i<100000;i++){
            put("key"+i,"value # Warning: since Redis is pretty fast an outside user can try up to aaaaaaaa"+i);
        }
        Long end2 =System.currentTimeMillis();
        Long t1 = end - start;
        Long t2 = end2 -end; 
        System.out.println("t1="+t1+"   t2="+t2); //t1=5942   t2=17037
        */
        
    }
    
}

 

© 著作权归作者所有

共有 人打赏支持
spinachgit
粉丝 6
博文 167
码字总数 102541
作品 0
亳州
Android 通用工具库--Common4Android

Common4Android是一个通用Android工具库,包含网络库、线程管理器、常用Util工具、热修复,它拥有良好的架构,低耦合、高内聚,使用起来非常轻松。 -基类 ClassName Description BaseApplic...

徐奕
2016/08/29
884
2
Android 工具类

前言 相信用过工具类的各位仁兄都觉得工具类好用,小弟不才,今天斗胆拿出自己感觉比较顺手的工具类。 1、Activity控制类 2、应用市场管理类 3、 Toast工具类(不建议使用,请看另外一篇And...

Silence潇湘夜雨
2017/03/23
0
0
各种各种的公共工具类

1、建立公共项目cloud-sdk 地址https://github.com/zhbxzc/cloud-sdk.git 序号 文件 序号 文件 1 StringUtil校验工具类(StringUtil.java) 2 序列化工具类(SerializeUtil.java) 3 安全类(Secu...

0了凡0
2016/09/21
61
0
翻翻git之---实用工具类Lazy(绝对的好东西,走过路过别错过)

转载请注明出处:这里写链接内容 今天还是继续昨天的从Git上找点“有用的”,“好玩的”,“推荐的”东西给大家,今天贴的是一个工具类。地址如下https://github.com/ddwhan0123/Lazy 原作者...

ddwhan0123
2016/02/02
0
0
Ajava攻城师/AjavaAndroidLib

将zftlive工程部分共通源代码抽取为类库 已集成第三方开源组件: 网络请求库android-async-http 图片异步加载库universal-image-loader Sqlite数据库操作ormlite-android 社会化分享ShareSD...

Ajava攻城师
2015/06/26
0
0
Android 应用开发框架|核心库--Cangol-appcore

这是一个Android 应用核心库,将应用的常用功能模块化,以便提高开发效率。 详细文档 引用方式 Maven <dependency> <groupId>mobi.cangol.mobile</groupId> <artifactId>appcore</artifactId......

Cangol
2016/06/08
447
0
Android项目实践——短信发送接口的封装与设计

版权声明:本文为博主原创文章,未经博主允许不得转载。 系列教程:Android开发之从零开始系列 大家要是看到有错误的地方或者有啥好的建议,欢迎留言评论 前言:前一段时间公司服务端开发人手...

Anlia
2017/11/30
0
0
Xss 跨站脚本测试平台--XssAPP

XssAPP 是一个专业的 XSS 渗透测试平台。 平台简介 用户在浏览网站、使用即时通讯软件、甚至在阅读电子邮件时,通常会点击其中的链接。攻击者通过在链接中插入恶意代码,就能够盗取用户信息。...

Coody
2017/02/07
550
0
关于Java中何时使用static和工具类相关知识

一.使用static修饰变量:当对象中出现共享数据时,该数据被静态修饰,对象中的特有数据要定义成非静态存放于堆内存中。 二.使用static修饰静态函数:当该函数内部没有访问到非静态数据(对象...

湖心亭看雪
2014/10/31
0
0
Django 基于类的视图源码分析 一

基于类的视图(Class-based view)是Django 1.3引入的新的视图编写方式,用于取代以前基于函数(Function-based)方式。借助于OO和Python中方便的多重继承特性,基于类的视图可以提供更好的抽象与...

XuYuan
2013/02/05
0
0

没有更多内容

加载失败,请刷新页面

加载更多

下一页

Java基础——异常

声明:本栏目所使用的素材都是凯哥学堂VIP学员所写,学员有权匿名,对文章有最终解释权;凯哥学堂旨在促进VIP学员互相学习的基础上公开笔记。 异常处理: 可以挖很多个陷阱,但是不要都是一样...

凯哥学堂
30分钟前
0
0
180723-Quick-Task 动态脚本支持框架之结构设计篇

文章链接:https://liuyueyi.github.io/hexblog/2018/07/23/180723-Quick-Task-动态脚本支持框架之结构设计篇/ Quick-Task 动态脚本支持框架之结构设计篇 相关博文: 180702-QuickTask动态脚本...

小灰灰Blog
34分钟前
0
0
SBT 常用开发技巧

SBT 一直以来都是 Scala 开发者不可言说的痛,最主要的原因就是官方文档维护质量较差,没有经过系统的、循序渐进式的整理,导致初学者入门门槛较高。虽然也有其它构建工具可以选择(例如 Mill...

joymufeng
38分钟前
0
0
HBase in Practice - 性能、监控及问题解决

李钰(社区ID:Yu Li),阿里巴巴计算平台事业部高级技术专家,HBase开源社区PMC&committer。开源技术爱好者,主要关注分布式系统设计、大数据基础平台建设等领域。连续4年基于HBase/HDFS设计和...

中国HBase技术社区
39分钟前
1
0
ES18-JAVA API 批量操作

1.批量查询 Multi Get API public static void multiGet() {// 批量查询MultiGetResponse response = getClient().prepareMultiGet().add("my_person", "my_index", "1")// 查......

贾峰uk
43分钟前
0
0
SpringBoot2.0使用health

1,引入actuator <dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-actuator</artifactId></dependency> 2,application.properties ......

暗中观察
50分钟前
0
0
阿里巴巴Java开发规约

###编程规约 命名风格 【强制】代码中的命名均不能以下划线或美元符号开始,也不能以下划线或美元符号结束 【强制】代码中的命名严禁使用拼音与英文混合的方式,更不允许直接使用中文的方式。...

简心
55分钟前
0
0
如何用TypeScript来创建一个简单的Web应用

转载地址 如何用TypeScript来创建一个简单的Web应用 安装TypeScript 获取TypeScript工具的方式: 通过npm(Node.js包管理器) npm install -g typescript 构建你的第一个TypeScript文件 创建...

durban
今天
0
0
分享好友,朋友圈自定义分享链接无效

这个问题是微信6.5.6版本以后,修改了分享规则:分享的连接必须在公众号后台设定的js安全域名内

LM_Mike
今天
0
0
2018年7月23日课程

一、LVS-DR介绍 director分配请求到不同的real server。real server 处理请求后直接回应给用户,这样director负载均衡器仅处理客户机与服务器的一半连接。负载均衡器仅处理一半的连接,避免了...

人在艹木中
今天
0
0

没有更多内容

加载失败,请刷新页面

加载更多

下一页

返回顶部
顶部