飞天班第37节：Redis（Final）

public class TestKey {
	public static void main(String[] args) {
		// Jedis 就是我们之前使用的客户端工具，抽象成为对象！
		Jedis jedis = new Jedis("39.99.3.39",6379);
    // 需要密码的要加这一行
		jedis.auth("xxxxdis");

		// 里面所有学习过的方法，都是我们之前命令的方法
		// System.out.println(jedis.flushDB());
		System.out.println(jedis.exists("username"));
		System.out.println(jedis.set("username", "jude"));
		System.out.println(jedis.get("username"));
    System.out.println(jedis.mset("k10","v10","k11","v11","k12","v12"));
		System.out.println(jedis.mget("k10","k11","k12"));
	}
}

public static void main(String[] args) {
  // 1、连接redis
  Jedis jedis = new Jedis("139.199.13.139",6379);
  jedis.auth("juderedis");

  // 2、初始数据
  jedis.set("money","100");
  jedis.set("use","0");
  jedis.watch("money"); // 事务开始之前监控money，事务过程中这个money没有发生变化，这个事务才可以执行成功，否则事务自动取消
  
  // 3、开启事务
  Transaction multi = jedis.multi();

  // 4、事务处理
  try {
    multi.decrBy("money",20);
    multi.incrBy("use",20);
    multi.exec();
  } catch (Exception e) {
    e.printStackTrace();
    multi.discard();
  } finally {
    System.out.println(jedis.get("money"));
    System.out.println(jedis.get("use"));
    jedis.close();
  }
}

@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(RedisOperations.class)
@EnableConfigurationProperties(RedisProperties.class)
// 引入了两个连接池，但实际上是使用lettuce做为连接池，jedis连接池失效，点击JedisConnectionConfiguration的源码就知道了
@Import({ LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class })
public class RedisAutoConfiguration {

  // 启动时，向spring注入了两个bean
  // 太简单，不符合真实开发需要，建议自定义一个Bean redisTemplate,则该bean失效
	@Bean
	@ConditionalOnMissingBean(name = "redisTemplate")
	public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory)
			throws UnknownHostException {
		RedisTemplate<Object, Object> template = new RedisTemplate<>();
		template.setConnectionFactory(redisConnectionFactory);
		return template;
	}

  // 因为在redis中，String最常用，所以单独提出一个bean
	@Bean
	@ConditionalOnMissingBean
	public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory)
			throws UnknownHostException {
		StringRedisTemplate template = new StringRedisTemplate();
		template.setConnectionFactory(redisConnectionFactory);
		return template;
	}
}

@Autowired
	RedisTemplate<String,String> redisTemplate;

@Test
public void testOps(){
  redisTemplate.opsForValue().set("name","jude");

  // list,向左插入值
  redisTemplate.opsForList().leftPush("mylist","one","two");
  // set,插入元素到集合
  redisTemplate.opsForSet().add("myset","hello","coding","world");
  // hash,给哈希key的field设置值
  redisTemplate.opsForHash().put("myhash","filed1","hello");
  // zset,员工的工资，安工资排序
  redisTemplate.opsForZSet().add("salary","jude",5000);
  // geo,添加城市和地理位置
  redisTemplate.opsForGeo().add("china:city",new Point(116.23128,40.22077),"北京");
  // bitmap,员工打卡情况
  redisTemplate.opsForValue().setBit("sign:12",1,true);
  // hyperloglog,统计基数
  redisTemplate.opsForHyperLogLog().add("myhyper","1","3","5","1","3");
  System.out.println(redisTemplate.opsForValue().getBit("sign:12",1));

  // bitmap统计，返回1的个数
  System.out.println(bitcount("sign:12"));
}

// redisTemplate 不能使用bitcount方法，需要自己扩充
private long bitcount(String key){
  return redisTemplate.execute((RedisCallback<Long>) redisConnection -> redisConnection.bitCount(key.getBytes()));
}

@Configuration
public class RedisConfig {
    // 对于对象和hash<key,value> 使用这个主要就是对象转换和编码问题！
    @Bean
    @SuppressWarnings("all")
    public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory factory){
        // 改为自己要操作的对象模式
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        // Object 如何序列化的问题
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper mapper = new ObjectMapper();
        mapper.setVisibility(PropertyAccessor.ALL,JsonAutoDetect.Visibility.ANY);
        mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(mapper);

        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
      
        // key: String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash: String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // Object： Jsckson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        // hashObject： Jsckson
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        // 其与的类型设置同理
      
      	// 生效
        template.afterPropertiesSet();

        return template;
    }
}

@Component
public class RedisUtils {
	@Autowired
	RedisTemplate<String,Object> redisTemplate;

	// ============================= common ============================

	/**
	 * 指定缓存失效时间
	 * @param key
	 * @param timeout
	 * @return
	 */
	public  boolean expire(String key,long timeout){
		try{
			if(timeout > 0){
				redisTemplate.expire(key,timeout, TimeUnit.SECONDS);
			}
			return true;
		}catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}



	// ============================ String =============================

	/**
	 * 普通缓存放入
	 * @param key
	 * @param value
	 * @return
	 */
	public boolean set(String key,Object value){
		try{
			redisTemplate.opsForValue().set(key,value);
			return true;
		}catch (Exception e){
			e.printStackTrace();
			return false;
		}
	}

	// ============================ List =============================

	/**
	 * 获取list缓存的内容
	 * @param key
	 * @param start
	 * @param end
	 * @return
	 */
	public List<Object> lrange(String key, long start, long end) {
		try{
			return redisTemplate.opsForList().range(key,start,end);
		}catch (Exception e){
			e.printStackTrace();
			return null;
		}
	}


	// ============================ Set =============================

	/**
	 * 将数据放入set缓存
	 *
	 * @param key    键
	 * @param values 值 可以是多个
	 * @return 成功个数
	 */
	public long sadd(String key, Object... values) {
		try {
			return redisTemplate.opsForSet().add(key, values);
		} catch (Exception e) {
			e.printStackTrace();
			return 0;
		}
	}

	// ============================ HashMap =============================
	/**
	 * 向一张hash表中放入数据,如果不存在将创建
	 *
	 * @param key   键
	 * @param item  项
	 * @param value 值
	 * @param timeout  失效时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
	 * @return true 成功 false失败
	 */
	public boolean hset(String key, String item, Object value, long timeout) {
		try {
			redisTemplate.opsForHash().put(key, item, value);
			if (timeout > 0) {
				expire(key, timeout);
			}
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}
	
	// ============================ zSet =============================

	// ============================ Geo =============================

	// ============================ Bitmaps =============================

	// ============================ HyperLogLog =============================
}

RedisUtils redis = new RedisUtils();
redis.hset("user","name","jude",10*60);

// 伪代码
public String getPassThrough(String key) {  
  // 从缓存中获取数据  
  String cacheValue = cache.get(key);  
  // 缓存为空  
  if (StringUtils.isBlank(cacheValue)) {  
    // 从存储中获取  
    String storageValue = storage.get(key);  
    cache.set(key, storageValue);  
    // 如果存储数据为空，需要设置一个过期时间(300秒)  
    if (StringUtils.isBlank(storageValue)) {  
      cache.expire(key, 60 * 5);  
    }  
    return storageValue;  
  } else {  
    // 缓存非空  
    return cacheValue;  
  }  
} 

public class TestBF {
  public static void main(String[] args) {

    // 创建一个布隆过滤器
    // 第一个参数：字符集
    // 第二个参数：预计插入数据的长度（二进制向量的容量长度）
    // 第三个参数：fpp就是期望的误判率，错误率越低，需要的空间越大
    BloomFilter<CharSequence> bloomFilter = BloomFilter.create(Funnels.stringFunnel(Charset.forName("utf-8")), 100000, 0.000001);

    // 填满数据
    for (int i = 0; i <100000; i++) {
      bloomFilter.put(String.valueOf(i));
    }

    int flag = 0;
    // 查询数据（故意查不存在的）
    for (int i = 100000; i < 200000; i++) {
      if (bloomFilter.mightContain(String.valueOf(i))){
        flag++;
      }
    }

    // 查询存在的数据（100% 可以查到）
    for (int i = 0; i < 100000; i++) {
      if (bloomFilter.mightContain(String.valueOf(i))){
        flag++;
      }
    }

    System.out.println("误判了："+ flag);
  }
}

package com.coding;

import io.rebloom.client.Client;

public class TestBF {
  public static void main(String[] args) {
    Client bfClient = new Client("127.0.0.1", 6379);
    // 创建一个过滤器，容量为1000个元素，误判率为0.01
    bfClient.createFilter("icoding",1000,0.01);
    // 向bf中添加数据（将这个数据hash运算之后，）
    bfClient.add("bm-icoding","arry");
    // 然后再次判断这个值是够存在 coding，hash，然后比对。！
    System.out.println(bfClient.exists("bm-icoding","coding"));
  }
}

@RestController
public class TestRedisson {

	@Autowired
	RedissonClient redissonClient;

	@GetMapping("redission")
	public String testRedison(){
		RLock userLock = redissonClient.getLock("userid:1223");
		System.out.println("get Lock");
		try{
			// 如果有锁，等待5秒，如果拿到了锁持有30秒
			userLock.tryLock(5,30, TimeUnit.SECONDS);
			System.out.println("获取到锁");
			TimeUnit.SECONDS.sleep(20);
			System.out.println("88");
		}catch (InterruptedException e){
			e.printStackTrace();
		}finally {
			System.out.println("释放锁");
			userLock.unlock();
		}
		return "redission";
	}
}

private Long tryAcquire(long leaseTime, TimeUnit unit, long threadId) {
  return get(tryAcquireAsync(leaseTime, unit, threadId));
}

    <T> RFuture<T> tryLockInnerAsync(long leaseTime, TimeUnit unit, long threadId, RedisStrictCommand<T> command) {
        internalLockLeaseTime = unit.toMillis(leaseTime);

        return evalWriteAsync(getName(), LongCodec.INSTANCE, command,
                "if (redis.call('exists', KEYS[1]) == 0) then " +
                        "redis.call('hincrby', KEYS[1], ARGV[2], 1); " +
                        "redis.call('pexpire', KEYS[1], ARGV[1]); " +
                        "return nil; " +
                        "end; " +
                        "if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then " +
                        "redis.call('hincrby', KEYS[1], ARGV[2], 1); " +
                        "redis.call('pexpire', KEYS[1], ARGV[1]); " +
                        "return nil; " +
                        "end; " +
                        "return redis.call('pttl', KEYS[1]);", // 返回key的剩余生存时间，因为当前线程bu
                Collections.singletonList(getName()), internalLockLeaseTime, getLockName(threadId));
    }

   protected <T> RFuture<T> evalWriteAsync(String key, Codec codec, RedisCommand<T> evalCommandType, String script, List<Object> keys, Object... params) {
        CommandBatchService executorService = createCommandBatchService();
        RFuture<T> result = executorService.evalWriteAsync(key, codec, evalCommandType, script, keys, params);
        if (!(commandExecutor instanceof CommandBatchService)) {
            executorService.executeAsync();
        }
        return result;
    }

private void scheduleExpirationRenewal(long threadId) {
  ExpirationEntry entry = new ExpirationEntry();
  ExpirationEntry oldEntry = EXPIRATION_RENEWAL_MAP.putIfAbsent(getEntryName(), entry);
  if (oldEntry != null) {
    oldEntry.addThreadId(threadId);
  } else {
    entry.addThreadId(threadId);
    renewExpiration(); // 失效前续命
  }
}

private void renewExpiration() {
  ExpirationEntry ee = EXPIRATION_RENEWAL_MAP.get(getEntryName());
  if (ee == null) {
    return;
  }

  Timeout task = commandExecutor.getConnectionManager().newTimeout(new TimerTask() {
    @Override
    public void run(Timeout timeout) throws Exception {
      ExpirationEntry ent = EXPIRATION_RENEWAL_MAP.get(getEntryName());
      if (ent == null) {
        return;
      }
      Long threadId = ent.getFirstThreadId();
      if (threadId == null) {
        return;
      }

      RFuture<Boolean> future = renewExpirationAsync(threadId); // 重点，锁续命
      future.onComplete((res, e) -> {
        if (e != null) {
          log.error("Can't update lock " + getName() + " expiration", e);
          return;
        }
        if (res) { // 续命成功，调用本身10后又来检查锁
          // reschedule itself
          renewExpiration();
        }
      });
    }
  }, internalLockLeaseTime / 3, TimeUnit.MILLISECONDS); // 这里internalLockLeaseTime是30秒,也就是10秒后观察锁的失效，

  ee.setTimeout(task);
}