加瓦一枚
加瓦一枚

[分布式][Redis]Redis分布式框架搭建与集成

1.启动服务：
如果基础以了解，请从后往前看。
n 下载安装文件(2.8.24 zip)                           

https://github.com/MSOpenTech/redis/releases

 

1.1打开cmd到你redis目录下：例如cd D:\Develop\Redis\64bit

1.2然后 d:

1.3然后在目录下输入 redis-server.exe redis-conf

1.4启动服务成功。

1.5 redis-cli --raw 启动客户端 解决中文编码

 

Liunx安装：

n 下载安装文件:

http://download.redis.io/releases/redis-3.2.0.tar.gz

 

1.切到压缩文件路径下解压：tar -zxvf redis.gz

2.切到redis3.2.0路径：make

3.修改配置文件

4.查看端口状况：ps auxf | grep redis-server

5.启动服务：./redis-server redis.conf(你的redis路径再前)

6.关闭服务：./src/redis-cli -h 172.30.23.77 -p 6604 shutdown(你的redis路径在前)

 

2.Redis练习
jedis下载

   http://mvnrepository.com/artifact/redis.clients/jedis/2.8.1

 

2.1创建项目导入
commons-pool-1.5.4.jar//连接池

jedis-2.8.1.jar //java操作redis的两个jar包。

2.2创建一个Redis池
import redis.clients.jedis.Jedis;

import redis.clients.jedis.JedisPool;

import redis.clients.jedis.JedisPoolConfig;

 

public class RedisUtil {

 

/**

 * 服务器Ip 172.0.0为默认IP可以再配置文件中更改

 */

private static StringADDR ="127.0.0.1";

/**

 * //端口号 同上

 */

private static int PORT = 6379;

/**

 * //访问密码

 */

    private static StringAUTH ="admin";

    /**

     * 可用连接实例的最大数目，默认值为8；

       如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。*/

    private static int MAX_ACTIVE = 1024;

    /**

 *  //控制一个pool最多有多少个状态为idle(空闲的)的jedis实例，默认值也是8。

 */

    private static int MAX_IDLE = 200;

    /**

 *  //等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。如果超过等待时间，则直接抛出JedisConnectionException；

 */

    private static int MAX_WAIT = 10000;

    private static int TIMEOUT = 10000;

    /**

 *  //在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；

 */

    private static boolean TEST_ON_BORROW =true;

    private static JedisPooljedisPool =null;

    //初始化

    public RedisUtil(){

     initialPool();

    }

    /**

     * 初始化redis连接池

     */

    private static void initialPool(){

     try {

     JedisPoolConfig config = new JedisPoolConfig();

     config.setMaxActive(MAX_ACTIVE);

     config.setMaxIdle(MAX_IDLE);

     config.setMaxWait(MAX_WAIT);

     config.setTestOnBorrow(TEST_ON_BORROW);

     jedisPool = new JedisPool(config,ADDR,PORT,TIMEOUT,AUTH);

} catch (Exception e) {

e.printStackTrace();

}

    }

    /**

     * 获取redis 实例

     */

    public synchronized static Jedis getJedis(){

try {

if(jedisPool !=null){

Jedis rescoues = jedisPool.getResource();

return rescoues;

}else{

return null;

}

} catch (Exception e) {

e.printStackTrace();

return null;

}

    }

    /**

      * 释放jedis资源

      */

    public static void returnResource(final Jedis jedis) {

        if (jedis !=null) {

            jedisPool.returnResource(jedis);

        }

     }

2.3创建实例操作数据
2.3.1 获取redis连接池
jedis= new RedisUtil().getJedis();

2.3.2对KEY的操作
**网上参考

System.out.println("======================key==========================");

        // 清空数据

        System.out.println("清空库中所有数据："+jedis.flushDB());

        // 判断key否存在

        System.out.println("判断key999键是否存在："+shardedJedis.exists("key999"));

        System.out.println("新增key001,value001键值对："+shardedJedis.set("key001", "value001"));

        System.out.println("判断key001是否存在："+shardedJedis.exists("key001"));

        // 输出系统中所有的key

        System.out.println("新增key002,value002键值对："+shardedJedis.set("key002", "value002"));

        System.out.println("系统中所有键如下：");

        Set keys = jedis.keys("*");

        Iterator it=keys.iterator() ;   

        while(it.hasNext()){   

            String key = it.next();   

            System.out.println(key);   

        }

        // 删除某个key,若key不存在，则忽略该命令。

        System.out.println("系统中删除key002: "+jedis.del("key002"));

        System.out.println("判断key002是否存在："+shardedJedis.exists("key002"));

        // 设置 key001的过期时间

        System.out.println("设置 key001的过期时间为5秒:"+jedis.expire("key001", 5));

        try{

            Thread.sleep(2000);

        }

        catch (InterruptedException e){

        }

        // 查看某个key的剩余生存时间,单位【秒】.永久生存或者不存在的都返回-1

        System.out.println("查看key001的剩余生存时间："+jedis.ttl("key001"));

        // 移除某个key的生存时间

        System.out.println("移除key001的生存时间："+jedis.persist("key001"));

        System.out.println("查看key001的剩余生存时间："+jedis.ttl("key001"));

        // 查看key所储存的值的类型

        System.out.println("查看key所储存的值的类型："+jedis.type("key001"));

        /*

         * 一些其他方法：1、修改键名：jedis.rename("key6", "key0");

         *             2、将当前db的key移动到给定的db当中：jedis.move("foo", 1)

         */

运行结果：

======================key==========================

清空库中所有数据：OK

判断key999键是否存在：false

新增key001,value001键值对：OK

判断key001是否存在：true

新增key002,value002键值对：OK

系统中所有键如下：

key002

key001

系统中删除key002: 1

判断key002是否存在：false

设置 key001的过期时间为5秒:1

查看key001的剩余生存时间：3

移除key001的生存时间：1

查看key001的剩余生存时间：-1

查看key所储存的值的类型：string

 

 

 

2.3.3操作字符串
System.out.println("======================String_1==========================");

        // 清空数据

        System.out.println("清空库中所有数据："+jedis.flushDB());

        

        System.out.println("=============增=============");

        jedis.set("key001","value001");

        jedis.set("key002","value002");

        jedis.set("key003","value003");

        System.out.println("已新增的3个键值对如下：");

        System.out.println(jedis.get("key001"));

        System.out.println(jedis.get("key002"));

        System.out.println(jedis.get("key003"));

        

        System.out.println("=============删=============");  

        System.out.println("删除key003键值对："+jedis.del("key003"));  

        System.out.println("获取key003键对应的值："+jedis.get("key003"));

        

        System.out.println("=============改=============");

        //1、直接覆盖原来的数据

        System.out.println("直接覆盖key001原来的数据："+jedis.set("key001","value001-update"));

        System.out.println("获取key001对应的新值："+jedis.get("key001"));

        //2、直接覆盖原来的数据  

        System.out.println("在key002原来值后面追加："+jedis.append("key002","+appendString"));

        System.out.println("获取key002对应的新值"+jedis.get("key002"));

   

        System.out.println("=============增，删，查（多个）=============");

        /**

         * mset,mget同时新增，修改，查询多个键值对

         * 等价于：

         * jedis.set("name","ssss");

         * jedis.set("jarorwar","xxxx");

         */  

        System.out.println("一次性新增key201,key202,key203,key204及其对应值："+jedis.mset("key201","value201",

                        "key202","value202","key203","value203","key204","value204"));  

        System.out.println("一次性获取key201,key202,key203,key204各自对应的值："+

                        jedis.mget("key201","key202","key203","key204"));

        System.out.println("一次性删除key201,key202："+jedis.del(new String[]{"key201", "key202"}));

        System.out.println("一次性获取key201,key202,key203,key204各自对应的值："+

                jedis.mget("key201","key202","key203","key204"));

        System.out.println();

                

            

        //jedis具备的功能shardedJedis中也可直接使用，下面测试一些前面没用过的方法

        System.out.println("======================String_2==========================");

        // 清空数据

        System.out.println("清空库中所有数据："+jedis.flushDB());       

       

        System.out.println("=============新增键值对时防止覆盖原先值=============");

        System.out.println("原先key301不存在时，新增key301："+shardedJedis.setnx("key301", "value301"));

        System.out.println("原先key302不存在时，新增key302："+shardedJedis.setnx("key302", "value302"));

        System.out.println("当key302存在时，尝试新增key302："+shardedJedis.setnx("key302", "value302_new"));

        System.out.println("获取key301对应的值："+shardedJedis.get("key301"));

        System.out.println("获取key302对应的值："+shardedJedis.get("key302"));

        

        System.out.println("=============超过有效期键值对被删除=============");

        // 设置key的有效期，并存储数据

        System.out.println("新增key303，并指定过期时间为2秒"+shardedJedis.setex("key303", 2, "key303-2second"));

        System.out.println("获取key303对应的值："+shardedJedis.get("key303"));

        try{

            Thread.sleep(3000);

        }

        catch (InterruptedException e){

        }

        System.out.println("3秒之后，获取key303对应的值："+shardedJedis.get("key303"));

        

        System.out.println("=============获取原值，更新为新值一步完成=============");

        System.out.println("key302原值："+shardedJedis.getSet("key302", "value302-after-getset"));

        System.out.println("key302新值："+shardedJedis.get("key302"));

        

        System.out.println("=============获取子串=============");

        System.out.println("获取key302对应值中的子串："+shardedJedis.getrange("key302", 5, 7));  

 

运行结果：

======================String_1==========================

清空库中所有数据：OK

=============增=============

已新增的3个键值对如下：

value001

value002

value003

=============删=============

删除key003键值对：1

获取key003键对应的值：null

=============改=============

直接覆盖key001原来的数据：OK

获取key001对应的新值：value001-update

在key002原来值后面追加：21

获取key002对应的新值value002+appendString

=============增，删，查（多个）=============

一次性新增key201,key202,key203,key204及其对应值：OK

一次性获取key201,key202,key203,key204各自对应的值：[value201, value202, value203, value204]

一次性删除key201,key202：2

一次性获取key201,key202,key203,key204各自对应的值：[null, null, value203, value204]

 

======================String_2==========================

清空库中所有数据：OK

=============新增键值对时防止覆盖原先值=============

原先key301不存在时，新增key301：1

原先key302不存在时，新增key302：1

当key302存在时，尝试新增key302：0

获取key301对应的值：value301

获取key302对应的值：value302

=============超过有效期键值对被删除=============

新增key303，并指定过期时间为2秒OK

获取key303对应的值：key303-2second

3秒之后，获取key303对应的值：null

=============获取原值，更新为新值一步完成=============

key302原值：value302

key302新值：value302-after-getset

=============获取子串=============

获取key302对应值中的子串：302

2.3.4操作LIST
 System.out.println("======================list==========================");

        // 清空数据

        System.out.println("清空库中所有数据："+jedis.flushDB());

 

        System.out.println("=============增=============");

        shardedJedis.lpush("stringlists", "vector");

        shardedJedis.lpush("stringlists", "ArrayList");

        shardedJedis.lpush("stringlists", "vector");

        shardedJedis.lpush("stringlists", "vector");

        shardedJedis.lpush("stringlists", "LinkedList");

        shardedJedis.lpush("stringlists", "MapList");

        shardedJedis.lpush("stringlists", "SerialList");

        shardedJedis.lpush("stringlists", "HashList");

        shardedJedis.lpush("numberlists", "3");

        shardedJedis.lpush("numberlists", "1");

        shardedJedis.lpush("numberlists", "5");

        shardedJedis.lpush("numberlists", "2");

        System.out.println("所有元素-stringlists："+shardedJedis.lrange("stringlists", 0, -1));

        System.out.println("所有元素-numberlists："+shardedJedis.lrange("numberlists", 0, -1));

        

        System.out.println("=============删=============");

        // 删除列表指定的值 ，第二个参数为删除的个数（有重复时），后add进去的值先被删，类似于出栈

        System.out.println("成功删除指定元素个数-stringlists："+shardedJedis.lrem("stringlists", 2, "vector"));

        System.out.println("删除指定元素之后-stringlists："+shardedJedis.lrange("stringlists", 0, -1));

        // 删除区间以外的数据

        System.out.println("删除下标0-3区间之外的元素："+shardedJedis.ltrim("stringlists", 0, 3));

        System.out.println("删除指定区间之外元素后-stringlists："+shardedJedis.lrange("stringlists", 0, -1));

        // 列表元素出栈

        System.out.println("出栈元素："+shardedJedis.lpop("stringlists"));

        System.out.println("元素出栈后-stringlists："+shardedJedis.lrange("stringlists", 0, -1));

        

        System.out.println("=============改=============");

        // 修改列表中指定下标的值

        shardedJedis.lset("stringlists", 0, "hello list!");

        System.out.println("下标为0的值修改后-stringlists："+shardedJedis.lrange("stringlists", 0, -1));

        System.out.println("=============查=============");

        // 数组长度

        System.out.println("长度-stringlists："+shardedJedis.llen("stringlists"));

        System.out.println("长度-numberlists："+shardedJedis.llen("numberlists"));

        // 排序

        /*

         * list中存字符串时必须指定参数为alpha，如果不使用SortingParams，而是直接使用sort("list")，

         * 会出现"ERR One or more scores can't be converted into double"

         */

        SortingParams sortingParameters = new SortingParams();

        sortingParameters.alpha();

        sortingParameters.limit(0, 3);

        System.out.println("返回排序后的结果-stringlists："+shardedJedis.sort("stringlists",sortingParameters));

        System.out.println("返回排序后的结果-numberlists："+shardedJedis.sort("numberlists"));

        // 子串：  start为元素下标，end也为元素下标；-1代表倒数一个元素，-2代表倒数第二个元素

        System.out.println("子串-第二个开始到结束："+shardedJedis.lrange("stringlists", 1, -1));

        // 获取列表指定下标的值

        System.out.println("获取下标为2的元素："+shardedJedis.lindex("stringlists", 2)+"\n");

 

 

运行结果：

======================list==========================

清空库中所有数据：OK

=============增=============

所有元素-stringlists：[HashList, SerialList, MapList, LinkedList, vector, vector, ArrayList, vector]

所有元素-numberlists：[2, 5, 1, 3]

=============删=============

成功删除指定元素个数-stringlists：2

删除指定元素之后-stringlists：[HashList, SerialList, MapList, LinkedList, ArrayList, vector]

删除下标0-3区间之外的元素：OK

删除指定区间之外元素后-stringlists：[HashList, SerialList, MapList, LinkedList]

出栈元素：HashList

元素出栈后-stringlists：[SerialList, MapList, LinkedList]

=============改=============

下标为0的值修改后-stringlists：[hello list!, MapList, LinkedList]

=============查=============

长度-stringlists：3

长度-numberlists：4

返回排序后的结果-stringlists：[LinkedList, MapList, hello list!]

返回排序后的结果-numberlists：[1, 2, 3, 5]

子串-第二个开始到结束：[MapList, LinkedList]

获取下标为2的元素：LinkedList

 

2.3.5 操作SET
System.out.println("======================set==========================");

        // 清空数据

        System.out.println("清空库中所有数据："+jedis.flushDB());

        

        System.out.println("=============增=============");

        System.out.println("向sets集合中加入元素element001："+jedis.sadd("sets", "element001"));

        System.out.println("向sets集合中加入元素element002："+jedis.sadd("sets", "element002"));

        System.out.println("向sets集合中加入元素element003："+jedis.sadd("sets", "element003"));

        System.out.println("向sets集合中加入元素element004："+jedis.sadd("sets", "element004"));

        System.out.println("查看sets集合中的所有元素:"+jedis.smembers("sets"));

        System.out.println();

        

        System.out.println("=============删=============");

        System.out.println("集合sets中删除元素element003："+jedis.srem("sets", "element003"));

        System.out.println("查看sets集合中的所有元素:"+jedis.smembers("sets"));

        /*System.out.println("sets集合中任意位置的元素出栈："+jedis.spop("sets"));//注：出栈元素位置居然不定？--无实际意义

        System.out.println("查看sets集合中的所有元素:"+jedis.smembers("sets"));*/

        System.out.println();

        

        System.out.println("=============改=============");

        System.out.println();

        

        System.out.println("=============查=============");

        System.out.println("判断element001是否在集合sets中："+jedis.sismember("sets", "element001"));

        System.out.println("循环查询获取sets中的每个元素：");

        Set set = jedis.smembers("sets");   

        Iterator it=set.iterator() ;   

        while(it.hasNext()){   

            Object obj=it.next();   

            System.out.println(obj);   

        }  

        System.out.println();

        

        System.out.println("=============集合运算=============");

        System.out.println("sets1中添加元素element001："+jedis.sadd("sets1", "element001"));

        System.out.println("sets1中添加元素element002："+jedis.sadd("sets1", "element002"));

        System.out.println("sets1中添加元素element003："+jedis.sadd("sets1", "element003"));

        System.out.println("sets1中添加元素element002："+jedis.sadd("sets2", "element002"));

        System.out.println("sets1中添加元素element003："+jedis.sadd("sets2", "element003"));

        System.out.println("sets1中添加元素element004："+jedis.sadd("sets2", "element004"));

        System.out.println("查看sets1集合中的所有元素:"+jedis.smembers("sets1"));

        System.out.println("查看sets2集合中的所有元素:"+jedis.smembers("sets2"));

        System.out.println("sets1和sets2交集："+jedis.sinter("sets1", "sets2"));

        System.out.println("sets1和sets2并集："+jedis.sunion("sets1", "sets2"));

        System.out.println("sets1和sets2差集："+jedis.sdiff("sets1", "sets2"));//差集：set1中有，set2中没有的元素

 

运行结果：

======================set==========================

清空库中所有数据：OK

=============增=============

向sets集合中加入元素element001：1

向sets集合中加入元素element002：1

向sets集合中加入元素element003：1

向sets集合中加入元素element004：1

查看sets集合中的所有元素:[element001, element002, element003, element004]

 

=============删=============

集合sets中删除元素element003：1

查看sets集合中的所有元素:[element001, element002, element004]

 

=============改=============

 

=============查=============

判断element001是否在集合sets中：true

循环查询获取sets中的每个元素：

element001

element002

element004

 

=============集合运算=============

sets1中添加元素element001：1

sets1中添加元素element002：1

sets1中添加元素element003：1

sets1中添加元素element002：1

sets1中添加元素element003：1

sets1中添加元素element004：1

查看sets1集合中的所有元素:[element001, element002, element003]

查看sets2集合中的所有元素:[element002, element003, element004]

sets1和sets2交集：[element002, element003]

sets1和sets2并集：[element001, element002, element003, element004]

sets1和sets2差集：[element001]

 

2.3.6 操作SortedSet（有序集合）
System.out.println("======================zset==========================");

        // 清空数据         System.out.println(jedis.flushDB());

        

        System.out.println("=============增=============");

        System.out.println("zset中添加元素element001："+shardedJedis.zadd("zset", 7.0, "element001"));

        System.out.println("zset中添加元素element002："+shardedJedis.zadd("zset", 8.0, "element002"));

        System.out.println("zset中添加元素element003："+shardedJedis.zadd("zset", 2.0, "element003"));

        System.out.println("zset中添加元素element004："+shardedJedis.zadd("zset", 3.0, "element004"));

        System.out.println("zset集合中的所有元素："+shardedJedis.zrange("zset", 0, -1));//按照权重值排序        System.out.println();

        

        System.out.println("=============删=============");

        System.out.println("zset中删除元素element002："+shardedJedis.zrem("zset", "element002"));

        System.out.println("zset集合中的所有元素："+shardedJedis.zrange("zset", 0, -1));

        System.out.println();

        

        System.out.println("=============改=============");

        System.out.println();

        

        System.out.println("=============查=============");

        System.out.println("统计zset集合中的元素中个数："+shardedJedis.zcard("zset"));

        System.out.println("统计zset集合中权重某个范围内（1.0——5.0），元素的个数："+shardedJedis.zcount("zset", 1.0, 5.0));

        System.out.println("查看zset集合中element004的权重："+shardedJedis.zscore("zset", "element004"));

        System.out.println("查看下标1到2范围内的元素值："+shardedJedis.zrange("zset", 1, 2));

 

运行结果：

======================zset==========================

OK

=============增=============

zset中添加元素element001：1

zset中添加元素element002：1

zset中添加元素element003：1

zset中添加元素element004：1

zset集合中的所有元素：[element003, element004, element001, element002]

 

=============删=============

zset中删除元素element002：1

zset集合中的所有元素：[element003, element004, element001]

 

=============改=============

 

=============查=============

统计zset集合中的元素中个数：3

统计zset集合中权重某个范围内（1.0——5.0），元素的个数：2

查看zset集合中element004的权重：3.0

查看下标1到2范围内的元素值：[element004, element001]

 

2.3.7操作Hash功能
System.out.println("======================hash==========================");

        //清空数据         System.out.println(jedis.flushDB());

        

        System.out.println("=============增=============");

        System.out.println("hashs中添加key001和value001键值对："+shardedJedis.hset("hashs", "key001", "value001"));

        System.out.println("hashs中添加key002和value002键值对："+shardedJedis.hset("hashs", "key002", "value002"));

        System.out.println("hashs中添加key003和value003键值对："+shardedJedis.hset("hashs", "key003", "value003"));

        System.out.println("新增key004和4的整型键值对："+shardedJedis.hincrBy("hashs", "key004", 4l));

        System.out.println("hashs中的所有值："+shardedJedis.hvals("hashs"));

        System.out.println();

        

        System.out.println("=============删=============");

        System.out.println("hashs中删除key002键值对："+shardedJedis.hdel("hashs", "key002"));

        System.out.println("hashs中的所有值："+shardedJedis.hvals("hashs"));

        System.out.println();

        

        System.out.println("=============改=============");

        System.out.println("key004整型键值的值增加100："+shardedJedis.hincrBy("hashs", "key004", 100l));

        System.out.println("hashs中的所有值："+shardedJedis.hvals("hashs"));

        System.out.println();

        

        System.out.println("=============查=============");

        System.out.println("判断key003是否存在："+shardedJedis.hexists("hashs", "key003"));

        System.out.println("获取key004对应的值："+shardedJedis.hget("hashs", "key004"));

        System.out.println("批量获取key001和key003对应的值："+shardedJedis.hmget("hashs", "key001", "key003"));

        System.out.println("获取hashs中所有的key："+shardedJedis.hkeys("hashs"));

        System.out.println("获取hashs中所有的value："+shardedJedis.hvals("hashs"));

        System.out.println();

 

运行结果：

======================hash==========================

OK

=============增=============

hashs中添加key001和value001键值对：1

hashs中添加key002和value002键值对：1

hashs中添加key003和value003键值对：1

新增key004和4的整型键值对：4

hashs中的所有值：[value001, value002, value003, 4]

 

=============删=============

hashs中删除key002键值对：1

hashs中的所有值：[value001, value003, 4]

 

=============改=============

key004整型键值的值增加100：104

hashs中的所有值：[value001, value003, 104]

 

=============查=============

判断key003是否存在：true

获取key004对应的值：104

批量获取key001和key003对应的值：[value001, value003]

获取hashs中所有的key：[key004, key003, key001]

获取hashs中所有的value：[value001, value003, 104]

 

3.Redis常用命令：
   1）连接操作命令
    quit：关闭连接（connection）
    auth：简单密码认证
    help cmd： 查看cmd帮助，例如：help quit
    
    2）持久化
    save：将数据同步保存到磁盘
    bgsave：将数据异步保存到磁盘
    lastsave：返回上次成功将数据保存到磁盘的Unix时戳
    shundown：将数据同步保存到磁盘，然后关闭服务
    
    3）远程服务控制
    info：提供服务器的信息和统计
    monitor：实时转储收到的请求
    slaveof：改变复制策略设置
    config：在运行时配置Redis服务器
    
    4）对value操作的命令
    exists(key)：确认一个key是否存在
    del(key)：删除一个key
    type(key)：返回值的类型
    keys(pattern)：返回满足给定pattern的所有key
    randomkey：随机返回key空间的一个
    keyrename(oldname, newname)：重命名key
    dbsize：返回当前数据库中key的数目
    expire：设定一个key的活动时间（s）
    ttl：获得一个key的活动时间
    select(index)：按索引查询
    move(key, dbindex)：移动当前数据库中的key到dbindex数据库
    flushdb：删除当前选择数据库中的所有key
    flushall：删除所有数据库中的所有key
    
    5）String
    set(key, value)：给数据库中名称为key的string赋予值value
    get(key)：返回数据库中名称为key的string的value
    getset(key, value)：给名称为key的string赋予上一次的value
    mget(key1, key2,…, key N)：返回库中多个string的value
    setnx(key, value)：添加string，名称为key，值为value
    setex(key, time, value)：向库中添加string，设定过期时间time
    mset(key N, value N)：批量设置多个string的值
    msetnx(key N, value N)：如果所有名称为key i的string都不存在
    incr(key)：名称为key的string增1操作
    incrby(key, integer)：名称为key的string增加integer
    decr(key)：名称为key的string减1操作
    decrby(key, integer)：名称为key的string减少integer
    append(key, value)：名称为key的string的值附加value
    substr(key, start, end)：返回名称为key的string的value的子串
    
    6）List 
    rpush(key, value)：在名称为key的list尾添加一个值为value的元素
    lpush(key, value)：在名称为key的list头添加一个值为value的 元素
    llen(key)：返回名称为key的list的长度
    lrange(key, start, end)：返回名称为key的list中start至end之间的元素
    ltrim(key, start, end)：截取名称为key的list
    lindex(key, index)：返回名称为key的list中index位置的元素
    lset(key, index, value)：给名称为key的list中index位置的元素赋值
    lrem(key, count, value)：删除count个key的list中值为value的元素
    lpop(key)：返回并删除名称为key的list中的首元素
    rpop(key)：返回并删除名称为key的list中的尾元素
    blpop(key1, key2,… key N, timeout)：lpop命令的block版本。
    brpop(key1, key2,… key N, timeout)：rpop的block版本。
    rpoplpush(srckey, dstkey)：返回并删除名称为srckey的list的尾元素，

　　　　　　　　　　　　　　并将该元素添加到名称为dstkey的list的头部
    
    7）Set
    sadd(key, member)：向名称为key的set中添加元素member
    srem(key, member) ：删除名称为key的set中的元素member
    spop(key) ：随机返回并删除名称为key的set中一个元素
    smove(srckey, dstkey, member) ：移到集合元素
    scard(key) ：返回名称为key的set的基数
    sismember(key, member) ：member是否是名称为key的set的元素
    sinter(key1, key2,…key N) ：求交集
    sinterstore(dstkey, (keys)) ：求交集并将交集保存到dstkey的集合
    sunion(key1, (keys)) ：求并集
    sunionstore(dstkey, (keys)) ：求并集并将并集保存到dstkey的集合
    sdiff(key1, (keys)) ：求差集
    sdiffstore(dstkey, (keys)) ：求差集并将差集保存到dstkey的集合
    smembers(key) ：返回名称为key的set的所有元素
    srandmember(key) ：随机返回名称为key的set的一个元素
    
    8）Hash
    hset(key, field, value)：向名称为key的hash中添加元素field
    hget(key, field)：返回名称为key的hash中field对应的value
    hmget(key, (fields))：返回名称为key的hash中field i对应的value
    hmset(key, (fields))：向名称为key的hash中添加元素field 
    hincrby(key, field, integer)：将名称为key的hash中field的value增加integer
    hexists(key, field)：名称为key的hash中是否存在键为field的域
    hdel(key, field)：删除名称为key的hash中键为field的域
    hlen(key)：返回名称为key的hash中元素个数
    hkeys(key)：返回名称为key的hash中所有键
    hvals(key)：返回名称为key的hash中所有键对应的value
    hgetall(key)：返回名称为key的hash中所有的键（field）及其对应的value

4.redis与多线程的小练习：
1.连接池同上
2.创建一个线程类操作数据
public class ThreadToolimplements Runnable{

private Jedis j;

public ThreadTool(Jedis j) {

super();

this.j = j;

}

@Override

public void run() {

synchronized (j) {//因为要操作同一个数据所以必须同步

j.incr("age");

System.out.println(Thread.currentThread().getName()+": "

+j.get("name") +"-" +j.get("age") +"-" +j.get("qq"));

}

}

}

3.创建redis实例加入数据调用线程：
public class MyRedis {

 

private Jedis jedis;

public void setUp(){

//jedis = new Jedis("127.0.0.1",6379);

//jedis.auth("admin");

jedis = new RedisUtil().getJedis();

//-----添加数据----------  

       jedis.set("name","张三");//向key-->name中放入了value-->xinxin  

       System.out.println("刚加进去的："+jedis.get("name"));//执行结果：xinxin  

       jedis.append("name"," is crasy");//拼接

       System.out.println("拼接后："+jedis.get("name"));

       jedis.del("name");  //删除某个键

       System.out.println("删除后："+jedis.get("name"));

       //设置多个键值对

       jedis.mset("name","张三","age","23","qq","476777XXX");

       jedis.incr("age");//进行加1操作

       System.out.println("name原值"+jedis.getSet("name","李四"));

//       Jedis  jedis2 =  new RedisUtil().getJedis();

//       jedis2.lpush("list", "arrayList");

//       jedis2.lpush("list", "arrayList2");

//       jedis2.lpush("number", "0");

//       jedis2.lpush("number", "1");

       System.out.println("**********************************");

}

public static void main(String[] args) {

new MyRedis().setUp();

//new RedisUtil().getJedis().set("name", "测试");

//System.out.println(RedisUtil.getJedis().get("name"));

Jedis j = new Jedis("127.0.0.1",6379);

j.auth("admin");

System.out.println(j.get("name") +"-" + j.get("age") +"-" + j.get("qq"));

//System.out.println("所有元素list: "+j.lrange("list", 0, -1));

//System.out.println("所有元素number: "+j.lrange("number", 0, -1));

//System.out.println("删除下标0-1区间之外的元素："+j.ltrim("number", 0, 1));

//System.out.println("删除指定区间之外元素后-stringlists："+j.lrange("number", 0, -1));

Thread t =new Thread(new ThreadTool(j));

Thread t2 =new Thread(new ThreadTool(j));

Thread t3 =new Thread(new ThreadTool(j));

t.start();

t2.start();

t3.start();

}

4.运行结果：
控制台：

刚加进去的： 张三

拼接后： 张三 is crasy

删除后： null

name原值张三

**********************************

李四-24-476777XXX

Thread-1: 李四-25-476777XXX

Thread-3: 李四-26-476777XXX

Thread-2: 李四-27-476777XXX

 

 

5.Spring整合redis
1.配置文件：

  

  

    

    

    

          class="org.springframework.data.redis.serializer.StringRedisSerializer"/>

 

    

          class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer"/>

 

  

    

          p:hostName="${redis.host}"p:port="${redis.port}"p:password="${redis.pass}"

           p:poolConfig-ref="jedisPoolConfig"/>

 

    

    

          p:connectionFactory-ref="jedisConnectionFactory"/>

          

    

    

          p:connectionFactory-ref="jedisConnectionFactory"

          p:keySerializer-ref="stringRedisSerializer"p:hashKeySerializer-ref="stringRedisSerializer"

          p:valueSerializer-ref="jdkRedisSerializer"p:hashValueSerializer-ref="jdkRedisSerializer"/> 

                  

  

          p:maxTotal="${redis.maxActive}"

          p:maxIdle="${redis.maxIdle}"

          p:maxWaitMillis="${redis.maxWait}"

          p:testOnBorrow="${redis.testOnBorrow}"

          p:testOnReturn="true"/>

6.Redis分布式：
1：配置文件（主从）：
 

主服务：

port 6379  //端口

bind 172.0.0.1  //IP地址 后面接空格ip可以绑定多个IP地址。

requirepass admin  //密码

1.启动服务 cmd --> cd redis安装路径-->redis-server.exe redis.conf  

2.再启动从服务连接到主服务。

 

从服务：可以设置多个

port 6380  //端口

bind 172.16.3.16  //IP地址

requirepass admin  //密码

 slaveof 127.0.0.1 6379 //主机的ip端口

 masterauth admin  //主机的密码认证

 

启动：开启测试  redis-cli.exe -h 从配置中绑定ip -p 配置中的端口。

此时主服务set key value

从服务 auth admin

get key  ------------------OK！。

 

7.java操作redis分布式：
1.概念性的东西：
Redis实现集群的方法主要是采用一致性哈稀分片（Shard），将不同的key分配到不同的redis server上，达到横向扩展的目的。

shared一致性哈希采用以下方案：

1. Redis服务器节点划分：将每台服务器节点采用hash算法划分为160个虚拟节点(可以配置划分权重)

2. 将划分虚拟节点采用TreeMap存储

3. 对每个Redis服务器的物理连接采用LinkedHashMap存储对Key or KeyTag 采用同样的hash算法，然后从TreeMap获取大于等于键hash值得节点，取最邻近节点存储；当key的hash值大于虚拟节点hash值得最大值时，存入第一个虚拟节点。

4. sharded采用的hash算法：MD5 和 MurmurHash两种；默认采用64位的MurmurHash算法；

sharding的核心理念就是将数据按照一定的策略"分散"存储在集群中不同的物理server上,本质上实现了"大数据"分布式存储,以及体现了"集群"的高可用性.比如1亿数据,我们按照数据的hashcode散列存储在5个server上.

2.redis分片代码：
 

1.ShardedJedisPool连接池：

这里直接写spring配置文件。和new一样。

        

        

            

                172.16.3.16:6380:master

                127.0.0.1:6379:clint 

                172.16.3.34:6381:clint2   

            

            

        

        

            1000

            

            

        

            200

            

        

        

            true

                

    

2.RedisInitBean：

 

public class RedisInitBean {

 

  private List Host;//连接请求

    private long maxWaitMillis;

    private int MaxIdle;

    private Boolean testOnBorrow;

    private static Listshards ;//分片信息

    private static ShardedJedisPoolpool;//分片池

    private static ShardedJedisjedis;//分片jedis实例

    

    //以下在构造方法中把分片信息处理好放在list中并初始化好连接池

    public RedisInitBean(List host,long maxWaitMillis,int maxIdle,

            Boolean testOnBorrow) {

        super();

        Host = host;

        this.maxWaitMillis = maxWaitMillis;

        MaxIdle = maxIdle;

        this.testOnBorrow = testOnBorrow;

        if(host.size()!=0){

            JedisShardInfo[] array = new JedisShardInfo[Host .size()];

            for (int i = 0; i

             //配置多个端口ip : host .prot. timeout.name

                String h[] = ((String) Host .get(i)).split(":");

                JedisShardInfo s= new JedisShardInfo(h[0].trim(),Integer.parseInt(h[1].trim()), 30000, h[2].trim().toString());

                array[i] = s;

            }

            shards = Arrays.asList(array);

            //配置密码

//          for (JedisShardInfo j : shards) {

//j.setPassword("admin");

//}

            System.out.println(shards);

        }else{

            System.out.println("请检查Redis配置，host项为必填项！格式[IP:PORT]");

        }

 

        pool = new ShardedJedisPool(new JedisPoolConfig(),shards);

        jedis = pool.getResource();        //获取资源

}

    

    public synchronized ShardedJedis getSingletonInstance(){

        return jedis; //获取资源

    }

    

    public synchronized static void returnResource(){

        pool.returnResource(jedis);//释放

    }

    

    public synchronized static void destroy(){

        pool.destroy();

    }

}

3.测试代码：

public static void main(String[] args) {

ApplicationContext context=new ClassPathXmlApplicationContext("springAnnotation-core.xml");

 

RedisInitBean rb = (RedisInitBean) context.getBean("RedisInitBean");

ShardedJedis jedis = rb.getSingletonInstance();

ShardedJedisPipeline pipeline = jedis.pipelined();

//long start = System.currentTimeMillis();

//        for (int i = 0; i < 10; i++) {

//            pipeline.set("key1" + i, "张" + i);      

//        }

//        List results = pipeline.syncAndReturnAll();//管道的数据提交server

//        long end = System.currentTimeMillis();

//        rb.returnResource();

//        rb.destroy();

//        System.out.println("分布式连接池异步调用耗时: " + ((end - start)/1000.0) + "秒");

//        try {

//            Thread.sleep(5000);//睡5秒，然后打印jedis返回的结果

//        } catch (InterruptedException e) {

//            e.printStackTrace();

//        }

//        System.out.println("返回结果："+results);

System.out.println(jedis.get("kk"));

        System.out.println(jedis.getShardInfo("kk").getName());

        

}

另外：

//jde.set("cnblog", "cnblog");

//jde.set("redis", "redis");

//jde.set("test", "test");

//jde.set("123456", "1234567");

//        Client client1 = jde.getShard("cnblog").getClient();

//        Client client2 = jde.getShard("redis").getClient();

//        Client client3 = jde.getShard("test").getClient();

//        Client client4 = jde.getShard("123456").getClient();

//        System.out.println(DataCaChe.getData("cnblog"));

//        ////打印key在哪个server中

//        System.out.println("cnblog in server:" + client1.getHost() + " and port is:" + client1.getPort());

//        System.out.println("redis  in server:" + client2.getHost() + " and port is:" + client2.getPort());

//        System.out.println("test   in server:" + client3.getHost() + " and port is:" + client3.getPort());

//        System.out.println("123456 in server:" + client4.getHost() + " and port is:" + client4.getPort());

可以看出来 存到了那个服务器。

以上增加数据后。在加入的任何服务都可以get到。

 

配置文件中只加入主服务。从服务虽然没在池中但是由于主从关系 从服务也可以get到主服务的数据。所以可以配置多个主从关系的分布。

8.redis解决并发：
Redis为单进程单线程模式，采用队列模式将并发访问变成串行访问，且多客户端对Redis的连接并不存在竞争关系。其次Redis提供一些命令SETNX，GETSET，可以方便实现分布式锁机制。

也可以使用队列以及redis发布订阅来消费方式处理。

因为这次是可行性的DEMO测试所以很多东西没有来得及做实战研究我就不BB了。

集群，哨兵，队列等模式等真正发布生产后在进行分享记录。


9.redis实际应用：
简单介绍一下我们实际应用的例子确定KEY的形式是必须的，这很重要关乎到你效率的快慢。

值我们一般插入序列化后的值，因为这样安全一些。
DEMO中的核心代码：
redis分片工厂在上述内容中：然后分享一个公用抽象方法。redis序列化的存取。
/**
* 根据key，使用管道，批量取value(value:取得是序列化对象)
* return Map String:传入的key，Object：序列化对象
*/
public static Map batchGetObject(Map keyMap){
ShardedJedis jedis = null;
Map returnMap = new HashMap();
try {
jedis = getJedisOfPool();
//调用管道异步处理
HashMap> valueMap = shardedJedisPipeline(keyMap,jedis);
       for(Iterator ite = valueMap.entrySet().iterator(); ite.hasNext();){  
           Map.Entry entry = (Map.Entry) ite.next();
           Response response=(Response)entry.getValue();
           byte[] value = response.get();
           if(null == value){
             String newKey = new String((byte[])entry.getKey());
             LoadDate(jedis, newKey);
             value = jedis.get(newKey.getBytes());
           }
           returnMap.put(new String((byte[])entry.getKey()), value==null?
             null:SerializationUtil.deserialize(value));
       }
} catch (Exception e) {
e.printStackTrace();
throw new RuntimeException("DataCaChe:批量查询Redis时有误,"+e.getMessage());
}
return returnMap;
}
/**
* 根据key，使用管道，批量取value(value:String对象)
* return Map String:传入的key，String：value 值
*/
public static Map batchGetString(Map keyMap){
ShardedJedis jedis = null;
Map returnMap = new HashMap();
try {
jedis = getJedisOfPool();
HashMap> valueMap = shardedJedisPipeline(keyMap, jedis);
       //获取后把value加工一下，不可以在上面加工因为是异步获取value
       for(Iterator ite = valueMap.entrySet().iterator(); ite.hasNext();){  
           Map.Entry entry = (Map.Entry) ite.next();
           Response response=(Response)entry.getValue();
           byte[] value = response.get();
           if(null == value){
             LoadDate(jedis, (String)entry.getKey());
             String stringValue = jedis.get((String)entry.getKey());
             if(EmptyUtils.isEmpty(stringValue)){
             value = null;
             }else{
             value = stringValue.getBytes();
             }
           }
           returnMap.put((String)entry.getKey(), value==null?null:new String(value));
       }
} catch (Exception e) {
e.printStackTrace();
throw new RuntimeException("批量查询Redis时有误"+e.getMessage());
} finally{
jedis.close();
}
return returnMap;
}
/**
* 异步管道处理
*/
public static HashMap> shardedJedisPipeline(Map keyMap,ShardedJedis jedis){
HashMap> valueMap=new HashMap>();
try {
ShardedJedisPipeline pipeline = jedis.pipelined();//获取管道异步处理
       for(Iterator ite = keyMap.entrySet().iterator(); ite.hasNext();){  
           Map.Entry entry = (Map.Entry) ite.next();
           valueMap.put(((String) entry.getKey()).getBytes(), pipeline.get(((String) entry.getKey()).getBytes()));
       }
       pipeline.sync();
} catch (Exception e) {
e.printStackTrace();
throw new RuntimeException("批量查询Redis时有误"+e.getMessage());
} finally{
jedis.close();
}
return valueMap;
}
/**
* 存入序列化对象
* @param key
* @return
*/
public static void setSerialObject(String key,Object value) {
ShardedJedis jedis = null;
try {
jedis = getJedisOfPool();
jedis.set(key.getBytes(), SerializationUtil.serialize(value));
} catch (Exception e) {
e.printStackTrace();
} finally{
jedis.close();
}
}
/**
* 通过key 取对象值
* @param key
* @return
*/
public static Object getSerialObject(String newKey) {
ShardedJedis jedis = null;
Object obj = null;
try {
jedis = getJedisOfPool();
//有直接取，直接用jedis对象判断不要再去池中拿了
if(jedis.exists(newKey)){
return SerializationUtil.deserialize(jedis.get(newKey.getBytes()));
}
synchronized (lock) {
obj = jedis.get(newKey);//再次获取防止别的操作已经加载
if (obj == null){
LoadDate(jedis,newKey);//获取不到去数据库查
return jedis.get(newKey.getBytes())==null?
null:SerializationUtil.deserialize(jedis.get(newKey.getBytes()));
}
}
} catch (Exception e) {
e.printStackTrace();
} finally{
jedis.close();
}
return null;
}
序列化工具类：
/**
 * 序列化工具
 * @author Harley 2017 01 04
 *
 */
public class SerializationUtil {
    /**
     * 序列化
     * 
     * @param object
     * @return
     */
    public static byte[] serialize(Object object) {
        ObjectOutputStream oos = null;
        ByteArrayOutputStream baos = null;
        try {
            baos = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(baos);
            oos.writeObject(object);
            byte[] bytes = baos.toByteArray();
            return bytes;
        } catch (Exception e) {
        }
        return null;
    }


    /**
     * 反序列化
     * 
     * @param bytes
     * @return
     */
    public static Object deserialize(byte[] bytes) {
        ByteArrayInputStream bais = null;
        try {
            bais = new ByteArrayInputStream(bytes);
            ObjectInputStream ois = new ObjectInputStream(bais);
            return ois.readObject();
        } catch (Exception e) {


        }
        return null;
    }


}
可以直接拿去用，省的写了。
--------------------- 
作者：ServiceGood 
来源：CSDN 
原文：https://blog.csdn.net/liud1/article/details/54946644 
版权声明：本文为博主原创文章，转载请附上博文链接！

你可能感兴趣的:([分布式][Redis]Redis分布式框架搭建与集成)

  • 斤斤计较的婚姻到底有多难？ 白心之岂必有为
    很多人私聊我会问到在哪个人群当中斤斤计较的人最多？我都会回答他，一般婚姻出现问题的斤斤计较的人士会非常多，以我多年经验，在婚姻落的一塌糊涂的人当中，斤斤计较的人数占比在20～30%以上，也就是说10个婚姻出现问题的斤斤计较的人有2-3个有多不减。在婚姻出问题当中，有大量的心理不平衡的、尖酸刻薄的怨妇。在婚姻中仅斤斤计较有两种类型：第一种是物质上的，另一种是精神上的。在物质与精神上抠门已经严重的影响
  • QQ群采集助手，精准引流必备神器 2401_87347160 其他经验分享
    功能概述微信群查找与筛选工具是一款专为微信用户设计的辅助工具，它通过关键词搜索功能，帮助用户快速找到相关的微信群，并提供筛选是否需要验证的群组的功能。主要功能关键词搜索：用户可以输入关键词，工具将自动查找包含该关键词的微信群。筛选功能：工具提供筛选机制，用户可以选择是否只显示需要验证或不需要验证的群组。精准引流：通过上述功能，用户可以更精准地找到目标群组，进行有效的引流操作。3.设备需求该工具可以
  • 机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习python
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
  • 随笔 | 仙一般的灵气 海思沧海
    仙岛今天，我看了你全部，似乎已经进入你的世界我不知道，这是否是梦幻，还是你仙一般的灵气吸引了我也许每一个人都要有一份属于自己的追求，这样才能够符合人生的梦想，生活才能够充满着阳光与快乐我不知道，我为什么会这样的感叹，是在感叹自己的人生，还是感叹自己一直没有孜孜不倦的追求只感觉虚度了光阴，每天活在自己的梦中，活在一个不真实的世界是在逃避自己，还是在逃避周围的一切有时候我嘲笑自己，嘲笑自己如此的虚无，
  • 一百九十四章. 自相矛盾 巨木擎天
    唉！就这么一夜，林子感觉就像过了很多天似的，先是回了阳间家里，遇到了那么多不可思议的事情儿。特别是小伙伴们，第二次与自己见面时，僵硬的表情和恐怖的气氛，让自己如坐针毡，打从心眼里难受！还有东子，他现在还好吗？有没有被人欺负？护城河里的小鱼小虾们，还都在吗？水不会真的干枯了吧？那对相亲相爱漂亮的太平鸟儿，还好吧！春天了，到了做窝、下蛋、喂养小鸟宝宝的时候了，希望它们都能够平安啊！虽然没有看见家人，也
  • 微服务下功能权限与数据权限的设计与实现 nbsaas-boot 微服务java架构
    在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
  • 学点心理知识，呵护孩子健康 静候花开_7090
    昨天听了华中师范大学教育管理学系副教授张玲老师的《哪里才是学生心理健康的最后庇护所，超越教育与技术的思考》的讲座。今天又重新学习了一遍，收获匪浅。张玲博士也注意到了当今社会上的孩子由于心理问题导致的自残、自杀及伤害他人等恶性事件。她向我们普及了一个重要的命题，她说心理健康的一些基本命题，我们与我们通常的一些教育命题是不同的，她还举了几个例子，让我们明白我们原来以为的健康并非心理学上的健康。比如如果
  • 《投行人生》读书笔记 小蘑菇的树洞
    《投行人生》----作者詹姆斯-A-朗德摩根斯坦利副主席40年的职业洞见-很短小精悍的篇幅，比较适合初入职场的新人。第一部分成功的职业生涯需要规划1.情商归为适应能力分享与协作同理心适应能力，更多的是自我意识，你有能力识别自己的情并分辨这些情绪如何影响你的思想和行为。2.对于初入职场的人的建议，细节，截止日期和数据很重要截止日期，一种有效的方法是请老板为你所有的任务进行优先级排序。和老板喝咖啡的好
  • Long类型前后端数据不一致 igotyback 前端
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
  • 店群合一模式下的社区团购新发展——结合链动 2+1 模式、AI 智能名片与 S2B2C 商城小程序源码 说私域 人工智能小程序
    摘要：本文探讨了店群合一的社区团购平台在当今商业环境中的重要性和优势。通过分析店群合一模式如何将互联网社群与线下终端紧密结合，阐述了链动2+1模式、AI智能名片和S2B2C商城小程序源码在这一模式中的应用价值。这些创新元素的结合为社区团购带来了新的机遇，提升了用户信任感、拓展了营销渠道，并实现了线上线下的完美融合。一、引言随着互联网技术的不断发展，社区团购作为一种新兴的商业模式，在满足消费者日常需
  • 2021-08-26 影幽
    在生活中，女人与男人的感悟往往有所不同。人生最大的舞台就是生活，大幕随时都可能拉开，关键是你愿不愿意表演都无法躲避。在生活中，遇事不要急躁，不要急于下结论，尤其生气时不要做决断，要学会换位思考，大事化小小事化了，把复杂的事情尽量简单处理，千万不要把简单的事情复杂化。永远不要扭曲，别人善意，无药可救。昨天是张过期的支票，明天是张信用卡，只有今天才是现金，要善加利用！执着的攀登者不必去与别人比较自己的
  • 高级编程--XML+socket练习题 masa010 java开发语言
    1.北京华北2114.8万人上海华东2,500万人广州华南1292.68万人成都华西1417万人（1）使用dom4j将信息存入xml中（2）读取信息，并打印控制台（3）添加一个city节点与子节点（4）使用socketTCP协议编写服务端与客户端，客户端输入城市ID，服务器响应相应城市信息（5）使用socketTCP协议编写服务端与客户端，客户端要求用户输入city对象，服务端接收并使用dom4j
  • 2018-07-23-催眠日作业-#不一样的31天#-66小鹿 小鹿_33
    预言日：人总是在逃避命运的路上，与之不期而遇。心理学上有个著名的名词，叫做自证预言；经济学上也有一个很著名的定律叫做，墨菲定律；在灵修派上，还有一个很著名的法则，叫做吸引力法则。这3个领域的词，虽然看起来不太一样，但是他们都在告诉人们一个现象：你越担心什么，就越有可能会发生什么。同样的道理，你越想得到什么，就应该要积极地去创造什么。无论是自证预言，墨菲定律还是吸引力法则，对人都有正反2个维度的影响
  • 回溯 Leetcode 332 重新安排行程 mmaerd Leetcode刷题学习记录leetcode算法职场和发展
    重新安排行程Leetcode332学习记录自代码随想录给你一份航线列表tickets，其中tickets[i]=[fromi,toi]表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。所有这些机票都属于一个从JFK（肯尼迪国际机场）出发的先生，所以该行程必须从JFK开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。例如，行程[“JFK”,“LGA”]与[“JFK”,“LGB
  • 每日一题——第九十题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：判断子串是否与主串匹配#include#include#include//////判断子串是否在主串中匹配//////主串///子串///boolisSubstring(constchar*str,constchar*substr){intlenstr=strlen(str);//计算主串的长度intlenSub=strlen(substr);//计算子串的长度//遍历主字符串，对每个可能得
  • Python数据分析与可视化实战指南 William数据分析 pythonpython数据
    在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
  • 《庄子.达生9》 钱江潮369
    【原文】孔子观于吕梁，县水三十仞，流沫四十里，鼋鼍鱼鳖之所不能游也。见一丈夫游之，以为有苦而欲死也，使弟子并流而拯之。数百步而出，被发行歌而游于塘下。孔子从而问焉，曰：“吾以子为鬼，察子则人也。请问，‘蹈水有道乎’”曰：“亡，吾无道。吾始乎故，长乎性，成乎命。与齐俱入，与汩偕出，从水之道而不为私焉。此吾所以蹈之也。”孔子曰：“何谓始乎故，长乎性，成乎命？”曰：“吾生于陵而安于陵，故也；长于水而安于
  • 水泥质量纠纷案代理词 徐宝峰律师
    贵州领航建设有限公司诉贵州纳雍隆庆乌江水泥有限公司产品质量纠纷案代理词尊敬的审判长、审判员：贵州千里律师事务所接受被告贵州纳雍隆庆乌江水泥有限公司的委托，指派我担任其诉讼代理人，参加本案的诉讼活动。下面，我结合本案事实和相关法律规定发表如下代理意见，供合议庭评议案件时参考：原告应当举证证明其遭受的损失与被告生产的水泥质量的因果关系。首先水泥是一种粉状水硬性无机胶凝材料。加水搅拌后成浆体，能在空气中
  • Goolge earth studio 进阶4——路径修改与平滑 陟彼高冈yu Googleearthstudio进阶教程旅游
    如果我们希望在大约中途时获得更多的城市鸟瞰视角。可以将相机拖动到这里并创建一个新的关键帧。camera_target_clip_7EarthStudio会自动平滑我们的路径，所以当我们通过这个关键帧时，不是一个生硬的角度，而是一个平滑的曲线。camera_target_clip_8路径上有贝塞尔控制手柄，允许我们调整路径的形状。右键单击，我们可以选择“平滑路径”，这是默认的自动平滑算法，或者我们可
  • PHP环境搭建详细教程 好看资源平台 前端php
    PHP是一个流行的服务器端脚本语言，广泛用于Web开发。为了使PHP能够在本地或服务器上运行，我们需要搭建一个合适的PHP环境。本教程将结合最新资料，介绍在不同操作系统上搭建PHP开发环境的多种方法，包括Windows、macOS和Linux系统的安装步骤，以及本地和Docker环境的配置。1.PHP环境搭建概述PHP环境的搭建主要分为以下几类：集成开发环境：例如XAMPP、WAMP、MAMP，这
  • 18-115 一切思考不能有效转化为行动，都TM是扯淡！ 成长时间线
    7月25号写了一篇关于为什么会断更如此严重的反思，然而，之后日更仅仅维持了一周，又出现了这次更严重的现象。从8月2号到昨天8月6号，5天！又是5天没有更文！虽然这次断更时间和上次一样，那为什么说这次更严重？因为上次之后就分析了问题的原因，以及应该如何解决，按理说应该会好转，然而，没过几天严重断更的现象再次出现，想想，经过反思，问题依然没有解决与改变，这让我有些担忧。到底是哪里出了问题，难道我就真的
  • 山东大学小树林支教调研团青青仓木队——翟晓楠 山东大学青青仓木队
    过了半年，又一次启程，又一次回到支教的初心之地。比起上一次的试探与不安，我更多了一丝稳重与熟练。心境、处境也都随着半个学期的过去而变得不同，半个学期中，身体上的，心理上的，太多的逆境让我变得步履维艰，曲曲折折，弯弯绕绕，我仿佛打不起精神，没有胃口，没有动力。感觉走的不顺畅的时候，支教这个旅程，给了我力量。自告奋勇承担起队长这一职务的我，从组织时的复杂和困难的经历，协调各种问题，从无到有，和校长和队
  • 直返最高等级与直返APP：无需邀请码的返利新体验 古楼
    随着互联网的普及和电商的兴起，直返模式逐渐成为一种流行的商业模式。在这种模式下，消费者通过购买产品或服务，获得一定的返利，并可以分享给更多的人。其中，直返最高等级和直返APP是直返模式中的重要概念和工具。本文将详细介绍直返最高等级的概念、直返APP的使用以及与邀请码的关系。【高省】APP（高佣金领导者）是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几百万篇报道，运行三年，稳定可靠。高省APP，
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计 网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
  • 2020-04-12每天三百字之连接与替代 冷眼看潮
    不知道是不是好为人师，有时候还真想和别人分享一下我对某些现象的看法或者解释。人类社会不断发展进步的过程，就是不断连接与替代的过程。人类发现了火并应用火以后，告别了茹毛饮血的野兽般的原始生活（火烧、烹饪替代了生食）人类用石器代替了完全手工，工具的使用使人类进步一大步。类似这样的替代还有很多，随着科技的发展，有更多的原始的事物被替代，代之以更高效、更先进的技术。在近现代，汽车替代了马车，高速公路和铁路
  • 探索OpenAI和LangChain的适配器集成：轻松切换模型提供商 nseejrukjhad langchaineasyui前端python
    #探索OpenAI和LangChain的适配器集成：轻松切换模型提供商##引言在人工智能和自然语言处理的世界中，OpenAI的模型提供了强大的能力。然而，随着技术的发展，许多人开始探索其他模型以满足特定需求。LangChain作为一个强大的工具，集成了多种模型提供商，通过提供适配器，简化了不同模型之间的转换。本篇文章将介绍如何使用LangChain的适配器与OpenAI集成，以便轻松切换模型提供商
  • 利用Requests Toolkit轻松完成HTTP请求 nseejrukjhad http网络协议网络python
    RequestsToolkit的力量：轻松构建HTTP请求Agent在现代软件开发中，API请求是与外部服务交互的核心。RequestsToolkit提供了一种便捷的方式，帮助开发者构建自动化的HTTP请求Agent。本文旨在详细介绍RequestsToolkit的设置、使用和潜在挑战。引言RequestsToolkit是一个强大的工具包，可用于构建执行HTTP请求的智能代理。这对于想要自动化与外
  • 利用LangChain的StackExchange组件实现智能问答系统 nseejrukjhad langchainmicrosoft数据库python
    利用LangChain的StackExchange组件实现智能问答系统引言在当今的软件开发世界中，StackOverflow已经成为程序员解决问题的首选平台之一。而LangChain作为一个强大的AI应用开发框架，提供了StackExchange组件，使我们能够轻松地将StackOverflow的海量知识库集成到我们的应用中。本文将详细介绍如何使用LangChain的StackExchange组件
  • 数组去重 好奇的猫猫猫
    整理自js中基础数据结构数组去重问题思考？如何去除数组中重复的项例如数组：[1,3,4,3,5]我们在做去重的时候，一开始想到的肯定是，逐个比较，外面一层循环，内层后一个与前一个一比较，如果是久不将当前这一项放进新的数组，挨个比较完之后返回一个新的去过重复的数组不好的实践方式上述方法效率极低，代码量还多，思考？有没有更好的方法这时候不禁一想当然有了！！！hashtable啊，通过对象的hash办法
  • GitHub上克隆项目 bigbig猩猩 github
    从GitHub上克隆项目是一个简单且直接的过程，它允许你将远程仓库中的项目复制到你的本地计算机上，以便进行进一步的开发、测试或学习。以下是一个详细的步骤指南，帮助你从GitHub上克隆项目。一、准备工作1.安装Git在克隆GitHub项目之前，你需要在你的计算机上安装Git工具。Git是一个开源的分布式版本控制系统，用于跟踪和管理代码变更。你可以从Git的官方网站（https://git-scm.
  • jvm调优总结（从基本概念 到 深度优化） oloz javajvmjdk虚拟机应用服务器
    JVM参数详解：http://www.cnblogs.com/redcreen/archive/2011/05/04/2037057.html   Java虚拟机中，数据类型可以分为两类：基本类型和引用类型。基本类型的变量保存原始值，即：他代表的值就是数值本身；而引用类型的变量保存引用值。“引用值”代表了某个对象的引用，而不是对象本身，对象本身存放在这个引用值所表示的地址的位置。
  • 【Scala十六】Scala核心十：柯里化函数 bit1129 scala
    本篇文章重点说明什么是函数柯里化，这个语法现象的背后动机是什么，有什么样的应用场景，以及与部分应用函数(Partial Applied Function)之间的联系   1. 什么是柯里化函数 A way to write functions with multiple parameter lists. For instance def f(x: Int)(y: Int) is a
  • HashMap dalan_123 java
    HashMap在java中对很多人来说都是熟的；基于hash表的map接口的非同步实现。允许使用null和null键；同时不能保证元素的顺序；也就是从来都不保证其中的元素的顺序恒久不变。 1、数据结构     在java中，最基本的数据结构无外乎：数组 和 引用（指针），所有的数据结构都可以用这两个来构造，HashMap也不例外，归根到底HashMap就是一个链表散列的数据
  • Java Swing如何实时刷新JTextArea，以显示刚才加append的内容 周凡杨 java更新swingJTextArea
    在代码中执行完textArea.append("message")后，如果你想让这个更新立刻显示在界面上而不是等swing的主线程返回后刷新，我们一般会在该语句后调用textArea.invalidate()和textArea.repaint()。 问题是这个方法并不能有任何效果，textArea的内容没有任何变化，这或许是swing的一个bug，有一个笨拙的办法可以实现
  • servlet或struts的Action处理ajax请求 g21121 servlet
    其实处理ajax的请求非常简单，直接看代码就行了： //如果用的是struts //HttpServletResponse response = ServletActionContext.getResponse(); // 设置输出为文字流 response.setContentType("text/plain"); // 设置字符集 res
  • FineReport的公式编辑框的语法简介 老A不折腾 finereport公式总结
    FINEREPORT用到公式的地方非常多，单元格（以=开头的便被解析为公式），条件显示，数据字典，报表填报属性值定义，图表标题，轴定义，页眉页脚，甚至单元格的其他属性中的鼠标悬浮提示内容都可以写公式。 简单的说下自己感觉的公式要注意的几个地方：   1.if语句语法刚接触感觉比较奇怪，if(条件式子,值1,值2)，if可以嵌套，if(条件式子1，值1，if(条件式子2，值2，值3)
  • linux mysql 数据库乱码的解决办法 墙头上一根草 linuxmysql数据库乱码
    linux 上mysql数据库区分大小写的配置 lower_case_table_names=1 1-不区分大小写 0-区分大小写   修改/etc/my.cnf 具体的修改内容如下:   [client] default-character-set=utf8   [mysqld] datadir=/var/lib/mysql socket=/va
  • 我的spring学习笔记6-ApplicationContext实例化的参数兼容思想 aijuans Spring 3
    ApplicationContext能读取多个Bean定义文件，方法是： ApplicationContext appContext = new ClassPathXmlApplicationContext（ new String[]｛“bean-config1.xml”，“bean-config2.xml”，“bean-config3.xml”，“bean-config4.xml
  • mysql 基准测试之sysbench annan211 基准测试mysql基准测试MySQL测试sysbench
    1 执行如下命令，安装sysbench-0.5： tar xzvf sysbench-0.5.tar.gz  cd sysbench-0.5  chmod +x autogen.sh  ./autogen.sh  ./configure --with-mysql --with-mysql-includes=/usr/local/mysql
  • sql的复杂查询使用案列与技巧 百合不是茶 oraclesql函数数据分页合并查询
      本片博客使用的数据库表是oracle中的scott用户表;          -------------------  自然连接查询           查询 smith 的上司(两种方法) &
  • 深入学习Thread类 bijian1013 javathread多线程java多线程
    一．             线程的名字 下面来看一下Thread类的name属性，它的类型是String。它其实就是线程的名字。在Thread类中，有String getName()和void setName(String)两个方法用来设置和获取这个属性的值。 同时，Thr
  • JSON串转换成Map以及如何转换到对应的数据类型 bijian1013 javafastjsonnet.sf.json
            在实际开发中，难免会碰到JSON串转换成Map的情况，下面来看看这方面的实例。另外，由于fastjson只支持JDK1.5及以上版本，因此在JDK1.4的项目中可以采用net.sf.json来处理。 一.fastjson实例 JsonUtil.java package com.study; impor
  • 【RPC框架HttpInvoker一】HttpInvoker：Spring自带RPC框架 bit1129 spring
    HttpInvoker是Spring原生的RPC调用框架，HttpInvoker同Burlap和Hessian一样，提供了一致的服务Exporter以及客户端的服务代理工厂Bean，这篇文章主要是复制粘贴了Hessian与Spring集成一文，【RPC框架Hessian四】Hessian与Spring集成   在 【RPC框架Hessian二】Hessian 对象序列化和反序列化一文中
  • 【Mahout二】基于Mahout CBayes算法的20newsgroup的脚本分析 bit1129 Mahout
    #!/bin/bash # # Licensed to the Apache Software Foundation (ASF) under one or more # contributor license agreements. See the NOTICE file distributed with # this work for additional information re
  • nginx三种获取用户真实ip的方法 ronin47
    随着nginx的迅速崛起，越来越多公司将apache更换成nginx. 同时也越来越多人使用nginx作为负载均衡, 并且代理前面可能还加上了CDN加速，但是随之也遇到一个问题：nginx如何获取用户的真实IP地址,如果后端是apache,请跳转到<apache获取用户真实IP地址>，如果是后端真实服务器是nginx，那么继续往下看。 实例环境： 用户IP 120.22.11.11
  • java-判断二叉树是不是平衡 bylijinnan java
    参考了 http://zhedahht.blog.163.com/blog/static/25411174201142733927831/ 但是用java来实现有一个问题。 由于Java无法像C那样“传递参数的地址，函数返回时能得到参数的值”，唯有新建一个辅助类：AuxClass import ljn.help.*; public class BalancedBTree {
  • BeanUtils.copyProperties VS PropertyUtils.copyProperties 诸葛不亮 PropertyUtilsBeanUtils
     BeanUtils.copyProperties VS  PropertyUtils.copyProperties  作为两个bean属性copy的工具类，他们被广泛使用，同时也很容易误用，给人造成困然；比如：昨天发现同事在使用BeanUtils.copyProperties copy有integer类型属性的bean时，没有考虑到会将null转换为0，而后面的业
  • [金融与信息安全]最简单的数据结构最安全 comsci 数据结构
          现在最流行的数据库的数据存储文件都具有复杂的文件头格式，用操作系统的记事本软件是无法正常浏览的，这样的情况会有什么问题呢？        从信息安全的角度来看，如果我们数据库系统仅仅把这种格式的数据文件做异地备份，如果相同版本的所有数据库管理系统都同时被攻击，那么
  • vi区段删除 Cwind linuxvi区段删除
    区段删除是编辑和分析一些冗长的配置文件或日志文件时比较常用的操作。简记下vi区段删除要点备忘。   vi概述    引文中并未将末行模式单独列为一种模式。单不单列并不重要，能区分命令模式与末行模式即可。   vi区段删除步骤： 1. 在末行模式下使用:set nu显示行号 非必须，随光标移动vi右下角也会显示行号，能够正确找到并记录删除开始行
  • 清除tomcat缓存的方法总结 dashuaifu tomcat缓存
    用tomcat容器，大家可能会发现这样的问题，修改jsp文件后，但用IE打开 依然是以前的Jsp的页面。 出现这种现象的原因主要是tomcat缓存的原因。 解决办法如下: 在jsp文件头加上 <meta http-equiv="Expires" content="0"> <meta http-equiv="kiben&qu
  • 不要盲目的在项目中使用LESS CSS dcj3sjt126com Webless
    　如果你还不知道LESS CSS是什么东西，可以看一下这篇文章，是我一朋友写给新人看的《CSS——LESS》 　　不可否认，LESS CSS是个强大的工具，它弥补了css没有变量、无法运算等一些“先天缺陷”，但它似乎给我一种错觉，就是为了功能而实现功能。 　　比如它的引用功能 ? .rounded_corners{     
  • [入门]更上一层楼 dcj3sjt126com PHPyii2
    更上一层楼 通篇阅读完整个“入门”部分，你就完成了一个完整 Yii 应用的创建。在此过程中你学到了如何实现一些常用功能，例如通过 HTML 表单从用户那获取数据，从数据库中获取数据并以分页形式显示。你还学到了如何通过 Gii 去自动生成代码。使用 Gii 生成代码把 Web 开发中多数繁杂的过程转化为仅仅填写几个表单就行。 本章将介绍一些有助于更好使用 Yii 的资源：
  • Apache HttpClient使用详解 eksliang httpclienthttp协议
    Http协议的重要性相信不用我多说了，HttpClient相比传统JDK自带的URLConnection，增加了易用性和灵活性（具体区别，日后我们再讨论），它不仅是客户端发送Http请求变得容易，而且也方便了开发人员测试接口（基于Http协议的），即提高了开发的效率，也方便提高代码的健壮性。因此熟练掌握HttpClient是很重要的必修内容，掌握HttpClient后，相信对于Http协议的了解会
  • zxing二维码扫描功能 gundumw100 androidzxing
    经常要用到二维码扫描功能 现给出示例代码 import com.google.zxing.WriterException; import com.zxing.activity.CaptureActivity; import com.zxing.encoding.EncodingHandler; import android.app.Activity; import an
  • 纯HTML+CSS带说明的黄色导航菜单 ini htmlWebhtml5csshovertree
    HoverTree带说明的CSS菜单:纯HTML+CSS结构链接带说明的黄色导航   在线体验效果：http://hovertree.com/texiao/css/1.htm代码如下,保存到HTML文件可以看到效果：   <!DOCTYPE html > <html > <head> <title>HoverTree
  • fastjson初始化对性能的影响 kane_xie fastjson序列化
    之前在项目中序列化是用thrift，性能一般，而且需要用编译器生成新的类，在序列化和反序列化的时候感觉很繁琐，因此想转到json阵营。对比了jackson，gson等框架之后，决定用fastjson，为什么呢，因为看名字感觉很快。。。   网上的说法：   fastjson 是一个性能很好的 Java 语言实现的 JSON 解析器和生成器，来自阿里巴巴的工程师开发。
  • 基于Mybatis封装的增删改查实现通用自动化sql mengqingyu DAO
    1.基于map或javaBean的增删改查可实现不写dao接口和实现类以及xml，有效的提高开发速度。 2.支持自定义注解包括主键生成、列重复验证、列名、表名等 3.支持批量插入、批量更新、批量删除 <bean id="dynamicSqlSessionTemplate" class="com.mqy.mybatis.support.Dynamic
  • js控制input输入框的方法封装(数字，中文，字母，浮点数等) qifeifei javascript js
    在项目开发的时候，经常有一些输入框，控制输入的格式，而不是等输入好了再去检查格式，格式错了就报错，体验不好。 /** 数字，中文，字母,浮点数(+/-/.) 类型输入限制，只要在input标签上加上 jInput="number,chinese,alphabet,floating" 备注：floating属性只能单独用*/     funct
  • java 计时器应用 tangqi609567707 javatimer
    mport java.util.TimerTask;   import java.util.Calendar;   public class MyTask extends TimerTask {        private static final int
  • erlang输出调用栈信息 wudixiaotie erlang
    在erlang otp的开发中，如果调用第三方的应用，会有有些错误会不打印栈信息，因为有可能第三方应用会catch然后输出自己的错误信息，所以对排查bug有很大的阻碍，这样就要求我们自己打印调用的栈信息。用这个函数：erlang:process_display (self (), backtrace).需要注意这个函数只会输出到标准错误输出。 也可以用这个函数：erlang:get_s