搜索
简帛阁>技术文章>springboot结合redis实现数据缓存

springboot结合redis实现数据缓存

安装redis
1、检查安装依赖程序
yum install gcc-c++
yum install -y tcl
yum install wget
2、获取安装文件
wget http://download.redis.io/releases/redis-4.0.7.tar.gz
3、解压文件

自己新建一个目录将redis解压到里面

tar -zxvf redis-4.0.7.tar.gz
mv redis-4.0.7 /usr/local/redis
4、进入目录

cd /usr/local/redis
5、编译安装

make
make install
6、设置配置文件路径

mkdir -p /etc/redis
cp redis.conf /etc/redis
7、修改配置文件

redis.conf是redis的配置文件,redis.conf在redis源码目录。

注意修改port作为redis进程的端口,port默认6379。

redis有两种启动方式

01:直接运行bin/redis-server将以前端模式启动,前端模式启动的缺点是ssh命令窗口关闭则redis-server程序结束,不推荐使用此方法。

02:后端模式启动

修改redis.conf配置文件, daemonize yes 以后端模式启动

打开redis.conf,使用命令 😕 daemonize 快速查找到daemonize然后修改。

vi /etc/redis/redis.conf
  仅修改: daemonize yes (no–>yes)
8、启动

/usr/local/bin/redis-server /etc/redis/redis.conf    启动服务
9、查看启动

ps -ef | grep redis
10、使用客户端

redis-cli    启动客户端

set name zmfx
OK
get name
“zmfx”
11.关闭客户端

redis-cli shutdown
12、开机启动配置

echo “/usr/local/bin/redis-server /etc/redis/redis.conf &” >> /etc/rc.local
开机启动要配置在 rc.local 中,而 /etc/profile 文件,要有用户登录了,才会被执行。

13、设置密码

因为这是给局域网内的很多人使用,所以设置一个访问密码很有必要。

修改redis.conf文件配置

使用命令 :/ requirepass 快速查找到 # requirepass foobared 然后去掉注释,这个foobared改为自己的密码。然后wq保存。

14、重启redis
redis-cli -h 127.0.0.1 -p 6379 -a password
redis 127.0.0.1:6379> keys *

  1. “myset”
  2. “mysortset”
    redis 127.0.0.1:6379> select 1
    OK

与springboot进行结合
pom.xml文件

<dependencies>
        <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.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.2</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

application.properties文件

server.port=8081

#数据库连接
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/user?useUnicode=true
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.username=root
spring.datasource.password=zhangxian11

#mybatis配置
mybatis.type-aliases-package=com.example.redisdemo.pojo
mybatis.mapper-locations=classpath:mapper/*.xml

#mybatis的下划线转驼峰配置
#mybatis.configuration.map-underscore-to-camel-case=true



#另外一种打印语句的方式
#mybatis.configuration.log-impl=org.appache.ibatis.logging.stdout.StdOutImpl

#将themilef的默认缓存禁用,热加载生效
spring.thymeleaf.cache=false

#启用分页插件[或者程序中进行配置]
#pagehelper.helper-dialect=mysql
#pagehelper.reasonable=true

## Redis 配置
## Redis数据库索引(默认为0)
spring.redis.database=0
## Redis服务器地址
spring.redis.host=172.16.238.161
## Redis服务器连接端口
spring.redis.port=6379
## Redis服务器连接密码(默认为空)
spring.redis.password=
## 连接池最大连接数(使用负值表示没有限制)
spring.redis.jedis.pool.max-idle=8
## 连接池最大阻塞等待时间(使用负值表示没有限制)
spring.redis.jedis.pool.max-wait=100
## 连接池中的最大空闲连接
## 连接池中的最小空闲连接
spring.redis.jedis.pool.min-idle=0
## 连接超时时间(毫秒)
spring.redis.timeout=1200

实体类

public class User implements Serializable {

    private static final long serialVersionUID = 1L;
    private int uid;
    private String userName;
    private String passWord;
    private int salary;
    public int getUid() {
        return uid;
    }
    public void setUid(int uid) {
        this.uid = uid;
    }
    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    public String getPassWord() {
        return passWord;
    }
    public void setPassWord(String passWord) {
        this.passWord = passWord;
    }
    public int getSalary() {
        return salary;
    }
    public void setSalary(int salary) {
        this.salary = salary;
    }
    public User(int uid, String userName, String passWord, int salary) {
        super();
        this.uid = uid;
        this.userName = userName;
        this.passWord = passWord;
        this.salary = salary;
    }
    public User() {
        super();
        // TODO Auto-generated constructor stub
    }

}

service接口

public interface UserService {

   //查询所以数据
    List<User> queryAll();
   //查询id为条件的数据
    User findUserById(int id);
//修改数据
    int updateUser(User user);
//删除数据
    int deleteUserById(int id);
}

serviceImpl实现类

@Service
public class UserServiceImpl implements UserService {

    /**
     * Ω
     */
   @Autowired
   private UserDao userDao;

    @Autowired
    private RedisTemplate redisTemplate;
/* 
*获取所以数据存入到一个key中,可以设定设定一个定时任务让数据不断的能够得到更新
*/
    public List<User> queryAll() {
        String key="userlist";
        ValueOperations<String,List<User>> operations=redisTemplate.opsForValue();
        boolean haskey=redisTemplate.hasKey(key);
        if(haskey){
        List<User> list=operations.get(key);
            System.out.println("==========从缓存中获得数据=========");
            return list;
        }else {
            List<User> list=userDao.queryAll();
            System.out.println("==========从数据表中获得数据=========");
            operations.set(key,list,5,TimeUnit.HOURS);
            return list;
        }

    }

    


    /**
     * 获取用户:先从缓存中获取用户,没有则取数据表中 数据,再将数据写入缓存
     */
    public User findUserById(int id) {
        String key = "user_" + id;

        ValueOperations<String, User> operations = redisTemplate.opsForValue();

        boolean hasKey = redisTemplate.hasKey(key);
        if (hasKey) {
            User user = operations.get(key);
            System.out.println("==========从缓存中获得数据=========");
            System.out.println(user.getUserName());
            System.out.println("==============================");
            return user;
        } else {
            User user = userDao.findUserById(id);
            System.out.println("==========从数据表中获得数据=========");
            System.out.println(user.getUserName());
            System.out.println("==============================");

            // 写入缓存
            operations.set(key, user, 5, TimeUnit.HOURS);

            return user;
        }

    }

    /**
     * 更新用户:先更新数据表,成功之后,删除原来的缓存,再更新缓存
     */
    public int updateUser(User user) {
        ValueOperations<String, User> operations = redisTemplate.opsForValue();
        int result = userDao.updateUser(user);
        if (result != 0) {
            String key = "user_" + user.getUid();
            boolean haskey = redisTemplate.hasKey(key);
            if (haskey) {
                redisTemplate.delete(key);
                System.out.println("删除缓存中的key=========>" + key);
            }
            // 再将更新后的数据加入缓存
            User userNew = userDao.findUserById(user.getUid());
            if (userNew != null) {
                operations.set(key, userNew, 3, TimeUnit.HOURS);

            }
        }
        return result;
    }

    /**
     * 删除用户:删除数据表中数据,然后删除缓存
     */

    public int deleteUserById(int id) {
        int result = userDao.deleteUserById(id);
        String key = "user_" + id;
        if (result != 0) {
            boolean hasKey = redisTemplate.hasKey(key);
            if (hasKey) {
                redisTemplate.delete(key);
                System.out.println("删除了缓存中的key:" + key);
            }
        }
        return result;
    }

Controller类

@Controller
@RequestMapping("/test")
public class UserController {

    @Autowired
    private UserService userService;

    @ResponseBody
    @RequestMapping("/testController")
    public String testController(){

        return "success";
    }

    @ResponseBody
    @RequestMapping("/queryAll")
    public List<User> queryAll(){
        List<User> lists = userService.queryAll();
        return lists;
    }


   
    @ResponseBody
    @RequestMapping("/findUserById")
    public Map<String, Object> findUserById(@RequestParam int id){
        User user = userService.findUserById(id);
        Map<String, Object> result = new HashMap<>();
        result.put("uid", user.getUid());
        result.put("uname", user.getUserName());
        result.put("pass", user.getPassWord());
        result.put("salary", user.getSalary());
        return result;
    }

    @ResponseBody
    @RequestMapping("/updateUser")
    public String updateUser(){
        User user=new User();
//        user.setUid(1);
//        user.setUserName("cat");
//        user.setPassWord("miaomiao");
//        user.setSalary(4000);

        int result = userService.updateUser(user);

        if(result != 0){
            return "update user success";
        }

        return "fail";
    }

    @ResponseBody
    @RequestMapping("/deleteUserById")
    public String deleteUserById(@RequestParam int id){
        int result = userService.deleteUserById(id);
        if(result != 0){
            return "delete success";
        }
        return "delete fail";
    }
}
1、实现目标通过redis缓存数据。(目的不是加快查询的速度,而是减少数据库的负担)2、所需jar包注意:jdies和commonspool两个jar的版本是有对应关系的,注意引入jar包是要配对使
篇文章主要介绍了SpringBootRedis缓存数据实现解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下1启用对缓存的支持spring对缓存
目录前言设计示例Redis懒加载缓存流程图代码示例优点缺点总结Redis结合本地缓存流程图代码示例优点缺点总结后记前言我们开发中经常用到Redis作为缓存,将高频数据放在Redis中能够提高业务性能,
前言Redis是一个开源的使用ANSIC语言编写、支持网络、可基于内存亦可持久化的日志型、KeyValue数据库,并提供多种语言的API。从2010年3月15日起,Redis的开发工作由VMware
(1)pomxml引入jar包,如下:<dependency><groupId>orgspringframeworkboot</groupId><artifa
SpringBoot+Mybtis+Redis缓存使用往期回顾:上一节简单的介绍了SpringBoot+Properties实现分布式服务动态配置内外部文件,applicationproperties
@BeanpublicRedisCacheManagercacheManager(RedisConnectionFactoryconnectionFactory){Jackson2JsonRedisS
1、实现目标通过redis缓存数据。(目的不是加快查询的速度,而是减少数据库的负担)2、所需Jar包注意:jdies和commonspool两个jar的版本是有对应关系的,注意引入jar包是要配对使
前言应用系统需要通过Cache来缓存不经常改变得数据来提高系统性能和增加系统吞吐量,避免直接访问数据库等低速存储系统。缓存数据通常存放在访问速度更快的内存里或者是低延迟存取的存储器,服务器上。应用系
我们在使用springboot搭建微服务的时候,在很多时候还是需要redis的高速缓存来缓存一些数据,存储一些高频率访问的数据,如果直接使用redis的话又比较麻烦,在这里,我们使用jedis来实现r