商城项目秒杀业务和订单业务秒杀订单整合----商城项目

原创 已于 2025-03-21 14:48:51 修改 · 489 阅读 · 14 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#spring boot #微服务 #mybatis #spring cloud #后端 #分布式 #jvm

于 2025-03-07 17:04:29 首次发布
package com.alatus.mall.seckill.service.impl;

import com.alatus.common.to.mq.SeckillOrderTo;
import com.alatus.common.utils.R;
import com.alatus.common.vo.MemberRespVo;
import com.alatus.mall.seckill.constant.SecKillConstants;
import com.alatus.mall.seckill.feign.CouponFeignService;
import com.alatus.mall.seckill.feign.ProductFeignService;
import com.alatus.mall.seckill.interceptor.LoginUserInterceptor;
import com.alatus.mall.seckill.service.SecKillService;
import com.alatus.mall.seckill.to.SecKillSkuRedisTo;
import com.alatus.mall.seckill.vo.SeckillSessionEntityVo;
import com.alatus.mall.seckill.vo.SkuInfoVo;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;
import org.apache.commons.lang.StringUtils;
import com.baomidou.mybatisplus.core.toolkit.IdWorker;
import org.redisson.api.RSemaphore;
import org.redisson.api.RedissonClient;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.BoundHashOperations;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

@Service
public class SecKillServiceImpl implements SecKillService {
    @Autowired
    private CouponFeignService couponFeignService;
    @Autowired
    private ProductFeignService productFeignService;
    @Autowired
    private StringRedisTemplate redisTemplate;
    @Autowired
    private RedissonClient redissonClient;
    @Autowired
    private RabbitTemplate rabbitTemplate;
    @Override
    public void uploadSecKillSkuLatest3Days() {
//        扫描需要参与秒杀的活动
        R daySession = couponFeignService.Latest3DaySession();
        if(daySession.getCode() == 0){
            List<SeckillSessionEntityVo> seckillSessionVos = daySession.getData(new TypeReference<List<SeckillSessionEntityVo>>() {});
//            缓存活动信息
            saveSessionInfos(seckillSessionVos);
//            缓存活动关联的商品信息
            saveSkuInfos(seckillSessionVos);
        }
    }

//    返回当前事件可以参与的秒杀商品信息
    @Override
    public List<SecKillSkuRedisTo> getCurrentSeckillSkus() {
        long time = new Date().getTime();
        Set<String> keys = redisTemplate.keys(SecKillConstants.SESSION_CACHE_PREFIX + "*");
        List<Object> currentSeckillSkus = new ArrayList<>();
        if (keys != null) {
            for (String key : keys) {
                String replace = key.replace(SecKillConstants.SESSION_CACHE_PREFIX, "");
                String[] tempString = replace.split(":");
                String timeString = tempString[1];
                String[] timeSplit = timeString.split("-");
                long start = Long.parseLong(timeSplit[0]);
                long end = Long.parseLong(timeSplit[1]);
                if(time >= start && time <= end){
                    List<String> range = redisTemplate.opsForList().range(key, -100, 100);
                    BoundHashOperations<String, String, Object> operations = redisTemplate.boundHashOps(SecKillConstants.SKU_CACHE_PREFIX);
                    List<Object> strings = null;
                    if (range != null) {
                        strings = operations.multiGet(range);
                    }
                    if(strings != null && !strings.isEmpty()){
                        currentSeckillSkus.addAll(strings);
                    }
                }
            }
        }
        if(!currentSeckillSkus.isEmpty()){
//            遍历获取到的JSON集合并转换为对象,并完整添加进去方便展示出来
            return currentSeckillSkus.stream().map(item -> {
                SecKillSkuRedisTo secKillSkuRedisTo = JSON.parseObject(item.toString(), SecKillSkuRedisTo.class);
//                屏蔽掉随机码
                secKillSkuRedisTo.setRandomCode(null);
                return secKillSkuRedisTo;
            }).collect(Collectors.toList());
        }
        else{
            return null;
        }
    }

    @Override
    public SecKillSkuRedisTo getSkuSeckillInfo(Long skuId) {
//        找到所有需要参与秒杀的SKU的Key信息
        BoundHashOperations<String, String, String> operations = redisTemplate.boundHashOps(SecKillConstants.SKU_CACHE_PREFIX);
        Set<String> keys = operations.keys();
        if (keys != null && !keys.isEmpty()) {
            String regx = "\\d_" +skuId;
            for (String key : keys) {
                if(Pattern.matches(regx,key)){
                    String json = operations.get(key);
                    SecKillSkuRedisTo secKillSkuRedisTo = JSON.parseObject(json, SecKillSkuRedisTo.class);
                    if(secKillSkuRedisTo.getEndTime() > new Date().getTime()){
                        if(secKillSkuRedisTo.getStartTime() > new Date().getTime()){
                            secKillSkuRedisTo.setRandomCode(null);
                        }
                        return secKillSkuRedisTo;
                    }
                }
            }
        }
        return null;
    }

    @Override
    public String kill(String killId, String key, Integer num) {
        MemberRespVo memberRespVo = LoginUserInterceptor.loginUser.get();
//        获取当前秒杀商品的详细信息
        BoundHashOperations<String, String, String> operations = redisTemplate.boundHashOps(SecKillConstants.SKU_CACHE_PREFIX);
        String skuInfo = operations.get(killId);
//        没找到这么一个秒杀商品
        if(!StringUtils.isEmpty(skuInfo)){
            SecKillSkuRedisTo secKillSkuRedisTo = JSON.parseObject(skuInfo, SecKillSkuRedisTo.class);
            Long startTime = secKillSkuRedisTo.getStartTime();
            Long endTime = secKillSkuRedisTo.getEndTime();
            long time = new Date().getTime();
//            在活动时间范围内
            if(time >= startTime && time <= endTime){
//                拼接商品ID
                String skuId = secKillSkuRedisTo.getPromotionSessionId()+"_"+secKillSkuRedisTo.getSkuId();
//                商品随机码
                String randomCode = secKillSkuRedisTo.getRandomCode();
//                校验随机码和商品ID
                if(key.equals(randomCode) && killId.equals(skuId)){
//                    验证购物数量是否合理
                    if(secKillSkuRedisTo.getSeckillLimit().intValue() >= num){
                        String redisKey = memberRespVo.getId() + "_" + skuId;
//                        验证这个人是否已经购买过,幂等性处理,如果秒杀成功,就去redis占位
//                        而且这个占位必须让它自动过期,不然会一直占用redis的资源
                        long ttl = endTime - time;
                        Boolean check = redisTemplate.opsForValue().setIfAbsent(redisKey, num.toString(), ttl, TimeUnit.MILLISECONDS);
//                        如果这里可以占位成功说明,当前用户没有在该场次购买过该商品
                        if(check){
                            RSemaphore semaphore = redissonClient.getSemaphore(SecKillConstants.SKU_STOCK_SEMAPHORE + randomCode);
                            try {
                                boolean acquire = semaphore.tryAcquire(num, 100, TimeUnit.MILLISECONDS);
//                                秒杀成功以后,我们就可以做一个快速下单,发送一个MQ消息
                                if(acquire){
                                    String orderSn = IdWorker.getTimeId();
                                    SeckillOrderTo secKillOrderTo = new SeckillOrderTo();
                                    BeanUtils.copyProperties(secKillSkuRedisTo,secKillOrderTo);
                                    secKillOrderTo.setOrderSn(orderSn);
                                    secKillOrderTo.setMemberId(memberRespVo.getId());
                                    secKillOrderTo.setNum(num);
                                    rabbitTemplate.convertAndSend("order-event-exchange","order.seckill.order",secKillOrderTo);
//                                    TODO 发送MQ消息
                                    return orderSn;
                                }
                            } catch (InterruptedException e) {
                                return null;
                            }
                        }
                    }
                }
            }
        }
        return null;
    }

    private void saveSessionInfos(List<SeckillSessionEntityVo> seckillSessionVos) {
        seckillSessionVos.stream().forEach(session -> {
            //获取秒杀活动开始和结束时间
            long start = session.getStartTime().getTime();
            long end = session.getEndTime().getTime();
            String key = SecKillConstants.SESSION_CACHE_PREFIX+session.getName()+":"+start+"-"+end;
//            保存活动的信息
            if (!redisTemplate.hasKey(key)) {
                List<String> ids = session.getRelationSkus().stream().map(item->{
                    return item.getPromotionSessionId()+"_"+item.getSkuId().toString();
                }).collect(Collectors.toList());
                redisTemplate.opsForList().leftPushAll(key,ids);
            }
        });
    }
    private void saveSkuInfos(List<SeckillSessionEntityVo> seckillSessionVos){
        seckillSessionVos.forEach(session -> {
//            准备哈希操作
            BoundHashOperations ops = redisTemplate.boundHashOps(SecKillConstants.SKU_CACHE_PREFIX);
            session.getRelationSkus().forEach(relationSku -> {
//                生成随机码
                String token = UUID.randomUUID().toString().replace("-", "");
//                拼接Key保存商品
                String key = relationSku.getPromotionSessionId().toString()+"_"+relationSku.getSkuId().toString();
                if(!ops.hasKey(key)){
                    //                缓存商品
                    SecKillSkuRedisTo secKillSkuRedisTo = new SecKillSkuRedisTo();
//                sku的基本信息
                    R info = productFeignService.getSkuInfo(relationSku.getSkuId());
                    if(info.getCode() == 0){
                        SkuInfoVo skuInfoVo = info.get("skuInfo",new TypeReference<SkuInfoVo>(){});
                        secKillSkuRedisTo.setSkuInfo(skuInfoVo);
                    }
//                sku的秒杀信息
                    BeanUtils.copyProperties(relationSku,secKillSkuRedisTo);
//                    设置上秒杀数量啊!!
                    secKillSkuRedisTo.setSeckillCount(relationSku.getSeckillCount());
//                设置秒杀的时间
                    secKillSkuRedisTo.setStartTime(session.getStartTime().getTime());
                    secKillSkuRedisTo.setEndTime(session.getEndTime().getTime());
                    secKillSkuRedisTo.setRandomCode(token);
//                    保存商品
                    String skuJson = JSON.toJSONString(secKillSkuRedisTo);
                    ops.put(key,skuJson);
//                    如果当前这个场次的商品的库存信息已经上架,就不需要再次上架了
//                设置库存为分布式秒杀的信号量,限流
                    RSemaphore semaphore = redissonClient.getSemaphore(SecKillConstants.SKU_STOCK_SEMAPHORE + token);
//                商品可以秒杀的数量作为信号量
                    semaphore.trySetPermits(relationSku.getSeckillCount().intValue());
                }
            });
        });
    }
}
package com.alatus.mall.seckill.service.impl;

import com.alatus.common.to.mq.SeckillOrderTo;
import com.alatus.common.utils.R;
import com.alatus.common.vo.MemberRespVo;
import com.alatus.mall.seckill.constant.SecKillConstants;
import com.alatus.mall.seckill.feign.CouponFeignService;
import com.alatus.mall.seckill.feign.ProductFeignService;
import com.alatus.mall.seckill.interceptor.LoginUserInterceptor;
import com.alatus.mall.seckill.service.SecKillService;
import com.alatus.mall.seckill.to.SecKillSkuRedisTo;
import com.alatus.mall.seckill.vo.SeckillSessionEntityVo;
import com.alatus.mall.seckill.vo.SkuInfoVo;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;
import org.apache.commons.lang.StringUtils;
import com.baomidou.mybatisplus.core.toolkit.IdWorker;
import org.redisson.api.RSemaphore;
import org.redisson.api.RedissonClient;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.BoundHashOperations;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

@Service
public class SecKillServiceImpl implements SecKillService {
    @Autowired
    private CouponFeignService couponFeignService;
    @Autowired
    private ProductFeignService productFeignService;
    @Autowired
    private StringRedisTemplate redisTemplate;
    @Autowired
    private RedissonClient redissonClient;
    @Autowired
    private RabbitTemplate rabbitTemplate;
    @Override
    public void uploadSecKillSkuLatest3Days() {
//        扫描需要参与秒杀的活动
        R daySession = couponFeignService.Latest3DaySession();
        if(daySession.getCode() == 0){
            List<SeckillSessionEntityVo> seckillSessionVos = daySession.getData(new TypeReference<List<SeckillSessionEntityVo>>() {});
//            缓存活动信息
            saveSessionInfos(seckillSessionVos);
//            缓存活动关联的商品信息
            saveSkuInfos(seckillSessionVos);
        }
    }

//    返回当前事件可以参与的秒杀商品信息
    @Override
    public List<SecKillSkuRedisTo> getCurrentSeckillSkus() {
        long time = new Date().getTime();
        Set<String> keys = redisTemplate.keys(SecKillConstants.SESSION_CACHE_PREFIX + "*");
        List<Object> currentSeckillSkus = new ArrayList<>();
        if (keys != null) {
            for (String key : keys) {
                String replace = key.replace(SecKillConstants.SESSION_CACHE_PREFIX, "");
                String[] tempString = replace.split(":");
                String timeString = tempString[1];
                String[] timeSplit = timeString.split("-");
                long start = Long.parseLong(timeSplit[0]);
                long end = Long.parseLong(timeSplit[1]);
                if(time >= start && time <= end){
                    List<String> range = redisTemplate.opsForList().range(key, -100, 100);
                    BoundHashOperations<String, String, Object> operations = redisTemplate.boundHashOps(SecKillConstants.SKU_CACHE_PREFIX);
                    List<Object> strings = null;
                    if (range != null) {
                        strings = operations.multiGet(range);
                    }
                    if(strings != null && !strings.isEmpty()){
                        currentSeckillSkus.addAll(strings);
                    }
                }
            }
        }
        if(!currentSeckillSkus.isEmpty()){
//            遍历获取到的JSON集合并转换为对象,并完整添加进去方便展示出来
            return currentSeckillSkus.stream().map(item -> {
                SecKillSkuRedisTo secKillSkuRedisTo = JSON.parseObject(item.toString(), SecKillSkuRedisTo.class);
//                屏蔽掉随机码
                secKillSkuRedisTo.setRandomCode(null);
                return secKillSkuRedisTo;
            }).collect(Collectors.toList());
        }
        else{
            return null;
        }
    }

    @Override
    public SecKillSkuRedisTo getSkuSeckillInfo(Long skuId) {
//        找到所有需要参与秒杀的SKU的Key信息
        BoundHashOperations<String, String, String> operations = redisTemplate.boundHashOps(SecKillConstants.SKU_CACHE_PREFIX);
        Set<String> keys = operations.keys();
        if (keys != null && !keys.isEmpty()) {
            String regx = "\\d_" +skuId;
            for (String key : keys) {
                if(Pattern.matches(regx,key)){
                    String json = operations.get(key);
                    SecKillSkuRedisTo secKillSkuRedisTo = JSON.parseObject(json, SecKillSkuRedisTo.class);
                    if(secKillSkuRedisTo.getEndTime() > new Date().getTime()){
                        if(secKillSkuRedisTo.getStartTime() > new Date().getTime()){
                            secKillSkuRedisTo.setRandomCode(null);
                        }
                        return secKillSkuRedisTo;
                    }
                }
            }
        }
        return null;
    }

    @Override
    public String kill(String killId, String key, Integer num) {
        MemberRespVo memberRespVo = LoginUserInterceptor.loginUser.get();
//        获取当前秒杀商品的详细信息
        BoundHashOperations<String, String, String> operations = redisTemplate.boundHashOps(SecKillConstants.SKU_CACHE_PREFIX);
        String skuInfo = operations.get(killId);
//        没找到这么一个秒杀商品
        if(!StringUtils.isEmpty(skuInfo)){
            SecKillSkuRedisTo secKillSkuRedisTo = JSON.parseObject(skuInfo, SecKillSkuRedisTo.class);
            Long startTime = secKillSkuRedisTo.getStartTime();
            Long endTime = secKillSkuRedisTo.getEndTime();
            long time = new Date().getTime();
//            在活动时间范围内
            if(time >= startTime && time <= endTime){
//                拼接商品ID
                String skuId = secKillSkuRedisTo.getPromotionSessionId()+"_"+secKillSkuRedisTo.getSkuId();
//                商品随机码
                String randomCode = secKillSkuRedisTo.getRandomCode();
//                校验随机码和商品ID
                if(key.equals(randomCode) && killId.equals(skuId)){
//                    验证购物数量是否合理
                    if(secKillSkuRedisTo.getSeckillLimit().intValue() >= num){
                        String redisKey = memberRespVo.getId() + "_" + skuId;
//                        验证这个人是否已经购买过,幂等性处理,如果秒杀成功,就去redis占位
//                        而且这个占位必须让它自动过期,不然会一直占用redis的资源
                        long ttl = endTime - time;
                        Boolean check = redisTemplate.opsForValue().setIfAbsent(redisKey, num.toString(), ttl, TimeUnit.MILLISECONDS);
//                        如果这里可以占位成功说明,当前用户没有在该场次购买过该商品
                        if(check){
                            RSemaphore semaphore = redissonClient.getSemaphore(SecKillConstants.SKU_STOCK_SEMAPHORE + randomCode);
                            try {
                                boolean acquire = semaphore.tryAcquire(num, 100, TimeUnit.MILLISECONDS);
//                                秒杀成功以后,我们就可以做一个快速下单,发送一个MQ消息
                                if(acquire){
                                    String orderSn = IdWorker.getTimeId();
                                    SeckillOrderTo secKillOrderTo = new SeckillOrderTo();
                                    BeanUtils.copyProperties(secKillSkuRedisTo,secKillOrderTo);
                                    secKillOrderTo.setOrderSn(orderSn);
                                    secKillOrderTo.setMemberId(memberRespVo.getId());
                                    secKillOrderTo.setNum(num);
                                    rabbitTemplate.convertAndSend("order-event-exchange","order.seckill.order",secKillOrderTo);
//                                    TODO 发送MQ消息
                                    return orderSn;
                                }
                            } catch (InterruptedException e) {
                                return null;
                            }
                        }
                    }
                }
            }
        }
        return null;
    }

    private void saveSessionInfos(List<SeckillSessionEntityVo> seckillSessionVos) {
        seckillSessionVos.stream().forEach(session -> {
            //获取秒杀活动开始和结束时间
            long start = session.getStartTime().getTime();
            long end = session.getEndTime().getTime();
            String key = SecKillConstants.SESSION_CACHE_PREFIX+session.getName()+":"+start+"-"+end;
//            保存活动的信息
            if (!redisTemplate.hasKey(key)) {
                List<String> ids = session.getRelationSkus().stream().map(item->{
                    return item.getPromotionSessionId()+"_"+item.getSkuId().toString();
                }).collect(Collectors.toList());
                redisTemplate.opsForList().leftPushAll(key,ids);
            }
        });
    }
    private void saveSkuInfos(List<SeckillSessionEntityVo> seckillSessionVos){
        seckillSessionVos.forEach(session -> {
//            准备哈希操作
            BoundHashOperations ops = redisTemplate.boundHashOps(SecKillConstants.SKU_CACHE_PREFIX);
            session.getRelationSkus().forEach(relationSku -> {
//                生成随机码
                String token = UUID.randomUUID().toString().replace("-", "");
//                拼接Key保存商品
                String key = relationSku.getPromotionSessionId().toString()+"_"+relationSku.getSkuId().toString();
                if(!ops.hasKey(key)){
                    //                缓存商品
                    SecKillSkuRedisTo secKillSkuRedisTo = new SecKillSkuRedisTo();
//                sku的基本信息
                    R info = productFeignService.getSkuInfo(relationSku.getSkuId());
                    if(info.getCode() == 0){
                        SkuInfoVo skuInfoVo = info.get("skuInfo",new TypeReference<SkuInfoVo>(){});
                        secKillSkuRedisTo.setSkuInfo(skuInfoVo);
                    }
//                sku的秒杀信息
                    BeanUtils.copyProperties(relationSku,secKillSkuRedisTo);
//                    设置上秒杀数量啊!!
                    secKillSkuRedisTo.setSeckillCount(relationSku.getSeckillCount());
//                设置秒杀的时间
                    secKillSkuRedisTo.setStartTime(session.getStartTime().getTime());
                    secKillSkuRedisTo.setEndTime(session.getEndTime().getTime());
                    secKillSkuRedisTo.setRandomCode(token);
//                    保存商品
                    String skuJson = JSON.toJSONString(secKillSkuRedisTo);
                    ops.put(key,skuJson);
//                    如果当前这个场次的商品的库存信息已经上架,就不需要再次上架了
//                设置库存为分布式秒杀的信号量,限流
                    RSemaphore semaphore = redissonClient.getSemaphore(SecKillConstants.SKU_STOCK_SEMAPHORE + token);
//                商品可以秒杀的数量作为信号量
                    semaphore.trySetPermits(relationSku.getSeckillCount().intValue());
                }
            });
        });
    }
}
package com.alatus.mall.member.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.session.web.http.CookieSerializer;
import org.springframework.session.web.http.DefaultCookieSerializer;

@Configuration
public class SessionConfig {
    @Bean
    public CookieSerializer cookieSerializer(){
        DefaultCookieSerializer cookieSerializer = new DefaultCookieSerializer();
        cookieSerializer.setDomainName("alatusmall.com");
        cookieSerializer.setCookieName("MALLSESSION");
        return cookieSerializer;
    }
    @Bean
    public RedisSerializer<Object> springSessionDefaultRedisSerializer(){
        return new GenericJackson2JsonRedisSerializer();
    }

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory);
        template.setDefaultSerializer(springSessionDefaultRedisSerializer());
        return template;
    }
}

package com.alatus.mall.member.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.session.web.http.CookieSerializer;
import org.springframework.session.web.http.DefaultCookieSerializer;

@Configuration
public class SessionConfig {
    @Bean
    public CookieSerializer cookieSerializer(){
        DefaultCookieSerializer cookieSerializer = new DefaultCookieSerializer();
        cookieSerializer.setDomainName("alatusmall.com");
        cookieSerializer.setCookieName("MALLSESSION");
        return cookieSerializer;
    }
    @Bean
    public RedisSerializer<Object> springSessionDefaultRedisSerializer(){
        return new GenericJackson2JsonRedisSerializer();
    }

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory);
        template.setDefaultSerializer(springSessionDefaultRedisSerializer());
        return template;
    }
}

package com.alatus.mall.seckill.scheduled;

import com.alatus.mall.seckill.service.SecKillService;
import lombok.extern.slf4j.Slf4j;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;

import java.util.concurrent.TimeUnit;

/**
 * 秒杀商品的定时上架
 * 每天晚上凌晨4点,上架最新三天秒杀商品
 * 重复上架无需处理
 */
@Service
@Slf4j
public class SecKillSkuScheduled {
    @Autowired
    private SecKillService secKillService;
    @Autowired
    private RedissonClient redissonClient;
    private final String upload_lock = "seckill:upload:lock";
    @Scheduled(cron = "0 0 4 * * ?")
//    TODO 幂等性处理
//    @Scheduled(cron = "*/3 * * * * ?")
    public void uploadSecKillSkuLatest3Days() {
        log.info("上架秒杀的商品信息...");
        RLock rLock = redissonClient.getLock(upload_lock);
        rLock.lock(30, TimeUnit.SECONDS);
        try{
            secKillService.uploadSecKillSkuLatest3Days();
        }finally {
            rLock.unlock();
        }
    }
}


package com.alatus.mall.seckill.scheduled;

import com.alatus.mall.seckill.service.SecKillService;
import lombok.extern.slf4j.Slf4j;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;

import java.util.concurrent.TimeUnit;

/**
 * 秒杀商品的定时上架
 * 每天晚上凌晨4点,上架最新三天秒杀商品
 * 重复上架无需处理
 */
@Service
@Slf4j
public class SecKillSkuScheduled {
    @Autowired
    private SecKillService secKillService;
    @Autowired
    private RedissonClient redissonClient;
    private final String upload_lock = "seckill:upload:lock";
    @Scheduled(cron = "0 0 4 * * ?")
//    TODO 幂等性处理
//    @Scheduled(cron = "*/3 * * * * ?")
    public void uploadSecKillSkuLatest3Days() {
        log.info("上架秒杀的商品信息...");
        RLock rLock = redissonClient.getLock(upload_lock);
        rLock.lock(30, TimeUnit.SECONDS);
        try{
            secKillService.uploadSecKillSkuLatest3Days();
        }finally {
            rLock.unlock();
        }
    }
}

package com.alatus.mall.order.config;

import com.alatus.common.constant.RabbitConstant;
import org.springframework.amqp.core.*;
import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
import org.springframework.amqp.support.converter.MessageConverter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.HashMap;
import java.util.Map;

@Configuration
public class RabbitConfig {
    @Autowired
    private RabbitMQConfigProperties rabbitMQConfigProperties;
    @Bean
    public MessageConverter messageConverter(){
        return new Jackson2JsonMessageConverter();
    }
//    容器中的Binding,Queue,Exchange都会自动创建,前提是rabbitmq没有
    @Bean
    public Queue orderDelayQueue(){
        Map<String,Object> arguments = new HashMap<>();
        arguments.put(RabbitConstant.X_DEAD_LETTER_EXCHANGE,rabbitMQConfigProperties.getExchange());
        arguments.put(RabbitConstant.X_DEAD_LETTER_ROUTING_KEY,rabbitMQConfigProperties.getReleaseKey());
        arguments.put(RabbitConstant.X_MESSAGE_TTL,rabbitMQConfigProperties.getMessageTTL());
        return new Queue(rabbitMQConfigProperties.getDelayQueue(), true, false, false,arguments);
    }
    @Bean
    public Queue orderReleaseQueue(){
        return new Queue(rabbitMQConfigProperties.getReleaseQueue(), true, false, false);
    }
    @Bean
    public Queue orderSeckillQueue(){
        return new Queue(rabbitMQConfigProperties.getSeckillQueue(), true, false, false);
    }
    @Bean
    public Exchange orderEventExchange(){
        return new TopicExchange(rabbitMQConfigProperties.getExchange(),true,false);
    }
    @Bean
    public Binding orderSeckill(){
        return new Binding(rabbitMQConfigProperties.getSeckillQueue(), Binding.DestinationType.QUEUE,
                rabbitMQConfigProperties.getExchange(), rabbitMQConfigProperties.getSeckillKey(),null);
    }
    @Bean
    public Binding orderCreate(){
        return new Binding(rabbitMQConfigProperties.getDelayQueue(), Binding.DestinationType.QUEUE,
                rabbitMQConfigProperties.getExchange(), rabbitMQConfigProperties.getCreateKey(),null);
    }
    @Bean
    public Binding orderRelease(){
        return new Binding(rabbitMQConfigProperties.getReleaseQueue(), Binding.DestinationType.QUEUE,
                rabbitMQConfigProperties.getExchange(),rabbitMQConfigProperties.getReleaseKey(),null);
    }
//    订单和库存绑定
    @Bean
    public Binding orderReleaseOther(){
        return new Binding(rabbitMQConfigProperties.getStockReleaseQueue(),Binding.DestinationType.QUEUE,
                rabbitMQConfigProperties.getExchange(),rabbitMQConfigProperties.getStockReleaseKey(),null);
    }
}


package com.alatus.mall.order.config;

import com.alatus.common.constant.RabbitConstant;
import org.springframework.amqp.core.*;
import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
import org.springframework.amqp.support.converter.MessageConverter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.HashMap;
import java.util.Map;

@Configuration
public class RabbitConfig {
    @Autowired
    private RabbitMQConfigProperties rabbitMQConfigProperties;
    @Bean
    public MessageConverter messageConverter(){
        return new Jackson2JsonMessageConverter();
    }
//    容器中的Binding,Queue,Exchange都会自动创建,前提是rabbitmq没有
    @Bean
    public Queue orderDelayQueue(){
        Map<String,Object> arguments = new HashMap<>();
        arguments.put(RabbitConstant.X_DEAD_LETTER_EXCHANGE,rabbitMQConfigProperties.getExchange());
        arguments.put(RabbitConstant.X_DEAD_LETTER_ROUTING_KEY,rabbitMQConfigProperties.getReleaseKey());
        arguments.put(RabbitConstant.X_MESSAGE_TTL,rabbitMQConfigProperties.getMessageTTL());
        return new Queue(rabbitMQConfigProperties.getDelayQueue(), true, false, false,arguments);
    }
    @Bean
    public Queue orderReleaseQueue(){
        return new Queue(rabbitMQConfigProperties.getReleaseQueue(), true, false, false);
    }
    @Bean
    public Queue orderSeckillQueue(){
        return new Queue(rabbitMQConfigProperties.getSeckillQueue(), true, false, false);
    }
    @Bean
    public Exchange orderEventExchange(){
        return new TopicExchange(rabbitMQConfigProperties.getExchange(),true,false);
    }
    @Bean
    public Binding orderSeckill(){
        return new Binding(rabbitMQConfigProperties.getSeckillQueue(), Binding.DestinationType.QUEUE,
                rabbitMQConfigProperties.getExchange(), rabbitMQConfigProperties.getSeckillKey(),null);
    }
    @Bean
    public Binding orderCreate(){
        return new Binding(rabbitMQConfigProperties.getDelayQueue(), Binding.DestinationType.QUEUE,
                rabbitMQConfigProperties.getExchange(), rabbitMQConfigProperties.getCreateKey(),null);
    }
    @Bean
    public Binding orderRelease(){
        return new Binding(rabbitMQConfigProperties.getReleaseQueue(), Binding.DestinationType.QUEUE,
                rabbitMQConfigProperties.getExchange(),rabbitMQConfigProperties.getReleaseKey(),null);
    }
//    订单和库存绑定
    @Bean
    public Binding orderReleaseOther(){
        return new Binding(rabbitMQConfigProperties.getStockReleaseQueue(),Binding.DestinationType.QUEUE,
                rabbitMQConfigProperties.getExchange(),rabbitMQConfigProperties.getStockReleaseKey(),null);
    }
}

/**
 * Copyright (c) 2016-2019 人人开源 All rights reserved.
 *
 * https://www.renren.io
 *
 * 版权所有，侵权必究！
 */

package io.renren.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.*;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * Redis配置
 *
 * @author Mark sunlightcs@gmail.com
 */
@Configuration
public class RedisConfig {
    @Autowired
    private RedisConnectionFactory factory;

    @Bean
    public RedisTemplate<String, Object> redisTemplate() {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();

        // 设置 key 和 value 的序列化器为 JSON
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());

        // 使用 GenericJackson2JsonRedisSerializer 序列化器来将数据以 JSON 格式存储
        redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());

        redisTemplate.setConnectionFactory(factory);
        return redisTemplate;
    }

    @Bean
    public HashOperations<String, String, Object> hashOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForHash();
    }

    @Bean
    public ValueOperations<String, String> valueOperations(RedisTemplate<String, String> redisTemplate) {
        return redisTemplate.opsForValue();
    }

    @Bean
    public ListOperations<String, Object> listOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForList();
    }

    @Bean
    public SetOperations<String, Object> setOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForSet();
    }

    @Bean
    public ZSetOperations<String, Object> zSetOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForZSet();
    }
}


/**
 * Copyright (c) 2016-2019 人人开源 All rights reserved.
 *
 * https://www.renren.io
 *
 * 版权所有，侵权必究！
 */

package io.renren.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.*;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * Redis配置
 *
 * @author Mark sunlightcs@gmail.com
 */
@Configuration
public class RedisConfig {
    @Autowired
    private RedisConnectionFactory factory;

    @Bean
    public RedisTemplate<String, Object> redisTemplate() {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();

        // 设置 key 和 value 的序列化器为 JSON
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());

        // 使用 GenericJackson2JsonRedisSerializer 序列化器来将数据以 JSON 格式存储
        redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());

        redisTemplate.setConnectionFactory(factory);
        return redisTemplate;
    }

    @Bean
    public HashOperations<String, String, Object> hashOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForHash();
    }

    @Bean
    public ValueOperations<String, String> valueOperations(RedisTemplate<String, String> redisTemplate) {
        return redisTemplate.opsForValue();
    }

    @Bean
    public ListOperations<String, Object> listOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForList();
    }

    @Bean
    public SetOperations<String, Object> setOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForSet();
    }

    @Bean
    public ZSetOperations<String, Object> zSetOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForZSet();
    }
}

package com.alatus.mall.order.listener;

import com.alatus.common.to.mq.SeckillOrderTo;
import com.alatus.mall.order.service.OrderService;
import com.rabbitmq.client.Channel;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.io.IOException;

@Component
@Slf4j
@RabbitListener(queues = "order.seckill.order.queue")
public class OrderSeckillListener {
    @Autowired
    private OrderService orderService;
    @RabbitHandler
    public void listener(SeckillOrderTo seckillOrderTo, Channel channel, Message message) throws IOException {
        try{
            log.info("收到秒杀单的订单信息,准备创建订单,订单号:{}",seckillOrderTo.getOrderSn());
            orderService.createSeckillOrder(seckillOrderTo);
            channel.basicAck(message.getMessageProperties().getDeliveryTag(),false);
        }
        catch (Exception e){
            channel.basicReject(message.getMessageProperties().getDeliveryTag(),true);
        }
    }
}


package com.alatus.mall.order.listener;

import com.alatus.common.to.mq.SeckillOrderTo;
import com.alatus.mall.order.service.OrderService;
import com.rabbitmq.client.Channel;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.io.IOException;

@Component
@Slf4j
@RabbitListener(queues = "order.seckill.order.queue")
public class OrderSeckillListener {
    @Autowired
    private OrderService orderService;
    @RabbitHandler
    public void listener(SeckillOrderTo seckillOrderTo, Channel channel, Message message) throws IOException {
        try{
            log.info("收到秒杀单的订单信息,准备创建订单,订单号:{}",seckillOrderTo.getOrderSn());
            orderService.createSeckillOrder(seckillOrderTo);
            channel.basicAck(message.getMessageProperties().getDeliveryTag(),false);
        }
        catch (Exception e){
            channel.basicReject(message.getMessageProperties().getDeliveryTag(),true);
        }
    }
}

package com.alatus.mall.coupon.entity;

import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.math.BigDecimal;
import java.io.Serializable;
import lombok.Data;

/**
 * 秒杀活动商品关联
 * 
 * @author alatus
 * @date 2024-03-12 13:32:54
 */
@Data
@TableName("sms_seckill_sku_relation")
public class SeckillSkuRelationEntity implements Serializable {
	private static final long serialVersionUID = 1L;

	/**
	 * id
	 */
	@TableId
	private Long id;
	/**
	 * 活动id
	 */
	private Long promotionId;
	/**
	 * 活动场次id
	 */
	private Long promotionSessionId;
	/**
	 * 商品id
	 */
	private Long skuId;
	/**
	 * 秒杀价格
	 */
	private BigDecimal seckillPrice;
	/**
	 * 秒杀总量
	 */
	private BigDecimal seckillCount;
	/**
	 * 每人限购数量
	 */
	private BigDecimal seckillLimit;
	/**
	 * 排序
	 */
	private Integer seckillSort;

}


package com.alatus.mall.coupon.entity;

import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.math.BigDecimal;
import java.io.Serializable;
import lombok.Data;

/**
 * 秒杀活动商品关联
 * 
 * @author alatus
 * @date 2024-03-12 13:32:54
 */
@Data
@TableName("sms_seckill_sku_relation")
public class SeckillSkuRelationEntity implements Serializable {
    private static final long serialVersionUID = 1L;

    /**
     * id
     */
    @TableId
    private Long id;
    /**
     * 活动id
     */
    private Long promotionId;
    /**
     * 活动场次id
     */
    private Long promotionSessionId;
    /**
     * 商品id
     */
    private Long skuId;
    /**
     * 秒杀价格
     */
    private BigDecimal seckillPrice;
    /**
     * 秒杀总量
     */
    private BigDecimal seckillCount;
    /**
     * 每人限购数量
     */
    private BigDecimal seckillLimit;
    /**
     * 排序
     */
    private Integer seckillSort;

}

package com.alatus.mall.seckill.to;

import com.alatus.mall.seckill.vo.SkuInfoVo;
import lombok.Data;

import java.math.BigDecimal;

@Data
public class SecKillSkuRedisTo {
    /**
     * 活动id
     */
    private Long promotionId;
    /**
     * 活动场次id
     */
    private Long promotionSessionId;
    /**
     * 商品id
     */
    private Long skuId;
    /**
     * 秒杀价格
     */
    private BigDecimal seckillPrice;
    /**
     * 秒杀总量
     */
    private BigDecimal seckillCount;
    /**
     * 每人限购数量
     */
    private BigDecimal seckillLimit;
    /**
     * 排序
     */
    private Integer seckillSort;

    /**
     * 商品详细信息
     */
    private SkuInfoVo skuInfo;
    /**
     * 秒杀开始时间
     */
    private Long startTime;
    /**
     * 秒杀结束时间
     */
    private Long endTime;
    /**
     * 秒杀随机码
     */
    private String randomCode;
}


package com.alatus.mall.seckill.to;

import com.alatus.mall.seckill.vo.SkuInfoVo;
import lombok.Data;

import java.math.BigDecimal;

@Data
public class SecKillSkuRedisTo {
    /**
     * 活动id
     */
    private Long promotionId;
    /**
     * 活动场次id
     */
    private Long promotionSessionId;
    /**
     * 商品id
     */
    private Long skuId;
    /**
     * 秒杀价格
     */
    private BigDecimal seckillPrice;
    /**
     * 秒杀总量
     */
    private BigDecimal seckillCount;
    /**
     * 每人限购数量
     */
    private BigDecimal seckillLimit;
    /**
     * 排序
     */
    private Integer seckillSort;

    /**
     * 商品详细信息
     */
    private SkuInfoVo skuInfo;
    /**
     * 秒杀开始时间
     */
    private Long startTime;
    /**
     * 秒杀结束时间
     */
    private Long endTime;
    /**
     * 秒杀随机码
     */
    private String randomCode;
}
全网最全-谷粒商城项目-面试总结-简历优化
成功最快的秘诀: 抱团取暖 。
09-20 29万+
该系用采用SpringCloud架构，利用SpringBoot构建应用，利用Nacos作为服务的注册、配置中心，利用OpenFeign实现与其他模块进行交互，利用Sentinel实现熔断降级和错误处理，利用Gateway作为服务网关，利用RabbitMQ实现延迟队列，利用Redis作为缓存解决读多写少的场景，利用MySQL进行持久化，利用MyBatisPlus作为持久化框架。
谷粒商城篇章11--P311-P325--秒杀服务【分布式高级篇八】
weixin_48568302的博客
08-23 1273
谷粒商城篇章11--P311-P325--秒杀服务【分布式高级篇八】
基于Java+Vue的商城抢购秒杀系统设计源码
09-30
本项目为一套基于Java和Vue框架的商城抢购秒杀系统设计源码，涵盖了丰富的文件结构和多语言编程技术，实现了系统在高并发情况下的高性能和稳定性。 首先，Java作为后端开发的核心语言，在本项目中承担了系统架构...
java版商城源码下载-seckill:手机秒杀系统
06-05
一个基于java技术的手机秒杀网站，这个项目是根据我在慕课网上面学习的几个课程，整合几门课的知识内容实现的一个学习项目， 课程如下： 《Java秒杀系统方案优化 高性能高并发实战》--学习秒杀高并发方面的各种技术 ...
java开发专家模版 简历 项目商场秒杀平台
06-20
此简历中的项目展示了开发者在构建商场秒杀平台时所运用的关键技术和实践经验。以下是对这些技术点的详细说明： 1. **Java多线程开发**：在秒杀场景中，高并发是常态，Java的多线程能力是解决这个问题的关键。...
基于deepseek的Spring boot入门
我爱写报告的博客
08-28 434
一次跟着deepseek记笔记的尝试，由于CSDN没有思维导图，只能按层级记录提问。
使用Spring Boot和EasyExcel导出Excel文件，并在前端使用Axios进行请求
软件开发领域中最需要你关注的博主！
08-27 1308
本文介绍了基于Spring Boot和EasyExcel的高效Excel导出方案，结合Axios实现前端文件下载。主要内容包括：1) 环境准备，需JDK8+、Spring Boot 2.5+和EasyExcel；2) 后端实现，通过配置类、服务层和控制层完成Excel导出功能；3) 前端实现，使用Axios请求导出接口并处理Blob响应实现文件下载。该方案解决了传统POI处理大数据量效率低的问题，提供了完整的Excel导出解决方案，适用于企业级应用开发场景。
Spring Boot 定时任务入门
无忧无虑的Coding~~~
08-28 840
在产品的色彩斑斓的黑的需求中，有存在一类需求，是需要去的，此时就需要使用到。例如说，每分钟扫描超时支付的订单，每小时清理一次日志文件，每天统计前一天的数据并生成报表，每个月月初的工资单的推送，每年一次的生日提醒等等。在日常开发中，我们很少直接使用 Timer 或 ScheduledExecutorService 来实现定时任务的需求。所以，一般情况下，我们会选择专业的。关于“”的叫法，也有叫“”的。在英文上，有 Task 也有 Job。本质是一样的，本文两种都会用。然后，一般来说是调度任务，定时执行。
基于 Spring Boot3 的ZKmall开源商城分层架构实践：打造高效可扩展的 Java 电商系统
08-30 842
作为基于 Java 技术栈的成熟电商解决方案，ZKmall 开源商城深度融合 Spring Boot3 特性，采用 “表示层 - 业务层 - 数据访问层 - 基础设施层” 的经典分层架构，通过清晰的层间解耦与特性适配，实现了系统的高效开发、灵活扩展与稳定运行。本文将从分层设计逻辑、各层技术落地、Spring Boot3 特性赋能及架构优势四个维度，拆解 ZKmall 分层架构的实战思路。
从PostgreSQL到人大金仓（KingBase）数据库迁移实战：Spring Boot项目完整迁移指南
zhz5214的博客
08-27 930
摘要：本文详细介绍了Spring Boot项目从PostgreSQL迁移到人大金仓数据库(KingBase)的完整过程。内容包括依赖配置调整、数据库连接优化、MyBatis Plus配置适配、表名模式前缀处理等关键步骤。针对迁移中遇到的典型问题如模式前缀缺失、SQL兼容性等，提供了三种解决方案：修改Mapper文件、调整实体类注解以及创建表名处理器。文章还分享了连接池配置优化和分页插件适配等最佳实践，为国产数据库迁移提供了可借鉴的技术方案。
Java面试现场：Spring Boot+Redis+MySQL在电商场景下的技术深度剖析
三贝
08-29 840
本文通过模拟互联网大厂Java面试场景，以电商业务为背景，深入探讨Spring Boot、Redis缓存、MySQL优化、分布式事务等核心技术。面试官与程序员谢飞机的对话既严肃又幽默，涵盖微服务架构、数据库设计、缓存策略、性能优化等实战问题，为Java开发者提供全面的技术面试准备指南。
Spring Boot 多数据源（读写分离）入门
无忧无虑的Coding~~~
08-29 737
简单来说，通过继承 AbstractRoutingDataSource 抽象类，实现一个管理项目中多个 DataSource 的。
Spring boot注解介绍
最新发布
youziguo的专栏
08-31 565
Spring boot注解介绍，包括Spring核心注解和Srping boot特有注解。
Spring Boot 数据库连接池入门
无忧无虑的Coding~~~
08-29 922
在我们的项目中，数据库连接池基本是必不可少的组件。在目前数据库连接池的选型中，主要是至于怎么选择，两者都非常优秀，不用过多纠结。
基于Spring Boot+Vue的创业资助管理系统-项目分享
weixin_43943214的博客
08-27 246
项目分享
Spring Boot 整合 MongoDB：CRUD 与聚合查询实战
夜雨的博客
08-29 966
Spring Boot 整合 MongoDB：CRUD 与聚合查询实战指南。文档设计原则：根据查询模式设计文档结构；合理使用嵌入和引用；控制文档大小，避免超过16MB限制；性能优化要点：为常用查询创建适当索引；使用投影减少网络传输；批量操作替代单条操作；事务使用建议：仅在必要时使用多文档事务；控制事务持续时间；处理乐观锁冲突
Spring - 文件上传与下载：真正的企业开发高频需求——Spring Boot文件上传与下载全场景实践指南
08-26 1106
摘要： 本文系统介绍了Spring Boot实现文件上传与下载的完整方案。首先解析了HTTP协议中multipart/form-data的文件传输原理，并介绍了Spring Boot的核心组件MultipartResolver和MultipartFile接口。文章详细演示了单文件和多文件上传的控制器实现，包括文件校验、元信息获取和存储路径处理，并提供了全局参数配置方法，如限制文件大小和设置临时目录。通过示例代码和配置说明，开发者可快速掌握企业级文件操作的关键技术点。
Java Spring Boot 集成淘宝 SDK：实现稳定可靠的商品信息查询服务
APItesterCris的博客
08-27 873
淘宝平台（Taobao Open Platform，简称 TOP）是阿里巴巴集团为开发者提供的电商生态服务，通过 API 接口允许外部系统获取淘宝 / 天猫的商品、订单、用户等数据。为降低开发门槛，淘宝官方提供了 Java 版 SDK（通常称为），封装了 API 调用的签名、请求封装、响应解析等底层逻辑，开发者无需关注复杂的接口协议细节，可专注于业务功能开发。
Java中使用Spring Boot+Ollama实现本地AI的MCP接入
makerjack001的博客
08-29 1237
在我的上一篇搭建好本地的聊天机器人后，准备接入MCP进一步增强AI的能力，以实现类似手机AI的功能参考的是第二篇文章其内容比较精炼，有些细节被忽略了，导致踩坑不少，可能是因为版本原因，最终我没能使用他的方案运行成功，转而使用了另一个方案，为什么使用Qwen3。
ECShop商城团购秒杀插件功能特性与易用性分析
根据提供的文件信息，以下是关于“商城团购秒杀插件，可以直接整合ecshop使用”的详细知识点： 1. 插件介绍： “商城团购秒杀插件”是一个专门针对电子商务平台的软件组件，旨在实现团购和秒杀这两种促销功能。团购...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值