基于java操作redis的测试[RedisTemplate对redis的操作]

先打开在redis.conf文件中：

1.注释掉

        #bind 127.0.0.1  -::1
 
2.protected-mode yes改为no

3.重新启动一下redis

1：首先先配置操作redis所需要的依赖

<dependencies>
    <!--            web启动器-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- redis-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    <!--单元测试-->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

2：redis所需要的配置文件

spring:
  redis:
    host: 192.168.245.129 #本机ip
    port: 6379
    timeout: 5000

3：redis的启动类

package com;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class redis_application {
    public static void main(String[] args) {
        SpringApplication.run(redis_application.class,args);
    }
}

一：创建一个测试类

/**
 * 基于springboot的单元测试
 */

@SpringBootTest(classes = redis_application.class)//导入启动类
@RunWith(SpringRunner.class)//把springrunner字节码文件加载进来

public class demo {

    //这是redis的对象用来调用redis的方法
    @Autowired
    private RedisTemplate redisTemplate;

 
}

1：基于string数据类型

 /**
     * 这是根据string类型
     * 每次执行都会覆盖
     */
    @Test
    public  void stringTest(){
        //设置和查询
        redisTemplate.boundValueOps("name").set("liu");
        String username = (String)redisTemplate.boundValueOps("name").get();
        System.out.println(username);

        //进行对象设置和查询
        //实体类一定要实现序列化,因为redis里面是序列化的
        person person = new person();
        person.setName("刘德华");
        person.setAge(21);
        redisTemplate.boundValueOps("person").set(person);
        person p = (person)redisTemplate.boundValueOps("person").get();
        System.err.println(p);


        //-------设置过期时间(这个设置时间在redis中是通用的)-------

        redisTemplate.boundValueOps("name").expire(1, TimeUnit.MINUTES);//一分钟后过期
        try {
            TimeUnit.SECONDS.sleep(1);//休眠一秒
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Long time = redisTemplate.boundValueOps("name").getExpire();
        System.err.println("过期时间还剩下:"+time);//休眠了一秒所以应该还有59秒过期
        
         //-------设置过期时间(这个设置时间在redis中是通用的)-------
        

        //删除
        Boolean name = redisTemplate.delete("name");
        System.err.println(name==true?"删除成功":"删除失败");
    }

 

2：基于hash数据结构----(key:(filed,values))

 /**
     * hash数据类型操作----(key:(filed,values))
     * redisTemplate.boundHashOps()
     */
    @Test
    public  void hashTest(){
        //设置和查询
        redisTemplate.boundHashOps("user").put("xiaowei","19");
        redisTemplate.boundHashOps("user").put("天天","23");
        redisTemplate.boundHashOps("user").put("卢","29");

        String user =(String)redisTemplate.boundHashOps("user").get("xiaowei");
        String user2 =(String)redisTemplate.boundHashOps("user").get("天天");
        String user3 =(String)redisTemplate.boundHashOps("user").get("卢");
        System.err.println(user);
        System.err.println(user2);
        System.err.println(user3);

        //通过hashmap设置查询--- .putAll(map);
        HashMap<String,String> map = new HashMap<>();
        map.put("假面骑士","19");
        map.put("555","23");
        map.put("liuxian","29");
        redisTemplate.boundHashOps("p").putAll(map);
        Map user4 =redisTemplate.boundHashOps("p").entries();
        System.err.println(user4);

        //删除(根据key值)
        Boolean delete = redisTemplate.delete(user);
        System.err.println(delete==true?"删除成功":"删除失败");
        //删除(根据key的filed)
        Long delete1 = redisTemplate.boundHashOps("user").delete("天天");
        System.err.println(delete1==1?"删除成功":"删除失败");
    }

3：基于list----(双向链表)left--right

/**
     * list----(双向链表)left--right
     * redisTemplate.boundListOps()
     */
    @Test
    public  void listTest(){
        //设置
        redisTemplate.boundListOps("list").leftPush("上海");
        redisTemplate.boundListOps("list").leftPush("广州");
        redisTemplate.boundListOps("list").rightPush("北京");
        redisTemplate.boundListOps("list").leftPush("四川");
        redisTemplate.boundListOps("list").leftPush("重庆");
        //取出:相当于删除
        String list = (String)redisTemplate.boundListOps("list").leftPop();//北京
        String list2 = (String)redisTemplate.boundListOps("list").rightPop();//重庆
        System.err.println("从左边取:"+list);
        System.err.println("从右边取:"+list2);
        //删除(根据索引)
        Long remove = redisTemplate.boundListOps("list").remove(1, "四川");
        System.err.println(remove==1?"删除成功":"删除失败");

        //通过集合放置
        List<String> l=new ArrayList<>();
        l.add("a");
        l.add("b");
        l.add("c");
        redisTemplate.boundListOps("l1").leftPushAll(l);//左
        redisTemplate.boundListOps("l2").rightPush(l);//右
        //遍历
        List l1 = redisTemplate.boundListOps("l1").range(0, -1);
        List l2 = redisTemplate.boundListOps("l2").range(0, -1);
        System.err.println("从左边取:"+l1);
        System.err.println("从右边取:"+l2);
    }

4：基于set集合

 /**
     * set----去重
     * redisTemplate.boundSetOps()
     */
    @Test
    public  void setTest(){
        //设置
        redisTemplate.boundSetOps("set").add("广州");
        redisTemplate.boundSetOps("set").add("广州");
        redisTemplate.boundSetOps("set").add("上海");
        redisTemplate.boundSetOps("set").add("上海");
        //查看
        Set set = redisTemplate.boundSetOps("set").members();
        System.out.println("set:"+set);
        //删除
        Long remove = redisTemplate.boundSetOps("set").remove("广州");
        System.err.println(remove==1?"删除成功":"删除失败");

    }
}