RedisPool操作Redis,工具类实例
redis.properties
配置文件内容
redis.pool.maxActive=100
redis.pool.maxIdle=20
redis.pool.maxWait=3000
redis.pool.testOnBorrow=false
redis.pool.testOnReturn=false
redis.ip=127.0.0.1
redis.port=6379
redis.port1=6380
redis.password=****
package com.szreach.rcrp.redis; import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.ResourceBundle;
import java.util.Set; import org.apache.log4j.Logger; import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.JedisShardInfo;
import redis.clients.jedis.ShardedJedis;
import redis.clients.jedis.ShardedJedisPool; public class RedisUtil { private static final Logger log = Logger.getLogger(RedisUtil.class);
private static JedisPool jedisPool = null;
private static ShardedJedisPool shardedJedisPool = null;
/**
* 初始化Redis连接池
*/
static {
try {
// 加载redis配置文件
ResourceBundle bundle = ResourceBundle.getBundle("redis");
if (bundle == null) {
throw new IllegalArgumentException(
"[redis.properties] is not found!");
}
int maxActivity = Integer.valueOf(bundle
.getString("redis.pool.maxActive"));
int maxIdle = Integer.valueOf(bundle
.getString("redis.pool.maxIdle"));
long maxWait = Long.valueOf(bundle.getString("redis.pool.maxWait"));
boolean testOnBorrow = Boolean.valueOf(bundle
.getString("redis.pool.testOnBorrow"));
boolean onreturn = Boolean.valueOf(bundle
.getString("redis.pool.testOnReturn"));
// 创建jedis池配置实例
JedisPoolConfig config = new JedisPoolConfig();
// 设置池配置项值
config.setMaxActive(maxActivity);
config.setMaxIdle(maxIdle); //最大空闲连接数
config.setMaxWait(maxWait);
config.setTestOnBorrow(testOnBorrow);
config.setTestOnReturn(onreturn);
jedisPool = new JedisPool(config, bundle.getString("redis.ip"),
Integer.valueOf(bundle.getString("redis.port")), 10000,
bundle.getString("redis.password"));
// slave链接
List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>();
shards.add(new JedisShardInfo(bundle.getString("redis.ip"), Integer
.valueOf(bundle.getString("redis.port1"))));
shardedJedisPool = new ShardedJedisPool(config, shards);
log.info("初始化Redis连接池success");
} catch (Exception e) {
log.error("初始化Redis连接池 出错!", e);
}
} /**
* 获取Jedis实例
*
* @return
*/
public synchronized static Jedis getJedis() {
try {
if (jedisPool != null) {
Jedis resource = jedisPool.getResource();
return resource;
} else {
return null;
}
} catch (Exception e) {
log.error("Redis缓存获取Jedis实例 出错!", e);
return null;
}
} /**
* 获取shardedJedis实例
*
* @return
*/
public static ShardedJedis getShardedJedis() {
try {
if (shardedJedisPool != null) {
ShardedJedis resource = shardedJedisPool.getResource();
return resource;
} else {
return null;
}
} catch (Exception e) {
log.error("Redis缓存获取shardedJedis实例 出错!", e);
return null;
}
} /**
* 释放jedis资源
*
* @param jedis
*/
public static void returnResource(final Jedis jedis) {
if (jedis != null) {
jedisPool.returnResource(jedis);
}
} /**
* 释放shardedJedis资源
*
* @param jedis
*/
public static void returnResource(final ShardedJedis shardedJedis) {
if (shardedJedis != null) {
shardedJedisPool.returnResource(shardedJedis);
}
} /**
* 向缓存中设置字符串内容
*
* @param key
* key
* @param value
* value
* @return
* @throws Exception
*/
public static boolean set(String key, String value) {
Jedis jedis = null;
try {
jedis = getJedis();
if(jedis != null){
jedis.set(key, value);
}
return true;
} catch (Exception e) {
log.error("Redis缓存设置key值 出错!", e);
return false;
} finally {
returnResource(jedis);
}
} /**
* 判断key是否存在
*/
public static boolean exists(String key){
ShardedJedis jedis = null;
try {
jedis = getShardedJedis();
if (jedis == null) {
return false;
} else {
return jedis.exists(key);
}
} catch (Exception e) {
log.error("Redis缓存判断key是否存在 出错!", e);
return false;
} finally {
returnResource(jedis);
}
} /**
* 删除缓存中的对象,根据key
* @param key
* @return
*/
public static boolean del(String key) {
Jedis jedis = null;
try {
jedis = getJedis();
jedis.del(key);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
} finally {
returnResource(jedis);
}
} //*******************key-value****************start /**
* 向缓存中设置对象
*
* @param key
* @param value
* @return
*/
public static boolean set(String key, Object value) {
Jedis jedis = null;
try {
String objectJson = JSONObject.fromObject(value).toString();
jedis = getJedis();
if (jedis != null) {
jedis.set(key, objectJson);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
} finally {
returnResource(jedis);
}
} /**
* 根据key 获取内容
*
* @param key
* @return
*/
public static Object get(String key) {
ShardedJedis jedis = null;
try {
jedis = shardedJedisPool.getResource();
Object value = jedis.get(key);
return value;
} catch (Exception e) {
e.printStackTrace();
return false;
} finally {
shardedJedisPool.returnResource(jedis);
}
} /**
* 根据key 获取对象
*
* @param key
* @return
*/
@SuppressWarnings("unchecked")
public static <T> T get(String key, Class<T> clazz) {
ShardedJedis jedis = null;
try {
jedis = getShardedJedis();
if (jedis != null) {
return (T) JSONObject.toBean(JSONObject.fromObject(jedis.get(key)), clazz);
} else {
return null;
}
} catch (Exception e) {
e.printStackTrace();
return null;
} finally {
returnResource(jedis);
}
}
//*******************key-value****************end //*************** 操作list****************start
/**
* 向缓存中设置对象
* @param key
* @param list
* T string calss
* @return
*/
public static <T> boolean setList(String key,List<T> list){
Jedis jedis = null;
try {
jedis = getJedis();
if (jedis != null) {
for (T vz : list) {
if (vz instanceof String) {
jedis.lpush(key, (String) vz);
} else {
String objectJson = JSONObject.fromObject(vz).toString();
jedis.lpush(key, objectJson);
}
}
return true;
} else {
return false;
}
} catch (Exception e) {
e.printStackTrace();
return false;
} finally {
returnResource(jedis);
}
} @SuppressWarnings("unchecked")
public static <T> List<T> getListEntity(String key,Class<T> entityClass){
ShardedJedis jedis = null;
try {
jedis = getShardedJedis();
if (jedis != null) {
List<String> valueJson = jedis.lrange(key, 0, -1);
JSONArray json = new JSONArray();
json.addAll(valueJson);
JSONArray jsonArray = JSONArray.fromObject(json.toString());
return (List<T>) JSONArray.toCollection(jsonArray, entityClass);
} else {
return null;
}
} catch (Exception e) {
e.printStackTrace();
return null;
} finally {
returnResource(jedis);
}
} public static List<String> getListString(String key){
ShardedJedis jedis = null;
try {
jedis = getShardedJedis();
if (jedis != null) {
return jedis.lrange(key, 0, -1);
} else {
return null;
}
} catch (Exception e) {
e.printStackTrace();
return null;
} finally {
returnResource(jedis);
}
}
//*************** 操作list****************end //*************** 操作map****************start
public static <K,V> boolean setMap(String key,Map<String,V> map){
Jedis jedis = null;
try {
jedis = getJedis();
if (jedis != null) {
Set<Map.Entry<String, V>> entry = map.entrySet();
for (Iterator<Map.Entry<String, V>> ite = entry.iterator(); ite.hasNext();) {
Map.Entry<String, V> kv = ite.next();
if (kv.getValue() instanceof String) {
jedis.hset(key, kv.getKey(), (String) kv.getValue());
}else if (kv.getValue() instanceof List) {
jedis.hset(key, kv.getKey(), JSONArray.fromObject(kv.getValue()).toString());
} else {
jedis.hset(key, kv.getKey(), JSONObject.fromObject(kv.getValue()).toString());
}
}
return true;
} else {
return false;
}
} catch (Exception e) {
e.printStackTrace();
return false;
} finally {
returnResource(jedis);
}
} public static boolean setMapKey(String key,String mapKey,Object value){
Jedis jedis = null;
try {
jedis = getJedis();
if (jedis != null) {
if (value instanceof String) {
jedis.hset(key, mapKey, String.valueOf(value));
} else if (value instanceof List) {
jedis.hset(key, mapKey, JSONArray.fromObject(value).toString());
} else {
jedis.hset(key, mapKey, JSONObject.fromObject(value).toString());
}
return true;
} else {
return false;
}
} catch (Exception e) {
e.printStackTrace();
return false;
} finally {
returnResource(jedis);
}
} /**
* seconds key和value 保存的有效时间(单位:秒)
* @return
*/
public static boolean setMapKeyExpire(String key,String mapKey,Object value, int seconds){
Jedis jedis = null;
try {
jedis = getJedis();
if (jedis != null) {
if (value instanceof String) {
jedis.hset(key, mapKey, String.valueOf(value));
} else if (value instanceof List) {
jedis.hset(key, mapKey, JSONArray.fromObject(value).toString());
} else {
jedis.hset(key, mapKey, JSONObject.fromObject(value).toString());
}
jedis.expire(key, seconds);
return true;
} else {
return false;
}
} catch (Exception e) {
e.printStackTrace();
return false;
} finally {
returnResource(jedis);
}
} @SuppressWarnings("unchecked")
public static <K,V> Map<String,V> getMap(String key){
ShardedJedis jedis = null;
try {
jedis = getShardedJedis();
if (jedis != null) {
Map<String, V> map = (Map<String, V>) jedis.hgetAll(key);
return map;
} else {
return null;
}
} catch (Exception e) {
e.printStackTrace();
return null;
} finally {
returnResource(jedis);
}
} @SuppressWarnings("unchecked")
public static <K,V> Map<String,V> getMapEntityClass(String key,Class<V> clazz){
ShardedJedis jedis = null;
try {
jedis = getShardedJedis();
if (jedis != null) {
Map<String, V> map = (Map<String, V>) jedis.hgetAll(key);
Set<Map.Entry<String, V>> entry = map.entrySet();
for (Iterator<Map.Entry<String, V>> ite = entry.iterator(); ite.hasNext();) {
Map.Entry<String, V> kv = ite.next();
map.put(kv.getKey(), (V) JSONObject.toBean(JSONObject.fromObject(kv.getValue()), clazz));
}
return map;
} else {
return null;
}
} catch (Exception e) {
e.printStackTrace();
return null;
} finally {
returnResource(jedis);
}
} @SuppressWarnings("unchecked")
public static <K,V> Map<String,List<V>> getMapList(String key,Class<V> clazz){
ShardedJedis jedis = null;
try {
jedis = getShardedJedis();
if (jedis != null) {
Map<String, V> map = (Map<String, V>) jedis.hgetAll(key);
Set<Map.Entry<String, V>> entry = map.entrySet();
for (Iterator<Map.Entry<String, V>> ite = entry.iterator(); ite.hasNext();) {
Map.Entry<String, V> kv = ite.next();
JSONArray jsonArray = JSONArray.fromObject(kv.getValue());
map.put(kv.getKey(), (V) JSONArray.toCollection(jsonArray, clazz));
}
return (Map<String, List<V>>) map;
} else {
return null;
}
} catch (Exception e) {
e.printStackTrace();
return null;
} finally {
returnResource(jedis);
}
} @SuppressWarnings("unchecked")
public static <T> List<T> getMapKeyListEntity(String key,String mapKey,
Class<T> entityClass){
ShardedJedis jedis = null;
try {
jedis = getShardedJedis();
if (jedis != null) {
String valueJson = jedis.hget(key, mapKey);
JSONArray jsonArray = JSONArray.fromObject(valueJson);
return (List<T>) JSONArray.toCollection(jsonArray, entityClass);
} else {
return null;
}
} catch (Exception e) {
e.printStackTrace();
return null;
} finally {
returnResource(jedis);
}
} @SuppressWarnings("unchecked")
public static <T> T getMapKeyEntity(String key,String mapKey,
Class<T> entityClass){
ShardedJedis jedis = null;
try {
jedis = getShardedJedis();
if(jedis != null){
String valueJson=jedis.hget(key, mapKey);
return (T) JSONObject.toBean(JSONObject.fromObject(valueJson), entityClass);
}else{return null;}
} catch (Exception e) {
e.printStackTrace();
return null;
} finally {
returnResource(jedis);
}
} public static Object getMapKey(String key,String mapKey){
ShardedJedis jedis = null;
try {
jedis = getShardedJedis();
if(jedis != null){
return jedis.hget(key, mapKey);
}else{return null;}
} catch (Exception e) {
e.printStackTrace();
return null;
} finally {
returnResource(jedis);
}
} public static boolean delMapKey(String key,String mapKey){
Jedis jedis = null;
try {
jedis = getJedis();
jedis.hdel(key, mapKey);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
} finally {
returnResource(jedis);
}
} public static boolean hexists(String key,String mapKey){
ShardedJedis jedis = null;
try {
jedis = shardedJedisPool.getResource();
return jedis.hexists(key,mapKey);
} catch (Exception e) {
e.printStackTrace();
return false;
} finally {
shardedJedisPool.returnResource(jedis);
}
}
//*************** 操作map****************end //***************计数器应用INCR,DECR****************begin
//Redis的命令都是原子性的,你可以轻松地利用INCR,DECR命令来构建计数器系统 /**
* incr(key):名称为key的string增1操作
*/
public static boolean incr(String key){
Jedis jedis = null;
try {
jedis = getJedis();
jedis.incr(key);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
} finally {
returnResource(jedis);
}
} /**
* incrby(key, integer):名称为key的string增加integer
*/
public static boolean incrBy(String key, int value){
Jedis jedis = null;
try {
jedis = getJedis();
jedis.incrBy(key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
} finally {
returnResource(jedis);
}
} /**
* decr(key):名称为key的string减1操作
*/
public static boolean decr(String key){
Jedis jedis = null;
try {
jedis = getJedis();
jedis.decr(key);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
} finally {
returnResource(jedis);
}
} /**
* decrby(key, integer):名称为key的string减少integer
*/
public static boolean decrBy(String key, int value){
Jedis jedis = null;
try {
jedis = getJedis();
jedis.decrBy(key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
} finally {
returnResource(jedis);
}
}
//***************计数器应用INCR,DECR****************end //***************使用sorted set(zset)甚至可以构建有优先级的队列系统***************begin
/**
* 向名称为key的zset中添加元素member,score用于排序。
* 如果该元素已经存在,则根据score更新该元素的顺序
*/
public static boolean zadd(String key, double score, String member){
Jedis jedis = null;
try {
jedis = getJedis();
jedis.zadd(key, score, member);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
} finally {
returnResource(jedis);
}
} /**
* 删除名称为key的zset中的元素member
*/
public static boolean zrem(String key, String... members){
Jedis jedis = null;
try {
jedis = getJedis();
jedis.zrem(key, members);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
} finally {
returnResource(jedis);
}
} /**
* 返回集合中score在给定区间的元素
*/
public static Set<String> zrangeByScore(String key, double min, double max){
ShardedJedis jedis = null;
try {
jedis = shardedJedisPool.getResource();
return jedis.zrangeByScore(key, min, max);
} catch (Exception e) {
e.printStackTrace();
return null;
} finally {
returnResource(jedis);
}
}
//***************使用sorted set(zset)甚至可以构建有优先级的队列系统***************end //***************sorted set 处理***************************************begin
//zset 处理
public static boolean zaddObject(String key, double score, Object value){
Jedis jedis = null;
try {
jedis = getJedis();
String objectJson = JSONObject.fromObject(value).toString();
jedis.zadd(key, score, objectJson);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
} finally {
returnResource(jedis);
}
} /**
* score值递减(从大到小)次序排列。
* @param key
* @param max score
* @param min score
* @param entityClass
* @return
*/
@SuppressWarnings("unchecked")
public static <T> List<T> zrevrangeByScore(String key,double max,double min,
Class<T> entityClass){
ShardedJedis jedis = null;
try {
jedis =shardedJedisPool.getResource();
Set<String> set=jedis.zrevrangeByScore(key, max, min);
List<T> list=new ArrayList<T>();
for (String str : set) {
list.add((T) JSONObject.toBean(JSONObject.fromObject(str), entityClass));
}
return list;
} catch (Exception e) {
e.printStackTrace();
return null;
} finally {
returnResource(jedis);
}
} /**
* score值递减(从大到小)次序排列。
* @param key
* @param max score
* @param min score
* @param offset count (类似mysql的 LIMIT)
* @param entityClass
* @return
*/
@SuppressWarnings("unchecked")
public static <T> List<T> zrevrangeByScore(String key,double max,double min,
int offset, int count,Class<T> entityClass){
ShardedJedis jedis = null;
try {
jedis =shardedJedisPool.getResource();
Set<String> set=jedis.zrevrangeByScore(key, max, min,offset,count);
List<T> list=new ArrayList<T>();
for (String str : set) {
list.add((T) JSONObject.toBean(JSONObject.fromObject(str), entityClass));
}
return list;
} catch (Exception e) {
e.printStackTrace();
return null;
} finally {
returnResource(jedis);
}
} //得到总记录数
public static long zcard(String key){
ShardedJedis jedis = null;
try {
jedis =shardedJedisPool.getResource();
return jedis.zcard(key);
} catch (Exception e) {
e.printStackTrace();
return 0;
} finally {
returnResource(jedis);
}
} //删除 元素
public static boolean zremObject(String key, Object value){
Jedis jedis = null;
try {
jedis = getJedis();
String objectJson = JSONObject.fromObject(value).toString();
jedis.zrem(key, objectJson);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
} finally {
returnResource(jedis);
}
} //统计zset集合中score某个范围内(1-5),元素的个数
public static long zcount(String key,double min, double max){
ShardedJedis jedis = null;
try {
jedis =shardedJedisPool.getResource();
return jedis.zcount(key,min,max);
} catch (Exception e) {
e.printStackTrace();
return 0;
} finally {
returnResource(jedis);
}
} //查看zset集合中元素的score
public static double zscore(String key,Object value){
ShardedJedis jedis = null;
try {
jedis =shardedJedisPool.getResource();
String objectJson = JSONObject.fromObject(value).toString();
return jedis.zscore(key,objectJson);
} catch (Exception e) {
e.printStackTrace();
return 0;
} finally {
returnResource(jedis);
}
}
//**************sorted set******************************************end //***********************Redis Set集合操作**************************begin
/**
* sadd:向名称为Key的set中添加元素,同一集合中不能出现相同的元素值。(用法:sadd set集合名称 元素值)
* @param key
* @param value
* @return
*/
public static boolean sadd(String key, String value) {
Jedis jedis = null;
try {
jedis = getJedis();
jedis.sadd(key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
} finally {
returnResource(jedis);
}
} /**
* srem:删除名称为key的set中的元素。(用法:srem set集合名称 要删除的元素值)
*
* @param key
* @param value
* @return
*/
public static boolean srem(String key, String value) {
Jedis jedis = null;
try {
jedis = getJedis();
jedis.srem(key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
} finally {
returnResource(jedis);
}
} /**
* sdiff:返回所有给定key与第一个key的差集。(用法:sdiff set集合1 set集合2)
*
* @param key1
* @param key2
* @return
*/
public static Set<String> sdiff(String key1, String key2) {
Jedis jedis = null;
Set<String> diffList = null;
try {
jedis = getJedis();
diffList = jedis.sdiff(key1, key2);
} catch (Exception e) {
e.printStackTrace();
} finally {
returnResource(jedis);
}
return diffList;
} /**
* sismember:判断某个值是否是集合的元素。(用法:sismember 集合1 指定的元素值)
*
* @param key
* @param value
* @return
*/
public static boolean sismember(String key, String value) {
ShardedJedis jedis = null;
try {
jedis = shardedJedisPool.getResource();
return jedis.sismember(key, value);
} catch (Exception e) {
e.printStackTrace();
return false;
} finally {
returnResource(jedis);
}
} /**
* smembers(key) :返回名称为key的set的所有元素
*
* @param key
* @return
*/
public static Set<String> smembers(String key) {
Jedis jedis = null;
Set<String> list = null;
try {
jedis = getJedis();
list = jedis.smembers(key);
} catch (Exception e) {
e.printStackTrace();
} finally {
returnResource(jedis);
}
return list;
} //***********************Redis Set集合操作****************************end
}
RedisPool操作Redis,工具类实例的更多相关文章
- Java操作Redis工具类
依赖 jar 包 <dependency> <groupId>redis.clients</groupId> <artifactId>jedis< ...
- Jedis 操作 Redis 工具类
配置类 pom.xml pom.xml 里配置依赖 <dependency> <groupId>redis.clients</groupId> <artifa ...
- Redis操作Set工具类封装,Java Redis Set命令封装
Redis操作Set工具类封装,Java Redis Set命令封装 >>>>>>>>>>>>>>>>& ...
- Redis操作List工具类封装,Java Redis List命令封装
Redis操作List工具类封装,Java Redis List命令封装 >>>>>>>>>>>>>>>> ...
- Redis操作Hash工具类封装,Redis工具类封装
Redis操作Hash工具类封装,Redis工具类封装 >>>>>>>>>>>>>>>>>> ...
- Redis操作字符串工具类封装,Redis工具类封装
Redis操作字符串工具类封装,Redis工具类封装 >>>>>>>>>>>>>>>>>>& ...
- redistemplate优雅地操作redis redis 工具类
参考:https://www.cnblogs.com/superfj/p/9232482.html redis 工具类 package com.service; import org.springfr ...
- redis 工具类 单个redis、JedisPool 及多个redis、shardedJedisPool与spring的集成配置
http://www.cnblogs.com/edisonfeng/p/3571870.html http://javacrazyer.iteye.com/blog/1840161 http://ww ...
- Redis 工具类 java 实现的redis 工具类
最近了解了一下非关系型数据库 redis 会使用简单的命令 在自己本地电脑 使用时必须先启动服务器端 在启动客户端 redis 简介 Redis是一个开源的使用ANSI C语言编写.支持网络.可基于内 ...
- springboot2.2.2企业级项目整合redis与redis 工具类大全
1.springboot2.2.2整合redis教程很多,为此编写了比较完整的redis工具类,符合企业级开发使用的工具类 2.springboot与redis maven相关的依赖 <depe ...
随机推荐
- Asp.net Core中SignalR Core预览版的一些新特性前瞻,附源码(消息订阅与发送二进制数据)
目录 SignalR系列目录(注意,是ASP.NET的目录.不是Core的) 前言 一晃一个月又过去了,上个月有个比较大的项目要验收上线.所以忙的脚不沾地.现在终于可以忙里偷闲,写一篇关于Signal ...
- ConcurrentHashMap\HashMap put操作时key为什么要rehash
参考java并发编程的艺术一书中,对ConcurrentHashMap的讲解 ConcurrentHashMap使用的是分段锁Segment来保证不同的Segment区域互相不干扰,不存在锁竞争关系, ...
- JS 中对变量类型的五种判断方法
5种基本数据类型:undefined.null.boolean.unmber.string 复杂数据类型:object. object:array.function.date等 方法一:使用typeo ...
- Linux 进程间通信(包含一个经典的生产者消费者实例代码)
前言:编写多进程程序时,有时不可避免的需要在多个进程之间传递数据,我们知道,进程的用户的地址空间是独立,父进程中对数据的修改并不会反映到子进程中,但内核是共享的,大多数进程间通信方式都是在内核中建立一 ...
- django同时查询两张表的数据,合并检索对象返回
原始需求: 1.一篇文章内容分N个版块,每篇文章的版块数量不同. 2.有个文章搜索功能,需要同时搜索标题和内容. 实现思路: 1.由于每篇文章的内容版块数量不同,因此将每个文章的标题和内容分开存入2张 ...
- 机器学习笔记1 - Hello World In Machine Learning
前言 Alpha Go在16年以4:1的战绩打败了李世石,17年又以3:0的战绩战胜了中国围棋天才柯洁,这真是科技界振奋人心的进步.伴随着媒体的大量宣传,此事变成了妇孺皆知的大事件.大家又开始激烈的讨 ...
- COM-IE-(2)
# -*- coding:UTF-8 -*- import sys from time import sleep import win32com.client from win32com.client ...
- 腾讯云数据库团队:MySQL语句复制(SBR)的缺陷列举
作者介绍: 赵伟 腾讯云TDSQL数据库开发者 MySQL (这里的MySQL是指广义的mysql,包括oracle,mysql,percona,mariadb等)的Statement Based R ...
- anaconda不能安装python的包问题
在点了n次,重启应用多次之后,安装包(apply)之后还是没有反应,依然心平气和的我突然想到用管理员模式打开,结果就可以愉快的装包了,估计创建新的环境也是要管理员打开的.
- python decorator 基础
一般来说,装饰器是一个函数,接受一个函数(或者类)作为参数,返回值也是也是一个函数(或者类).首先来看一个简单的例子: # -*- coding: utf-8 -*- def log_cost_tim ...