JavacKaka

Java 秒杀方案(下)

技术点

秒杀方案简介

本短文完成项目搭建, 分布式 Session 和秒杀功能三个小模块;

秒杀系统设计

秒杀其实主要解决两个问题，一个是并发读，一个是并发写。
并发读的核心优化理念是尽量减少用户到服务端来“读”数据，或者让他们读更少的数据；并发写的处理原则也一样，它要求我们在数据库层面独立出来一个库，做特殊的处理。另外，我们还要针对秒杀系统做一些保护，针对意料之外的情况设计兜底方案，以防止最坏的情况发生。
秒杀的整体架构可以概括为“稳、准、快”几个关键字。
所谓“稳”，就是整个系统架构要满足高可用，流量符合预期时肯定要稳定，就是超出预期时也同样不能掉链子，你要保证秒杀活动顺利完成，即秒杀商品顺利地卖出去，这个是最基本的前提。
然后就是**“准”，就是秒杀 10 台手机，那就只能成交 10 台，多一台少一台都不行。一旦库存不对，那平台就要承担损失，所以“准”就是要求保证数据的一致性。
最后再看“快”**，“快”其实很好理解，它就是说系统的性能要足够高，否则你怎么支撑这么大的流量呢？不光是服务端要做极致的性能优化，而且在整个请求链路上都要做协同的优化，每个地方快一点，整个系统就完美了。
所以从技术角度上看“稳、准、快”，就对应了我们架构上的高可用、一致性和高性能的要求

高性能。秒杀涉及大量的并发读和并发写，因此支持高并发访问这点非常关键。对应的方案比如动静分离方案、热点的发现与隔离、请求的削峰与分层过滤、服务端的极致优化
一致性。秒杀中商品减库存的实现方式同样关键。可想而知，有限数量的商品在同一时刻被很多倍的请求同时来减库存，减库存又分为“拍下减库存”“付款减库存”以及预扣等几种，在大并发更新的过程中都要保证数据的准确性，其难度可想而知
高可用。现实中总难免出现一些我们考虑不到的情况，所以要保证系统的高可用和正确性，我们还要设计一个 B 计划来兜底，以便在最坏情况发生时仍然能够从容应对

环境搭建(这部分见上一篇文章)

Java秒杀上篇

秒杀功能实现

业务层

package com.itkaka.seckill.service;

import com.itkaka.seckill.pojo.Order;
import com.baomidou.mybatisplus.extension.service.IService;
import com.itkaka.seckill.pojo.User;
import com.itkaka.seckill.vo.GoodsVo;

/**
 * 
 *  服务类
 * 
 *
 * @author itkaka
 * @since 2023-05-11
 */
public interface IOrderService extends IService<Order> {

    // 简单 秒杀功能
    Order seckill(User user, GoodsVo goodsVo);

}

package com.itkaka.seckill.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.itkaka.seckill.pojo.Order;
import com.itkaka.seckill.mapper.OrderMapper;
import com.itkaka.seckill.pojo.SeckillGoods;
import com.itkaka.seckill.pojo.SeckillOrder;
import com.itkaka.seckill.pojo.User;
import com.itkaka.seckill.service.IGoodsService;
import com.itkaka.seckill.service.IOrderService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.itkaka.seckill.service.ISeckillGoodsService;
import com.itkaka.seckill.service.ISeckillOrderService;
import com.itkaka.seckill.vo.GoodsVo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.Date;

/**
 * 
 *  服务实现类
 * 
 *
 * @author itkaka
 * @since 2023-05-11
 */
@Service
public class OrderServiceImpl extends ServiceImpl<OrderMapper, Order> implements IOrderService {

    @Resource
    private ISeckillGoodsService seckillGoodsService;
    @Autowired
    private OrderMapper orderMapper;
    @Autowired
    private ISeckillOrderService seckillOrderService;
    @Autowired
    private IGoodsService goodsService;
    @Autowired
    private RedisTemplate redisTemplate;

    // 秒杀
    @Override
    @Transactional
    public Order seckill(User user, GoodsVo goodsVo) {

        // 秒杀商品减库存
        SeckillGoods seckillGoods = seckillGoodsService.getOne(new
                QueryWrapper<SeckillGoods>().eq("goods_id",goodsVo.getId()));
        seckillGoods.setStockCount(seckillGoods.getStockCount()-1);
        seckillGoodsService.updateById(seckillGoods);

        // 生成订单
        Order order = new Order();
        order.setUserId(user.getId());
        order.setGoodsId(goodsVo.getId());
        order.setDeliverAddrId(0);
        order.setGoodsName(goodsVo.getGoodsName());
        order.setGoodsCount(1);
        order.setGoodsPrice(seckillGoods.getSeckillPrice());
        order.setOrderChannel(1);
        order.setStatus(0);
        order.setCreateDate(new Date());
        orderMapper.insert(order);
        //生成秒杀订单
        SeckillOrder seckillOrder = new SeckillOrder();
        seckillOrder.setUserId(user.getId());
        seckillOrder.setOrderId(order.getId());
        seckillOrder.setGoodsId(goodsVo.getId());
        seckillOrderService.save(seckillOrder);
        //valueOperations.set("order:" + user.getId() + ":" + goods.getId(), seckillOrder);

        return order;
    }
}

控制层 : 新建 SeckillController 接口

package com.itkaka.seckill.controller;

/**
 * 秒杀
 */
@Slf4j
@Controller
@RequestMapping("/seckill")
public class SecKillController  {

	@Autowired
	private IGoodsService goodsService;
	@Autowired
	private ISeckillOrderService seckillOrderService;
	@Autowired
	private IOrderService orderService;
	@Autowired
	private RedisTemplate redisTemplate;

	@RequestMapping("/doSeckill")
	public String doSeckill(Model model,User user,Long goodsId){
		if (null == user){
			return "login";
		}
		model.addAttribute("user",user);
		GoodsVo goodsVo = goodsService.queryGoodsVoByGoodsId(goodsId);
		// 判断库存
		if (goodsVo.getStockCount() < 1){
			model.addAttribute("errmsg",RespBeanEnum.EMPTY_STOCK.getMessage());
			return "seckillFail";
		}
		// 判断是否重复抢购
		SeckillOrder seckillOrder = seckillOrderService.getOne(new
				QueryWrapper<SeckillOrder>().eq("user_id",user.getId()).eq("goods_id",goodsId));
		if (seckillOrder != null){
			model.addAttribute("errmsg",RespBeanEnum.REPEATE_ERROR.getMessage());
			return "seckillFail";
		}
		Order order = orderService.seckill(user,goodsVo);
		model.addAttribute("order",order);
		model.addAttribute("goods",goodsVo);
		return "orderDetail";
	}
}

测试 :
秒杀成功进去定安详情 [注意查看库存是否正确扣减,订单是否正确生成]
两个限制条件 : ①限制超卖(库存不足) ②单品每人限购一件(重复抢购)

优化阶段目录

系统压测

JMeter 入门

下载安装
官网 : https://jmeter.apache.org/
下载地址 : https://jmeter.apache.org/download_jmeter.cgi
下载解压后直接在 bin 目录里双击 jmeter.bat 即可启动（Lunix系统通过 jmeter.sh 启动）

修改中文
Options --> Choose Language --> Chinese(Simplified)

测试demo
我们先使用JMeter测试一下跳转商品列表页的接口。
首先创建线程组，步骤：添加–> 线程(用户) --> 线程组

Ramp-up 指在几秒之内启动指定线程数
创建HTTP请求默认值，步骤：添加–> 配置元件 --> HTTP请求默认值

添加测试接口，步骤：添加 --> 取样器 --> HTTP请求

查看输出结果，步骤：添加 --> 监听器 --> 聚合报告/图形结果/用表格察看结果

启动即可在监听器看到对应的结果

自定义变量

准备测试接口

package com.itkaka.seckill.controller;


import com.itkaka.seckill.pojo.User;
import com.itkaka.seckill.vo.RespBean;
import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

/**
 * 
 * 前端控制器
 * 
 *
 * @author itkaka
 * @since 2023-05-11
 */
@RestController
@RequestMapping("/user")
public class UserController {

    // 用户信息(测试)
    @RequestMapping("/info")
    @ResponseBody
    public RespBean info(User user) {
        return RespBean.success(user);
    }

}

配置同一用户测试
添加 HTTP 请求用户信息

查看聚合结果

配置不同用户测试
准备配置文件 config.txt
#具体用户和userTicket
18012345678,bd055fb14eef4d1ea2933ff8d6e44575
添加 --> 配置元件 --> CSV Data Set Config

添加 --> 配置元件 --> HTTP Cookie管理器

修改 HTTP 请求用户信息

查看结果

正式压测

压测商品列表接口
准备5000线程,循环10次压测商品列表接口,测试三次,查看结果


HTTP 请求

结果

压测秒杀接口
新建用户
使用工具类往数据库插入5000用户，并且调用登录接口获取token，写入config.txt
config.txt

配置秒杀接口测试
线程组

HTTP 请求默认值

CVS 数据文件设置

HTTP Cookie管理器

HTTP 请求

结果

此时, 已经出现超卖问题

页面优化

缓存

页面缓存

GoodsController 修改完善 ;

// 将页面存入缓存 Redis 提速
    // 跳转商品列表页
    @RequestMapping(value = "/toList", produces = "text/html;charset=utf-8")
    @ResponseBody
    //public String toList(Model model, @CookieValue("userTicket") String ticket, HttpServletRequest request,HttpServletResponse response){
    public String toList(Model model, User user,
                         HttpServletRequest request, HttpServletResponse response) {
        // Redis中获取页面，如果不为空，直接返回页面
        ValueOperations valueOperations = redisTemplate.opsForValue();
        String html = (String) valueOperations.get("goodList");
        if (!StringUtils.isEmpty(html)){
            return html;
        }
        model.addAttribute("user",user);
        model.addAttribute("goodLList",goodsService.queryGoodsVo());
        // 如果为空,手动渲染,先存 redis 并返回
        WebContext context =  new WebContext(request,response, request.getServletContext(),request.getLocale(),model.asMap());
        html = thymeleafViewResolver.getTemplateEngine().process("goodList",context);
        if (!org.springframework.util.StringUtils.isEmpty(html)) {
            valueOperations.set("goodsList", html, 60, TimeUnit.SECONDS);
        }
        return html;


     // 跳转商品详情页
    @RequestMapping(value = "/toDetail2/{goodsId}", produces = "text/html;charset=utf-8")
    @ResponseBody
    public String toDetail2(Model model, User user, @PathVariable Long goodsId,
                            HttpServletRequest request, HttpServletResponse response) {
        ValueOperations valueOperations = redisTemplate.opsForValue();
        //Redis中获取页面，如果不为空，直接返回页面
        String html = (String) valueOperations.get("goodsDetail:" + goodsId);
        if (!org.springframework.util.StringUtils.isEmpty(html)) {
            return html;
        }
        model.addAttribute("user", user);
        GoodsVo goodsVo = goodsService.queryGoodsVoByGoodsId(goodsId);
        Date startDate = goodsVo.getStartDate();
        Date endDate = goodsVo.getEndDate();
        Date nowDate = new Date();
        //秒杀状态
        int secKillStatus = 0;
        //秒杀倒计时
        int remainSeconds = 0;
        //秒杀还未开始
        if (nowDate.before(startDate)) {
            remainSeconds = ((int) ((startDate.getTime() - nowDate.getTime()) / 1000));
        } else if (nowDate.after(endDate)) {
            //	秒杀已结束
            secKillStatus = 2;
            remainSeconds = -1;
        } else {
            //秒杀中
            secKillStatus = 1;
            remainSeconds = 0;
        }
        model.addAttribute("remainSeconds", remainSeconds);
        model.addAttribute("secKillStatus", secKillStatus);
        model.addAttribute("goods", goodsVo);
        WebContext context = new WebContext(request, response, request.getServletContext(), request.getLocale(),
                model.asMap());
        html = thymeleafViewResolver.getTemplateEngine().process("goodsDetail", context);
        if (!org.springframework.util.StringUtils.isEmpty(html)) {
            valueOperations.set("goodsDetail:" + goodsId, html, 60, TimeUnit.SECONDS);
        }
        return html;
        // return "goodsDetail";
    }

重新运行项目查看效果



测试发现 : 结果对比之前的 QPS提升比较明显

对象缓存

更新对象返回枚举类

package com.itkaka.seckill.vo;

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.ToString;
/*
*   公共返回对象枚举类
* */
@Getter
@ToString
@AllArgsConstructor
public enum RespBeanEnum {

    //通用
    SUCCESS(200, "SUCCESS"),
    ERROR(500, "服务端异常"),
    //登录模块5002xx
    LOGIN_ERROR(500210, "用户名或密码不正确"),
    MOBILE_ERROR(500211, "手机号码格式不正确"),
    BIND_ERROR(500212, "参数校验异常"),
    MOBILE_NOT_EXIST(500213, "手机号码不存在"),
    PASSWORD_UPDATE_FAIL(500214, "密码更新失败"),
    ;
    private final Integer code;
    private final String message;

}

更新 IUserService 业务层接口和实现类

    // 更新密码
    RespBean updatePassword(String userTicket, String password, HttpServletRequest request,
                            HttpServletResponse response);

// 更新密码
    @Override
    public RespBean updatePassword(String userTicket, String password, HttpServletRequest request, HttpServletResponse response) {
        User user = getUserByCookie(userTicket, request, response);
        if (user == null) {
            throw new GlobalException(RespBeanEnum.MOBILE_NOT_EXIST);
        }
        user.setPassword(MD5Util.inputPassToDBPass(password, user.getSlat()));
        int result = userMapper.updateById(user);
        if (1 == result) {
            //删除Redis
            redisTemplate.delete("user:" + userTicket);
            return RespBean.success();
        }
        return RespBean.error(RespBeanEnum.PASSWORD_UPDATE_FAIL);
    }

页面静态化

商品详情静态化

package com.itkaka.seckill.vo;

import com.itkaka.seckill.pojo.User;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

// 商品详情返回对象
@Data
@NoArgsConstructor
@AllArgsConstructor
public class DetailVo {

    private User user;

    private GoodsVo goodsVo;

    private int secKillStatus;

    private int remainSeconds;

}


// 跳转商品详情页
    @RequestMapping("/detail/{goodsId}")
    @ResponseBody
    public RespBean toDetail(User user,@PathVariable Long goodsId){
        GoodsVo goodsVo = goodsService.queryGoodsVoByGoodsId(goodsId);
        Date startDate = goodsVo.getStartDate();
        Date endDate = goodsVo.getEndDate();
        Date nowDate = new Date();
        // 秒杀状态
        int secKillStatus = 0;
        //秒杀倒计时
        int remainSeconds = 0;
        //秒杀还未开始
        if (nowDate.before(startDate)) {
            remainSeconds = ((int) ((startDate.getTime() - nowDate.getTime()) / 1000));
        } else if (nowDate.after(endDate)) {
            //	秒杀已结束
            secKillStatus = 2;
            remainSeconds = -1;
        } else {
            //秒杀中
            secKillStatus = 1;
            remainSeconds = 0;
        }
        DetailVo detailVo = new DetailVo();
        detailVo.setUser(user);
        detailVo.setGoodsVo(goodsVo);
        detailVo.setSecKillStatus(secKillStatus);
        detailVo.setRemainSeconds(remainSeconds);
        return RespBean.success(detailVo);
    }

//展示loading
function g_showLoading(){
	var idx = layer.msg('处理中...', {icon: 16,shade: [0.5, '#f5f5f5'],scrollbar: false,offset: '0px', time:100000}) ;  
	return idx;
}
//salt
var g_passsword_salt="1a2b3c4d"
// 获取url参数
function g_getQueryString(name) {
	var reg = new RegExp("(^|&)" + name + "=([^&]*)(&|$)");
	var r = window.location.search.substr(1).match(reg);
	if(r != null) return unescape(r[2]);
	return null;
};
//设定时间格式化函数，使用new Date().format("yyyy-MM-dd HH:mm:ss");
Date.prototype.format = function (format) {
	var args = {
		"M+": this.getMonth() + 1,
		"d+": this.getDate(),
		"H+": this.getHours(),
		"m+": this.getMinutes(),
		"s+": this.getSeconds(),
	};
	if (/(y+)/.test(format))
		format = format.replace(RegExp.$1, (this.getFullYear() + "").substr(4 - RegExp.$1.length));
	for (var i in args) {
		var n = args[i];
		if (new RegExp("(" + i + ")").test(format))
			format = format.replace(RegExp.$1, RegExp.$1.length == 1 ? n : ("00" + n).substr(("" + n).length));
	}
	return format;
};

DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>商品详情title>
    
    <script type="text/javascript" src="/js/jquery.min.js">script>
    
    <link rel="stylesheet" type="text/css" href="/bootstrap/css/bootstrap.min.css"/>
    <script type="text/javascript" src="/bootstrap/js/bootstrap.min.js">script>
    
    <script type="text/javascript" src="/layer/layer.js">script>
    
    <script type="text/javascript" src="/js/common.js">script>
head>
<body>
<div class="panel panel-default">
    <div class="panel-heading">秒杀商品详情div>
    <div class="panel-body">
        <span id="userTip"> 您还没有登录，请登陆后再操作<br/>span>
        <span>没有收货地址的提示。。。span>
    div>
    <table class="table" id="goods">
        <tr>
            <td>商品名称td>
            <td colspan="3" id="goodsName">td>
        tr>
        <tr>
            <td>商品图片td>
            <td colspan="3"><img id="goodsImg" width="200" height="200"/>td>
        tr>
        <tr>
            <td>秒杀开始时间td>
            <td id="startTime">td>
            <td>
                <input type="hidden" id="remainSeconds">
                
                <span id="seckillTip">span>
            td>
            <td>
                
                <div class="row">
                    <div class="form-inline">
                        <img id="captchaImg" width="130" height="32" onclick="refreshCaptcha()" style="display: none"/>
                        <input id="captcha" class="form-control" style="display: none">
                        <button class="btn btn-primary" type="button" id="buyButton"
                                onclick="getSeckillPath()">立即秒杀
                            <input type="hidden" name="goodsId" id="goodsId">
                        button>
                    div>
                div>
            td>
        tr>
        <tr>
            <td>商品原价td>
            <td colspan="3" id="goodsPrice">td>
        tr>
        <tr>
            <td>秒杀价td>
            <td colspan="3" id="seckillPrice">td>
        tr>
        <tr>
            <td>库存数量td>
            <td colspan="3" id="stockCount">td>
        tr>
    table>
div>
body>
<script>
    $(function () {
        // countDown();
        getDetails();
    });

    function refreshCaptcha() {
        $("#captchaImg").attr("src", "/seckill/captcha?goodsId=" + $("#goodsId").val() + "&time=" + new Date());
    }

    function getSeckillPath() {
        var goodsId = $("#goodsId").val();
        var captcha = $("#captcha").val();
        g_showLoading();
        $.ajax({
            url: "/seckill/path",
            type: "GET",
            data: {
                goodsId: goodsId,
                captcha: captcha
            },
            success: function (data) {
                if (data.code == 200) {
                    var path = data.obj;
                    doSeckill(path);
                } else {
                    layer.msg(data.message);
                }
            },
            error: function () {
                layer.msg("客户端请求错误");
            }
        })
    }

    function doSeckill(path) {
        $.ajax({
            url: '/seckill/' + path + '/doSeckill',
            type: 'POST',
            data: {
                goodsId: $("#goodsId").val()
            },
            success: function (data) {
                if (data.code == 200) {
                    // window.location.href = "/orderDetail.htm?orderId=" + data.obj.id;
                    getResult($("#goodsId").val());
                } else {
                    layer.msg(data.message);
                }
            },
            error: function () {
                layer.msg("客户端请求错误");
            }
        })
    }

    function getResult(goodsId) {
        g_showLoading();
        $.ajax({
            url: "/seckill/result",
            type: "GET",
            data: {
                goodsId: goodsId,
            },
            success: function (data) {
                if (data.code == 200) {
                    var result = data.obj;
                    if (result < 0) {
                        layer.msg("对不起，秒杀失败！");
                    } else if (result == 0) {
                        setTimeout(function () {
                            getResult(goodsId);
                        }, 50);
                    } else {
                        layer.confirm("恭喜你，秒杀成功！查看订单？", {btn: ["确定", "取消"]},
                            function () {
                                window.location.href = "/orderDetail.htm?orderId=" + result;
                            },
                            function () {
                                layer.close();
                            })
                    }
                }
            },
            error: function () {
                layer.msg("客户端请求错误");
            }
        })
    }


    function getDetails() {
        var goodsId = g_getQueryString("goodsId");
        $.ajax({
            url: '/goods/detail/' + goodsId,
            type: 'GET',
            success: function (data) {
                if (data.code == 200) {
                    render(data.obj);
                } else {
                    layer.msg("客户端请求出错");
                }
            },
            error: function () {
                layer.msg("客户端请求出错");
            }
        });
    }


    function render(detail) {
        var user = detail.user;
        var goods = detail.goodsVo;
        var remainSeconds = detail.remainSeconds;
        if (user) {
            $("#userTip").hide();
        }
        $("#goodsName").text(goods.goodsName);
        $("#goodsImg").attr("src", goods.goodsImg);
        $("#startTime").text(new Date(goods.startDate).format("yyyy-MM-dd HH:mm:ss"));
        $("#remainSeconds").val(remainSeconds);
        $("#goodsId").val(goods.id);
        $("#goodsPrice").text(goods.goodsPrice);
        $("#seckillPrice").text(goods.seckillPrice);
        $("#stockCount").text(goods.stockCount);
        countDown();
    }


    function countDown() {
        var remainSeconds = $("#remainSeconds").val();
        var timeout;
        //秒杀还未开始
        if (remainSeconds > 0) {
            $("#buyButton").attr("disabled", true);
            $("#seckillTip").html("秒杀倒计时：" + remainSeconds + "秒");
            timeout = setTimeout(function () {
                // $("#countDown").text(remainSeconds - 1);
                $("#remainSeconds").val(remainSeconds - 1);
                countDown();
            }, 1000);
            // 秒杀进行中
        } else if (remainSeconds == 0) {
            $("#buyButton").attr("disabled", false);
            if (timeout) {
                clearTimeout(timeout);
            }
            $("#seckillTip").html("秒杀进行中")
            $("#captchaImg").attr("src", "/seckill/captcha?goodsId=" + $("#goodsId").val() + "&time=" + new Date());
            $("#captchaImg").show();
            $("#captcha").show();
        } else {
            $("#buyButton").attr("disabled", true);
            $("#seckillTip").html("秒杀已经结束");
            $("#captchaImg").hide();
            $("#captcha").hide();
        }
    };

script>
html>

秒杀静态化

	/**
	 * 功能描述: 秒杀
	 * windows优化前QPS：785
	 * 缓存QPS：1356
	 * 优化QPS：2454
	 */
	@RequestMapping(value = "/{path}/doSeckill", method = RequestMethod.POST)
	@ResponseBody
	public RespBean doSeckill(@PathVariable String path, User user, Long goodsId) {
		if (user == null) {
			return RespBean.error(RespBeanEnum.SESSION_ERROR);
		}

		ValueOperations valueOperations = redisTemplate.opsForValue();
		boolean check = orderService.checkPath(user, goodsId, path);
		if (!check) {
			return RespBean.error(RespBeanEnum.REQUEST_ILLEGAL);
		}
		// 判断是否重复抢购
		SeckillOrder seckillOrder =
				(SeckillOrder) redisTemplate.opsForValue().get("order:" + user.getId() + ":" + goodsId);
		if (seckillOrder != null) {
			return RespBean.error(RespBeanEnum.REPEATE_ERROR);
		}
		// 内存标记，减少Redis的访问
		if (EmptyStockMap.get(goodsId)) {
			return RespBean.error(RespBeanEnum.EMPTY_STOCK);
		}
		// 预减库存
		// Long stock = valueOperations.decrement("seckillGoods:" + goodsId);
		Long stock = (Long) redisTemplate.execute(script, Collections.singletonList("seckillGoods:" + goodsId),
				Collections.EMPTY_LIST);
		if (stock < 0) {
			EmptyStockMap.put(goodsId, true);
			valueOperations.increment("seckillGoods:" + goodsId);
			return RespBean.error(RespBeanEnum.EMPTY_STOCK);
		}
		SeckillMessage seckillMessage = new SeckillMessage(user, goodsId);
		mqSender.sendSeckillMessage(JsonUtil.object2JsonStr(seckillMessage));
		return RespBean.success(0);

DOCTYPE HTML>
<html>
<head>
    <title>订单详情title>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
    
    <script type="text/javascript" src="/js/jquery.min.js">script>
    
    <link rel="stylesheet" type="text/css" href="/bootstrap/css/bootstrap.min.css"/>
    <script type="text/javascript" src="/bootstrap/js/bootstrap.min.js">script>
    
    <script type="text/javascript" src="/layer/layer.js">script>
    
    <script type="text/javascript" src="/js/common.js">script>
head>
<body>
<div class="panel panel-default">
    <div class="panel-heading">秒杀订单详情div>
    <table class="table" id="order">
        <tr>
            <td>商品名称td>
            <td id="goodsName" colspan="3">td>
        tr>
        <tr>
            <td>商品图片td>
            <td colspan="2"><img id="goodsImg" width="200" height="200"/>td>
        tr>
        <tr>
            <td>订单价格td>
            <td colspan="2" id="goodsPrice">td>
        tr>
        <tr>
            <td>下单时间td>
            <td id="createDate" colspan="2">td>
        tr>
        <tr>
            <td>订单状态td>
            <td id="status">
                
            td>
            <td>
                <button class="btn btn-primary btn-block" type="submit" id="payButton">立即支付button>
            td>
        tr>
        <tr>
            <td>收货人td>
            <td colspan="2">XXX 18012345678td>
        tr>
        <tr>
            <td>收货地址td>
            <td colspan="2">上海市浦东区世纪大道td>
        tr>
    table>
div>
<script>
    $(function () {
        getOrderDetail();
    });


    function getOrderDetail() {
        var orderId = g_getQueryString("orderId");
        $.ajax({
            url: '/order/detail',
            type: 'GET',
            data: {
                orderId: orderId
            },
            success: function (data) {
                if (data.code == 200) {
                    render(data.obj);
                } else {
                    layer.msg(data.message);
                }
            },
            error: function () {
                layer.msg("客户端请求错误")
            }
        })
    }


    function render(detail) {
        var goods = detail.goodsVo;
        var order = detail.order;
        $("#goodsName").text(goods.goodsName);
        $("#goodsImg").attr("src", goods.goodsImg);
        $("#goodsPrice").text(order.goodsPrice);
        $("#createDate").text(new Date(order.createDate).format("yyyy-MM-dd HH:mm:ss"));
        var status = order.status;
        var statusText = "";
        switch (status) {
            case 0:
                statusText = "未支付";
                break;
            case 1:
                statusText = "待发货";
                break;
            case 2:
                statusText = "已发货";
                break;
            case 3:
                statusText = "已收货";
                break;
            case 4:
                statusText = "已退款";
                break
            case 5:
                statusText = "已完成";
                break;
        }
        $("#status").text(statusText);
    }
script>
body>
html>

同步修改配置文件,注意缩进

spring:
 #静态资源处理
resources:
  #启用默认静态资源处理，默认启用
 add-mappings: true
 cache:
  cachecontrol:
    #缓存响应时间，单位秒
   max-age: 3600
 chain:
   #资源链中启用缓存，默认启用
  cache: true
   #启用资源链，默认禁用
  enabled: true
   #启用压缩资源(gzip,brotli)解析,默认禁用
  compressed: true
   #启用H5应用缓存，默认禁用
  html-application-cache: true
  #静态资源位置
 static-locations: classpath:/static/

测试

订单详情静态化

订单接口的控制层

package com.itkaka.seckill.controller;


import com.itkaka.seckill.pojo.User;
import com.itkaka.seckill.service.IOrderService;
import com.itkaka.seckill.vo.OrderDetailVo;
import com.itkaka.seckill.vo.RespBean;
import com.itkaka.seckill.vo.RespBeanEnum;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RestController;

/**
 * 
 *  前端控制器
 * 
 *
 * @author itkaka
 * @since 2023-05-11
 */
@RestController
@RequestMapping("/order")
public class OrderController {
    @Autowired
    private IOrderService orderService;

    // 订单详情
    @RequestMapping("detail")
    public RespBean detail(User user,Long orderId){
        if (user == null){
            return RespBean.error(RespBeanEnum.SESSION_ERROR);
        }
        OrderDetailVo detailVo = orderService.detail(orderId);
        return RespBean.success(detailVo);
    }

}

订单业务层的接口和实现类修改

package com.itkaka.seckill.service;

import com.itkaka.seckill.pojo.Order;
import com.baomidou.mybatisplus.extension.service.IService;
import com.itkaka.seckill.pojo.User;
import com.itkaka.seckill.vo.GoodsVo;
import com.itkaka.seckill.vo.OrderDetailVo;

/**
 * 
 *  服务类
 * 
 *
 * @author itkaka
 * @since 2023-05-11
 */
public interface IOrderService extends IService<Order> {

    // 简单 秒杀功能
    Order seckill(User user, GoodsVo goodsVo);

    OrderDetailVo detail(Long orderId); // 订单详情
}

    // 订单详情
    @Override
    public OrderDetailVo detail(Long orderId) {

        if (orderId == null){
            throw new GlobalException(RespBeanEnum.ORDER_NOT_EXIST);
        }
        Order order = orderMapper.selectById(orderId);
        GoodsVo goodsVo = goodsService.queryGoodsVoByGoodsId( (order.getGoodsId()).longValue());
        OrderDetailVo detailVo = new OrderDetailVo();
        detailVo.setOrder(order);
        detailVo.setGoodsVo(goodsVo);

        return detailVo;
    }

package com.itkaka.seckill.vo;
// 订单详情返回对象

import com.itkaka.seckill.pojo.Order;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class OrderDetailVo {

    private Order order;

    private GoodsVo goodsVo;

}

解决库存超卖
扣减库存时候判断库存是否足够

//秒杀商品表减库存
SeckillGoods seckillGoods = seckillGoodsService.getOne(new
QueryWrapper<SeckillGoods>().eq("goods_id",
   goods.getId()));
seckillGoods.setStockCount(seckillGoods.getStockCount() - 1);
seckillGoodsService.update(new UpdateWrapper<SeckillGoods>().set("stock_count",
seckillGoods.getStockCount()).eq("id", seckillGoods.getId()).gt("stock_count",0));
// seckillGoodsService.updateById(seckillGoods);

解决同一个用户同时秒杀多件商品
可以通过数据库建立唯一索引避免

将秒杀订单信息存入 Redis ,方便判断是都重复抢购时进行查询

 // 秒杀
    @Override
    @Transactional
    public Order seckill(User user, GoodsVo goodsVo) {

        ValueOperations valueOperations = redisTemplate.opsForValue();

        // 秒杀商品减库存
        SeckillGoods seckillGoods = seckillGoodsService.getOne(new
                QueryWrapper<SeckillGoods>().eq("goods_id",goodsVo.getId()));
        seckillGoods.setStockCount(seckillGoods.getStockCount()-1);
        //seckillGoodsService.updateById(seckillGoods);

        //  解决库存超卖 扣减库存时候判断库存是否足够
        // seckillGoodsService.update(new UpdateWrapper().set("stock_count",
        //        seckillGoods.getStockCount()).eq("id",seckillGoods.getId()).gt("stock_count",0));

        //
        boolean seckillGoodsResult = seckillGoodsService.update(new UpdateWrapper<SeckillGoods>().set("stock_count",
                seckillGoods.getStockCount()).eq("id",seckillGoods.getId()).gt("stock_count",0));
       if ((seckillGoods.getStockCount())<1){
          // 判断是否还有库存
           valueOperations.set("isStockEmpty:"+ goodsVo.getId(),"0");
           return null;
       }
        // 生成订单
        Order order = new Order();
        order.setUserId(user.getId());
        order.setGoodsId(goodsVo.getId());
        order.setDeliverAddrId(0);
        order.setGoodsName(goodsVo.getGoodsName());
        order.setGoodsCount(1);
        order.setGoodsPrice(seckillGoods.getSeckillPrice());
        order.setOrderChannel(1);
        order.setStatus(0);
        order.setCreateDate(new Date());
        orderMapper.insert(order);
        //生成秒杀订单
        SeckillOrder seckillOrder = new SeckillOrder();
        seckillOrder.setUserId(user.getId());
        seckillOrder.setOrderId(order.getId());
        seckillOrder.setGoodsId(goodsVo.getId());
        seckillOrderService.save(seckillOrder);
        valueOperations.set("order:" + user.getId() + ":" + goodsVo.getId(), seckillOrder);

        return order;
    }

 @RequestMapping(value = "/doSeckill", method = RequestMethod.POST)
 @ResponseBody
 public RespBean doSeckill(User user, Long goodsId) {
      if (user == null) {
           return RespBean.error(RespBeanEnum.SESSION_ERROR);
      }
   GoodsVo goods = goodsService.findGoodsVoByGoodsId(goodsId);
   //判断库存
   if (goods.getStockCount() < 1) {
       return RespBean.error(RespBeanEnum.EMPTY_STOCK);
   }
   //判断是否重复抢购
   // SeckillOrder seckillOrder = seckillOrderService.getOne(new QueryWrapper().eq("user_id",
   //    user.getId()).eq(
   //    "goods_id",
   //    goodsId));
   String seckillOrderJson = (String)redisTemplate.opsForValue().get("order:" + user.getId() + ":" + goodsId);
   if (!StringUtils.isEmpty(seckillOrderJson)) {
       return RespBean.error(RespBeanEnum.REPEATE_ERROR);
   }
   Order order = orderService.seckill(user, goods);
   if (null != order) {
       return RespBean.success(order);
   }
   return RespBean.error(RespBeanEnum.ERROR);
 }

服务优化

RabbitMQ 入门

安装 : 官网 https://www.erlang-solutions.com/resources/download.html
安装erlang Linux命令: yum -y install esl-erlang_23.0.2-1_centos_7_amd64.rpm
检测erlang
安装RabbitMQ
官网下载地址：http://www.rabbitmq.com/download.html
安装rabbitmq yum -y install rabbitmq-server-3.8.5-1.el7.noarch.rpm
安装UI插件 rabbitmq-plugins enable rabbitmq_management

启用 rabbitMQ服务 systemctl start rabbitmq-server.service
检测服务 systemctl status rabbitmq-server.service
访问 guest用户默认只可以localhost(本机)访问

在rabbitmq的配置文件目录下（默认为：/etc/rabbitmq）创建一个rabbitmq.config文件。
文件中添加如下配置（请不要忘记那个“.”）： [{rabbit, [{loopback_users, []}]}].
重启rabbitmq服务 systemctl restart rabbitmq-server.service
重新访问
使用
依赖


<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-amqpartifactId>
dependency>

配置

spring:
 #RabbitMQ
rabbitmq:
  #服务器地址
 host: 192.168.10.100
  #用户名
 username: guest
  #密码
 password: guest
  #虚拟主机
 virtual-host: /
  #端口
 port: 5672
 listener:
  simple:
    #消费者最小数量
   concurrency: 10
    #消费者最大数量
   max-concurrency: 10
    #限制消费者每次只处理一条消息，处理完再继续下一条消息
   prefetch: 1
    #启动时是否默认启动容器，默认true
   auto-startup: true
    #被拒绝时重新进入队列
   default-requeue-rejected: true
 template:
  retry:
    #发布重试，默认false
   enabled: true
    #重试时间 默认1000ms
   initial-interval: 1000
    #重试最大次数，默认3次
   max-attempts: 3
    #重试最大间隔时间，默认10000ms
   max-interval: 10000
    #重试间隔的乘数。比如配2.0 第一次等10s，第二次等20s，第三次等40s
   multiplier: 1.0

package com.itkaka.seckill.rabbitmq;

import com.itkaka.seckill.pojo.SeckillMessage;
import com.itkaka.seckill.pojo.SeckillOrder;
import com.itkaka.seckill.pojo.User;
import com.itkaka.seckill.service.IGoodsService;
import com.itkaka.seckill.service.IOrderService;
import com.itkaka.seckill.utils.JsonUtil;
import com.itkaka.seckill.vo.GoodsVo;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

/**
* 消息消费者
*/
@Service
    @Slf4j
    public class MQReceiver {

        // @RabbitListener(queues = "queue")
        // public void receive(Object msg) {
        // 	log.info("接收消息：" + msg);
        // }
        //
        //
        // @RabbitListener(queues = "queue_fanout01")
        // public void receive01(Object msg) {
        // 	log.info("QUEUE01接收消息：" + msg);
        // }
        //
        // @RabbitListener(queues = "queue_fanout02")
        // public void receive02(Object msg) {
        // 	log.info("QUEUE02接收消息：" + msg);
        // }
        //
        //
        // @RabbitListener(queues = "queue_direct01")
        // public void receive03(Object msg) {
        // 	log.info("QUEUE01接收消息：" + msg);
        // }
        //
        // @RabbitListener(queues = "queue_direct02")
        // public void receive04(Object msg) {
        // 	log.info("QUEUE02接收消息：" + msg);
        // }
        //
        // @RabbitListener(queues = "queue_topic01")
        // private void receive05(Object msg) {
        // 	log.info("QUEUE01接收消息：" + msg);
        // }
        //
        // @RabbitListener(queues = "queue_topic02")
        // private void receive06(Object msg) {
        // 	log.info("QUEUE02接收消息：" + msg);
        // }
        //
        // @RabbitListener(queues = "queue_header01")
        // public void receive07(Message message) {
        // 	log.info("QUEUE01接收Message对象：" + message);
        // 	log.info("QUEUE01接收消息：" + new String(message.getBody()));
        // }
        //
        // @RabbitListener(queues = "queue_header02")
        // public void receive08(Message message) {
        // 	log.info("QUEUE02接收Message对象：" + message);
        // 	log.info("QUEUE02接收消息：" + new String(message.getBody()));
        // }

        @Autowired
        private IGoodsService goodsService;
        @Autowired
        private RedisTemplate redisTemplate;
        @Autowired
        private IOrderService orderService;

        /**
* 下单操作
*/
        @RabbitListener(queues = "seckillQueue")
        public void receive(String message) {
            log.info("接收的消息：" + message);
            SeckillMessage seckillMessage = JsonUtil.jsonStr2Object(message, SeckillMessage.class);
            Long goodId = seckillMessage.getGoodId();
            User user = seckillMessage.getUser();
            //判断库存
            GoodsVo goodsVo = goodsService.queryGoodsVoByGoodsId(goodId);
            if (goodsVo.getStockCount() < 1) {
                return;
            }
            //判断是否重复抢购
            SeckillOrder seckillOrder =
                (SeckillOrder) redisTemplate.opsForValue().get("order:" + user.getId() + ":" + goodId);
            if (seckillOrder != null) {
                return;
            }
            //下单操作
            orderService.seckill(user, goodsVo);
        }
    }

package com.itkaka.seckill.rabbitmq;

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * 消息发送者
 */
@Service
@Slf4j
public class MQSender {

	@Autowired
	private RabbitTemplate rabbitTemplate;


	// public void send(Object msg) {
	// 	log.info("发送消息：" + msg);
	// 	rabbitTemplate.convertAndSend("fanoutExchange", "", msg);
	// }
	//
	//
	// public void send01(Object msg) {
	// 	log.info("发送red消息：" + msg);
	// 	rabbitTemplate.convertAndSend("directExchange", "queue.red", msg);
	// }
	//
	//
	// public void send02(Object msg) {
	// 	log.info("发送green消息：" + msg);
	// 	rabbitTemplate.convertAndSend("directExchange", "queue.green", msg);
	// }
	//
	//
	// public void send03(Object msg) {
	// 	log.info("发送消息(QUEUE01接收)：" + msg);
	// 	rabbitTemplate.convertAndSend("topicExchange", "queue.red.message", msg);
	// }
	//
	// public void send04(Object msg) {
	// 	log.info("发送消息(被两个queue接收)：" + msg);
	// 	rabbitTemplate.convertAndSend("topicExchange", "message.queue.green.abc", msg);
	// }
	//
	//
	// public void send05(String msg) {
	// 	log.info("发送消息(被两个queue接收)：" + msg);
	// 	MessageProperties properties = new MessageProperties();
	// 	properties.setHeader("color", "red");
	// 	properties.setHeader("speed", "fast");
	// 	Message message = new Message(msg.getBytes(), properties);
	// 	rabbitTemplate.convertAndSend("headersExchange", "", message);
	// }
	//
	// public void send06(String msg) {
	// 	log.info("发行消息(被QUEUE01接收)：" + msg);
	// 	MessageProperties properties = new MessageProperties();
	// 	properties.setHeader("color", "red");
	// 	properties.setHeader("speed", "normal");
	// 	Message message = new Message(msg.getBytes(), properties);
	// 	rabbitTemplate.convertAndSend("headersExchange", "", message);
	// }

	/**
	 * 发送秒杀信息
	 *
	 * @param message
	 */
	public void sendSeckillMessage(String message) {
		log.info("发送消息：" + message);
		rabbitTemplate.convertAndSend("seckillExchange", "seckill.message", message);
	}


}

package com.itkaka.seckill.controller;


import com.itkaka.seckill.pojo.User;
import com.itkaka.seckill.rabbitmq.MQSender;
import com.itkaka.seckill.vo.RespBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

/**
 * 
 * 前端控制器
 * 
 *
 * @author itkaka
 * @since 2023-05-11
 */
@RestController
@RequestMapping("/user")
public class UserController {
    @Autowired
    private MQSender mqSender;

    // 用户信息(测试)
    @RequestMapping("/info")
    @ResponseBody
    public RespBean info(User user) {
        return RespBean.success(user);
    }


    // /**
    //  * 功能描述: 测试发送RabbitMQ消息
    //  */
    // @RequestMapping("/mq")
    // @ResponseBody
    // public void mq() {
    // 	mqSender.send("Hello");
    // }
    //
    //
    // /**
    //  * 功能描述: Fanout模式
    //  */
    // @RequestMapping("/mq/fanout")
    // @ResponseBody
    // public void mq01() {
    // 	mqSender.send("Hello");
    // }
    //
    //
    // /**
    //  * 功能描述: Direct模式
    //  */
    // @RequestMapping("/mq/direct01")
    // @ResponseBody
    // public void mq02() {
    // 	mqSender.send01("Hello,Red");
    // }
    //
    // /**
    //  * 功能描述: Direct模式
    //  */
    // @RequestMapping("/mq/direct02")
    // @ResponseBody
    // public void mq03() {
    // 	mqSender.send02("Hello,Green");
    // }
    //
    //
    // /**
    //  * 功能描述: Topic模式
    //  */
    // @RequestMapping("/mq/topic01")
    // @ResponseBody
    // public void mq04() {
    // 	mqSender.send03("Hello,Red");
    // }
    //
    //
    // /**
    //  * 功能描述: Topic模式
    //  */
    // @RequestMapping("/mq/topic02")
    // @ResponseBody
    // public void mq05() {
    // 	mqSender.send04("Hello,Green");
    // }
    //
    //
    // /**
    //  * 功能描述: Header模式
    //  */
    // @RequestMapping("/mq/header01")
    // @ResponseBody
    // public void mq06() {
    // 	mqSender.send05("Hello,Header01");
    // }
    //
    // /**
    //  * 功能描述: Header模式
    //  */
    // @RequestMapping("/mq/header02")
    // @ResponseBody
    // public void mq07() {
    // 	mqSender.send06("Hello,Header02");
    // }

}

RabbitMQ交换机

添加配置类,测试

package com.itkaka.seckill.config;// package com.xxxx.seckill.config;
//
// import org.springframework.amqp.core.Binding;
// import org.springframework.amqp.core.BindingBuilder;
// import org.springframework.amqp.core.FanoutExchange;
// import org.springframework.amqp.core.Queue;
// import org.springframework.context.annotation.Bean;
// import org.springframework.context.annotation.Configuration;
//
// /**
//  * RabbitMQ配置类
//  */
// @Configuration
// public class RabbitMQConfig {
//
// 	private static final String QUEUE01 = "queue_fanout01";
// 	private static final String QUEUE02 = "queue_fanout02";
// 	private static final String EXCHANGE = "fanoutExchange";
//
// 	@Bean
// 	public Queue queue(){
// 		return new Queue("queue",true);
// 	}
//
// 	@Bean
// 	public Queue queue01(){
// 		return new Queue(QUEUE01);
// 	}
//
// 	@Bean
// 	public Queue queue02(){
// 		return new Queue(QUEUE02);
// 	}
//
// 	@Bean
// 	public FanoutExchange fanoutExchange(){
// 		return new FanoutExchange(EXCHANGE);
// 	}
//
// 	@Bean
// 	public Binding binding01(){
// 		return BindingBuilder.bind(queue01()).to(fanoutExchange());
// 	}
//
//
// 	@Bean
// 	public Binding binding02(){
// 		return BindingBuilder.bind(queue02()).to(fanoutExchange());
// 	}
// }

package com.itkaka.seckill.config;// package com.xxxx.seckill.config;
//
// import org.springframework.amqp.core.Binding;
// import org.springframework.amqp.core.BindingBuilder;
// import org.springframework.amqp.core.DirectExchange;
// import org.springframework.amqp.core.Queue;
// import org.springframework.context.annotation.Bean;
// import org.springframework.context.annotation.Configuration;
//
// /**
//  * RabbitMQ配置类-Direct模式
//  */
// @Configuration
// public class RabbitMQDirectConfig {
//
// 	private static final String QUEUE01 = "queue_direct01";
// 	private static final String QUEUE02 = "queue_direct02";
// 	private static final String EXCHANGE = "directExchange";
// 	private static final String ROUTINGKEY01 = "queue.red";
// 	private static final String ROUTINGKEY02 = "queue.green";
//
// 	@Bean
// 	public Queue queue01() {
// 		return new Queue(QUEUE01);
// 	}
//
// 	@Bean
// 	public Queue queue02() {
// 		return new Queue(QUEUE02);
// 	}
//
// 	@Bean
// 	public DirectExchange directExchange() {
// 		return new DirectExchange(EXCHANGE);
// 	}
//
// 	@Bean
// 	public Binding binding01() {
// 		return BindingBuilder.bind(queue01()).to(directExchange()).with(ROUTINGKEY01);
// 	}
//
// 	@Bean
// 	public Binding binding02() {
// 		return BindingBuilder.bind(queue02()).to(directExchange()).with(ROUTINGKEY02);
// 	}
// }

package com.itkaka.seckill.config;// package com.xxxx.seckill.config;
//
// import org.springframework.amqp.core.Binding;
// import org.springframework.amqp.core.BindingBuilder;
// import org.springframework.amqp.core.HeadersExchange;
// import org.springframework.amqp.core.Queue;
// import org.springframework.context.annotation.Bean;
// import org.springframework.context.annotation.Configuration;
//
// import java.util.HashMap;
// import java.util.Map;
//
//
// /**
//  * RabbitMQ配置类-Headers模式
//  */
// @Configuration
// public class RabbitMQHeadersConfig {
//
// 	private static final String QUEUE01 = "queue_header01";
// 	private static final String QUEUE02 = "queue_header02";
// 	private static final String EXCHANGE = "headersExchange";
//
// 	@Bean
// 	public Queue queue01() {
// 		return new Queue(QUEUE01);
// 	}
//
// 	@Bean
// 	public Queue queue02() {
// 		return new Queue(QUEUE02);
// 	}
//
// 	@Bean
// 	public HeadersExchange headersExchange() {
// 		return new HeadersExchange(EXCHANGE);
// 	}
//
// 	@Bean
// 	public Binding binding01() {
// 		Map map = new HashMap<>();
// 		map.put("color", "red");
// 		map.put("speed", "low");
// 		return BindingBuilder.bind(queue01()).to(headersExchange()).whereAny(map).match();
// 	}
//
// 	@Bean
// 	public Binding binding02() {
// 		Map map = new HashMap<>();
// 		map.put("color", "red");
// 		map.put("speed", "fast");
// 		return BindingBuilder.bind(queue02()).to(headersExchange()).whereAll(map).match();
// 	}
// }

package com.itkaka.seckill.config;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * RabbitMQ配置类-Topic
 * 
 */
@Configuration
public class RabbitMQTopicConfig {

	// private static final String QUEUE01 = "queue_topic01";
	// private static final String QUEUE02 = "queue_topic02";
	// private static final String EXCHANGE = "topicExchange";
	// private static final String ROUTINGKEY01 = "#.queue.#";
	// private static final String ROUTINGKEY02 = "*.queue.#";
	//
	// @Bean
	// public Queue queue01() {
	// 	return new Queue(QUEUE01);
	// }
	//
	// @Bean
	// public Queue queue02() {
	// 	return new Queue(QUEUE02);
	// }
	//
	// @Bean
	// public TopicExchange topicExchange() {
	// 	return new TopicExchange(EXCHANGE);
	// }
	//
	// @Bean
	// public Binding binding01() {
	// 	return BindingBuilder.bind(queue01()).to(topicExchange()).with(ROUTINGKEY01);
	// }
	//
	// @Bean
	// public Binding binding02() {
	// 	return BindingBuilder.bind(queue02()).to(topicExchange()).with(ROUTINGKEY02);
	// }

	private static final String QUEUE = "seckillQueue";
	private static final String EXCHANGE = "seckillExchange";


	@Bean
	public Queue queue() {
		return new Queue(QUEUE);
	}

	@Bean
	public TopicExchange topicExchange() {
		return new TopicExchange(EXCHANGE);
	}

	@Bean
	public Binding binding() {
		return BindingBuilder.bind(queue()).to(topicExchange()).with("seckill.#");
	}
}

接口优化

思路：减少数据库访问

系统初始化，把商品库存数量加载到Redis
收到请求，Redis预减库存。库存不足，直接返回。否则进入第3步
请求入队，立即返回排队中
请求出队，生成订单，减少库存
客户端轮询，是否秒杀成功

Redis 操作库存

package com.itkaka.seckill.controller;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.itkaka.seckill.config.AccessLimit;
import com.itkaka.seckill.pojo.SeckillMessage;
import com.itkaka.seckill.rabbitmq.MQSender;
import com.wf.captcha.ArithmeticCaptcha;

import com.itkaka.seckill.exception.GlobalException;
import com.itkaka.seckill.pojo.Order;

import com.itkaka.seckill.pojo.SeckillOrder;
import com.itkaka.seckill.pojo.User;

import com.itkaka.seckill.service.IGoodsService;
import com.itkaka.seckill.service.IOrderService;
import com.itkaka.seckill.service.ISeckillOrderService;
import com.itkaka.seckill.utils.JsonUtil;
import com.itkaka.seckill.vo.GoodsVo;
import com.itkaka.seckill.vo.RespBean;
import com.itkaka.seckill.vo.RespBeanEnum;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.data.redis.core.script.RedisScript;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.util.CollectionUtils;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;

/**
 * 秒杀
 */
@Slf4j
@Controller
@RequestMapping("/seckill")
public class SecKillController  {

	@Autowired
	private IGoodsService goodsService;
	@Autowired
	private ISeckillOrderService seckillOrderService;
	@Autowired
	private IOrderService orderService;
	@Autowired
	private RedisTemplate redisTemplate;

	@Autowired
	private MQSender mqSender;
	@Autowired
	private RedisScript<Long> script;

	private Map<Long, Boolean> EmptyStockMap = new HashMap<>();




	/**
	 * 功能描述: 秒杀
	 * windows优化前QPS：785
	 * 缓存QPS：1356
	 * 优化QPS：2454
	 */
	@RequestMapping(value = "/{path}/doSeckill", method = RequestMethod.POST)
	@ResponseBody
	public RespBean doSeckill(@PathVariable String path, User user, Long goodsId) {
		if (user == null) {
			return RespBean.error(RespBeanEnum.SESSION_ERROR);
		}

		ValueOperations valueOperations = redisTemplate.opsForValue();
		boolean check = orderService.checkPath(user, goodsId, path);
		if (!check) {
			return RespBean.error(RespBeanEnum.REQUEST_ILLEGAL);
		}
		// 判断是否重复抢购
		SeckillOrder seckillOrder =
				(SeckillOrder) redisTemplate.opsForValue().get("order:" + user.getId() + ":" + goodsId);
		if (seckillOrder != null) {
			return RespBean.error(RespBeanEnum.REPEATE_ERROR);
		}
		// 内存标记，减少Redis的访问
		if (EmptyStockMap.get(goodsId)) {
			return RespBean.error(RespBeanEnum.EMPTY_STOCK);
		}
		// 预减库存
		// Long stock = valueOperations.decrement("seckillGoods:" + goodsId);
		Long stock = (Long) redisTemplate.execute(script, Collections.singletonList("seckillGoods:" + goodsId),
				Collections.EMPTY_LIST);
		if (stock < 0) {
			EmptyStockMap.put(goodsId, true);
			valueOperations.increment("seckillGoods:" + goodsId);
			return RespBean.error(RespBeanEnum.EMPTY_STOCK);
		}
		SeckillMessage seckillMessage = new SeckillMessage(user, goodsId);
		mqSender.sendSeckillMessage(JsonUtil.object2JsonStr(seckillMessage));
		return RespBean.success(0);


		/*GoodsVo goods = goodsService.queryGoodsVoByGoodsId(goodsId);
		//判断库存
		if (goods.getStockCount() < 1) {
			return RespBean.error(RespBeanEnum.EMPTY_STOCK);
		}
		//判断是否重复抢购
//		 SeckillOrder seckillOrder =
//		 		seckillOrderService.getOne(new QueryWrapper().eq("user_id", user.getId()).eq("goods_id",
//		 				goodsId));
		String seckillOrderJson =
				(String) redisTemplate.opsForValue().get("order:" + user.getId() + ":" + goodsId);
//		if (seckillOrder != null) {
//			return RespBean.error(RespBeanEnum.REPEATE_ERROR);
//		}
		if (!StringUtils.isEmpty(seckillOrderJson)){
			return RespBean.error(RespBeanEnum.REPEATE_ERROR);
		}
		Order order = orderService.seckill(user, goods);
		if (null != order){
			return  RespBean.success(order);
		}
		return RespBean.error(RespBeanEnum.ERROR);*/

	}



	/**
	 * 系统初始化，把商品库存数量加载到Redis
	 *
	 */
	public void afterPropertiesSet() throws Exception {
		List<GoodsVo> list = goodsService.queryGoodsVo();
		if (CollectionUtils.isEmpty(list)) {
			return;
		}
		list.forEach(goodsVo -> {
					redisTemplate.opsForValue().set("seckillGoods:" + goodsVo.getId(), goodsVo.getStockCount());
					EmptyStockMap.put(goodsVo.getId().longValue(), false);
				}
		);
	}
}

RabbitMQ 秒杀

package com.itkaka.seckill.pojo;
// 秒杀信息

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class SeckillMessage {


    private User user;

    private Long goodId;

}

@Configuration
public class RabbitMQConfig {
     private static final String QUEUE = "seckillQueue";
     private static final String EXCHANGE = "seckillExchange";
    
     @Bean
     public Queue queue(){
       return new Queue(QUEUE);
     }
    
     @Bean
     public TopicExchange topicExchange(){
       return new TopicExchange(EXCHANGE);
     }
    
     @Bean
     public Binding binding01(){
       return BindingBuilder.bind(queue()).to(topicExchange()).with("seckill.#");
     }
}

@Service
@Slf4j
public class MQSender {
 @Autowired
 private RabbitTemplate rabbitTemplate;
 public void sendsecKillMessage(String message) {
   log.info("发送消息：" + message);
   rabbitTemplate.convertAndSend("seckillExchange", "seckill.msg", message);
 }
}

@Service
@Slf4j
public class MQReceiver {
 @Autowired
 private IGoodsService goodsService;
 @Autowired
 private RedisTemplate redisTemplate;
 @Autowired
 private IOrderService orderService;
 @RabbitListener(queues = "seckillQueue")
 public void receive(String msg) {
   log.info("QUEUE接受消息：" + msg);
   SeckillMessage message = JsonUtil.jsonStr2Object(msg,
SeckillMessage.class);
   Long goodsId = message.getGoodsId();
   User user = message.getUser();
   GoodsVo goods = goodsService.findGoodsVoByGoodsId(goodsId);
   //判断库存
   if (goods.getStockCount() < 1) {
    return;
  }
   //判断是否重复抢购
   // SeckillOrder seckillOrder = seckillOrderService.getOne(new
QueryWrapper<SeckillOrder>().eq("user_id",
   //    user.getId()).eq(
   //    "goods_id",
   //    goodsId));
   String seckillOrderJson = (String)
redisTemplate.opsForValue().get("order:" + user.getId() + ":" + goodsId);
   if (!StringUtils.isEmpty(seckillOrderJson)) {
    return;
  }
   orderService.seckill(user, goods);
 }
}

客户端轮询秒杀结果

	/**
	 * 功能描述: 获取秒杀结果
	 * 			orderId:成功，-1：秒杀失败，0：排队中
	 */
	@RequestMapping(value = "/result", method = RequestMethod.GET)
	@ResponseBody
	public RespBean getResult(User user, Long goodsId) {
		if (user == null) {
			return RespBean.error(RespBeanEnum.SESSION_ERROR);
		}
		Long orderId = seckillOrderService.getResult(user, goodsId);
		return RespBean.success(orderId);
	}

package com.itkaka.seckill.service;

import com.itkaka.seckill.pojo.SeckillOrder;
import com.baomidou.mybatisplus.extension.service.IService;
import com.itkaka.seckill.pojo.User;

/**
 * 
 *  服务类
 * 
 *
 * @author itkaka
 * @since 2023-05-11
 */
public interface ISeckillOrderService extends IService<SeckillOrder> {

    // 获取秒杀结果
    Long getResult(User user,Long goodsId);

}

package com.itkaka.seckill.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.itkaka.seckill.pojo.SeckillOrder;
import com.itkaka.seckill.mapper.SeckillOrderMapper;
import com.itkaka.seckill.pojo.User;
import com.itkaka.seckill.service.ISeckillOrderService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

/**
 * 
 *  服务实现类
 * 
 *
 * @author itkaka
 * @since 2023-05-11
 */
@Service
public class SeckillOrderServiceImpl extends ServiceImpl<SeckillOrderMapper, SeckillOrder> implements ISeckillOrderService {

    @Autowired
    private SeckillOrderMapper seckillOrderMapper;
    @Autowired
    private RedisTemplate redisTemplate;

    @Override
    public Long getResult(User user, Long goodsId) {
        SeckillOrder seckillOrder = seckillOrderMapper.selectOne(new QueryWrapper<SeckillOrder>().eq("user_id",
                user.getId()).eq("goods_id",
                goodsId));
        if (null != seckillOrder) {
            return seckillOrder.getOrderId().longValue();
        } else if (redisTemplate.hasKey("isStockEmpty:" + goodsId)) {
            return -1L;
        } else {
            return 0L;
        }
    }
}

package com.itkaka.seckill.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.itkaka.seckill.exception.GlobalException;
import com.itkaka.seckill.pojo.Order;
import com.itkaka.seckill.mapper.OrderMapper;
import com.itkaka.seckill.pojo.SeckillGoods;
import com.itkaka.seckill.pojo.SeckillOrder;
import com.itkaka.seckill.pojo.User;
import com.itkaka.seckill.service.IGoodsService;
import com.itkaka.seckill.service.IOrderService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.itkaka.seckill.service.ISeckillGoodsService;
import com.itkaka.seckill.service.ISeckillOrderService;
import com.itkaka.seckill.utils.MD5Util;
import com.itkaka.seckill.utils.UUIDUtil;
import com.itkaka.seckill.vo.GoodsVo;
import com.itkaka.seckill.vo.OrderDetailVo;
import com.itkaka.seckill.vo.RespBeanEnum;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;

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

/**
 * 
 *  服务实现类
 * 
 *
 * @author itkaka
 * @since 2023-05-11
 */
@Service
public class OrderServiceImpl extends ServiceImpl<OrderMapper, Order> implements IOrderService {

    @Resource
    private ISeckillGoodsService seckillGoodsService;
    @Autowired
    private OrderMapper orderMapper;
    @Autowired
    private ISeckillOrderService seckillOrderService;
    @Autowired
    private IGoodsService goodsService;
    @Autowired
    private RedisTemplate redisTemplate;

    // 秒杀
    @Override
    @Transactional
    public Order seckill(User user, GoodsVo goodsVo) {

        ValueOperations valueOperations = redisTemplate.opsForValue();

        // 秒杀商品减库存
        SeckillGoods seckillGoods = seckillGoodsService.getOne(new
                QueryWrapper<SeckillGoods>().eq("goods_id",goodsVo.getId()));
        seckillGoods.setStockCount(seckillGoods.getStockCount()-1);
        //seckillGoodsService.updateById(seckillGoods);

        //  解决库存超卖 扣减库存时候判断库存是否足够
        // seckillGoodsService.update(new UpdateWrapper().set("stock_count",
        //        seckillGoods.getStockCount()).eq("id",seckillGoods.getId()).gt("stock_count",0));

        //
        boolean seckillGoodsResult = seckillGoodsService.update(new UpdateWrapper<SeckillGoods>().set("stock_count",
                seckillGoods.getStockCount()).eq("id",seckillGoods.getId()).gt("stock_count",0));
       if ((seckillGoods.getStockCount())<1){
          // 判断是否还有库存
           valueOperations.set("isStockEmpty:"+ goodsVo.getId(),"0");
           return null;
       }
        // 生成订单
        Order order = new Order();
        order.setUserId(user.getId());
        order.setGoodsId(goodsVo.getId());
        order.setDeliverAddrId(0);
        order.setGoodsName(goodsVo.getGoodsName());
        order.setGoodsCount(1);
        order.setGoodsPrice(seckillGoods.getSeckillPrice());
        order.setOrderChannel(1);
        order.setStatus(0);
        order.setCreateDate(new Date());
        orderMapper.insert(order);
        //生成秒杀订单
        SeckillOrder seckillOrder = new SeckillOrder();
        seckillOrder.setUserId(user.getId());
        seckillOrder.setOrderId(order.getId());
        seckillOrder.setGoodsId(goodsVo.getId());
        seckillOrderService.save(seckillOrder);
        valueOperations.set("order:" + user.getId() + ":" + goodsVo.getId(), seckillOrder);

        return order;
    }
}

测试

项目启动，Redis预加载库存

秒杀成功，数据库及Redis库存数量正确

压测秒杀

QPS 相对而言有一定的提升

数据库以及 Redis 库存数量和订单都正确

优化 Redis 操作库存

发现小问题 : Redis 的库存会有问题, 原因是 Redis 没有做到原子性; 采用锁去解决
分布式锁

// 先进来的线程先占位,当别的线程进来操作,发现已经有人占位,会放弃或者稍后再尝试
// 线程操作执行完成以后,需要调用 del 指令释放位置
@SpringBootTest
class SeckillApplicationTests {
    @Autowired
    private RedisTemplate redisTemplate;
    
    @Test
    public void testLock01(){
        ValueOperations valueOperations = redisTemplate.opsForValue();
        Boolean isLock = valueOperations.setIfAbsent("k1", "v1");
        if (isLock){
            valueOperations.set("name","有锁测试1");
            String name = (String) valueOperations.get("name");
            System.out.println(name);
            redisTemplate.delete("k1");
        }else {
        	System.out.println("有线程在使用，请稍后");
        }
    }
}

// 为了防止业务执行过程中抛异常或者挂机导致 del 指令没办法调用形成死锁,可以添加超时时间
@Test
public void testLock02(){
     ValueOperations valueOperations = redisTemplate.opsForValue();
     Boolean isLock = valueOperations.setIfAbsent("k1","v1",5, TimeUnit.SECONDS);
     if (isLock){
       valueOperations.set("name","有锁测试2");
       String name = (String) valueOperations.get("name");
       System.out.println(name);
       redisTemplate.delete("k1");
     }else {
       System.out.println("有线程在使用，请稍后");
     }
}

上面例子，如果业务非常耗时会紊乱。举例：第一个线程首先获得锁，然后执行业务代码，但是业务代码耗时8秒，这样会在第一个线程的任务还未执行成功锁就会被释放，这时第二个线程会获取到锁开始执行，在第二个线程开执行了3秒，第一个线程也执行完了，此时第一个线程会释放锁，但是注意，他释放的第二个现成的锁，释放之后，第三个线程进来。
解决方案 :

尽量避免在获取锁之后，执行耗时操作
将锁的value设置为一个随机字符串，每次释放锁的时候，都去比较随机字符串是否一致，如果一致，再去释放，否则不释放。
释放锁时要去查看所得value，比较value是否正确，释放锁总共三个步骤，这三个步骤不具备原子性

Lua 脚本
Lua脚本优势：

使用方便，Redis内置了对Lua脚本的支持
Lua脚本可以在Rdis服务端原子的执行多个Redis命令
由于网络在很大程度上会影响到Redis性能，使用Lua脚本可以让多个命令一次执行，可以有效解决网络给Redis带来的性能问题

使用Lua脚本思路：

提前在Redis服务端写好Lua脚本，然后在java客户端去调用脚本
可以在java客户端写Lua脚本，写好之后，去执行。需要执行时，每次将脚本发送到Redis上去执行

创建 Lua 脚本( 在resources 目录下 )
lock.lua

if redis.call("get",KEYS[1])==ARGV[1] then
    return redis.call("del",KEYS[1])
else
    return 0
end

调用掉本

package com.itkaka.seckill.config;
// redis 配置类

    // @Bean
    // public DefaultRedisScript script() {
    // 	DefaultRedisScript redisScript = new DefaultRedisScript<>();
    // 	//lock.lua脚本位置和application.yml同级目录
    // 	redisScript.setLocation(new ClassPathResource("lock.lua"));
    // 	redisScript.setResultType(Boolean.class);
    // 	return redisScript;
    // }

@Test
public void testLock03(){
 ValueOperations valueOperations = redisTemplate.opsForValue();
 String value = UUID.randomUUID().toString();
   //给锁添加一个过期时间，防止应用在运行过程中抛出异常导致锁无法及时得到释放
 Boolean isLock = valueOperations.setIfAbsent("k1",value,5, TimeUnit.SECONDS);
 //没人占位
 if (isLock){
   valueOperations.set("name","xxxx");
   String name = (String) valueOperations.get("name");
   System.out.println(name);
   System.out.println(valueOperations.get("k1"));
   //释放锁
   Boolean result = (Boolean) redisTemplate.execute(script,Collections.singletonList("k1"), value);
   System.out.println(result);
 }else {
   //有人占位，停止/暂缓 操作
   System.out.println("有线程在使用，请稍后");
 }
}

优化 Redis 预减库存
stock.lua

if (redis.call('exists', KEYS[1]) == 1) then
  local stock = tonumber(redis.call('get', KEYS[1]));
  if (stock > 0) then
    redis.call('incrby', KEYS[1], -1);
    return stock;
  end;
  return 0;
end;

    @Bean
    public DefaultRedisScript<Long> script() {
        DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>();
        //放在和application.yml 同层目录下
        redisScript.setLocation(new ClassPathResource("stock.lua"));
        redisScript.setResultType(Long.class);
        return redisScript;
    }

SeckillController.java

// 秒杀
@RequestMapping(value = "/doSeckill", method = RequestMethod.POST)
@ResponseBody
public RespBean doSeckill(User user, Long goodsId) {
 if (user == null) {
   return RespBean.error(RespBeanEnum.SESSION_ERROR);
 }
 ValueOperations valueOperations = redisTemplate.opsForValue();
 //判断是否重复抢购
 String seckillOrderJson = (String) valueOperations.get("order:" +
user.getId() + ":" + goodsId);
 if (!StringUtils.isEmpty(seckillOrderJson)) {
   return RespBean.error(RespBeanEnum.REPEATE_ERROR);
 }
 //内存标记,减少Redis访问
 if (EmptyStockMap.get(goodsId)) {
   return RespBean.error(RespBeanEnum.EMPTY_STOCK);
 }
 //预减库存
 Long stock = (Long) redisTemplate.execute(script,
Collections.singletonList("seckillGoods:" + goodsId), Collections.EMPTY_LIST);
 if (stock < 0) {
   EmptyStockMap.put(goodsId,true);
   return RespBean.error(RespBeanEnum.EMPTY_STOCK);
 }
 // 请求入队，立即返回排队中
 SeckillMessage message = new SeckillMessage(user, goodsId);
 mqSender.sendsecKillMessage(JsonUtil.object2JsonStr(message));
 return RespBean.success(0);
}

安全优化

隐藏秒杀接口地址

秒杀开始前,先去请求接口获取秒杀地址

	/**
	 * 功能描述: 获取秒杀地址
	 */
	@AccessLimit(second = 5, maxCount = 5, needLogin = true)
	@RequestMapping(value = "/path", method = RequestMethod.GET)
	@ResponseBody
	public RespBean getPath(User user, Long goodsId, String captcha, HttpServletRequest request) {
		if (user == null) {
			return RespBean.error(RespBeanEnum.SESSION_ERROR);
		}
		boolean check = orderService.checkCaptcha(user, goodsId, captcha);
		if (!check) {
			return RespBean.error(RespBeanEnum.ERROR_CAPTCHA);
		}
		String str = orderService.createPath(user, goodsId);
		return RespBean.success(str);
	}

IOrderService.java

    // 校验秒杀地址
    boolean checkPath(User user,Long goodsId,String path);

    // 获取秒杀地址
    String createPath(User user,Long goodsId);

OrderServiceImpl.java

    // 获取秒杀地址
    @Override
    public String createPath(User user, Long goodsId) {
        String str = MD5Util.md5(UUIDUtil.uuid() + "123456");
        redisTemplate.opsForValue().set("seckillPath:" + user.getId() + ":" + goodsId, str, 60, TimeUnit.SECONDS);
        return str;
    }

    // 校验秒杀地址
    @Override
    public boolean checkPath(User user, Long goodsId, String path) {
        if (user == null || goodsId < 0 || StringUtils.isEmpty(path)) {
            return false;
        }
        String redisPath = (String) redisTemplate.opsForValue().get("seckillPath:" + user.getId() + ":" + goodsId);
        return path.equals(redisPath);
    }

goodsDetail.htm

function getSeckillPath() {
  var goodsId = $("#goodsId").val();
  g_showLoading();
  $.ajax({
    url: "/seckill/path",
    type: "GET",
    data: {
      goodsId: goodsId,
   },
    success: function (data) {
      if (data.code == 200) {
        var path = data.obj;
        doSeckill(path);
     } else {
        layer.msg(data.message);
     }
   }
   ,
    error: function () {
      layer.msg("客户端请求错误");
   }
 })
}
function doSeckill(path) {
  $.ajax({
    url: "/seckill/" + path + "/doSeckill",
    type: "POST",
    data: {
      goodsId: $("#goodsId").val(),
   },
    success: function (data) {
      if (data.code == 200) {
        // window.location.href = "/orderDetail.htm?orderId=" +
data.obj.id;
        getResult($("#goodsId").val());
     } else {
        layer.msg(data.message);
     }
   },
    error: function () {
      layer.msg("客户端请求错误");
   }
 })
}

先去请求接口获取秒杀地址

秒杀真正地址

图形验证码

点击秒杀开始前, 先输入验证码,分散用户请求
生成验证码
引入依赖 pom.xml


<dependency>
<groupId>com.github.whvcsegroupId>
<artifactId>easy-captchaartifactId>
<version>1.6.2version>
dependency>

SeckillController.java

// 验证码
	@RequestMapping(value = "/captcha", method = RequestMethod.GET)
	public void verifyCode(User user, Long goodsId, HttpServletResponse response) {
		if (user == null || goodsId < 0) {
			throw new GlobalException(RespBeanEnum.REQUEST_ILLEGAL);
		}
		//设置请求头为输出图片的类型
		response.setContentType("image/jpg");
		response.setHeader("Pargam", "No-cache");
		response.setHeader("Cache-Control", "no-cache");
		response.setDateHeader("Expires", 0);
		//生成验证码，将结果放入Redis
		ArithmeticCaptcha captcha = new ArithmeticCaptcha(130, 32, 3);
		redisTemplate.opsForValue().set("captcha:" + user.getId() + ":" + goodsId, captcha.text(), 300,
				TimeUnit.SECONDS);
		try {
			captcha.out(response.getOutputStream());
		} catch (IOException e) {
			log.error("验证码生成失败", e.getMessage());
		}
	}

验证验证码
SeckillController.java

/**
* 获取秒杀地址
*
* @param user
* @param goodsId
* @return
*/
@RequestMapping(value = "/path", method = RequestMethod.GET)
@ResponseBody
public RespBean getPath(User user, Long goodsId,String captcha) {
 if (user == null) {
   return RespBean.error(RespBeanEnum.SESSION_ERROR);
 }
 boolean check = orderService.checkCaptcha(user, goodsId, captcha);
 if (!check){
   return RespBean.error(RespBeanEnum.ERROR_CAPTCHA);
 }
 String str = orderService.createPath(user, goodsId);
 return RespBean.success(str);
}

IOrderService.java

boolean checkCaptcha(User user, Long goodsId, String captcha);  // 校验验证码

OrderServiceImpl.java

    // 校验验证码
    @Override
    public boolean checkCaptcha(User user, Long goodsId, String captcha) {
        if (StringUtils.isEmpty(captcha) || user == null || goodsId < 0) {
            return false;
        }
        String redisCaptcha = (String) redisTemplate.opsForValue().get("captcha:" + user.getId() + ":" + goodsId);
        return captcha.equals(redisCaptcha);
    }

测试
输入错误验证码,提示错误并且无法秒杀

接口限流

简单接口限流

SeckillController.java

@RequestMapping(value = "/path", method = RequestMethod.GET)
@ResponseBody
public RespBean getPath(User user, Long goodsId, String captcha,
HttpServletRequest request) {
 if (user == null) {
   return RespBean.error(RespBeanEnum.SESSION_ERROR);
 }
 ValueOperations valueOperations = redisTemplate.opsForValue();
 //限制访问次数，5秒内访问5次
 String uri = request.getRequestURI();
 //方便测试
 captcha = "0";
 Integer count = (Integer) valueOperations.get(uri + ":" + user.getId());
 if (count==null){
   valueOperations.set(uri + ":" + user.getId(),1,5,TimeUnit.SECONDS);
 }else if (count<5){
   valueOperations.increment(uri + ":" + user.getId());
 }else {
   return RespBean.error(RespBeanEnum.ACCESS_LIMIT_REACHED);
 }
 boolean check = orderService.checkCaptcha(user, goodsId, captcha);
 if (!check){
   return RespBean.error(RespBeanEnum.ERROR_CAPTCHA);
      String str = orderService.createPath(user, goodsId);
 return RespBean.success(str);
}

通用接口限流

UserContext.java

package com.itkaka.seckill.config;

import com.itkaka.seckill.pojo.User;

/**
 * 
 */
public class UserContext {

	private static ThreadLocal<User> userHolder = new ThreadLocal<User>();

	public static void setUser(User user) {
		userHolder.set(user);
	}

	public static User getUser() {
		return userHolder.get();
	}
}

UserArgumentResolver.java

package com.itkaka.seckill.config;

import com.itkaka.seckill.pojo.User;
import com.itkaka.seckill.service.IUserService;
import com.itkaka.seckill.utils.CookieUtil;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.MethodParameter;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.support.WebDataBinderFactory;
import org.springframework.web.context.request.NativeWebRequest;
import org.springframework.web.method.support.HandlerMethodArgumentResolver;
import org.springframework.web.method.support.ModelAndViewContainer;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * 自定义用户参数
 */
@Component
public class UserArgumentResolver implements HandlerMethodArgumentResolver {
	@Autowired
	private IUserService userService;

	@Override
	public boolean supportsParameter(MethodParameter parameter) {
		Class<?> clazz = parameter.getParameterType();
		return clazz == User.class;
	}

//	@Override
//	public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
//	                              NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
//
//		HttpServletRequest request = webRequest.getNativeRequest(HttpServletRequest.class);
//		HttpServletResponse response = webRequest.getNativeResponse(HttpServletResponse.class);
//		String ticket = CookieUtil.getCookieValue(request,"userTicket");
//		if (StringUtils.isEmpty(ticket)){
//			return null;
//		}
//
//		return userService.getUserByCookie(ticket,request,response);
//	}

	@Override
	public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
								  NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
		return UserContext.getUser();
	}
}

AccessInterceptor.java

package com.itkaka.seckill.config;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.itkaka.seckill.pojo.User;
import com.itkaka.seckill.service.IUserService;
import com.itkaka.seckill.utils.CookieUtil;
import com.itkaka.seckill.vo.RespBean;
import com.itkaka.seckill.vo.RespBeanEnum;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.concurrent.TimeUnit;

/**
 * 
 */
@Component
public class AccessLimitInterceptor implements HandlerInterceptor {

	@Autowired
	private IUserService userService;
	@Autowired
	private RedisTemplate redisTemplate;

	@Override
	public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
		if (handler instanceof HandlerMethod) {
			User user = getUser(request, response);
			UserContext.setUser(user);
			HandlerMethod hm = (HandlerMethod) handler;
			AccessLimit accessLimit = hm.getMethodAnnotation(AccessLimit.class);
			if (accessLimit == null) {
				return true;
			}
			int second = accessLimit.second();
			int maxCount = accessLimit.maxCount();
			boolean needLogin = accessLimit.needLogin();
			String key = request.getRequestURI();
			if (needLogin) {
				if (user == null) {
					render(response, RespBeanEnum.SESSION_ERROR);
					return false;
				}
				key += ":" + user.getId();
			}
			ValueOperations valueOperations = redisTemplate.opsForValue();
			Integer count = (Integer) valueOperations.get(key);
			if (count == null) {
				valueOperations.set(key, 1, second, TimeUnit.SECONDS);
			} else if (count < maxCount) {
				valueOperations.increment(key);
			} else {
				render(response, RespBeanEnum.ACCESS_LIMIT_REAHCED);
				return false;
			}
		}
		return true;
	}


	/**
	 * 功能描述: 构建返回对象
	 *
	 */
	private void render(HttpServletResponse response, RespBeanEnum respBeanEnum) throws IOException {
		response.setContentType("application/json");
		response.setCharacterEncoding("UTF-8");
		PrintWriter out = response.getWriter();
		RespBean respBean = RespBean.error(respBeanEnum);
		out.write(new ObjectMapper().writeValueAsString(respBean));
		out.flush();
		out.close();
	}

	/**
	 * 功能描述: 获取当前登录用户
	 *
	 */
	private User getUser(HttpServletRequest request, HttpServletResponse response) {
		String ticket = CookieUtil.getCookieValue(request, "userTicket");
		if (StringUtils.isEmpty(ticket)) {
			return null;
		}
		return userService.getUserByCookie(ticket, request, response);
	}
}

WebConfig.java

package com.itkaka.seckill.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.method.support.HandlerMethodArgumentResolver;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

import java.util.List;

/**
 * MVC配置类
 */
@Configuration
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {

	@Autowired
	private UserArgumentResolver userArgumentResolver;
	@Autowired
	private AccessLimitInterceptor accessLimitInterceptor;

	@Override
	public void addArgumentResolvers(List<HandlerMethodArgumentResolver> resolvers) {
		resolvers.add(userArgumentResolver);
	}

	@Override
	public void addResourceHandlers(ResourceHandlerRegistry registry) {
		registry.addResourceHandler("/**").addResourceLocations("classpath:/static/");
	}

	@Override
	public void addInterceptors(InterceptorRegistry registry) {
		registry.addInterceptor(accessLimitInterceptor);
	}
}

AccessLimit.java

package com.itkaka.seckill.config;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

// 自定义权限注解
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface AccessLimit {

   int second();

   int maxCount();

   boolean needLogin() default true;

}

SeckillController.java

	/**
	 * 功能描述: 获取秒杀地址
	 */
	@AccessLimit(second = 5, maxCount = 5, needLogin = true)
	@RequestMapping(value = "/path", method = RequestMethod.GET)
	@ResponseBody
	public RespBean getPath(User user, Long goodsId, String captcha, HttpServletRequest request) {
		if (user == null) {
			return RespBean.error(RespBeanEnum.SESSION_ERROR);
		}
		boolean check = orderService.checkCaptcha(user, goodsId, captcha);
		if (!check) {
			return RespBean.error(RespBeanEnum.ERROR_CAPTCHA);
		}
		String str = orderService.createPath(user, goodsId);
		return RespBean.success(str);
	}

至此 , 本次 Java 秒杀以及简单优化基本结束;
整体的项目目录结构如下图

后端接口基本写完了,剩余部分前台页面和静态资源尚未同步上传。

你可能感兴趣的:(JAVA,Java秒杀方案,Java实战项目,java,rabbitmq,redis)

Long类型前后端数据不一致 igotyback 前端
响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
LocalDateTime 转 String igotyback java 开发语言
importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类 qt 开发语言 sdl2 linux
需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
消息中间件有哪些常见类型 xmh-sxh-1314 java
消息中间件根据其设计理念和用途，可以大致分为以下几种常见类型：点对点消息队列（Point-to-PointMessagingQueues）：在这种模型中，消息被发送到特定的队列中，消费者从队列中取出并处理消息。队列中的消息只能被一个消费者消费，消费后即被删除。常见的实现包括IBM的MQSeries、RabbitMQ的部分使用场景等。适用于任务分发、负载均衡等场景。发布/订阅消息模型（Pub/Sub
《大清方方案》| 第二话谁佐清欢
和珅究竟说了些什么？竟能令堂堂九五之尊龙颜失色！此处暂且按下不表；单说这位乾隆皇帝，果真不愧是康熙从小带过的，一旦决定了要做的事，便杀伐决断毫不含糊。他当即亲自拟旨，着令和珅为钦差大臣，全权负责处理方方事件，并钦赐尚方宝剑，遇急则三品以下官员可先斩后奏。和珅身负皇上重托，岂敢有半点怠慢，当夜即率领相关人等，马不停蹄杀奔江汉。这一路上，和珅的几位幕僚一直在商讨方方事件的处置方案。有位年轻幕僚建议快刀
DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计网页设计期末网页作业 html静态网页 html5期末大作业网页设计 web大作业
️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
【华为OD机试真题2023B卷 JAVA&JS】We Are A Team 若博豆 java 算法华为 javascript
华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
深入理解 MultiQueryRetriever：提升向量数据库检索效果的强大工具 nseejrukjhad 数据库 python
深入理解MultiQueryRetriever：提升向量数据库检索效果的强大工具引言在人工智能和自然语言处理领域，高效准确的信息检索一直是一个关键挑战。传统的基于距离的向量数据库检索方法虽然广泛应用，但仍存在一些局限性。本文将介绍一种创新的解决方案：MultiQueryRetriever，它通过自动生成多个查询视角来增强检索效果，提高结果的相关性和多样性。MultiQueryRetriever的工
关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业 javascript html css 旅游风景
⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
HTML网页设计制作大作业（div+css）云南我的家乡旅游景点带文字滚动二挡起步 web前端期末大作业 web设计网页规划与设计 html css javascript dreamweaver 前端
Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
node.js学习小猿L node.js node.js 学习 vim
node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
CX8903：Ebike自行车仪表电源方案开发,Ebike智能仪表电源芯片诚芯微科技社交电子
CX8903：电动Ebike自行车仪表电源方案开发,Ebike智能仪表电源芯片推荐。电动助力自行车EBIKE凭借其环保、健康、低噪、和便捷等特点，成为了越来越受欢迎的骑行便利交通工具。提供电动Ebike自行车仪表电源方案开发、E-BIKE电动助力自行车仪表供电电源解决方案。CX8903采用100V高压制造工艺（芯片最高耐压可到100V以上），SOP-8L贴片封装，CX8903内置100V/90mΩ
CX8836：小体积大功率升降压方案推荐（附Demo设计指南）诚芯微科技社交电子
CX8836是一颗同步四开关单向升降压控制器，在4.5V-40V宽输入电压范围内稳定工作，持续负载电流10A，能够在输入高于或低于输出电压时稳定调节输出电压，可适用于USBPD快充、车载充电器、HUB、汽车启停系统、工业PC电源等多种升降压应用场合，为大功率TYPE-CPD车载充电器提供最优解决方案。提供CX8836Demo测试、CX8836样品申请及CX8836方案开发技术支持。CX8836同升
Redis系列：Geo 类型赋能亿级地图位置计算 Ly768768 redis bootstrap 数据库
1前言我们在篇深刻理解高性能Redis的本质的时候就介绍过Redis的几种基本数据结构，它是基于不同业务场景而设计的：动态字符串(REDIS_STRING)：整数(REDIS_ENCODING_INT)、字符串(REDIS_ENCODING_RAW)双端列表(REDIS_ENCODING_LINKEDLIST)压缩列表(REDIS_ENCODING_ZIPLIST)跳跃表(REDIS_ENCODI
ARM驱动学习之基础小知识 JT灬新一 ARM 嵌入式 arm开发学习
ARM驱动学习之基础小知识•sch原理图工程师工作内容–方案–元器件选型–采购（能不能买到，价格）–原理图（涉及到稳定性）•layout画板工程师–layout（封装、布局，布线，log）（涉及到稳定性）–焊接的一部分工作（调试阶段板子的焊接）•驱动工程师–驱动，原理图，layout三部分的交集容易发生矛盾•PCB研发流程介绍–方案，原理图(网表)–layout工程师（gerber文件）–PCB板
Low Power概念介绍-Voltage Area 飞奔的大虎
随着智能手机，以及物联网的普及，芯片功耗的问题最近几年得到了越来越多的重视。为了实现集成电路的低功耗设计目标，我们需要在系统设计阶段就采用低功耗设计的方案。而且，随着设计流程的逐步推进，到了芯片后端设计阶段，降低芯片功耗的方法已经很少了，节省的功耗百分比也不断下降。芯片的功耗主要由静态功耗（staticleakagepower）和动态功耗(dynamicpower)构成。静态功耗主要是指电路处于等
摩托车加装车载手机充电usb方案/雅马哈USB充电方案开发诚芯微科技社交电子
长途骑行需要给手机与行车记录仪等设备供电，那么，加装USB充电器就相继在两轮电动车上应用起来了。摩托车加装usb充电方案主要应用于汽车、电动自行车、摩托车、房车、渡轮、游艇等交通工具。提供电动车USB充电器方案/摩托车加装usb充电方案/渡轮加装usb充电方案/游艇加装usb充电方案开发。摩托车加装车载手机充电usb方案、汽车游艇改装四孔面板装双USB车充点烟器5V/4A电动车USB充电器输入4.
OPENAIGC开发者大赛企业组AI黑马奖 | AIGC数智传媒解决方案 RPA中国人工智能 AIGC 传媒
在第二届拯救者杯OPENAIGC开发者大赛中，涌现出一批技术突出、创意卓越的作品。为了让这些优秀项目被更多人看到，我们特意开设了优秀作品报道专栏，旨在展示其独特之处和开发者的精彩故事。无论您是技术专家还是爱好者，希望能带给您不一样的知识和启发。让我们一起探索AIGC的无限可能，见证科技与创意的完美融合！创未来AI应用赛-企业组AI黑马奖作品名称：AIGC数智传媒解决方案参赛团队：深圳市三象智能技术
Xinference如何注册自定义模型玩人工智能的辣条哥人工智能 AI 大模型 Xinference
环境：Xinference问题描述：Xinference如何注册自定义模型解决方案：1.写个model_config.json，内容如下{"version":1,"context_length":2048,"model_name":"custom-llama-3","model_lang":["en","ch"],"model_ability":["generate","chat"],"model
Java 重写(Override)与重载(Overload) 叨唧唧的
Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
简单了解 JVM 记得开心一点啊 jvm
目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven Energet!c 开发语言
1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
Java企业面试题3 马龙强_ java
1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
JVM、JRE和 JDK：理解Java开发的三大核心组件 Y雨何时停T Java java
Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选 java kafka
一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
白骑士的Java教学基础篇 2.5 控制流语句白骑士所长 Java 教学 java 开发语言
欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
python语法——三目运算符 HappyRocking python python 三目运算符
在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
ArrayList 源码解析程序猿进阶 Java基础 ArrayList List java 面试性能优化架构设计 idea
ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
网络通信流程记得开心一点啊服务器网络运维
目录♫IP地址♫子网掩码♫MAC地址♫相关设备♫ARP寻址♫网络通信流程♫IP地址我们已经知道IP地址由网络号+主机号组成，根据IP地址的不同可以有5钟划分网络号和主机号的方案：其中，各类地址的表示范围是：分类范围适用网络网络数量主机最大连接数A类0.0.0.0~127.255.255.255大型网络12616777214【(2^24)-2】B类128.0.0.0~191.255.255.255中
Java爬虫框架（一）--架构设计狼图腾-狼之传说 java 框架 java 任务 html解析器存储电子商务
一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
jvm调优总结（从基本概念到深度优化） oloz java jvm jdk 虚拟机应用服务器
JVM参数详解：http://www.cnblogs.com/redcreen/archive/2011/05/04/2037057.html Java虚拟机中，数据类型可以分为两类：基本类型和引用类型。基本类型的变量保存原始值，即：他代表的值就是数值本身；而引用类型的变量保存引用值。“引用值”代表了某个对象的引用，而不是对象本身，对象本身存放在这个引用值所表示的地址的位置。
【Scala十六】Scala核心十：柯里化函数 bit1129 scala
本篇文章重点说明什么是函数柯里化，这个语法现象的背后动机是什么，有什么样的应用场景，以及与部分应用函数(Partial Applied Function)之间的联系 1. 什么是柯里化函数 A way to write functions with multiple parameter lists. For instance def f(x: Int)(y: Int) is a
HashMap dalan_123 java
HashMap在java中对很多人来说都是熟的；基于hash表的map接口的非同步实现。允许使用null和null键；同时不能保证元素的顺序；也就是从来都不保证其中的元素的顺序恒久不变。 1、数据结构在java中，最基本的数据结构无外乎：数组和引用（指针），所有的数据结构都可以用这两个来构造，HashMap也不例外，归根到底HashMap就是一个链表散列的数据
Java Swing如何实时刷新JTextArea，以显示刚才加append的内容周凡杨 java 更新 swing JTextArea
在代码中执行完textArea.append("message")后，如果你想让这个更新立刻显示在界面上而不是等swing的主线程返回后刷新，我们一般会在该语句后调用textArea.invalidate()和textArea.repaint()。问题是这个方法并不能有任何效果，textArea的内容没有任何变化，这或许是swing的一个bug，有一个笨拙的办法可以实现
servlet或struts的Action处理ajax请求 g21121 servlet
其实处理ajax的请求非常简单，直接看代码就行了： //如果用的是struts //HttpServletResponse response = ServletActionContext.getResponse(); // 设置输出为文字流 response.setContentType("text/plain"); // 设置字符集 res
FineReport的公式编辑框的语法简介老A不折腾 finereport 公式总结
FINEREPORT用到公式的地方非常多，单元格（以=开头的便被解析为公式），条件显示，数据字典，报表填报属性值定义，图表标题，轴定义，页眉页脚，甚至单元格的其他属性中的鼠标悬浮提示内容都可以写公式。简单的说下自己感觉的公式要注意的几个地方： 1.if语句语法刚接触感觉比较奇怪，if(条件式子,值1,值2)，if可以嵌套，if(条件式子1，值1，if(条件式子2，值2，值3)
linux mysql 数据库乱码的解决办法墙头上一根草 linux mysql 数据库乱码
linux 上mysql数据库区分大小写的配置 lower_case_table_names=1 1-不区分大小写 0-区分大小写修改/etc/my.cnf 具体的修改内容如下: [client] default-character-set=utf8 [mysqld] datadir=/var/lib/mysql socket=/va
我的spring学习笔记6-ApplicationContext实例化的参数兼容思想 aijuans Spring 3
ApplicationContext能读取多个Bean定义文件，方法是： ApplicationContext appContext = new ClassPathXmlApplicationContext（ new String[]｛“bean-config1.xml”，“bean-config2.xml”，“bean-config3.xml”，“bean-config4.xml
mysql 基准测试之sysbench annan211 基准测试 mysql基准测试 MySQL测试 sysbench
1 执行如下命令，安装sysbench-0.5： tar xzvf sysbench-0.5.tar.gz cd sysbench-0.5 chmod +x autogen.sh ./autogen.sh ./configure --with-mysql --with-mysql-includes=/usr/local/mysql
sql的复杂查询使用案列与技巧百合不是茶 oracle sql 函数数据分页合并查询
本片博客使用的数据库表是oracle中的scott用户表; ------------------- 自然连接查询查询 smith 的上司(两种方法) &
深入学习Thread类 bijian1013 java thread 多线程 java多线程
一．线程的名字下面来看一下Thread类的name属性，它的类型是String。它其实就是线程的名字。在Thread类中，有String getName()和void setName(String)两个方法用来设置和获取这个属性的值。同时，Thr
JSON串转换成Map以及如何转换到对应的数据类型 bijian1013 java fastjson net.sf.json
在实际开发中，难免会碰到JSON串转换成Map的情况，下面来看看这方面的实例。另外，由于fastjson只支持JDK1.5及以上版本，因此在JDK1.4的项目中可以采用net.sf.json来处理。一.fastjson实例 JsonUtil.java package com.study; impor
【RPC框架HttpInvoker一】HttpInvoker：Spring自带RPC框架 bit1129 spring
HttpInvoker是Spring原生的RPC调用框架，HttpInvoker同Burlap和Hessian一样，提供了一致的服务Exporter以及客户端的服务代理工厂Bean，这篇文章主要是复制粘贴了Hessian与Spring集成一文，【RPC框架Hessian四】Hessian与Spring集成在【RPC框架Hessian二】Hessian 对象序列化和反序列化一文中
【Mahout二】基于Mahout CBayes算法的20newsgroup的脚本分析 bit1129 Mahout
#!/bin/bash # # Licensed to the Apache Software Foundation (ASF) under one or more # contributor license agreements. See the NOTICE file distributed with # this work for additional information re
nginx三种获取用户真实ip的方法 ronin47
随着nginx的迅速崛起，越来越多公司将apache更换成nginx. 同时也越来越多人使用nginx作为负载均衡, 并且代理前面可能还加上了CDN加速，但是随之也遇到一个问题：nginx如何获取用户的真实IP地址,如果后端是apache,请跳转到<apache获取用户真实IP地址>，如果是后端真实服务器是nginx，那么继续往下看。实例环境：用户IP 120.22.11.11
java-判断二叉树是不是平衡 bylijinnan java
参考了 http://zhedahht.blog.163.com/blog/static/25411174201142733927831/ 但是用java来实现有一个问题。由于Java无法像C那样“传递参数的地址，函数返回时能得到参数的值”，唯有新建一个辅助类：AuxClass import ljn.help.*; public class BalancedBTree {
BeanUtils.copyProperties VS PropertyUtils.copyProperties 诸葛不亮 PropertyUtils BeanUtils
BeanUtils.copyProperties VS PropertyUtils.copyProperties 作为两个bean属性copy的工具类，他们被广泛使用，同时也很容易误用，给人造成困然；比如：昨天发现同事在使用BeanUtils.copyProperties copy有integer类型属性的bean时，没有考虑到会将null转换为0，而后面的业
[金融与信息安全]最简单的数据结构最安全 comsci 数据结构
现在最流行的数据库的数据存储文件都具有复杂的文件头格式，用操作系统的记事本软件是无法正常浏览的，这样的情况会有什么问题呢？从信息安全的角度来看，如果我们数据库系统仅仅把这种格式的数据文件做异地备份，如果相同版本的所有数据库管理系统都同时被攻击，那么
vi区段删除 Cwind linux vi 区段删除
区段删除是编辑和分析一些冗长的配置文件或日志文件时比较常用的操作。简记下vi区段删除要点备忘。 vi概述引文中并未将末行模式单独列为一种模式。单不单列并不重要，能区分命令模式与末行模式即可。 vi区段删除步骤： 1. 在末行模式下使用:set nu显示行号非必须，随光标移动vi右下角也会显示行号，能够正确找到并记录删除开始行
清除tomcat缓存的方法总结 dashuaifu tomcat 缓存
用tomcat容器，大家可能会发现这样的问题，修改jsp文件后，但用IE打开依然是以前的Jsp的页面。出现这种现象的原因主要是tomcat缓存的原因。解决办法如下: 在jsp文件头加上 <meta http-equiv="Expires" content="0"> <meta http-equiv="kiben&qu
不要盲目的在项目中使用LESS CSS dcj3sjt126com Web less
　如果你还不知道LESS CSS是什么东西，可以看一下这篇文章，是我一朋友写给新人看的《CSS——LESS》　　不可否认，LESS CSS是个强大的工具，它弥补了css没有变量、无法运算等一些“先天缺陷”，但它似乎给我一种错觉，就是为了功能而实现功能。　　比如它的引用功能 ? .rounded_corners{
[入门]更上一层楼 dcj3sjt126com PHP yii2
更上一层楼通篇阅读完整个“入门”部分，你就完成了一个完整 Yii 应用的创建。在此过程中你学到了如何实现一些常用功能，例如通过 HTML 表单从用户那获取数据，从数据库中获取数据并以分页形式显示。你还学到了如何通过 Gii 去自动生成代码。使用 Gii 生成代码把 Web 开发中多数繁杂的过程转化为仅仅填写几个表单就行。本章将介绍一些有助于更好使用 Yii 的资源：
Apache HttpClient使用详解 eksliang httpclient http协议
Http协议的重要性相信不用我多说了，HttpClient相比传统JDK自带的URLConnection，增加了易用性和灵活性（具体区别，日后我们再讨论），它不仅是客户端发送Http请求变得容易，而且也方便了开发人员测试接口（基于Http协议的），即提高了开发的效率，也方便提高代码的健壮性。因此熟练掌握HttpClient是很重要的必修内容，掌握HttpClient后，相信对于Http协议的了解会
zxing二维码扫描功能 gundumw100 android zxing
经常要用到二维码扫描功能现给出示例代码 import com.google.zxing.WriterException; import com.zxing.activity.CaptureActivity; import com.zxing.encoding.EncodingHandler; import android.app.Activity; import an
纯HTML+CSS带说明的黄色导航菜单 ini html Web html5 css hovertree
HoverTree带说明的CSS菜单:纯HTML+CSS结构链接带说明的黄色导航在线体验效果：http://hovertree.com/texiao/css/1.htm代码如下,保存到HTML文件可以看到效果： <!DOCTYPE html > <html > <head> <title>HoverTree
fastjson初始化对性能的影响 kane_xie fastjson 序列化
之前在项目中序列化是用thrift，性能一般，而且需要用编译器生成新的类，在序列化和反序列化的时候感觉很繁琐，因此想转到json阵营。对比了jackson，gson等框架之后，决定用fastjson，为什么呢，因为看名字感觉很快。。。网上的说法： fastjson 是一个性能很好的 Java 语言实现的 JSON 解析器和生成器，来自阿里巴巴的工程师开发。
基于Mybatis封装的增删改查实现通用自动化sql mengqingyu DAO
1.基于map或javaBean的增删改查可实现不写dao接口和实现类以及xml，有效的提高开发速度。 2.支持自定义注解包括主键生成、列重复验证、列名、表名等 3.支持批量插入、批量更新、批量删除 <bean id="dynamicSqlSessionTemplate" class="com.mqy.mybatis.support.Dynamic
js控制input输入框的方法封装(数字，中文，字母，浮点数等) qifeifei javascript js
在项目开发的时候，经常有一些输入框，控制输入的格式，而不是等输入好了再去检查格式，格式错了就报错，体验不好。 /** 数字，中文，字母,浮点数(+/-/.) 类型输入限制，只要在input标签上加上 jInput="number,chinese,alphabet,floating" 备注：floating属性只能单独用*/ funct
java 计时器应用 tangqi609567707 java timer
mport java.util.TimerTask; import java.util.Calendar; public class MyTask extends TimerTask { private static final int
erlang输出调用栈信息 wudixiaotie erlang
在erlang otp的开发中，如果调用第三方的应用，会有有些错误会不打印栈信息，因为有可能第三方应用会catch然后输出自己的错误信息，所以对排查bug有很大的阻碍，这样就要求我们自己打印调用的栈信息。用这个函数：erlang:process_display (self (), backtrace).需要注意这个函数只会输出到标准错误输出。也可以用这个函数：erlang:get_s