springboot整合redis

​​​​​​​

目录

1.java连接redis

(1) 引入redis的依赖------>jedis

(2) java代码操作redis

2.springboot整合redis

(1) 依赖---->启动依赖---->自动装配---->自动读取配置

(2) 代码测试--------StringRedistemplate

(3) 代码测试----------RedisTemplate

3. 连接集群

4.springboot使用redis作为缓存。

（1）添加依赖 

（2）在配置中心里添加redis配置

（3）实体类User

（4）接口类mapper，使用通用mapper

（5）启动类，加入包扫描

（6）controller层

（7）service业务层

---

​​​​​​​

1.java连接redis

(1) 引入redis的依赖------>jedis

<dependencies>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>3.6.0</version>
        </dependency>
    </dependencies>

(2) java代码操作redis

package com;

import redis.clients.jedis.Jedis;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class TsetRedis {
    public static void main(String[] args) {
         //1.获取连接对象
        Jedis jedis=new Jedis("192.168.28.69" ,6379);
        //默认连接的为localhost  端口号为6379
        //2.操作redis数据库 -----String类型
        jedis.set("k1","v1");
        jedis.set("k2","v2");
        jedis.setnx("k1","v3");
        jedis.mset("k3","v3","k4,","v4");
        List<String> mget = jedis.mget("k1", "k2");
        System.out.println(mget);
        jedis.flushAll();
        //3.操作hash类型    
        Map<String, String> map=new HashMap<>();
        map.put("name","yyk");
        map.put("age","12");
        jedis.hset("k1",map);

        Map<String ,String> k1=jedis.hgetAll("k1");
        System.out.println(k1);

        Set<String> keys=jedis.keys("*");
        System.out.println(keys);
    }
}

2.springboot整合redis

(1) 依赖---->启动依赖---->自动装配---->自动读取配置

 <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

(2) 代码测试--------StringRedistemplate

  @Autowired StringRedisTemplate stringRedisTemplate;//存放的数据格式为string类型
    @Test
    void contextLoads() {
        //使用ValueOperations -----操作的为字符串类型
        ValueOperations<String,String> ops=stringRedisTemplate.opsForValue();
        ops.set("u", JSON.toJSONString(new User("zs",12,"郑州")));
        String u=ops.get("u");
        User user=JSON.parseObject(u,User.class);
        System.out.println(user);



        System.out.println(stringRedisTemplate);
        ValueOperations<String,String> ops=stringRedisTemplate.opsForValue();
        ops.set("k1","spring-boot-v1");
        System.out.println(ops.get("k1"));
        Boolean aboolean=ops.setIfAbsent("k1","3222");
        System.out.println(aboolean);

        Map<String,String> map=new HashMap<>();
        map.put("name","zs");
        map.put("age","12");
        map.put("name","wu");
        ops.multiSet(map);
        System.out.println(stringRedisTemplate.keys("*"));
        //操作hash类型 HashOperations<String, Object, Object>
        HashOperations<String,Object,Object>         
        hash=stringRedisTemplate.opsForHash();
        hash.put("k1","name","yy");
        hash.put("k1","age","19");
        Object o=hash.get("k1","name");
        System.out.println(hash.keys("k1"));
        System.out.println(hash.values("k1"));
        System.out.println(o);
        System.out.println(hash.entries("k1"));
    }

(3) 代码测试----------RedisTemplate

它的key和value可以存放Object类型,那么它的key和value默认采用的序列化方式为JDK序列化方式。一般我们需要为key和value指定序列化方式。

        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(new StringRedisSerializer());

 @Autowired
    RedisTemplate redisTemplate;
    @Test
    void contextLoadsHash(){

        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new StringRedisSerializer());
        HashOperations hashOperations=redisTemplate.opsForHash();
        hashOperations.put("u","n","ew");

    }
    @Test
    void contextLoads(){
        //因为RedisTemplate默认会为key和value进行序列  按照JDK的序列化方式进行的，
        //再实际开发过程中不用默认的序列化方式。空间少  而且不用为实体类实现序列化接口
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        ValueOperations valueOperations=redisTemplate.opsForValue();
        //可以指定key的序列化方式
        valueOperations.set("k",new User("wu",32,"henan"));
        Object k=valueOperations.get("k");
        System.out.println(k);
    }
}

3. 连接集群

哨兵,配置可以参考之前写的。

集群，配置可以参考之前写的。

4.springboot使用redis作为缓存。

作用： 为了减少对数据库的访问频率。从而提高项目的性能。

什么样的数据适合放入缓存中？

1. 查询频率高
2. 修改频率低
3. 数据安全行要求低的

（1）添加依赖 

       <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.23</version>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.3</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

（2）在配置中心里添加redis配置

spring.datasource.password=123456
spring.datasource.username=root
spring.datasource.url=jdbc:mysql://localhost:3306/user?serverTimezone=Asia/Shanghai
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

spring.redis.sentinel.master=mymaster
spring.redis.sentinel.nodes=192.168.28.69:26379

#日志打印
logging.level.com.springboot1.demo.mapper=debug

（3）实体类User

package com.springboot1.demo.entity;

import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import java.util.Date;

@Data
@TableName(value = "user")
public class User {
    private Long id;
    private String uName;
    private Integer age;
    private String email;
    private Integer deleted;
    private Date createTime;
    private Date updateTime;


}

（4）接口类mapper，使用通用mapper

package com.springboot1.demo.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.springboot1.demo.entity.User;

public interface UserMapper extends BaseMapper<User> {
}

（5）启动类，加入包扫描

package com.springboot1.demo;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@MapperScan(basePackages = {"com.springboot1.demo.mapper"})
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

}

（6）controller层

package com.ykq.springbootrediscache.controller;

import com.ykq.springbootrediscache.entity.User;
import com.ykq.springbootrediscache.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping("byId/{id}")
    public User byId(@PathVariable Long id){

        return userService.findById(id);
    }
}

（7）service业务层

package com.springboot1.demo.service;

import com.springboot1.demo.entity.User;
import com.springboot1.demo.mapper.UserMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

@Service
public class UserService {
    @Resource
    private UserMapper userMapper;

    @Resource
    private RedisTemplate redisTemplate;
    public User findById(Long id){
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());

        ValueOperations valueOperations = redisTemplate.opsForValue();
        //1.先从redis中获取数据
        Object o = valueOperations.get("user::findById::" + id);
        //2.如果存在  则直接返回
        if(o!=null){
             return (User) o;
        }
        //3.如果不存在则查询数据库  并把查询的结果放入redis中
        User user = userMapper.selectById(id);
        if(user!=null){
            valueOperations.set("user::findById::"+id,user);
        }
        return user;
    }
}

启动项目，第一次访问：http://localhost:8080/byId/4

通过控制台输出，我们可以看到是从数据库中获取的数据，并且存入了redis缓存中。

我们再次刷新浏览器

可以看到，第二次是从缓存中读取的,没有经过mysql查询，我们试试不断刷新浏览器。

到此我们的redis就配置好了。