redis 与java的连接 和集群环境下Session管理

redis 的安装与设置开机自启（https://www.cnblogs.com/zhulina-917/p/11746993.html）

 第一步：

a) 搭建环境 引入 jedis jar包 commons-lang3.jar

b) 扩展MyBatis 应用Redis 扩展 Cache 

1. MyBatis 应用 Redis作为缓存的开发步骤

2. Redis与java连接

当我们要连接java 代码时，配置文件默认绑定的端口号是127.0.0.1 那么也就意味着使用的是本机进行连接 此时如果要能够被eclipse访问就需要改变ip地址 可以

使用   redis-cli -h 192.168.253.101 -p 6379

public class Demo01 {
  public static void main(String[] args) {
    //连接本地的 Redis 服务
    Jedis jedis = new Jedis("127.0.0.1",6379);
    //查看服务是否运行，打出pong表示OK
    System.out.println("connection is OK==========>: "+jedis.ping());
  }
}

 

package com.atguigu.redis.test;
import java.util.*;
import redis.clients.jedis.Jedis;
public class Test02 {
  public static void main(String[] args) {
     Jedis jedis = new Jedis("127.0.0.1",6379);
     //key
     Set<String> keys = jedis.keys("*");
     System.out.println("jedis.exists====>"+jedis.exists("k2"));
     System.out.println(jedis.ttl("k1"));
     //String
     //jedis.append("k1","myreids");
     System.out.println(jedis.get("k1"));
     jedis.set("k4","k4_redis");
     System.out.println("----------------------------------------");
     jedis.mset("str1","v1","str2","v2","str3","v3");
     System.out.println(jedis.mget("str1","str2","str3"));
     //list
     System.out.println("----------------------------------------");
     //jedis.lpush("mylist","v1","v2","v3","v4","v5");
     List<String> list = jedis.lrange("mylist",0,-1);
  
     //set
     jedis.sadd("orders","jd001");
     jedis.sadd("orders","jd002");
     jedis.sadd("orders","jd003");
     Set<String> set1 = jedis.smembers("orders");
   
     jedis.srem("orders","jd002");
     System.out.println(jedis.smembers("orders").size());
     //hash
     jedis.hset("hash1","userName","lisi");
     System.out.println(jedis.hget("hash1","userName"));
     Map<String,String> map = new HashMap<String,String>();
     map.put("telphone","13811814763");
     map.put("address","atguigu");
     map.put("email","abc@163.com");
     jedis.hmset("hash2",map);
     List<String> result = jedis.hmget("hash2", "telphone","email");
    
     //zset
     jedis.zadd("zset01",60d,"v1");
     jedis.zadd("zset01",70d,"v2");
     jedis.zadd("zset01",80d,"v3");
     jedis.zadd("zset01",90d,"v4");
     
     Set<String> s1 = jedis.zrange("zset01",0,-1);
  
  }
}

事务

package com.atguigu.redis.test;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.Response;
import redis.clients.jedis.Transaction;

public class Test03 
{
  public static void main(String[] args) 
{
     Jedis jedis = new Jedis("127.0.0.1",6379);
     
     //监控key，如果该动了事务就被放弃
     /*3
     jedis.watch("serialNum");
     jedis.set("serialNum","s#####################");
     jedis.unwatch();*/
     
     Transaction transaction = jedis.multi();//被当作一个命令进行执行
     Response<String> response = transaction.get("serialNum");
     transaction.set("serialNum","s002");
     response = transaction.get("serialNum");
     transaction.lpush("list3","a");
     transaction.lpush("list3","b");
     transaction.lpush("list3","c");
     
     transaction.exec();
     //2 transaction.discard();
     System.out.println("serialNum***********"+response.get());      
  }
}

public class TestTransaction {

  public boolean transMethod() {
     Jedis jedis = new Jedis("127.0.0.1", 6379);
     int balance;// 可用余额
     int debt;// 欠额
     int amtToSubtract = 10;// 实刷额度

     jedis.watch("balance");
     //jedis.set("balance","5");//此句不该出现，讲课方便。模拟其他程序已经修改了该条目
     balance = Integer.parseInt(jedis.get("balance"));
     if (balance < amtToSubtract) {
       jedis.unwatch();
       System.out.println("modify");
       return false;
     } else {
       System.out.println("***********transaction");
       Transaction transaction = jedis.multi();
       transaction.decrBy("balance", amtToSubtract);
       transaction.incrBy("debt", amtToSubtract);
       transaction.exec();
       balance = Integer.parseInt(jedis.get("balance"));
       debt = Integer.parseInt(jedis.get("debt"));

       System.out.println("*******" + balance);
       System.out.println("*******" + debt);
       return true;
     }
  }
  /**
  * 通俗点讲，watch命令就是标记一个键，如果标记了一个键， 在提交事务前如果该键被别人修改过，那事务就会失败，这种情况通常可以在程序中
  * 重新再尝试一次。
  * 首先标记了键balance，然后检查余额是否足够，不足就取消标记，并不做扣减； 足够的话，就启动事务进行更新操作，
  * 如果在此期间键balance被其它人修改， 那在提交事务（执行exec）时就会报错， 程序中通常可以捕获这类错误再重新执行一次，直到成功。
  */
  public static void main(String[] args) {
     TestTransaction test = new TestTransaction();
     boolean retValue = test.transMethod();
     System.out.println("main retValue-------: " + retValue);
  }
}

主从复制

public static void main(String[] args) throws InterruptedException 
  {
     Jedis jedis_M = new Jedis("127.0.0.1",6379);
     Jedis jedis_S = new Jedis("127.0.0.1",6380);
     
     jedis_S.slaveof("127.0.0.1",6379);
     
     jedis_M.set("k6","v6");
     Thread.sleep(500);
     System.out.println(jedis_S.get("k6"));
  }

JedisPoolUtil

package com.atguigu.redis.test;

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

public class JedisPoolUtil {
  
 private static volatile JedisPool jedisPool = null;//被volatile修饰的变量不会被本地线程缓存，对该变量的读写都是直接操作共享内存。
  
  private JedisPoolUtil() {}
  
  public static JedisPool getJedisPoolInstance()
 {
     if(null == jedisPool)
   {
       synchronized (JedisPoolUtil.class)
     {
          if(null == jedisPool)
        {
          JedisPoolConfig poolConfig = new JedisPoolConfig();
          poolConfig.setMaxActive(1000);
          poolConfig.setMaxIdle(32);
          poolConfig.setMaxWait(100*1000);
          poolConfig.setTestOnBorrow(true);
            
            jedisPool = new JedisPool(poolConfig,"127.0.0.1");
        }
     }
   }
     return jedisPool;
 }
  public static void release(JedisPool jedisPool,Jedis jedis)
 {
     if(null != jedis)
   {
     jedisPool.returnResourceObject(jedis);
   }
 }
}

package com.atguigu.redis.test;

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

public class Test01 {
  public static void main(String[] args) {
     JedisPool jedisPool = JedisPoolUtil.getJedisPoolInstance();
     Jedis jedis = null;
     
     try 
     {
       jedis = jedisPool.getResource();
       jedis.set("k18","v183");
       
     } catch (Exception e) {
       e.printStackTrace();
     }finally{
       JedisPoolUtil.release(jedisPool, jedis);
     }
  }
}

 

集群环境下Session管理

1. 集群环境下管理HTTPSession遇到的问题：

在多个服务器中，session是不能够互通的为了解决这个问题 集群环境下管理session的4种方式

 

1. Session的Replication（复制）将当前服务器中使用的session全部复制到其他服务器

          缺陷：Session数据冗余 浪费内存资源

2. Session的sticky  session的黏着 session只能单点操作发布到一个Tomcat上

缺陷：存在单节点故障，容易操作数据丢失

3. Cookie的保存状态

4. 通过Redis或者Memcache等分布式缓存集中管理Session

Redis是一个基于内存的key-value的内存数据库

Session存Redis中 因为要跨网络session需要序列化 key=sessionid     value=session

Tomcat

Cookie = jsessionid

Jedis.get(“jsessionid”) ===session

通过Redis集中管理session的开发步骤  但是这种操作在eclipse中部署不会出现问题如果使用idea则会出现问题

通过Redis集中管理Session的开发步骤
1、在tomcat的lib目录中导入
        tomcat-redis-session-manager-1.2-tomcat-6.jar
        jedis-2.0.0.jar
        commons-pool-1.6
2、在tomcat的conf目录中修改context.xml配置文件
    <Valve className="com.radiadesign.catalina.session.RedisSessionHandlerValve" />
       <Manager className="com.radiadesign.catalina.session.RedisSessionManager"
                                   host="192.168.1.105"
                                   port="6379"
                                   maxInactiveInterval="60"/>

注意：Java中的实体类需要实现序列化接口

实现序列化的目的不仅仅是将对象写入到文件中更多的是可以进行对象的网络传输

所谓的复制session就是通过一个流将session传过来。Session传过来，session中的对象也要传过来，所以这个user对象要实现序列化。String已经实现了序列化8中基本类型包装器

 

网络中传输实体的方式？

序列化 效率高，序列化传输的是二进制的内容 基于传输层  内网 tcp 局域网

JSON：传输的是字符串       

Redis的分片(sharding)

1. 为什么要是用分片

例如：将1000万数据量拆分成10分100万的数据使用10个redis 服务器进行处理

这个是分而治之的思想。可以提高查询效率。

2. 怎么实现分片？

Redis2.x 通过程序员自己实现  （客户端的分片）

Redis3.x redis支持分片的特性 （又叫服务器分片） 

3. 分片是如何进行选取的？

Hash 取模的思想 余数是几就对应哪个redis 有几个redis就对几取模

 

Redis3.0x的特点

1. 支持sharding

2.支持master-slaver 

3.支持auto failover(自动故障切换)

如果从节点发现主节点宕机 那么会自动称为主节点

Redis3.x集群中

Hashsolt（虚拟的概念） hash槽

好处：便于提高查询效率

便于集群的扩展，当增加一个节点的时候，如果移动数据是很难移动的，但是移动槽是很容易的，同理如果一个节点宕机了，移动数据也是很难做到的，那么移动槽就会很容易