从零搭建 Spring Boot 后端项目（三）

最新推荐文章于 2020-07-28 10:30:50 发布
最新推荐文章于 2020-07-28 10:30:50 发布
阅读量4.6k 收藏 8
点赞数 10
分类专栏： 后端模板 文章标签： redis spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_22136439/article/details/107465623
版权
简介

这一小节主要是，整合Redis，需要提前在开发机上安装好Redis才能进行以下操作

步骤

这里我用的是Windows下的 redis 3.0，可以自行下载安装适合自己系统的redis

  • 添加Redis依赖

        <!-- redis -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
        <version>1.4.5.RELEASE</version>
    </dependency>

  • 在 application-dev.properties 下添加如下配置

    # Redis
# Redis服务器地址
spring.redis.host=127.0.0.1
# Redis连接端口
spring.redis.port=6379
# Redis连接密码(默认为空)
spring.redis.password=password
# 连接池最大连接数（使用负值表示没有限制）
spring.redis.jedis.pool.max-active=20
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.jedis.pool.max-wait=-1
# 连接池中的最大空闲连接、最小空闲连接
spring.redis.jedis.pool.max-idle=10
spring.redis.jedis.pool.min-idle=0
# 连接超时时间（毫秒）
spring.redis.timeout=1000

  • 在com.example.backend_template.config下新建RedisConfigurer类

    package com.example.backend_template.config;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.data.redis.RedisProperties;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisPassword;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;

/**
 * @ClassName RedisConfigurer Redis的配置类
 * @Description
 * @Author L
 * @Date Create by 2020/6/26
 */
@Configuration
@EnableCaching      //开启缓存
public class RedisConfigurer extends CachingConfigurerSupport {

    /**
     * redis 的各种配置信息，由框架注入
     */
    @Autowired
    private RedisProperties redisProperties;

    /**
     * 日志工具
     */
    private static final Logger log = LoggerFactory.getLogger(RedisConfigurer.class);

    @Bean
    public JedisConnectionFactory getConnectionFactory() {
        RedisStandaloneConfiguration redisStandaloneConfiguration =
                new RedisStandaloneConfiguration(redisProperties.getHost(), redisProperties.getPort());
        redisStandaloneConfiguration.setPassword(RedisPassword.of(redisProperties.getPassword()));
        JedisConnectionFactory factory = new JedisConnectionFactory(redisStandaloneConfiguration);
        log.info("The hostname of the redis connection is：{}, and the port is: {}", factory.getHostName(), factory.getPort());
        return factory;
    }

    public RedisTemplate<?, ?> getRedisTemplate() {
        RedisTemplate<?, ?> template = new StringRedisTemplate(getConnectionFactory());
        return template;
    }
}

  • 在com.example.backend_template.service下新建RedisService类

    package com.example.backend_template.service;

import java.util.List;

/**
 * @ClassName RedisService Redis常用方法
 * @Description 
 * @Author L
 * @Date Create by 2020/6/26
 */
public interface RedisService {

    /**
     * 设置给定 key 的值。如果 key 已经存储其他值， SET 就覆写旧值，且无视类型。
     * @param key
     * @param value
     * @return
     */
    boolean set(String key, String value);

    /**
     * 获取指定 key 的值。如果 key 不存在，返回 nil 。如果key 储存的值不是字符串类型，返回一个错误。
     * @param key
     * @return
     */
    String get(String key);

    /**
     * 设置 key 的过期时间。key 过期后将不再可用。
     * @param key
     * @param expire
     * @return
     */
    boolean expire(String key, long expire);

    /**
     * 存集合
     * @param key
     * @param list
     * @param <T>
     * @return
     */
    <T> boolean setList(String key, List<T> list);

    /**
     * 取集合
     * @param key
     * @param clz
     * @param <T>
     * @return
     */
    <T> List<T> getList(String key, Class<T> clz);

    /**
     * 将一个或多个值插入到列表头部。 如果 key 不存在，一个空列表会被创建并执行 LPUSH 操作。
     * 当 key 存在但不是列表类型时，返回一个错误。
     * @param key
     * @param obj
     * @return
     */
    long lpush(String key, Object obj);

    /**
     * 将一个或多个值插入到列表的尾部(最右边)。
     * 如果列表不存在，一个空列表会被创建并执行 RPUSH 操作。 当列表存在但不是列表类型时，返回一个错误。
     * @param key
     * @param obj
     * @return
     */
    long rpush(String key, Object obj);

    /**
     * 移除并返回列表的第一个元素。
     * @param key
     * @return
     */
    String lpop(String key);

    /**
     * 删除已存在的键。不存在的 key 会被忽略。
     * @param key
     * @return
     */
    long del(final String key);
}

  • 在com.example.backend_template.service.impl下新建RedisServiceImpl类，这里需要alibaba的fastjson包，所示要提前有pom.xml添加如下依赖

            <!-- fastjson -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.41</version>
        </dependency>

    package com.example.backend_template.service.impl;

import com.alibaba.fastjson.JSON;
import com.example.backend_template.service.RedisService;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.List;
import java.util.concurrent.TimeUnit;

/**
 * @ClassName RedisServiceImpl
 * @Description 
 * @Author L
 * @Date Create by 2020/6/26
 */
@Service
public class RedisServiceImpl implements RedisService {

    @Resource
    private RedisTemplate<String, ?> redisTemplate;


    @Override
    public boolean set(final String key, final String value) {
        boolean result = redisTemplate.execute(new RedisCallback<Boolean>() {
            @Override
            public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
                RedisSerializer<String> serializer = redisTemplate.getStringSerializer();
                connection.set(serializer.serialize(key), serializer.serialize(value));
                return true;
            }
        });
        return result;
    }

    @Override
    public String get(final String key){
        String result = redisTemplate.execute(new RedisCallback<String>() {
            @Override
            public String doInRedis(RedisConnection connection) throws DataAccessException {
                RedisSerializer<String> serializer = redisTemplate.getStringSerializer();
                byte[] value =  connection.get(serializer.serialize(key));
                return serializer.deserialize(value);
            }
        });
        return result;
    }

    @Override
    public long del(final String key){
        long result = redisTemplate.execute(new RedisCallback<Long>() {
            @Override
            public Long doInRedis(RedisConnection connection) throws DataAccessException {
                RedisSerializer<String> serializer = redisTemplate.getStringSerializer();
                long value =  connection.del(serializer.serialize(key));
                return value;
            }
        });
        return result;
    }

    @Override
    public boolean expire(final String key, long expire) {
        return redisTemplate.expire(key, expire, TimeUnit.SECONDS);
    }

    @Override
    public <T> boolean setList(String key, List<T> list) {
        String value = JSON.toJSONString(list);
        return set(key,value);
    }

    @Override
    public <T> List<T> getList(String key,Class<T> clz) {
        String json = get(key);
        if(json!=null){
            List<T> list = JSON.parseArray(json, clz);
            return list;
        }
        return null;
    }

    @Override
    public long lpush(final String key, Object obj) {
        final String value = JSON.toJSONString(obj);
        long result = redisTemplate.execute(new RedisCallback<Long>() {
            @Override
            public Long doInRedis(RedisConnection connection) throws DataAccessException {
                RedisSerializer<String> serializer = redisTemplate.getStringSerializer();
                long count = connection.lPush(serializer.serialize(key), serializer.serialize(value));
                return count;
            }
        });
        return result;
    }

    @Override
    public long rpush(final String key, Object obj) {
        final String value = JSON.toJSONString(obj);
        long result = redisTemplate.execute(new RedisCallback<Long>() {
            @Override
            public Long doInRedis(RedisConnection connection) throws DataAccessException {
                RedisSerializer<String> serializer = redisTemplate.getStringSerializer();
                long count = connection.rPush(serializer.serialize(key), serializer.serialize(value));
                return count;
            }
        });
        return result;
    }

    @Override
    public String lpop(final String key) {
        String result = redisTemplate.execute(new RedisCallback<String>() {
            @Override
            public String doInRedis(RedisConnection connection) throws DataAccessException {
                RedisSerializer<String> serializer = redisTemplate.getStringSerializer();
                byte[] res =  connection.lPop(serializer.serialize(key));
                return serializer.deserialize(res);
            }
        });
        return result;
    }
}
测试
  • 在com.example.backend_template.controller下新建RedisController类
    package com.example.backend_template.controller;

import com.example.backend_template.service.RedisService;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

/**
 * @ClassName RedisController
 * @Description 
 * @Author L
 * @Date Create by 2020/6/26
 */
@RestController
@RequestMapping("redis")
public class RedisController {

    @Resource
    private RedisService redisService;

    @PostMapping("/setRedis")
    public Boolean setRedis(String name) {
        return redisService.set("name", name);
    }

    @GetMapping("/getRedis")
    public String getRedis() {
        return redisService.get("name");
    }
}
  • 启动项目，请求方式为POST，URL为 http://localhost:8080/redis/setRedis ，参数名为name，如下图方式进行访问
    在这里插入图片描述
  • 请求方式为GET，URL为 http://localhost:8080/redis/getRedis 如下图方式进行访问
    在这里插入图片描述
    如出现如上两种结果，则表示Redis已整合成功
项目地址

项目介绍：从零搭建 Spring Boot 后端项目
代码地址：https://github.com/xiaoxiamo/backend-template

下一篇

四、整合 Spring Security

小夏陌
关注
  • 10
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
基于spring boot搭建的毕设后端系统.zip
12-29
基于spring的源码，可用于毕业设计、课程设计、参考学习 基于spring的源码，可用于毕业设计、课程设计、参考学习 基于spring的源码，可用于毕业设计、课程设计、参考学习 基于spring的源码，可用于毕业设计、课程...
spring-boot完整项目搭建
weixin_45843676的博客
03-11 766
spring-boot完整项目搭建
从零搭建 Spring Boot 后端项目
热门推荐
小夏陌的博客
07-20 3万+
一个基于 Spring Boot 的后端开发模板，主要用于减少平时重复的工作量，以及使开发有良好的开发规范。
从零搭建 Spring Boot 后端项目（六）
小夏陌的博客
07-20 4477
简介 这一小节主要是为了，统一请求结果格式 步骤 在提倡前后端分离的当下，统一返回结果就显得尤其重要，在com.example.backend_template.utils下新增ResultData类package com.example.backend_template.utils; /** * @ClassName ResultData 封装结果集成统一的json样式 * @Description TODO * @Author L * @Date Create by 2020/7/2 */
从零搭建 Spring Boot 后端项目（九）
小夏陌的博客
07-20 5412
单元测试 简介 单元测试是先mock一些正常边界异常条件来对接口进行操作，并且期望接口返回什么内容，最后接口实现了之后再重新测试一遍。单元测试要测试任何可能的错误，单元测试不是用来证明你是对的，而是为了证明你没有错。在TDD(Test-Driven Development)开发模式中，重点强调在开发功能代码之前，先编写测试代码。单元测试不仅仅用来保证当前代码的正确性，更重要的是用来保证代码修复、改进或重构之后的正确性。当然这里没有，而是给一个单元测试的模板，要注意的是，我们不要为了单测而单测。 JUnit
从零搭建Spring Boot脚手架，开篇以及技术选型.docx
07-03
Spring Boot 已经成为主流的 Java Web 开发框架，熟练掌握 Spring Boot 并能够根据业务来定制 Spring Boot 成为一个 Java 开发者的必备技巧，但是总是零零碎碎不够系统，所以萌生了从零搭建一个后端脚手架...
spring-boot示例项目
03-25
spring boot demo 是一个Spring Boot、Spring Cloud的项目示例，根据市场主流的后端技术，共集成了30+个demo，未来将持续更新。该项目包含helloworld(快速入门)、web(ssh项目快速搭建）、aop(切面编程)、data-redis...
Spring Boot整合Shiro搭建权限管理系统教学提纲.docx
06-08
Spring Boot整合Shiro搭建权限管理系统教学提纲.docxSpring Boot整合Shiro搭建权限管理系统教学提纲.docxSpring Boot整合Shiro搭建权限管理系统教学提纲.docxSpring Boot整合Shiro搭建权限管理系统教学提纲....
Spring Boot整合Shiro搭建权限管理系统教学提纲.pdf
06-07
Spring Boot整合Shiro搭建权限管理系统教学提纲.pdfSpring Boot整合Shiro搭建权限管理系统教学提纲.pdfSpring Boot整合Shiro搭建权限管理系统教学提纲.pdfSpring Boot整合Shiro搭建权限管理系统教学提纲.pdfSpring ...
从零搭建 Spring Boot 后端项目（一）
小夏陌的博客
07-20 5289
简介 这一小节主要是初始化项目，以及创建好相应的目录结构 步骤 点击创建 选择Spring Initializr 后，选择Jdk 版本 新建项目时，需输入公司名称和项目名称，其它默认或选择自己所需都可 这个页面可选择我们项目需要的各种组件，例如像mybatis，redis等，只要选择Spring Initializr就会自动帮我们整合，非常方便，但这里之后我们手动整合这些，所以选择一个Spring Web就行 这里输入项目名称和项目的本地地址，点击Finish完成即可 初始化后的项目结构如图所示
从零搭建 Spring Boot 后端项目（二）
小夏陌的博客
07-20 4954
简介 这一小节主要是整合mybatis、Druid连接池、PageHelper分页 步骤 在之前的开发依赖界面中，我们可以选择所需要的依赖，当然我们也可以手动添加依赖，以在项目中整合mybatis、Druid连接池、PageHelper分页，在pom.xml 文件中<dependencies>添加如下依赖 <!-- mysql数据库驱动--> <dependency> <groupId>mysql&l
从零搭建 Spring Boot 后端项目（四）
小夏陌的博客
07-20 4622
简介 这一小节主要是，整合 Spring Security 步骤 新建数据库与表 Create DATABASE `backend_template`; USE backend_template; CREATE TABLE `user` ( `id` bigint(11) NOT NULL AUTO_INCREMENT, `username` varchar(255) NOT NULL, `password` varchar(255) NOT NULL, PRIMARY KEY
从零搭建 Spring Boot 后端项目（十）
小夏陌的博客
07-20 4599
简介 在 RESTful 的接口传参时，我们不能信任任何用户输入，所以开发时要进行数据校验。例如经常要写判断字段是否为空，长度限制等，这些代码繁琐，冗长，还容易出错，这里我们使用 Hibernate-Validator 来解决数据校验问题，会使问题的解决方式优雅很多。那么什么是Hibernate-Validator呢，一开始Java规定了一套关于验证器的接口，即Bean Validation（JSR 303 和 JSR 349）。Bean Validation并不是一项技术而是一种规范，需要对其实现。这里h
从零搭建 Spring Boot 后端项目（五）
小夏陌的博客
07-20 4560
简介 这一小节主要是，整合Swagger2 步骤 在pom.xml下添加如下依赖 <!-- swagger2 --> <dependency> <groupId>io.springfox</groupId> <artifactId>springfox-swagger2</artifactId> <version>2.7.0<
从零搭建 Spring Boot 后端项目（七）
小夏陌的博客
07-20 4551
代码自动生成 步骤 这里给大家介绍一个代码生成神器EasyCode插件，可减少重复业务代码，提高工作效率，减少加班，该插件目前只在IDEA有 安装步骤如下 File --> Settings… --> 选择Plugins --> 安装Easy Code插件 --> 安装之后注意重启 idea 接下来使用Easy Code插件，先创建数据表 USE backend_template; CREATE table goods ( id INT not null,
从零搭建 Spring Boot 后端项目（十二）
小夏陌的博客
07-28 4549
多人同时开发后端时，数据表的创建和修改会显得格外头痛，因为mybatis只能先建数据表，再用逆向工程生成类。如数据表修改后，多人未做即时沟通，那么代码就会乱，那有什么东西办法解决吗，有，那就是数据库版本控制工具---Flyway，不只方便多人合作，更可以支持数据库的版本控制，和数据库的迁移。使用Flyway，用户可以从任意一个数据库版本迁移到最新版本，简单而且有效。
从零搭建 Spring Boot 后端项目（八）
小夏陌的博客
07-20 4517
简介 这一小节主要是做，全局统一异常处理 步骤 Web 应用中经常使用 try－catch 这会导致代码结构杂乱无章的感觉，也不利于调试代码，如果能将所有异常统一到一个模块将是一个很美好的事，那么利用@ControllerAdvice和@ExceptionHandler定义一个统一异常处理类，就能做到全局的异常捕获和处理 @ControllerAdvice：控制器增强，使@ExceptionHandler、@InitBinder、@ModelAttribute注解的方法应用到所有的 @RequestMa
从零搭建 Spring Boot 后端项目（十一）
小夏陌的博客
07-24 4510
简介 日志能记录程序的运行轨迹，方便查找关键信息，也方便快速定位解决问题。尤其是项目线上问题，不允许远程调试的情况下，只能依赖日志定位问题，如果日志写的好，那就能快速找到问题所在。反之，日志没写好，反而会影响程序的运行性能和稳定性。
spring boot 后端搭建流程
最新发布
03-26
1. 创建项目：使用IDE或者Maven命令创建Spring Boot项目。 2. 配置数据库：在application.properties或application.yml中配置数据库信息。 3. 定义实体类：创建实体类，使用注解定义表、字段等信息。 4. 定义...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小夏陌

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值