秒杀系统Web实践——01框架搭建Spring Boot+Mybatis +Redis（Jedis）

最新推荐文章于 2023-01-19 00:38:59 发布
最新推荐文章于 2023-01-19 00:38:59 发布
阅读量341 收藏 4
点赞数
分类专栏： 秒杀项目实战 文章标签： spring boot redis jedis mybatis java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/linchaoyang_/article/details/106112785
版权

第一章项目框架搭建

项目github:https://github.com/LCYang-1/-

主要任务

1.Spring Boot环境搭建

2.集成Thymeleaf , Result结果封装

3.集成Mybatis + Druid

4.集成Jedis+ Redis安装+通用缓存Key封装

5.测试

 

 

1.Spring Boot环境搭建

目前选取这些依赖，后期遇到什么，再添加就行了（记性不好！！一步一步来吧）

2.集成Thymeleaf , Result结果封装

编辑application.properties配置文件

Result结果封装

    private int code;        //响应码
    private String msg;      //提示
    private T data;          //内容

详细封装请看gitbut

3.集成Mybatis + Druid

添加依赖

 <!-- https://mvnrepository.com/artifact/org.mybatis.spring.boot/mybatis-spring-boot-starter -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.1</version>
        </dependency>

         <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.6</version>
        </dependency>

添加配置

#mybatis
mybatis.type-aliases-package=com.lcy.miaosha.pojo
mybatis.configuration.map-underscore-to-camel-case=true
mybatis.configuration.default-fetch-size=100
mybatis.configuration.default-statement-timeout=3000
mybatis.mapper-locations=classpath:com/lcy/miaosha/dao/*.xml

#数据源
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/miaosha?serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=1234
        
# druid
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.filters=stat
spring.datasource.maxActive=2
spring.datasource.initialSize=1
spring.datasource.maxWait=60000
spring.datasource.minIdle=1
spring.datasource.timeBetweenEvictionRunsMillis=60000
spring.datasource.minEvictableIdleTimeMillis=300000
spring.datasource.validationQuery=select 'x'
spring.datasource.testWhileIdle=true
spring.datasource.testOnBorrow=false
spring.datasource.testOnReturn=false
spring.datasource.poolPreparedStatements=true
spring.datasource.maxOpenPreparedStatements=20

4.集成Jedis+ Redis安装+通用缓存Key封装

Redis安装

请参考https://www.runoob.com/redis/redis-install.html

添加依赖

依赖原生Jedis；添加Fastjson,序列化后为json，方便查看。

        <!-- https://mvnrepository.com/artifact/redis.clients/jedis -->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>3.1.0</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.62</version>
        </dependency>

在application.properties设置配置参数

这里我使用的是自定义的配置参数

#redis
redis.host=***.***.***.***
redis.port=6379
#连接超时时间
redis.timeout=3
redis.password=123456
#连接池配置
#最大连接数
redis.poolMaxTotal=10
#最大空闲连接数
redis.poolMaxIdle=10
#最大等待连接数
redis.poolMaxWait=3

所以我们要写一个类来获取配置参数信息

@Component
@ConfigurationProperties(prefix = "redis")
public class RedisConfig {

    private String host;
    private int port;
    private int timeout;//秒
    private String password;
    private int poolMaxTotal;
    private int poolMaxIdle;
    private int  poolMaxWait;//秒

    //set/get方法
    /**
    *别忘添加
    */
}

编写JedisPoolFactory类来配置JedisPool资源连接池

@Service
public class JedisPoolFactory {

    @Autowired
    RedisConfig redisConfig;

    @Bean
    public JedisPool JedisPoolFactory(){

        System.out.println(redisConfig.toString());
        JedisPoolConfig poolConfig=new JedisPoolConfig();
        poolConfig.setMaxIdle(redisConfig.getPoolMaxIdle());
        poolConfig.setMaxTotal(redisConfig.getPoolMaxTotal());
        poolConfig.setMaxWaitMillis(redisConfig.getPoolMaxWait()*1000);
        JedisPool jp=new JedisPool(poolConfig,redisConfig.getHost(),redisConfig.getPort()
                ,redisConfig.getTimeout()*1000,redisConfig.getPassword(),0);
        return jp;
    }
}

通用缓存Key封装

为防止我们使用Redis时Key值重复给予不同类型含义的Value，我们在此对通用缓存Key封装

一个接口

public interface KeyPrefix {

    public int expireSeconds();

    public String getPrefix();

}

一个抽象类

public abstract class BasePrefix implements KeyPrefix {

    private int expireSeconds;

    private String prefix;

    public BasePrefix( String prefix) {
        this(0,prefix);
    }

    public BasePrefix(int expireSeconds, String prefix) {
        this.expireSeconds = expireSeconds;
        this.prefix = prefix;
    }

    @Override
    public int expireSeconds() {//0代表永不过期
        return expireSeconds;
    }

    @Override
    public String getPrefix() {
        String classname = getClass().getSimpleName();
        return classname+":"+prefix;
    }
}

RedisService类的编写

分别有get、set、exists、incr、decr。

@Service
public class RedisService {

    @Autowired
    JedisPool jedisPool;

    /**
     * 获取单个对象
     * @param prefix
     * @param key
     * @param clazz
     * @param <T>
     * @return
     */
    public <T> T get(KeyPrefix prefix,String key,Class<T> clazz){
        Jedis jedis =null;
        try {
            jedis = jedisPool.getResource();
            //生成真正的key
            String realKey =prefix.getPrefix()+key;
            String str = jedis.get(realKey);
            T t=stringToBean(str,clazz);
            return t;

        }finally {
            returnToPool(jedis);
        }

    }

    /**
     * 设置对象
     * @param prefix
     * @param key
     * @param value
     * @param <T>
     * @return
     */
    public <T> boolean set(KeyPrefix prefix,String key,T value){
        Jedis jedis =null;
        try {
            jedis = jedisPool.getResource();
            String str=beanToString(value);
            if (str==null||str.length()<=0)
                return false;
            //生成真正的key
            String realKey =prefix.getPrefix()+key;
            int seconds=prefix.expireSeconds();
            if (seconds<=0){
                jedis.set(realKey,str);
            } else {
                jedis.setex(realKey,seconds,str);
            }
            jedis.set(realKey, str);
            return true;

        }finally {
            returnToPool(jedis);
        }

    }

    /**
     * 判断是否存在
     * @param prefix
     * @param key
     * @param <T>
     * @return
     */
    public <T> boolean exists(KeyPrefix prefix,String key){
        Jedis jedis =null;
        try {
            jedis = jedisPool.getResource();
            //生成真正的key
            String realKey =prefix.getPrefix()+key;
            return jedis.exists(realKey);

        }finally {
            returnToPool(jedis);
        }

    }

    /**
     * 增加值
     * @param prefix
     * @param key
     * @param <T>
     * @return
     */
    public <T> Long incr(KeyPrefix prefix,String key){
        Jedis jedis =null;
        try {
            jedis = jedisPool.getResource();
            //生成真正的key
            String realKey =prefix.getPrefix()+key;
            return jedis.incr(realKey);

        }finally {
            returnToPool(jedis);
        }

    }

    /**
     * 减少值
     * @param prefix
     * @param key
     * @param <T>
     * @return
     */
    public <T> Long decr(KeyPrefix prefix,String key){
        Jedis jedis =null;
        try {
            jedis = jedisPool.getResource();
            //生成真正的key
            String realKey =prefix.getPrefix()+key;
            return jedis.decr(realKey);

        }finally {
            returnToPool(jedis);
        }

    }


    private <T> String beanToString(T value) {
        if (value==null)
            return null;
        Class<?> aClass = value.getClass();
        if (aClass==int.class||aClass==Integer.class){
            return ""+value;
        }else if (aClass==String.class){
            return (String) value;
        }else if (aClass==long.class||aClass==Long.class){
            return ""+value;
        }else {
            return JSON.toJSONString(value);
        }
    }

    private <T> T stringToBean(String str,Class<T> aClass) {
        if (str==null||str.length()<=0||aClass==null)
            return null;


        if (aClass==int.class||aClass==Integer.class){
            return (T)Integer.valueOf(str);
        }else if (aClass==String.class){
            return (T)str;
        }else if (aClass==long.class||aClass==Long.class){
            return (T)Long.valueOf(str);
        }else {
            return JSON.toJavaObject(JSON.parseObject(str),aClass);
        }
    }

    private void returnToPool(Jedis jedis) {
        if (jedis!=null){
            jedis.close();
        }
    }


}

 

5.测试

前提条件，数据库中有一个可用的表

对应的User类

public class User {
    private int id;
    private String name;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

对应的一个UserDao

@Mapper
public interface UserDao {

    @Select("select * from user where id=#{id}")
    public User getById(@Param("id") int id);


}

当然还有UserService

@Service
public class UserService {

    @Autowired
    UserDao userDao;

    public User getById(int id){
        return userDao.getById(id);
    }
}

我们还要实现一个UserKey来继承BasePrefix

public class UserKey extends BasePrefix {
    public UserKey(String prefix) {
        super(prefix);
    }
    public static UserKey getById=new UserKey("id");
    public static UserKey getByName=new UserKey("name");
}

现在我们就可以进行测试了，我们通过Controll类来进行测试

@Controller
@RequestMapping("/demo")
public class SampleController {

    @Autowired
    RedisService redisService;

    @Autowired
    UserService userService;

    @RequestMapping("/thymeleaf")
    public String thymeleaf(Model model){
        model.addAttribute("name","Joshua");
        return "hello";
    }

    @RequestMapping("/db/get")
    @ResponseBody
    public String dbGet(){
        User user=userService.getById(1);
        return user.toString();
    }

    @RequestMapping("/redis/get")
    @ResponseBody
    public String redisGet(){
        User v1=redisService.get(UserKey.getById,""+1,User.class);
        return v1.toString();
    }

    @RequestMapping("/redis/set")
    @ResponseBody
    public boolean redisSet(){
        User user = new User(1, "1111");
        boolean b = redisService.set(UserKey.getById, "" + 1, user);

        return b;
    }
}

看到第一个方法返回一个“hello”字符串，并且没有 @ResponseBody注解，我们就要编辑相应的hello.html页面

他的位置对应在classpath:/templates/

<!DOCTYPE HTML>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>hello</title>
    <meta http-equiv="Content-Type " content="text/html;charset=UTF-8"/>
</head>
<body>
<p th:text="'hello:'+${name}"></p>
</body>
</html>

启动项目

图片说明Thymeleaf一切正常

图片说明Mybatis+Druid+Result结果封装正常图片说明redis服务正常

到此为止第一章的内容就算结束了！！！！！！

linchaoyang_
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring+mybatis+redis
07-20
在spring+spring mvc+mybatis模式下，使用的最多的就是jedis，但是spring boot整合了redis后，依然可以使用jedis，但是同时也提供了一个RedisTemplate和StringRedisTemplate，RedisTemplate使用的序列化类是默认...
基于若依开源框架的Java项目：小区物业管理系统（spring Boot + mybatis + vue + security）前后端分离架构
Soncat2000的博客
11-23 1429
基础信忌官理:可查看、修改住户信息;系统使用SpringBoot作为开发框架、Mysql作为数据库管理系统，采用B/S模式作为系统的物理架构，开发—个基于SpringBoot的小区管理系统。住户(微信端):可查看个人基本信息，修改登录密码;问官理四申请装修监督，并能修改、查看、撤销自己的申请;可提出投诉，并能修改、查看、撤销E的控诉;可提出报修，并能修改、查看、撒销的报修;Controller：负责读取视图表现层的数据，控制用户的输入，并调用业务层的方法，通过controller实现。
Springboot+shiro+mybatis-plus+vue前后端分离项目架构设计
guochengabcd的博客
12-30 9195
前言： 根据公司要求，搭建个前后端分离的权限系统，根据目前技术技术水平，采用以下技术栈开发，以此写一份博客记录下构架的系统框架，同时希望能帮助因搭建系统架构不怎么会的小伙伴们，废话不多说，直接列出技术栈： 前端项目 Vue2.x+element全家桶+webpack+node+vue-admin 后端项目 Springboot2.x+shiro+mybatis-plus+mysql ...
springboot+mybatis-plus+redis整合（附上脚手架完整代码）
风团团
09-23 5144
首先新建一个springboot项目 next到这里的时候，我们可以选择用jdk几，还有就是group，这个一般就是com.公司名字了，artifact就是项目名字。个人开发我还是喜欢用com.名字前缀哈。 到了这一步的话，如果对这个项目有什么别的需求，比如需要用到mybatis啥的可以勾相应的选项。其实就是idea自动帮咱导入相关的依赖。这里我们暂且啥也不勾。写过这么多的项目，咱们自己整合的依赖还是挺香的哈。 2：导入依赖 可能我比较懒，喜欢用mybatisplus，这些是整合mybatisplus需要
springboot+mybatis+redis整合（超方便的框架）
萝卜坑
06-06 1万+
springboot+mybatis+redis整合（超方便的框架）一、先整合springboot+mybatis（_一定要注意自己的springboot版本，去找对应版本的参考，不然坑很多~_）1、创建好springboot框架项目2、添加pom.xml的jar包依赖（所有）3、把数据库中的表建好（注意使用建表语句创建表，直接使用工具创建一直失败，PS：似乎是编码格式的问题~）4、把model里...
MyBatis与Redis
热门推荐
yongqi_wang的博客
05-27 1万+
一。MyBatis    1.简介 ① MyBatis是一个持久层框架，完成的是对数据库的访问和操作；（CRUD） ② 它解决了JDBC对数据库的操作与访问过程中存在的问题，是对原有JDBC技术的封装 ③ MyBatis解决JDBC的问题 【1】虽然JDBC操作数据库的方式很直观，但其核心就是对于数据库的操作。多个方法间存在大量的冗余 【2】基于Java中面向对象的基本思想，所以我们会将查询出...
spring+mybatis+redis+bootstrap 简单框架
08-22
框架整合，直接上手开发，免去搭框架的烦恼
ShiroJwt：API SpringBoot + Shiro + Java-Jwt + Redis（Jedis）
02-04
ShiroJwt 前端地址： : ...实现Shiro的Cache（Redis）功能： : 项目介绍 RESTful API Maven集成Mybatis Generator（逆向工程） Shiro + Java-JWT实现无状态鉴权机制（令牌） 密码加密（采用AES-128 + Base6
基于SpringBoot+Shiro+Redis+Jwt+Thymeleaf+MyBatis 开发的后台用户、角色+源代码+文档
最新发布
11-28
Geek-Framework是在SpringBoot基础上搭建的一个Java基础开发框架，以Spring MVC为模型视图控制器，MyBatis为数据访问层， Apache Shiro和Spring-Security为权限授权层，redis进行缓存。 Geek-Framework主要定位于微...
基于spring Boot的Java秒杀系统
05-31
本项目主要实现的是一个电商秒杀系统。...Spring Boot环境搭建，集成Thymeleaf，Result结果封装，集成Mybatis+Druid，集成Jedis+Redis安装+通用缓存Key封装。 redis实现一个高性能的key-value数据库。
SpringBoot+Mybatis+SpringSecurity+JWT
09-12
SpringBoot2.0.4 +Mybatis+SpringSecurity+JWT实现权限管理及登陆管理
mybatis与redis整合示例
01-02
mybatis与redis的简单整合示例，供大家学习参考，内含完整maven工程。 博客内容地址：https://blog.csdn.net/magi1201/article/details/85635878
demo：redis作为mybatis的第三方缓存以及spring集成redis的直接操作数据库
09-30
spring集成redis的demo项目。其中包括redis作为mybatis的第三方缓存配置和redis直接操作缓存数据库的集成。说明：将application.properties中数据源的修改成你的配置。若你只想看spring集成redis的操作，则可以将mysql的配置注释掉，将applicationContext.xml中 也注释掉。则可以只配置redis的数据源即可运行。另外，若你对redis使用不太熟悉，则有必要在说一句，你需要将redis启动配置文件redis.conf中的bind那一行注释掉，否则远程是连接不上的。我的redis配置了密码为redis，可以在redis.conf 里找到requirepass “”这一行，改为requirepass “redis”。当然你也可以尝试将配置文件里的密码redis修改为空
springboot整合redis、mybatis以及redis和mybatis的联合使用
09-17
springboot集成redis、mybatis 1、集成redis 2、集成mybatis 3、自定义redis KEY生成器/CacheManager来管理redis缓存 4、分布式redis-session共享 5、springboot实现初始化加载配置（实现缓存预热）的两种方式 6、二级缓存联合使用 方式一：redis原生方法工具类（RedisService）+redis+mybatis 方式二：CacheManager+redis+mybatis
mybatis+redis使用
qq_40453972的博客
08-26 1466
mybatis缓存机制和redis
MyBatis 使用 Redis 缓存
很酷的站长的博客
01-19 896
在上一文中，我们介绍了 MyBatis 的多级缓存。MyBatis 的二级缓存可在多个会话中共享缓存，但是这也加大了内存的使用空间，如果二级缓存空间占有量过多势必会导致程序运行空间的不足，因此我们需要将二级缓存转移到专业的缓存服务器上。Redis 是一个高性能的 kv 数据库，被广泛的使用在缓存服务上，MyBatis 项目开发者提供了 Redis 缓存的实现。本小节我们将一起来学习如何在 MyBatis 中集成 Redis 缓存。
Mybatis整合Redis实现分布式缓存
sunshineKay的博客
06-28 1794
Mybatis自带二级缓存底层数据结构为HashMap，无法适用于分布式环境。 本文要点： 1.Mybatis整合Redis实现分布式缓存 2.查看自定义缓存实现类RedisCache及相关源码，了解Redis在实现MyBatis二级缓存中的执行工作流 (更多二级缓存知识点可参考MyBatis二级缓存)，存储类型（hash）等 1.Mybatis整合Redis实现分布式缓存 A.引入Mybatis整合Redis依赖Jar包 <dependency> ..
mybatis与redis整合
蜗牛学习笔记
01-02 8081
redis与ehcache都是专业的缓存框架，redis与mybatis的整合方式与ehcache类似，不同的是，redis需要先搭建自己的redis服务，用来存放缓存数据。 这里主要演示mybatis与redis的整合过程，redis服务的搭建可以参考 Java连接redis简单demo示例，这里使用本地的Windows环境的redis服务，与mybatis进行整合。 1、添加redis依赖...
Mybatis整合Redis实现二级缓存
m0_70274796的博客
05-03 2351
mybaits的二级缓存是mapper范围级别，除了在SqlMapConfig.xml设置二级缓存的总开关，还要在具体的mapper.xml中开启二级缓存 开启mybatis的二级缓存 <!--设置mybaits对缓存的支持-->    <property name="configurationProperties">        <props&g...
Spring Boot+Mybatis Plus 使用Redis实现二级缓存具体步骤以及代码
03-24
以下是 Spring Boot Mybatis Plus 使用 Redis 实现二级缓存的具体步骤和代码： 1. 首先，在 pom.xml 文件中添加 Redis 相关依赖： ``` <groupId>org.springframework.boot <artifactId>spring-boot-starter-...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值