1. Day01.  

<!-- jedis -->

      <dependency>

          <groupId>redis.clients</groupId>

          <artifactId>jedis</artifactId>

          <version>${jedis.version}</version>

      </dependency>

      <!--添加spring-datajar包 -->

      <dependency>

          <groupId>org.springframework.data</groupId>

          <artifactId>spring-data-redis</artifactId>

          <version>1.4.1.RELEASE</version>

      </dependency>

/**

    * 1.通过IP和端口可以连接Redis

    * 2.操作方法就是命令

    * **/

   @Test

   public void StringTest() {

      Jedis jedis =

             new Jedis("192.168.126.174", 6379);

       String result = jedis.set("1811","今天周四");

      System.out.println("保存后的返回值为:"+result);

      System.out.println("获取数据:"+jedis.get("1811"));

   }

//操作hash

   @Test

   public void testHash() {

      Jedis jedis = new Jedis("192.168.126.174", 6379);

      jedis.hset("dog", "name","二哈");

      jedis.hset("dog", "age", "7");

      Map<String,String> map =

             jedis.hgetAll("dog");

      System.out.println(map);

   }

/**操作List集合,改数据类型,不能长期保存数据,

   数据最终会被消费.*/

   @Test

   public void testList() {

      Jedis jedis = new Jedis("192.168.126.174", 6379);

      jedis.rpush("list","1","2","3");

      String a = jedis.rpop("list");

      System.out.println(a);

   }

//控制redis事务问题

   @Test

   public void tx() {

      Jedis jedis = new Jedis("192.168.126.174", 6379);

      //开启事务

      Transaction transaction = jedis.multi();

      try {

          transaction.set("kk", "kk");

          transaction.set("ww", "ww");

          int a = 1/0;

          transaction.exec();

      } catch (Exception e) {

          e.printStackTrace();

          transaction.discard();

      }

   }

public class ObjectMapperTest {

   @Test

   public void objectToJSON() throws IOException {

      User user = new User();

      user.setId(100);

      user.setName("测试");

      user.setAge(10000);

      user.setSex("男");

      ObjectMapper objectMapper = new ObjectMapper();

      String json =

      objectMapper.writeValueAsString(user);

      System.out.println(json);

      //将json串转化为对象

      User user2 =

      objectMapper.readValue(json, User.class);

      //get方法获取属性值. set方法为属性赋值.

      System.out.println(user2.toString());

   }

   @SuppressWarnings("unchecked")

   @Test

   public void listToJSON() throws IOException {

      List<User> userList = new ArrayList<User>();

      User user1 = new User();

      user1.setId(1);

      user1.setName("杯子");

      user1.setAge(19);

      user1.setSex("男");

      userList.add(user1);

      ObjectMapper objectMapper = new ObjectMapper();

      String result =

             objectMapper.writeValueAsString(userList);

      System.out.println(result);

      //将JSON转化为List集合

      List<User> uList =

      objectMapper.readValue(result,ArrayList.class);

      System.out.println(uList);

   }

}

<!--1.创建objectMapper  -->

   <bean id="objectMapper" class="com.fasterxml.jackson.databind.ObjectMapper"></bean>

   <!--2.创建Jedis对象  -->

   <bean id="jedis" class="redis.clients.jedis.Jedis">

      <constructor-arg name="host" value="${redis.host}"/>

      <constructor-arg name="port" value="${redis.port}"/>

   </bean>

public class ObjectMapperUtil {

   private static ObjectMapper mapper = new ObjectMapper();

   public static String toJSON(Object object) {

      String json = null;

      try {

          json = mapper.writeValueAsString(object);

      } catch (Exception e) {

          e.printStackTrace();

          throw new RuntimeException();

      }

      return json;

   }

   @SuppressWarnings("unchecked")

   public static <T> T toObject(String json,Class<?> targetClass) {

      T t = null;  //定义泛型对象

      try {

          t = (T) mapper.readValue(json,targetClass);

      } catch (Exception e) {

          e.printStackTrace();

          throw new RuntimeException();

      }

      return t;   

   }

}

#编辑后台管理服务器

   server {

      listen 80;

      server_name manage.jt.com;

      location / {

          #代理请求url路径

          #proxy_pass http://jtLinux;

          #proxy_pass http://jt;

          proxy_pass http://localhost:8091;

          proxy_connect_timeout       3; 

          proxy_read_timeout          3; 

          proxy_send_timeout          3;

      }

   }

jdbc.driver=com.mysql.jdbc.Driver

jdbc.url=jdbc:mysql://localhost:3306/jtdb?useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowMultiQueries=true

jdbc.username=root

jdbc.password=root

/**

    * 1.生成key

    * 2.查询redis缓存

    *     null: 则调用业务层方法获取数据,

    *          利用工具类封装为JSON,保存到缓存中

    *     !null:

    *          将缓存转化为对象返回

    */

   @SuppressWarnings("unchecked")

   @Override

   public List<EasyUITree> findCacheItemCat(Long parentId) {

      String key = "ITEM_CAT_" + parentId;

      String json = jedis.get(key);

      List<EasyUITree> treeList = new ArrayList<>();

      if(StringUtils.isEmpty(json)) {

          treeList = findItemCatList(parentId);

          String result =

                ObjectMapperUtil.toJSON(treeList);

          jedis.set(key, result);

          System.out.println("查询数据库!!!!!");

      }else {

          treeList = ObjectMapperUtil.toObject(json,ArrayList.class);

          System.out.println("查询缓存!!!!!!!");

      }

      return treeList;

   }

[root@localhost redis-3.2.8]# cp redis.conf shards/redis-6379.conf

[root@localhost redis-3.2.8]# cp redis.conf shards/redis-6380.conf

[root@localhost redis-3.2.8]# cp redis.conf shards/redis-6381.conf

[root@localhost shards]# vim redis-6380.conf

[root@localhost shards]# vim redis-6381.conf

[root@localhost shards]# redis-server redis-6379.conf

[root@localhost shards]# redis-server redis-6380.conf

[root@localhost shards]# redis-server redis-6381.conf

ps -ef |grep redis

@Test

   public void test01() {

      List<JedisShardInfo> shards =

                new ArrayList<JedisShardInfo>();

      JedisShardInfo info1 =

             new JedisShardInfo("192.168.126.174",6379);

      JedisShardInfo info2 =

             new JedisShardInfo("192.168.126.174",6380);

      JedisShardInfo info3 =

             new JedisShardInfo("192.168.126.174",6381);

      shards.add(info1);

      shards.add(info2);

      shards.add(info3);

      ShardedJedis jedis = new ShardedJedis(shards);

      jedis.set("1811","分片测试");

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

      //问:数据保存到了哪个redis节点??如何存储??

   }

1. Day02.  

Redis高级

@Target(ElementType.METHOD)

@Retention(RetentionPolicy.RUNTIME)

//反射???? 不加参数??? 方法名称 find

public @interface CacheAnno {

   String key();         //定义key值

   int index();       //参数定义位置

   Class targetClass();  //定义目标类型

   CACHE_TYPE cacheType() default CACHE_TYPE.FIND;

   //定义泛型类型

   enum CACHE_TYPE{

      FIND,           //定义查找

      UPDATE          //定义更新

   }

}

@Component      //交给spring容器管理

@Aspect         //标识切面

public class CacheAspect {

   //当执行时才注入,后期将该对象换为集群对象

   @Autowired(required=false)

   private Jedis jedis;

   /**

    * 控制用户是否查询数据库  目标方法

    * @param joinPoint

    * @param cacheAnno

    * @return

    */

   //利用环绕通知 拦截所有的缓存注解

   @Around("@annotation(cacheAnno)")

   public Object around(ProceedingJoinPoint joinPoint,CacheAnno cacheAnno) {

      return getObject(joinPoint,cacheAnno);

   }

   public Object getObject(ProceedingJoinPoint joinPoint, CacheAnno cacheAnno) {

      //获取参数

      CACHE_TYPE cacheType = cacheAnno.cacheType();

      String key = cacheAnno.key();

      int index = cacheAnno.index();

      Class<?> targetClass = cacheAnno.targetClass();

      //根据位置获取参数

      Long id = (Long) joinPoint.getArgs()[index];

      //拼接参数 ITEM_CAT_0

      String redisKey = key + id;

      Object object = null;

      switch (cacheType) {

          case FIND:      //表示查询缓存

             object = findObject(joinPoint,redisKey,targetClass);

             break;

          case UPDATE: //表示更新缓存

             object = updateObject(joinPoint,redisKey);

             break;

          }

      return object;

   }

   private Object findObject(ProceedingJoinPoint joinPoint, String key, Class<?> targetClass) {

      //检查缓存中是否有数据

      String result = jedis.get(key);

      Object object = null;

      try {

          if(StringUtils.isEmpty(result)) {

             //表示缓存中没有数据,则查询数据库

             object = joinPoint.proceed();

             String json = ObjectMapperUtil.toJSON(object);

             jedis.set(key, json);

             System.out.println("AOP查询真实数据库!!");

          }else {

             //表示缓存中有数据,查询缓存

             object = ObjectMapperUtil.toObject(result, targetClass);

             System.out.println("AOP查询缓存!!");

          }

      } catch (Throwable e) {

          e.printStackTrace();

          throw new RuntimeException();

      }

      return object;

   }

   private Object updateObject(ProceedingJoinPoint joinPoint, String redisKey) {

      //更新缓存,删除即可

      Object object = null;

      try {

          jedis.del(redisKey);

          object = joinPoint.proceed();

          System.out.println("AOP缓存删除");

      } catch (Throwable e) {

          e.printStackTrace();

          throw new RuntimeException();

      }

      return object;

   }

}

redis.host=192.168.126.174

redis.port.a=6379

redis.port.b=6380

redis.port.c=6381

<!--value如果存储字符串/基本类型-->

   <!--ref存储对象-->

   <!--2.redis分片  -->

   <bean id="shardJedis" class="redis.clients.jedis.ShardedJedis">

      <constructor-arg name="shards">

          <list>

             <ref bean="info1"/>

             <ref bean="info2"/>

             <ref bean="info3"/>

          </list>

      </constructor-arg>

   </bean>

   <bean id="info1" class="redis.clients.jedis.JedisShardInfo">

      <constructor-arg name="host" value="${redis.host}"/>

      <constructor-arg name="port" value="${redis.port.a}"/>

   </bean>

   <bean id="info2" class="redis.clients.jedis.JedisShardInfo">

      <constructor-arg name="host" value="${redis.host}"/>

      <constructor-arg name="port" value="${redis.port.b}"/>

   </bean>

   <bean id="info3" class="redis.clients.jedis.JedisShardInfo">

      <constructor-arg name="host" value="${redis.host}"/>

      <constructor-arg name="port" value="${redis.port.c}"/>

   </bean>

[root@localhost sentinel]# redis-server redis-6379.conf

[root@localhost sentinel]# redis-server redis-6380.conf

[root@localhost sentinel]# redis-server redis-6381.conf

redis-cli -p 6380

SLAVEOF 192.168.126.174 6379

cp sentinel.conf  sentinel

/**

    * 参数说明

    * 1.masterName  主机的变量名称

    *  2.sentinels   哨兵的信息

    *  String=IP:端口

    */

   @Test

   public void testSentinel() {

      Set<String> sentinels = new HashSet<>();

      sentinels.add("192.168.126.174:26379");

      JedisSentinelPool pool =

      new JedisSentinelPool("mymaster", sentinels);

      Jedis jedis = pool.getResource();

      jedis.set("aa", "abc");

      System.out.println("获取redis数据:"+jedis.get("aa"));

      jedis.close();

   }

redis.masterName=mymaster

redis.node1=192.168.126.174:26379

<bean id="jedisSentinelPool" class="redis.clients.jedis.JedisSentinelPool">

      <constructor-arg name="masterName" value="${redis.masterName}"/>

      <constructor-arg name="sentinels">

          <set>

             <value>${redis.node1}</value>

          </set>

      </constructor-arg>

   </bean>

@Service

public class RedisService {

   //使用时注入

   @Autowired(required=false)

   private JedisSentinelPool pool;

   //set get

   public void set(String key,String value) {

      Jedis jedis = pool.getResource();

      jedis.set(key, value);

      jedis.expire(key, 7*24*3600);

      jedis.close();

   }

   public String get(String key) {

      Jedis jedis = pool.getResource();

      String result = jedis.get(key);

      jedis.close();

      return result;

   }

}

save 900 1     #在900秒内,执行一次set操作,则持久化一次

save 300 10    #在300秒内,执行10次set操作,则持久化一次

save 60 10000   #在60秒内,执行10000次set操作,则持久化一次

# appendfsync always  每次执行set操作,则持久化一次

appendfsync everysec  每秒持久化一次.

# appendfsync no       由操作系统决定何时持久化一般默认15分钟