SpringBoot+MP实现简单购物车并集成用户下单功能

Posted 2023-03-30 懒羊羊.java

文章目录

• • 前言
  • 一.购物车
  • 二.用户下单

前言

各位新人请注意，在真实的生产环境中，购物车模块往往比网上教的复杂得多，以下只是简单地实现一些基本功能，业务量决定技术实现！

一.购物车

购物车在日常生活中十分常见，加入购物车、移出购物车、查看购物车…通过OOP的角度来看这就是一些CRUD，但值得注意的是，这不是简单的CRUD。首先，每一个用户的购物车是不同的，其次在现实生活中添加进去的商品不仅仅涉及到的是一张表（一类实体），比如我已经添加了选中的菜品（dish表），我还想添加套餐（套餐表）…这就不是一个简单的save方法能解决的

但是，只要静下心来理清表的结构，实体的联系，知道购物车对应表的字段是干什么的，是来操作什么关联表的，就会简单很多，先来看一下表的结构：

框起来的三个id格外的亮眼，在实现方法里就是通过id查到表对应的实体信息，然后对实体的属性进行操作，最后保存到各自对应的表中。
所谓的多表在代码实现过程中，其实就是几个表对应的Service之间调用方法来保存针对场景设置的属性值，记住这句话来看下面的代码就会变得非常简单！

@PostMapping("/add")
public R<ShoppingCart> add(@RequestBody ShoppingCart shoppingCart) 

    log.info("购物车信息：", shoppingCart.toString());

    //设置用户id，指定是当前是哪个用户的购物车
    Long currentId = BaseContext.getCurrentId();
    shoppingCart.setUserId(currentId);

    LambdaQueryWrapper<ShoppingCart> shoppingCartLqw = new LambdaQueryWrapper<>();
    shoppingCartLqw.eq(ShoppingCart::getUserId, currentId);//查找用户
    //查询当前菜品或者套餐是否在购物车中
    Long dishId = shoppingCart.getDishId();
    if (dishId != null) 
        //添加到购物车的是菜品
        shoppingCartLqw.eq(ShoppingCart::getDishId, dishId);
     else 
        //添加到购物车的是套餐
        shoppingCartLqw.eq(ShoppingCart::getSetmealId, shoppingCart.getSetmealId());
    

    ShoppingCart shopOne = shoppingCartService.getOne(shoppingCartLqw);

    if (shopOne != null) 
        //如果已在购物车中则菜品数量+1
        Integer num = shopOne.getNumber();
        shopOne.setNumber(num + 1);
        shopOne.setCreateTime(LocalDateTime.now());
        shoppingCartService.updateById(shopOne);
     else 
        //如果不在购物车中则加入购物车，且数量默认为1
        shoppingCart.setNumber(1);
        shoppingCartService.save(shoppingCart);
        shopOne = shoppingCart;
    
    return R.success(shopOne);

看完这段代码，其实不难发现就是围绕着“拿实体，改实体”来做，只不过在实现的过程中需要注意一些小细节罢了。

下单关联表

经常网购都清楚，在下单前最重要的要素就是收货地址、用户基本信息（电话，身份证，姓名等等…）
在进行下单操作生成订单时都需要同时操作这几张表，把表里的信息读到订单表中。

在购物车的基础之上，用户下单就是对购物车对应表中的数据进行进一步操作，只不过下单的过程不仅仅涉及到购物车对应的表，还包括（用户地址，个人信息等等…），又是一次涉及到多表的操作。

二.用户下单

这次以订单表来保存用户基本信息Order，以订单明细表保存所选菜品信息OrderDetails，简单的购物车实现逻辑如图所示：

当点击下单，前端会发送过来一个请求（包含一些其他关联表的id）：

对于后端，需要通过Order类型的实体接收，并通过其中已经封装的各种表id来操作其他表，就像这样：

@Transactional
public void submit(Orders orders) 
    //获得当前用户id
    Long currentId = BaseContext.getCurrentId();
    LambdaQueryWrapper<ShoppingCart> shopLqw = new LambdaQueryWrapper<>();
    shopLqw.eq(ShoppingCart::getUserId, currentId);

    //查询当前用户购物车数据
    List<ShoppingCart> shopOne = shoppingCartService.list(shopLqw);
    if (shopOne == null || shopOne.size() == 0) 

        throw new CustomException("购物车为空，不能下单~");
    

    //查询用户信息
    User userNow = userService.getById(currentId);

    //查询地址信息
    Long addressBookId = orders.getAddressBookId();

    AddressBook addressBook = addressBookService.getById(addressBookId);
    if (addressBook == null) 
        throw new CustomException("不好意思，您还没有填写地址哟");
    

    long orderId = IdWorker.getId();//订单号

    AtomicInteger amount = new AtomicInteger(); //确保在多线程的情况下保证线程安全

    //向订单明细表中添加购物车中的内容(主要是餐品信息)
    List<OrderDetail> orderDetails = shopOne.stream().map((item) -> 
        OrderDetail orderDetail = new OrderDetail();
        orderDetail.setOrderId(orderId);
        orderDetail.setNumber(item.getNumber());
        orderDetail.setDishFlavor(item.getDishFlavor());
        orderDetail.setDishId(item.getDishId());
        orderDetail.setSetmealId(item.getSetmealId());
        orderDetail.setName(item.getName());
        orderDetail.setImage(item.getImage());
        orderDetail.setAmount(item.getAmount());
        amount.addAndGet(item.getAmount().multiply(new BigDecimal(item.getNumber())).intValue());
        return orderDetail;
    ).collect(Collectors.toList());


    //向订单表中添加基本信息(用户基本信息)
    orders.setId(orderId);
    orders.setOrderTime(LocalDateTime.now());
    orders.setCheckoutTime(LocalDateTime.now());
    orders.setStatus(2);
    orders.setAmount(new BigDecimal(amount.get()));
    orders.setUserId(currentId);
    orders.setNumber(String.valueOf(orderId));
    orders.setUserName(userNow.getName());
    orders.setConsignee(addressBook.getConsignee());
    orders.setPhone(addressBook.getPhone());
    orders.setAddress((addressBook.getProvinceName() == null ? "" : addressBook.getProvinceName())
            + (addressBook.getCityName() == null ? "" : addressBook.getCityName())
            + (addressBook.getDistrictName() == null ? "" : addressBook.getDistrictName()) + (addressBook.getDetail() == null ? "" : addressBook.getDetail()));

    //向订单插入一条数据，主要是客户基本信息
    this.save(orders);
    //向订单明细表插入多条数据，主要是客户所选餐品
    orderDetailService.saveBatch(orderDetails);
    //清空购物车数据
    shoppingCartService.remove(shopLqw);

在实现过程中有一些细节还是值得注意一下：
1.涉及多表要开启事务，确保一致性
2.new AtomicInteger()来定义餐品数量，确保线程安全
3.全局异常要处理好
4.当完成了生成订单之后要记得清空购物车

购物车与订单的关系
在这之前，我总是不能深刻理解购物车与订单之间的关系，实现下单功能后才逐渐明了，原来订单是购物车的载体，购物车的出现就是为了生成订单而服务的，购物车包含于订单！

SpringBoot集成Redis并实现主从架构

hello，你好呀，我是灰小猿，一个超会写bug的程序猿！

今天这篇文章来和大家分享一下在springboot中如何集成redis，并实现主从架构，进行数据的简单存储。

我的Redis是部署在Windows系统下面的，所以在这里附上Redis在Windows环境下的安装地址和安装说明。

一、Windows环境下安装Redis

首先去官网下载Redis的安装包，官方下载地址：
https://github.com/tporadowski/redis/releases
在其中选择当前版本即可。

下载之后解压压缩包，得到这样的文件目录：

打开cmd命令行，切换到该redis的文件目录下。运行：

redis-server.exe redis.windows.conf

输入之后，显示这样的页面就说明Redis服务器运行成功了！

这个时候这个命令行窗口不要关闭，一旦关闭，Redis服务就停止了！这一点以后在开发的时候也是一样的，需要注意！
现在打开一个新的cmd窗口，同样定位到Redis的目录下，
运行如下命令：

redis-cli.exe -h 127.0.0.1 -p 6379

运行这个命令的原因是连接到redis的服务器，其中的地址为本地地址，6379为redis的默认端口号，

设置键值对

因为我们知道Redis中数据的存储都是以键值对的形式来到的，所以我们可以以键值对的形式来在Redis中存储一个数据，书写格式如下

set key value

比如存储key为Mykey，value为huixiaoyuan的内容，则输入

set Mykey huixiaoyuan

根据key获取value

根据key来获取value，我们可以直接以get的形式获取。
如获取我们刚才设置的key为Mykey的value值，那么直接：

get Mykey

就可以获取到对应的value值了，

这样在Windows环境下Redis的安装就算是完成了，以后在使用的过程中记得，Redis的窗口不要关闭就可以了。

二、SpringBoot连接Redis

springboot连接Redis时需要在pom文件中导入所需的jar包依赖，依赖如下：

        <!-- 加入jedis依赖 -->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.9.0</version>
        </dependency>

（1）使用Jedis类直接连接Redis服务器

在springboot环境下连接redis的方法有很多，首先最简单的就是直接通过jedis类来连接，

jedis类就相当于是redis的客户端表示。

连接方法如下：

    /**
     * redis连接测试01
     */
    @Test
    public void redisTest01() 
        //连接本地的 Redis 服务
        Jedis jedis = new Jedis("localhost");
        // 如果 Redis 服务设置了密码，需要用下面这行代码输入密码
        // jedis.auth("123456"); 
        System.out.println("连接成功");
        //查看服务是否运行
        System.out.println("服务正在运行: "+jedis.ping());
    

运行后结果：

通过这种方式进行连接时，springboot会自动的去本地寻找redis服务器进行连接，如果没有找到那么就会报错，

如果你去阅读jedis的底层源码，你会发现Jedis类有多种构造方法，
常用的几个是

使用默认地址和端口

//不传值，那么使用默认的127.0.0.1地址，6379端口就访问
public Jedis()

使用指定地址和默认端口

//只传入目的地址，那么使用指定的地址和默认的端口号去访问
public Jedis(String host)

使用指定地址和端口

//传入目的地址和端口号，那么使用指定的地址和端口号去访问
public Jedis(String host, int port)

（2）通过配置文件进行连接

在springboot中，当然是可以通过配置文件的形式来设置各种连接参数了，Redis也是一样的，


在yml文件中进行如下配置：

注意：这是没有使用连接池的，如果使用连接池，需要在下边增加配置，关于使用连接池的可以继续往下看。

##redis配置信息
spring:
  redis:
    database: 0 #redis数据库索引，默认为0
    host: 127.0.0.1 #redis服务器地址
    port: 6379 #redis服务器连接端口
    password: #redis服务器连接密码，默认为null
    timeout: 5000 #redis连接超时时间

通过配置文件来进行配置之后，我们就可以使用springboot中的一个工具类来操作Redis的操作了，springboot会自动读取配置文件中的配置信息，然后通过该配置信息去连接Redis服务器，springboot中提供操作Redis的工具类有两个，分别是：StringRedisTemplate和RedisTemplate，

StringRedisTemplate和RedisTemplate的区别如下

• 在进行序列化时，RedisTemplate使用的是 JdkSerializationRedisSerializer，而StringRedisTemplate使用的是StringRedisSerializer
• StringRedisTemplate继承了RedisTemplate<String,String>,而RedisTemplate 定义为 RedisTemplate<K, V>,所有StringRedisTemplate就限定了K，V为String类型的

相同处体现在他们对Redis的操作上，

RedisTemplate和StringRedisSerializer都定义了五种对Redis的操作，分别对应这Redis中的五种数据类型。

redisTemplate.opsForValue();　　//操作字符串
redisTemplate.opsForHash();　　 //操作hash
redisTemplate.opsForList();　　 //操作list
redisTemplate.opsForSet();　　  //操作set
redisTemplate.opsForZSet();　 　//操作有序set

那么在使用的时候，这两个类应该如何选择呢？

如果你的redis数据库里面本来存的是字符串数据，或者你要存取的数据就是字符串类型数据的时候，那么你就使用StringRedisTemplate即可，

》但是如果你的数据是复杂的对象类型，而取出的时候又不想做任何的数据转换，直接从Redis里面取出一个对象，那么使用RedisTemplate是更好的选择。

接下来我以StringRedisSerializer为例子，来给大家演示一下使用StringRedisSerializer操作Redis的方法，

    /**
     * springboot主从连接测试,
     * 使用springRedisTemplate操作
     */
    @Test
    public void redisTest06() 
//        操作字符型
        stringRedisTemplate.opsForValue().set("test06","Test06");
        System.out.println(stringRedisTemplate.opsForValue().get("test06"));

//        设置key的过期时间，30秒
        stringRedisTemplate.expire("test06", 30 * 1000, TimeUnit.MILLISECONDS);

//        根据key获取过期时间
        Long test06ExpireTime = stringRedisTemplate.getExpire("test06");
        System.out.println("根据key获取过期时间:" + test06ExpireTime);

//        根据key获取过期时间，并且换算成指定单位
        Long test06ExpireTimeToUnit = stringRedisTemplate.getExpire("test06", TimeUnit.SECONDS);
        System.out.println("根据key获取过期时间，并且换算成指定单位:" + test06ExpireTimeToUnit);

//        检查key是否存在，返回布尔类型
        Boolean test06IsExist = stringRedisTemplate.hasKey("test06");
        System.out.println("检查key是否存在，返回布尔类型:" + test06IsExist);

    

在上面的操作中，有一点关于获取和设置key过期时间的操作，当时在操作的时候对其进行了一下探究，在这里分享给大家

stringRedisTemplate中获取过期时间的getExpire()方法的说明

如果最开始没有设置过期时间，那么就返回-1，数据在没有达到Redis数据最大限额的情况下会一直存在.

如果设置了过期时间，但是数据还未过期，就返回剩余时间，如果到了过期时间，那么数据会被删除
如果数据被删除或者不存在，那么就返回-2.

三、使用连接池操作Redis

和使用mysql数据库一样，Redis在springboot中也是有连接池的，上面在yml中写入配置文件的时候，我有和大家说过可以在yml配置文件中写入连接池参数，那么配置如下：

##redis配置信息
spring:
  redis:
    database: 0 #redis数据库索引，默认为0
    host: 127.0.0.1 #redis服务器地址
    port: 6379 #redis服务器连接端口
    password: #redis服务器连接密码，默认为null
    timeout: 5000 #redis连接超时时间
    jedis:
      pool: #连接池配置
        max-active: 8 #连接池最大连接数
        max-wait: -1 #连接池最大阻塞等待时间
        max-idle: 8 #连接池中的最大空闲连接数
        min-idle: 0 #连接池中的最小空闲连接数

使用连接池时还有一种不需要写入配置文件的方法，使用这种方法就需要在构造函数中传入参数。
并且将配置信息写入到配置类中，

当然，在进行实际的项目开发的时候，还是将配置信息写入到配置文件中会好一点。

    /**
     * redis连接测试01
     * 建立简单主从架构
     */
    @Test
    public void redisTest02() 
//        配置redis连接池
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
//        在指定时刻通过连接池能够获取到的最大的jedis的数量
        jedisPoolConfig.setMaxTotal(20);
//        最大空闲jedis的数量
        jedisPoolConfig.setMaxIdle(10);
//        最小空闲jedis的数量
        jedisPoolConfig.setMinIdle(5);

//        建立redis连接池，设置本地地址，端口号，连接超时时间和读写超时时间，如果没有连接密码，那么久为null
        JedisPool jedisPool = new JedisPool(jedisPoolConfig, "127.0.0.1", 6379, 300, null);

//        新建一个jedis，jedis：redis在Java中的客户端实现
        Jedis jedis = null;
        try 
//            从连接池中获取到一个jedis资源
            jedis = jedisPool.getResource();
//            设置key-value，并获取value
            System.out.println(jedis.set("hxy", "888"));
            System.out.println(jedis.get("hxy"));
         catch (Exception e) 
            e.printStackTrace();
         finally 
//            注意！！这里不是关闭连接，只是将jedis归还到连接池
            if (jedis != null) 
                jedis.close();
            
        

    

以上是不使用配置文件的情况下，将参数传入到Jdispool类中来实现连接池的，如果使用了配置文件，那么直接调用Jdispool的无参构造即可了，其他的操作和上面代码的都是一样的，我就不重复写了。


最后在操作完的时候，别忘了使用jedis.close();将jedis归还到连接池即可！

关于springboot连接Redis的操作，就先分享这些，当然Redis的操作肯定远远不止这些，之后小猿慢慢和大家分享吧！


一键三连加关注，灰小猿带你上高速！

我是灰小猿，我们下期见呀！