RedisUtil工具类

2023-11-03

package com.test.util;

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

import javax.annotation.Resource;

import com.ucf.platform.framework.core.log.UcfLogger;
import com.ucf.platform.framework.core.log.UcfLoggerFactory;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.ScanParams;
import redis.clients.jedis.ScanResult;
import redis.clients.jedis.ShardedJedis;
import redis.clients.jedis.ShardedJedisPool;

/**
 * 
 * @ClassName RedisUtil
 * @Description: redisUtil 工具类  
 * @author: GuXiYang  
 * @date: 2016-11-28 下午4:48:37
 * @see http://haiziwoainixx.iteye.com/blog/2087115
 */
public class RedisUtil {
	private  static final UcfLogger logger = UcfLoggerFactory.getLogger(RedisUtil.class);
	@Resource  
	private ShardedJedisPool shardedJedisPool;  


	/** 
	 * 设置一个key的过期时间（单位：秒） 
	 * @param key key值 
	 * @param seconds 多少秒后过期 
	 * @return 1：设置了过期时间  0：没有设置过期时间/不能设置过期时间 
	 */  
	public long expire(String key, int seconds) {  
		if (key==null || key.equals("")) {  
			return 0;  
		}  

		ShardedJedis shardedJedis = null;  
		try {  
			shardedJedis = shardedJedisPool.getResource();  
			return shardedJedis.expire(key, seconds);  
		} catch (Exception ex) {  
			logger.error("EXPIRE error[key=" + key + " seconds=" + seconds + "]" + ex.getMessage(), ex);  
			returnBrokenResource(shardedJedis);  
		} finally {  
			returnResource(shardedJedis);  
		}  
		return 0;  
	}  

	/** 
	 * 设置一个key在某个时间点过期 
	 * @param key key值 
	 * @param unixTimestamp unix时间戳，从1970-01-01 00:00:00开始到现在的秒数 
	 * @return 1：设置了过期时间  0：没有设置过期时间/不能设置过期时间 
	 */  
	public long expireAt(String key, int unixTimestamp) {  
		if (key==null || key.equals("")) {  
			return 0;  
		}  

		ShardedJedis shardedJedis = null;  
		try {  
			shardedJedis = shardedJedisPool.getResource();  
			return shardedJedis.expireAt(key, unixTimestamp);  
		} catch (Exception ex) {  
			logger.error("EXPIRE error[key=" + key + " unixTimestamp=" + unixTimestamp + "]" + ex.getMessage(), ex);  
			returnBrokenResource(shardedJedis);  
		} finally {  
			returnResource(shardedJedis);  
		}  
		return 0;  
	}  

	/** 
	 * 截断一个List 
	 * @param key 列表key 
	 * @param start 开始位置 从0开始 
	 * @param end 结束位置 
	 * @return 状态码 
	 */  
	public String trimList(String key, long start, long end) {  
		if (key == null || key.equals("")) {  
			return "-";  
		}  
		ShardedJedis shardedJedis = null;  
		try {  
			shardedJedis = shardedJedisPool.getResource();  
			return shardedJedis.ltrim(key, start, end);  
		} catch (Exception ex) {  
			logger.error("LTRIM 出错[key=" + key + " start=" + start + " end=" + end + "]" + ex.getMessage() , ex);  
			returnBrokenResource(shardedJedis);  
		} finally {  
			returnResource(shardedJedis);  
		}  
		return "-";  
	}  
	/** 
	 * 检查Set长度 
	 * @param key 
	 * @return 
	 */  
	public long countSet(String key){  
		if(key == null ){  
			return 0;  
		}  
		ShardedJedis shardedJedis = null;  
		try {  
			shardedJedis = shardedJedisPool.getResource();  
			return shardedJedis.scard(key);  
		} catch (Exception ex) {  
			logger.error("countSet error.", ex);  
			returnBrokenResource(shardedJedis);  
		} finally {  
			returnResource(shardedJedis);  
		}  
		return 0;  
	}  
	/** 
	 * 添加到Set中（同时设置过期时间） 
	 * @param key key值 
	 * @param seconds 过期时间 单位s 
	 * @param value 
	 * @return 
	 */  
	public boolean addSet(String key,int seconds, String... value) {  
		boolean result = addSet(key, value);  
		if(result){  
			long i = expire(key, seconds);  
			return i==1;  
		}  
		return false;  
	}  
	/** 
	 * 添加到Set中 
	 * @param key 
	 * @param value 
	 * @return 
	 */  
	public boolean addSet(String key, String... value) {  
		if(key == null || value == null){  
			return false;  
		}  
		ShardedJedis shardedJedis = null;  
		try {  
			shardedJedis = shardedJedisPool.getResource();  
			shardedJedis.sadd(key, value);  
			return true;  
		} catch (Exception ex) {  
			logger.error("setList error.", ex);  
			returnBrokenResource(shardedJedis);  
		} finally {  
			returnResource(shardedJedis);  
		}  
		return false;  
	}  


	/** 
	 * @param key 
	 * @param value 
	 * @return 判断值是否包含在set中 
	 */  
	public boolean containsInSet(String key, String value) {  
		if(key == null || value == null){  
			return false;  
		}  
		ShardedJedis shardedJedis = null;  
		try {  
			shardedJedis = shardedJedisPool.getResource();  
			return shardedJedis.sismember(key, value);  
		} catch (Exception ex) {  
			logger.error("setList error.", ex);  
			returnBrokenResource(shardedJedis);  
		} finally {  
			returnResource(shardedJedis);  
		}  
		return false;  
	}  
	/** 
	 * 获取Set 
	 * @param key 
	 * @return 
	 */  
	public  Set<String> getSet(String key){  
		ShardedJedis shardedJedis = null;  
		try {  
			shardedJedis = shardedJedisPool.getResource();  
			return shardedJedis.smembers(key);  
		} catch (Exception ex) {  
			logger.error("getList error.", ex);  
			returnBrokenResource(shardedJedis);  
		} finally {  
			returnResource(shardedJedis);  
		}  
		return null;  
	}  

	/** 
	 * 从set中删除value 
	 * @param key 
	 * @return 
	 */  
	public  boolean removeSetValue(String key,String... value){  
		ShardedJedis shardedJedis = null;  
		try {  
			shardedJedis = shardedJedisPool.getResource();  
			shardedJedis.srem(key, value);  
			return true;  
		} catch (Exception ex) {  
			logger.error("getList error.", ex);  
			returnBrokenResource(shardedJedis);  
		} finally {  
			returnResource(shardedJedis);  
		}  
		return false;  
	}  



	/** 
	 * 从list中删除value 默认count 1 
	 * @param key 
	 * @param values 值list 
	 * @return 
	 */  
	public  int removeListValue(String key,List<String> values){  
		return removeListValue(key, 1, values);  
	}  
	/** 
	 * 从list中删除value 
	 * @param key 
	 * @param count  
	 * @param values 值list 
	 * @return 
	 */  
	public  int removeListValue(String key,long count,List<String> values){  
		int result = 0;  
		if(values != null && values.size()>0){  
			for(String value : values){  
				if(removeListValue(key, count, value)){  
					result++;  
				}  
			}  
		}  
		return result;  
	}  
	/** 
	 *  从list中删除value 
	 * @param key 
	 * @param count 要删除个数 
	 * @param value 
	 * @return 
	 */  
	public  boolean removeListValue(String key,long count,String value){  
		ShardedJedis shardedJedis = null;  
		try {  
			shardedJedis = shardedJedisPool.getResource();  
			shardedJedis.lrem(key, count, value);  
			return true;  
		} catch (Exception ex) {  
			logger.error("getList error.", ex);  
			returnBrokenResource(shardedJedis);  
		} finally {  
			returnResource(shardedJedis);  
		}  
		return false;  
	}  

	/** 
	 * 截取List 
	 * @param key  
	 * @param start 起始位置 
	 * @param end 结束位置 
	 * @return 
	 */  
	public List<String> rangeList(String key, long start, long end) {  
		if (key == null || key.equals("")) {  
			return null;  
		}  
		ShardedJedis shardedJedis = null;  
		try {  
			shardedJedis = shardedJedisPool.getResource();  
			return shardedJedis.lrange(key, start, end);  
		} catch (Exception ex) {  
			logger.error("rangeList 出错[key=" + key + " start=" + start + " end=" + end + "]" + ex.getMessage() , ex);  
			returnBrokenResource(shardedJedis);  
		} finally {  
			returnResource(shardedJedis);  
		}  
		return null;  
	}  

	/** 
	 * 检查List长度 
	 * @param key 
	 * @return 
	 */  
	public long countList(String key){  
		if(key == null ){  
			return 0;  
		}  
		ShardedJedis shardedJedis = null;  
		try {  
			shardedJedis = shardedJedisPool.getResource();  
			return shardedJedis.llen(key);  
		} catch (Exception ex) {  
			logger.error("countList error.", ex);  
			returnBrokenResource(shardedJedis);  
		} finally {  
			returnResource(shardedJedis);  
		}  
		return 0;  
	}  

	/** 
	 * 添加到List中（同时设置过期时间） 
	 * @param key key值 
	 * @param seconds 过期时间 单位s 
	 * @param value  
	 * @return  
	 */  
	public boolean addList(String key,int seconds, String... value){  
		boolean result = addList(key, value);  
		if(result){  
			long i = expire(key, seconds);  
			return i==1;  
		}  
		return false;  
	}  
	/** 
	 * 添加到List 
	 * @param key 
	 * @param value 
	 * @return 
	 */  
	public boolean addList(String key, String... value) {  
		if(key == null || value == null){  
			return false;  
		}  
		ShardedJedis shardedJedis = null;  
		try {  
			shardedJedis = shardedJedisPool.getResource();  
			shardedJedis.lpush(key, value);  
			return true;  
		} catch (Exception ex) {  
			logger.error("setList error.", ex);  
			returnBrokenResource(shardedJedis);  
		} finally {  
			returnResource(shardedJedis);  
		}  
		return false;  
	}  
	/** 
	 * 添加到List(只新增) 
	 * @param key 
	 * @param value 
	 * @return 
	 */  
	public boolean addList(String key, List<String> list) {  
		if(key == null || list == null || list.size() == 0){  
			return false;  
		}  
		for(String value : list){  
			addList(key, value);  
		}  
		return true;  
	}  

	/** 
	 * 获取List 
	 * @param key 
	 * @return 
	 */  
	public  List<String> getList(String key){  
		ShardedJedis shardedJedis = null;  
		try {  
			shardedJedis = shardedJedisPool.getResource();  
			return shardedJedis.lrange(key, 0, -1);  
		} catch (Exception ex) {  
			logger.error("getList error.", ex);  
			returnBrokenResource(shardedJedis);  
		} finally {  
			returnResource(shardedJedis);  
		}  
		return null;  
	}  
	/** 
	 * 设置HashSet对象 
	 * 
	 * @param domain 域名 
	 * @param key    键值 
	 * @param value  Json String or String value 
	 * @return 
	 */  
	public boolean setHSet(String domain, String key, String value) {  
		if (value == null) return false;  
		ShardedJedis shardedJedis = null;  
		try {  
			shardedJedis = shardedJedisPool.getResource();  
			shardedJedis.hset(domain, key, value);  
			return true;  
		} catch (Exception ex) {  
			logger.error("setHSet error.", ex);  
			returnBrokenResource(shardedJedis);  
		} finally {  
			returnResource(shardedJedis);  
		}  
		return false;  
	}  

	/** 
	 * 获得HashSet对象 
	 * 
	 * @param domain 域名 
	 * @param key    键值 
	 * @return Json String or String value 
	 */  
	public String getHSet(String domain, String key) {  
		ShardedJedis shardedJedis = null;  
		try {  
			shardedJedis = shardedJedisPool.getResource();  
			return shardedJedis.hget(domain, key);  
		} catch (Exception ex) {  
			logger.error("getHSet error.", ex);  
			returnBrokenResource(shardedJedis);  
		} finally {  
			returnResource(shardedJedis);  
		}  
		return null;  
	}  

	/** 
	 * 删除HashSet对象 
	 * 
	 * @param domain 域名 
	 * @param key    键值 
	 * @return 删除的记录数 
	 */  
	public long delHSet(String domain, String key) {  
		ShardedJedis shardedJedis = null;  
		long count = 0;  
		try {  
			shardedJedis = shardedJedisPool.getResource();  
			count = shardedJedis.hdel(domain, key);  
		} catch (Exception ex) {  
			logger.error("delHSet error.", ex);  
			returnBrokenResource(shardedJedis);  
		} finally {  
			returnResource(shardedJedis);  
		}  
		return count;  
	}  

	/** 
	 * 删除HashSet对象 
	 * 
	 * @param domain 域名 
	 * @param key    键值 
	 * @return 删除的记录数 
	 */  
	public long delHSet(String domain, String... key) {  
		ShardedJedis shardedJedis = null;  
		long count = 0;  
		try {  
			shardedJedis = shardedJedisPool.getResource();  
			count = shardedJedis.hdel(domain, key);  
		} catch (Exception ex) {  
			logger.error("delHSet error.", ex);  
			returnBrokenResource(shardedJedis);  
		} finally {  
			returnResource(shardedJedis);  
		}  
		return count;  
	}  

	/** 
	 * 判断key是否存在 
	 * 
	 * @param domain 域名 
	 * @param key    键值 
	 * @return 
	 */  
	public boolean existsHSet(String domain, String key) {  
		ShardedJedis shardedJedis = null;  
		boolean isExist = false;  
		try {  
			shardedJedis = shardedJedisPool.getResource();  
			isExist = shardedJedis.hexists(domain, key);  
		} catch (Exception ex) {  
			logger.error("existsHSet error.", ex);  
			returnBrokenResource(shardedJedis);  
		} finally {  
			returnResource(shardedJedis);  
		}  
		return isExist;  
	}  

	/** 
	 * 全局扫描hset 
	 * 
	 * @param match field匹配模式 
	 * @return 
	 */  
	public List<Map.Entry<String, String>> scanHSet(String domain, String match) {  
		ShardedJedis shardedJedis = null;  
		try {  
			int cursor = 0;  
			shardedJedis = shardedJedisPool.getResource();  
			ScanParams scanParams = new ScanParams();  
			scanParams.match(match);  
			Jedis jedis = shardedJedis.getShard(domain);  
			ScanResult<Map.Entry<String, String>> scanResult;  
			List<Map.Entry<String, String>> list = new ArrayList<Map.Entry<String, String>>();  
			do {  
				scanResult = jedis.hscan(domain, String.valueOf(cursor), scanParams);  
				list.addAll(scanResult.getResult());  
				cursor = Integer.parseInt(scanResult.getStringCursor());  
			} while (cursor > 0);  
			return list;  
		} catch (Exception ex) {  
			logger.error("scanHSet error.", ex);  
			returnBrokenResource(shardedJedis);  
		} finally {  
			returnResource(shardedJedis);  
		}  
		return null;  
	}  


	/** 
	 * 返回 domain 指定的哈希集中所有字段的value值 
	 * 
	 * @param domain 
	 * @return 
	 */  

	public List<String> hvals(String domain) {  
		ShardedJedis shardedJedis = null;  
		List<String> retList = null;  
		try {  
			shardedJedis = shardedJedisPool.getResource();  
			retList = shardedJedis.hvals(domain);  
		} catch (Exception ex) {  
			logger.error("hvals error.", ex);  
			returnBrokenResource(shardedJedis);  
		} finally {  
			returnResource(shardedJedis);  
		}  
		return retList;  
	}  

	/** 
	 * 返回 domain 指定的哈希集中所有字段的key值 
	 * 
	 * @param domain 
	 * @return 
	 */  

	public Set<String> hkeys(String domain) {  
		ShardedJedis shardedJedis = null;  
		Set<String> retList = null;  
		try {  
			shardedJedis = shardedJedisPool.getResource();  
			retList = shardedJedis.hkeys(domain);  
		} catch (Exception ex) {  
			logger.error("hkeys error.", ex);  
			returnBrokenResource(shardedJedis);  
		} finally {  
			returnResource(shardedJedis);  
		}  
		return retList;  
	}  

	/** 
	 * 返回 domain 指定的哈希key值总数 
	 * 
	 * @param domain 
	 * @return 
	 */  
	public long lenHset(String domain) {  
		ShardedJedis shardedJedis = null;  
		long retList = 0;  
		try {  
			shardedJedis = shardedJedisPool.getResource();  
			retList = shardedJedis.hlen(domain);  
		} catch (Exception ex) {  
			logger.error("hkeys error.", ex);  
			returnBrokenResource(shardedJedis);  
		} finally {  
			returnResource(shardedJedis);  
		}  
		return retList;  
	}  

	/** 
	 * 设置排序集合 
	 * 
	 * @param key 
	 * @param score 
	 * @param value 
	 * @return 
	 */  
	public boolean setSortedSet(String key, long score, String value) {  
		ShardedJedis shardedJedis = null;  
		try {  
			shardedJedis = shardedJedisPool.getResource();  
			shardedJedis.zadd(key, score, value);  
			return true;  
		} catch (Exception ex) {  
			logger.error("setSortedSet error.", ex);  
			returnBrokenResource(shardedJedis);  
		} finally {  
			returnResource(shardedJedis);  
		}  
		return false;  
	}  

	/** 
	 * 获得排序集合 
	 * 
	 * @param key 
	 * @param startScore 
	 * @param endScore 
	 * @param orderByDesc 
	 * @return 
	 */  
	public Set<String> getSoredSet(String key, long startScore, long endScore, boolean orderByDesc) {  
		ShardedJedis shardedJedis = null;  
		try {  
			shardedJedis = shardedJedisPool.getResource();  
			if (orderByDesc) {  
				return shardedJedis.zrevrangeByScore(key, endScore, startScore);  
			} else {  
				return shardedJedis.zrangeByScore(key, startScore, endScore);  
			}  
		} catch (Exception ex) {  
			logger.error("getSoredSet error.", ex);  
			returnBrokenResource(shardedJedis);  
		} finally {  
			returnResource(shardedJedis);  
		}  
		return null;  
	}  

	/** 
	 * 计算排序长度 
	 * 
	 * @param key 
	 * @param startScore 
	 * @param endScore 
	 * @return 
	 */  
	public long countSoredSet(String key, long startScore, long endScore) {  
		ShardedJedis shardedJedis = null;  
		try {  
			shardedJedis = shardedJedisPool.getResource();  
			Long count = shardedJedis.zcount(key, startScore, endScore);  
			return count == null ? 0L : count;  
		} catch (Exception ex) {  
			logger.error("countSoredSet error.", ex);  
			returnBrokenResource(shardedJedis);  
		} finally {  
			returnResource(shardedJedis);  
		}  
		return 0L;  
	}  

	/** 
	 * 删除排序集合 
	 * 
	 * @param key 
	 * @param value 
	 * @return 
	 */  
	public boolean delSortedSet(String key, String value) {  
		ShardedJedis shardedJedis = null;  
		try {  
			shardedJedis = shardedJedisPool.getResource();  
			long count = shardedJedis.zrem(key, value);  
			return count > 0;  
		} catch (Exception ex) {  
			logger.error("delSortedSet error.", ex);  
			returnBrokenResource(shardedJedis);  
		} finally {  
			returnResource(shardedJedis);  
		}  
		return false;  
	}  

	/** 
	 * 获得排序集合 
	 * 
	 * @param key 
	 * @param startRange 
	 * @param endRange 
	 * @param orderByDesc 
	 * @return 
	 */  
	public Set<String> getSoredSetByRange(String key, int startRange, int endRange, boolean orderByDesc) {  
		ShardedJedis shardedJedis = null;  
		try {  
			shardedJedis = shardedJedisPool.getResource();  
			if (orderByDesc) {  
				return shardedJedis.zrevrange(key, startRange, endRange);  
			} else {  
				return shardedJedis.zrange(key, startRange, endRange);  
			}  
		} catch (Exception ex) {  
			logger.error("getSoredSetByRange error.", ex);  
			returnBrokenResource(shardedJedis);  
		} finally {  
			returnResource(shardedJedis);  
		}  
		return null;  
	}  

	/** 
	 * 获得排序打分 
	 * 
	 * @param key 
	 * @return 
	 */  
	public Double getScore(String key, String member) {  
		ShardedJedis shardedJedis = null;  
		try {  
			shardedJedis = shardedJedisPool.getResource();  
			return shardedJedis.zscore(key, member);  
		} catch (Exception ex) {  
			logger.error("getSoredSet error.", ex);  
			returnBrokenResource(shardedJedis);  
		} finally {  
			returnResource(shardedJedis);  
		}  
		return null;  
	}  

	public boolean set(String key, String value, int second) {  
		ShardedJedis shardedJedis = null;  
		try {  
			shardedJedis = shardedJedisPool.getResource();  
			shardedJedis.setex(key, second, value);  
			return true;  
		} catch (Exception ex) {  
			logger.error("set error.", ex);  
			returnBrokenResource(shardedJedis);  
		} finally {  
			returnResource(shardedJedis);  
		}  
		return false;  
	}  

	public boolean set(String key, String value) {  
		ShardedJedis shardedJedis = null;  
		try {  
			shardedJedis = shardedJedisPool.getResource();  
			shardedJedis.set(key, value);  
			return true;  
		} catch (Exception ex) {  
			logger.error("set error.", ex);  
			returnBrokenResource(shardedJedis);  
		} finally {  
			returnResource(shardedJedis);  
		}  
		return false;  
	}  

	public String get(String key, String defaultValue) {  
		ShardedJedis shardedJedis = null;  
		try {  
			shardedJedis = shardedJedisPool.getResource();  
			return shardedJedis.get(key) == null?defaultValue:shardedJedis.get(key);  
		} catch (Exception ex) {  
			logger.error("get error.", ex);  
			returnBrokenResource(shardedJedis);  
		} finally {  
			returnResource(shardedJedis);  
		}  
		return defaultValue;  
	}  

	public boolean del(String key) {  
		ShardedJedis shardedJedis = null;  
		try {  
			shardedJedis = shardedJedisPool.getResource();  
			shardedJedis.del(key);  
			return true;  
		} catch (Exception ex) {  
			logger.error("del error.", ex);  
			returnBrokenResource(shardedJedis);  
		} finally {  
			returnResource(shardedJedis);  
		}  
		return false;  
	}  

	public long incr(String key) {  
		ShardedJedis shardedJedis = null;  
		try {  
			shardedJedis = shardedJedisPool.getResource();  
			return shardedJedis.incr(key);  
		} catch (Exception ex) {  
			logger.error("incr error.", ex);  
			returnBrokenResource(shardedJedis);  
		} finally {  
			returnResource(shardedJedis);  
		}  
		return 0;  
	}  

	public long decr(String key) {  
		ShardedJedis shardedJedis = null;  
		try {  
			shardedJedis = shardedJedisPool.getResource();  
			return shardedJedis.decr(key);  
		} catch (Exception ex) {  
			logger.error("incr error.", ex);  
			returnBrokenResource(shardedJedis);  
		} finally {  
			returnResource(shardedJedis);  
		}  
		return 0;  
	}  



	private void returnBrokenResource(ShardedJedis shardedJedis) {  
		try {  
			shardedJedisPool.returnBrokenResource(shardedJedis);  
		} catch (Exception e) {  
			logger.error("returnBrokenResource error.", e);  
		}  
	}  

	private void returnResource(ShardedJedis shardedJedis) {  
		try {  
			shardedJedisPool.returnResource(shardedJedis);  
		} catch (Exception e) {  
			logger.error("returnResource error.", e);  
		}  
	}  
}

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

Java

开发积累

工具类

RedisUtil工具类的相关文章

如果我在 XML 布局中声明一个片段，如何将它传递为 Bundle？

我有一个活动已替换为片段该活动采用了一个 Intent 其中包含一些有关该活动应该显示哪些数据的额外信息现在我的 Activity 只是执行相同工作的 Fragment 的包装器如果我使用标记在 XML 中声明该片段如何将该捆绑包
Java：如何将ArrayList作为对象的实例变量？

我正在开展一个班级项目用 Java 构建一个小型 Connect4 游戏我目前的想法是拥有一类 Columns 它具有一些整数索引最大长度 isFull 作为实例变量以及一个 ArrayList 来接收上面的整数和每个玩家的表现
正则表达式奇/偶数

我有一个正则表达式问题我不知道该怎么做它必须匹配开头包含任意数量的 a 的所有字符串如果 a 的数量为偶数则匹配单个 0 如果 a 的数量为奇数则匹配单个 1 如何跟踪偶数奇数 Sample aaa1 aaaa0 a aa 1
如何设置评分栏的星星颜色？

如何设置评分栏的星星颜色我想要黄色星星最简单的方法 android progressTint color color 光滑有光泽
禁用特定的 ServletContextListener 以防止在 tomcat 上启动

我的项目正在使用spring boot with webflux tomcat 我有一个内部库类它是ServletContextListener WebListener public class DevIoServletContextLi
C# 到 Java：Base64String、MemoryStream、GZipStream

我有一个在 NET 中压缩的 Base64 字符串我想将其转换回 Java 中的字符串我正在寻找一些与 C 语法等效的 Java 语法特别是 Convert FromBase64String 内存流压缩流这是我想要转换的方法 pu
Swing 是否支持 Windows 7 风格的文件选择器？

我刚刚添加了一个标准打开文件与我正在编写的一个小型桌面应用程序的对话基于JFileChooserSwing 教程的入口 http download oracle com javase tutorial uiswing componen
Apache POI - JAVA - 迭代 Excel 中的列

这里是java新手我正在编写一个代码该代码读取 Excel 文件查看列中的单元格然后编写如下表所示的内容我有一个 Excel 文件如下所示 col1 col2 col3 col4 row1 2 3 1 1 w row2 3 2
在其抽象超类中使用子类的泛型类型？

在我的代码中有以下抽象超类 public abstract class AbstractClass
在 Android 谷歌地图中绘制 4K 折线

我现在正在开发一个适用于 Android 设备的应用程序主要功能是在地图上绘制折线以显示城市中每条街道的交通情况不幸的是当我绘制大约 3K 折线时数量会根据屏幕尺寸和缩放级别而减少我的地图变得非常慢我没有提及绘制所有线条的时间
Java中的字符算术

在玩的过程中我遇到了一些对我来说似乎很奇怪的事情以下不是有效的 Java 代码 char x A x x 1 possible loss of precision 因为其中一个操作数是整数所以另一个操作数被转换为整数结果无法分配给字
JVM 是否会内联对象的实例变量和方法？

假设我有一个非常紧密的内部循环每次迭代都会访问和改变一个簿记对象该对象存储有关算法的一些简单数据并具有用于操作它的简单逻辑簿记对象是私有的和最终的并且它的所有方法都是私有的最终的和 inline 下面是一个示例 Scala 语法
尝试将过滤器添加到 Grizzly+Jersey 应用程序时出现问题

我有这个服务器初始化类 package magic app main import org glassfish grizzly http server HttpServer import org glassfish jersey grizz
int 到 long 赋值

我一直在尝试这个 int 和 long 转换我尝试分配一个int变量为along多变的代码如下 public static void main String args int i 1024 long j i long k i i i i
Spring JPA (Hibernate) Entity Manager 何时将连接返回到连接池？

在我的 java 进程中我使用以下 spring 配置连接到 MySql Configuration EnableTransactionManagement PropertySources PropertySource classpath
如何对动态渲染 html 和 css 的 Java 代码进行单元测试？

我有一个 Java 类它从数据库获取表单定义然后根据表单定义呈现 html javascript 和 css 它使用大量 appendable append append 来构建html 片段这很容易出错 Jsp 和通用模板框架例如
GAE、JPA、XG 事务、实体组过多异常

我知道 GAE 上的 XG 交易有 5 个实体组的限制但我认为我在一项交易中仅使用 3 个组商品类别商品类别但仍然遇到此异常引起原因 java lang IllegalArgumentException 在单个事务中对太多实体组
遍历多行字符串

我得到一些数据 def data some useless text n even more n finally interesting text 我怎样才能得到其中有趣的部分所以基本上所有行都不是以开头的 Groovy 的一种选择是
扫描图像到可读文本

我想知道是否有一种方法可以通过编写代码来将带有文本的扫描图像转换为可读文本那可能吗 OCRTools http www ocrtools com是我用于 net 的对于Java 我用过Aspire http asprise com pr
“您的安全设置已阻止本地应用程序运行”Java 8

我正在尝试在 Chrome 窗口中运行一个小小程序但收到错误消息我确实看到所有回复都告诉我将安全性更改为中级但版本 8 中不存在该选项到目前为止几个小时的谷歌搜索和向同学寻求帮助没有带来任何进展有人可以建议一下吗 Medium在

随机推荐

js实现框选截屏功能

实现的思路大概就是先将dom转化为canvas画布再对canvas进行裁切然后通过canvas api生成图片这里用到了一个库html2canvas 效果如图首先实现框选效果 const mousedownEvent e gt m
java 订单审核加锁_日常小记：订单添加锁机制

考虑情况 java是个多线程机制多线程是一把双刃剑一旦设计到多个线程操作共享资源的情况下处理不好就会出现线程安全问题线程安全性可能是非常复杂的在沒有充足的同步情况下多个线程执行顺序是不好操作的同步和异步同步就是一件事一件事
数据结构——栈和队列

数据结构栈和队列数据结构栈和队列数据结构栈和队列 1 栈 1 1 栈的概念及结构 1 2 栈的实现 2 队列 2 1 队列的概念及结构 2 2 队列的实现 1 栈 1 1 栈的概念及结构栈一种特殊的线性表其只允许在固定的一端
ubuntu goland import 红色波浪线

首先查看对应的环境变量GOPATH 一定要和goland的是同一个用户使用命令如下 go env 然后打开goland的 setting 找到对应的GOPATH 如下 apply 然后 ok 即可错误就没有了
sysdig_功能强大的系统工具Sysdig命令实例介绍

Sysdig是一个能够让系统管理员和开发人员以前所未有方式洞察其系统行为的监控工具我们可以用sysdig命令做很多很酷的事情你如果有更有趣的用法想添加到下面的命令例子中请告诉我们 1 网络查看占用网络带宽最多的进程 sysdig
R-squared 和 Adjusted R-squared联系与区别

原文见 https discuss analyticsvidhya com t difference between r square and adjusted r square 264 8 下面是自己理解的总结大概意思就是说 R squ
【DateFormat】DateFormat用于实现日期的格式化

DateFormat 创建实例 getDateInstance 返回一个日期格式器 getTimeInstance 返回一个时间格式器 getDateTimeInstance 返回一个日期时间格式器上述方法均可传入参数指定日期样式和地区
链表OJ练习（2）

一分割链表题目介绍思路创建两个链表 ghead尾插大于x的节点 lhead尾插小于x的节点先遍历链表最后将ghead尾插到lhead后面将大小链表链接我们需要在创建两个链表指针指向两个链表的头节点用这两个指针标记lhea
c# 本机IP修改

校园网总是要修改ip 去实验室也要修改ip 想着编一个IP修改的软件比较方便我用的是 using System Management 报错的话记得在项目的引用中添加右击引用添加引用 System Management private
怎么把wsl1 变成wsl2

Ensure the distribution runs in WSL 2 mode WSL can run distributions in both v1 or v2 mode To check the WSL mode run wsl
宝塔安装,创建WordPress

宝塔安装 1 进入宝塔官网官网地址 https www bt cn new index html 2 安装Linux面板7 9 4 2 1选择下载安装这里我们在CentOS7 4上安装所以选择 Linux面板7 9 4 安装脚本 2
清华镜像源下载pytorch及Torchvision

conda config add channels https mirrors tuna tsinghua edu cn anaconda pkgs free conda config add channels https mirrors
挖掘机铲斗关于是否用最小二乘法

根源应该在连接杆P3P4那里它绕P4的旋转使得P5P3旋转并产生一定位移绕液压杆伸缩同时 P3P1位移或者旋转或者先旋转一定角度再位移此时P2P1运动这里P2P1的值发生了变化可能要拟合铲斗再绕着P2P1的新向量旋转
无人机rtmp推流直播解决方案

无人机直播的需求无人机直播是航拍的价值延伸在无人机进行现场航拍监控成为行业的基本需求后将航拍视频实时回传到指挥大厅和业务平台进行远程观看和分析将会带来更新颖的应用效果和价值客户需要独立部署的流媒体服务器尽管不少品牌的无人机可以
Pytorch快速入门系列---（三）pytorch中的数据操作和预处理

目录 1 高维数组 1 1 回归数据准备 1 2 分类数据准备 2 图像数据 1 torchv
Vuex从了解到实际运用，彻底搞懂什么是Vuex（一）

什么是Vuex全局状态管理一句话来说 Vuex全局状态管理是任意组件之间的通信的解决方案 Vuex实现原理借助于Vuex提供的单例可供任意组件的调度它里面提供了一些对应的状态和方法比如 state getter mutation
php页面添加计数器

index php 1 4 5 6 7 8 9 10 11
一个好玩的网络空间测绘站（fofa）

无意间发现了一个好玩的网络空间测绘站 https fofa info 可以轻松嗅探公网资源而且官方还提供搜索语法说明上手容易适合信安学习也适合相关从业人员 ps 禁止干违法的事情哟
计算机科学和Python编程导论(一) 计算机相关理论

基本概念 1 计算机基础知识陈述性知识关于事实的描述如果满足y y x 那么x的平方根就是数值y 程序性知识说明如何做描述的是信息演绎的过程算法是一个有穷指令序列它在给定的输入集合中执行时会按照一系列定义明确的状态进行
RedisUtil工具类

package com test util import java util ArrayList import java util List import java util Map import java util Set import

RedisUtil工具类

RedisUtil工具类 的相关文章

随机推荐

热门标签

RedisUtil工具类的相关文章