2. 程式人生 > >三、高併發秒殺API之Service層設計實現

三、高併發秒殺API之Service層設計實現

阿新 • • 發佈：2019-01-31

Dao層設計與實現———-》介面設計和sql編寫

實現程式碼和SQL的分離，方便Review，dao層也叫做資料訪問層，是對遠端儲存系統執行操作的過程，這些操作統一存放在Dao層。

而通過Dao層組成的邏輯則是由Service來完成。

一、秒殺Service介面設計

這裡寫圖片描述

service包：存放我們的service介面和實現類
exception包：存放service層出現的異常，例如：重複秒殺商品異常、秒殺已關閉等異常
dto包：作為傳輸層，dto和entity的區別在於 entity用於業務資料的封裝，而dto用於完成web和service層的資料傳遞

service包:
建立Service介面SeckillService.java

package service;

import dto.Exposer;
import dto.SeckillExecution;
import entity.Seckill;
import exception.RepeatKillException;
import exception.SeckillCloseException;
import exception.SeckillException;

import java.util.List;

/**
 * @Author:peishunwu
 * @Description:
 * @Date:Created  2018/6/4
 */
public
 
 interface SeckillService {
    /**
     * 查詢所有秒殺記錄
     * @return
     */
    List<Seckill> getSeckillList();

    /**
     * 查詢單個秒殺記錄
     * @param seckillId
     * @return
     */
    Seckill  getById(long seckillId);

    /**
     * 秒殺開啟時輸出秒殺介面地址，
     * 否則輸出系統時間和秒殺時間
     * @param seckillId
     */
 

    Exposer exportSeckillUrl(long seckillId);

    /**
     * 執行秒殺操作
     * @param seckillId
     * @param userPhone
     * @param md5
     * @throws SeckillException 秒殺業務相關異常
     * @throws RepeatKillException 秒殺重複異常
     * @throws SeckillCloseException 秒殺關閉異常
     *
     */
    SeckillExecution executeSeckill(long seckillId, long userPhone, String md5)throws SeckillException, RepeatKillException, SeckillCloseException;
}

/**
* 秒殺開啟時輸出秒殺介面地址，
* 否則輸出系統時間和秒殺時間
* @param seckillId
*/
Exposer exportSeckillUrl(long seckillId);
Exposer.java:

package dto;

/**
 * @Author:peishunwu
 * @Description:暴露秒殺地址DTO
 * @Date:Created  2018/6/4
 */
public class Exposer {
    //是否開啟秒殺
    private boolean exposed;
    //一種加密處理
    private String md5;

    private long seckillId;

    //系統當前時間（毫秒）
    private long now;

    private long start;

    private long end;

    public Exposer(boolean exposed, String md5, long seckillId) {
        this.exposed = exposed;
        this.md5 = md5;
        this.seckillId = seckillId;
    }

    public Exposer(boolean exposed, long seckillId, long now, long start, long end) {
        this.exposed = exposed;
        this.md5 = md5;
        this.seckillId = seckillId;
        this.now = now;
        this.start = start;
        this.end = end;
    }

    public Exposer(boolean exposed, long seckillId) {
        this.exposed = exposed;
        this.seckillId = seckillId;
    }

    public boolean isExposed() {
        return exposed;
    }

    public void setExposed(boolean exposed) {
        this.exposed = exposed;
    }

    public String getMd5() {
        return md5;
    }

    public void setMd5(String md5) {
        this.md5 = md5;
    }

    public long getSeckillId() {
        return seckillId;
    }

    public void setSeckillId(long seckillId) {
        this.seckillId = seckillId;
    }

    public long getNow() {
        return now;
    }

    public void setNow(long now) {
        this.now = now;
    }

    public long getStart() {
        return start;
    }

    public void setStart(long start) {
        this.start = start;
    }

    public long getEnd() {
        return end;
    }

    public void setEnd(long end) {
        this.end = end;
    }
}

/**
* 執行秒殺操作
* @param seckillId
* @param userPhone
* @param md5
* @throws SeckillException 秒殺業務相關異常
* @throws RepeatKillException 秒殺重複異常
* @throws SeckillCloseException 秒殺關閉異常
*
*/

丟擲的三個異常：
秒殺業務相關異常SeckillException.java

package exception;

/**
 * @Author:peishunwu
 * @Description:秒殺業務相關異常
 * @Date:Created  2018/6/4
 */
public class SeckillException extends RuntimeException{
    public SeckillException(String message) {
        super(message);
    }

    public SeckillException(String message, Throwable cause) {
        super(message, cause);
    }
}

秒殺關閉異常SeckillCloseException.java

package exception;

/**
 * @Author:peishunwu
 * @Description:秒殺關閉異常，當秒殺結束時候使用者還要進行秒殺就會出現這個異常
 * @Date:Created  2018/6/4
 */
public class SeckillCloseException extends SeckillException{
    public SeckillCloseException(String message) {
        super(message);
    }

    public SeckillCloseException(String message, Throwable cause) {
        super(message, cause);
    }
}

秒殺重複異常RepeatKillException.java

package exception;

/**
 * @Author:peishunwu
 * @Description:重複秒殺異常，是一個執行期異常，不需要我們手動try catch
 * mysql只支援執行期異常的回滾操作
 * @Date:Created  2018/6/4
 */
public class RepeatKillException extends SeckillException{
    public RepeatKillException(String message) {
        super(message);
    }

    public RepeatKillException(String message, Throwable cause) {
        super(message, cause);
    }
}

二、秒殺Service介面實現

這裡寫圖片描述

Service包下建立impl包：存放service包介面的實現類

SeckillServiceImpl.java:

package service.impl;

import dao.SeckillDao;
import dao.SuccessKilledDao;
import dto.Exposer;
import dto.SeckillExecution;
import entity.Seckill;
import entity.SuccessKilled;
import enums.SeckillStateEnum;
import exception.RepeatKillException;
import exception.SeckillCloseException;
import exception.SeckillException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.DigestUtils;
import service.SeckillService;

import java.util.Date;
import java.util.List;

/**
 * @Author:peishunwu
 * @Description:
 * @Date:Created  2018/6/4
 */
public class SeckillServiceImpl implements SeckillService {
    private Logger logger = LoggerFactory.getLogger(SeckillServiceImpl.class);

    private SeckillDao seckillDao;

    private SuccessKilledDao successKilledDao;

    //md5鹽值字串，用於混淆md5;
    private final String salt="jnqw&o4ut922v#y54vq34U#*mn4v";
    @Override
    public List<Seckill> getSeckillList() {
        return seckillDao.queryAll(0,4);
    }

    @Override
    public Seckill getById(long seckillId) {
        return seckillDao.queryById(seckillId);
    }

    @Override
    public Exposer exportSeckillUrl(long seckillId) {
        Seckill seckill = seckillDao.queryById(seckillId);
        if(seckill == null){
            return new Exposer(false,seckillId);
        }
        Date startTime = seckill.getStartTime();
        Date endTime = seckill.getEndTime();
        //系統當前時間
        Date nowTime = new Date();
        if(nowTime.getTime() < startTime.getTime() || nowTime.getTime()>endTime.getTime()){
            return new Exposer(false,seckillId,nowTime.getTime(),startTime.getTime(),endTime.getTime());
        }
        String md5 = getMD5(seckillId);
        return new Exposer(true,md5,seckillId);
    }

    private String getMD5(long seckillId){
        String base = seckillId+"/"+salt;
        //通過鹽值轉化為加密資料
        String md5 = DigestUtils.md5DigestAsHex(base.getBytes());
        return md5;
    }
    //秒殺是否成功，成功：減庫存，增加明細；失敗：丟擲異常，事務回滾
    @Override
    public SeckillExecution executeSeckill(long seckillId, long userPhone, String md5) throws SeckillException, RepeatKillException, SeckillCloseException {
        if(md5 == null || !md5.equals(getMD5(seckillId))){
            throw new SeckillException("秒殺資料被重寫了 (seckill data rewrite)");//秒殺資料被重寫了
        }
        //執行秒殺邏輯：減庫存+增加購買明細
        Date nowTime = new Date();
        try{
            //減庫存
            int updateCount = seckillDao.reduceNumber(seckillId,nowTime);
            if(updateCount <= 0){
                //沒有更新庫存記錄，說明秒殺結束
                throw new SeckillCloseException("說明秒殺結束(seckill is closed)");
            }else {
                //否則更新庫存成功，秒殺成功，增加明細
                int insertCount = successKilledDao.insertSuccessKilled(seckillId,userPhone);
               //看是否該明細被重複插入，即使用者是否重複秒殺
                if(insertCount <= 0){
                    throw new RepeatKillException("重複秒殺（seckill repeated）");
                }else{
                    //秒殺成功，得到成功插入的明細記錄，並返回秒殺資訊
                    SuccessKilled successKilled = successKilledDao.queryByIdWithSeckill(seckillId,userPhone);
                    return new SeckillExecution(seckillId,SeckillStateEnum.SUCCESS,successKilled);
                }
            }

        }catch (SeckillCloseException e1){
            throw e1;
        }catch (RepeatKillException e2){
            throw e2;
        }catch (Exception e){
            logger.error(e.getMessage(),e);
            //所以編譯期異常轉化為執行期異常
            throw new SeckillException(""+e.getMessage());
        }
    }
}

在上述方法中， return new SeckillExecution(seckillId,SeckillStateEnum.SUCCESS,successKilled);
其中SeckillStateEnum.SUCCESS這個表示的是一種操作執行的狀態，用來輸出給前端，通常用資料欄位記錄這些狀態。
在這裡考慮用列舉封存常量表示狀態，實現資料字典；

建立列舉
SeckillStateEnum.java:

package enums;

/**
 * @Author:peishunwu
 * @Description:使用列舉表示常量資料字典
 * @Date:Created  2018/6/4
 */
public enum SeckillStateEnum {
    SUCCESS(1,"秒殺成功"),
    END(0,"秒殺結束"),
    REPEAT_KILL(-1,"重複秒殺"),
    INNER_ERROR(-2,"系統異常"),
    DATA_REWRITE(-3,"資料篡改");

    private int state;

    private String stateInfo;

    SeckillStateEnum(int state, String stateInfo) {
        this.state = state;
        this.stateInfo = stateInfo;
    }

    public int getState() {
        return state;
    }

    public void setState(int state) {
        this.state = state;
    }

    public String getStateInfo() {
        return stateInfo;
    }

    public void setStateInfo(String stateInfo) {
        this.stateInfo = stateInfo;
    }

    public static SeckillStateEnum stateOf(int index){
        for(SeckillStateEnum state : values()){
            if(state.getState() == index){
                return state;
            }
        }
        return null;
    }
}

修改秒殺操作的非業務類SeckillExcution.java裡面涉及到的state和stateInfo引數的構造方法，將其替換為列舉型別：
SeckillExecution .java

package dto;

import entity.SuccessKilled;
import enums.SeckillStateEnum;

/**
 * @Author:peishunwu
 * @Description:封裝秒殺執行後的結果
 * @Date:Created  2018/6/4
 */
public class SeckillExecution {
    private long seckillId;
    //秒殺執行結果狀態
    private int state;
    //狀態表示
    private String stateInfo;
    //秒殺成功物件
    private SuccessKilled successKilled;
    public SeckillExecution(long seckillId, SeckillStateEnum seckillStateEnum, SuccessKilled successKilled) {
        super();
        this.seckillId = seckillId;
    }
    public SeckillExecution(long seckillId, SeckillStateEnum stateEnum) {
        super();
        this.seckillId = seckillId;
        this.state = stateEnum.getState();
        this.stateInfo = stateEnum.getStateInfo();
    }

}

至此，Service介面實現類實現完成，接下來要將Service交付給Spring容器託管，主要是進行一些配置。

三、基於Spring的Service依賴管理

Spring託管Service，實際就是通過Spring IOC管理依賴，主要通過依賴注入。

利用物件工程這些依賴進行依賴管理，給出一致的訪問介面，通過applicationContext或者註解來拿到一個管理例項。

這裡寫圖片描述

那麼對該專案有哪些依賴呢？

這裡寫圖片描述

那麼，為什麼使用Spring IOC呢？

  • 物件的建立統一託管
  • 規範的生命週期的管理
  • 靈活的依賴注入
  • 一致的物件注入

Spring-IOC注入方式和場景是怎樣的？

這裡寫圖片描述

實現：
在spring包下面建立一個檔案spring-service.xml檔案：用於掃描service類

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
         http://www.springframework.org/schema/beans/spring-beans.xsd
         http://www.springframework.org/schema/context
         http://www.springframework.org/schema/context/spring-context-3.0.xsd
         http://www.springframework.org/schema/tx
         http://www.springframework.org/schema/tx/spring-tx.xsd
         " >
    <!--掃描service包下素有使用註解型別-->
    <context:component-scan base-package="service"/>
</beans>

然後採用註解的方式將Service介面的實現類新增到SpringIOC容器中對其進行管理：
這裡寫圖片描述

package service.impl;

import dao.SeckillDao;
import dao.SuccessKilledDao;
import dto.Exposer;
import dto.SeckillExecution;
import entity.Seckill;
import entity.SuccessKilled;
import enums.SeckillStateEnum;
import exception.RepeatKillException;
import exception.SeckillCloseException;
import exception.SeckillException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.DigestUtils;
import service.SeckillService;

import java.util.Date;
import java.util.List;

/**
 * @Author:peishunwu
 * @Description:
 * @Date:Created  2018/6/4
 */
@Service
public class SeckillServiceImpl implements SeckillService {
    private Logger logger = LoggerFactory.getLogger(SeckillServiceImpl.class);
    @Autowired
    private SeckillDao seckillDao;
    @Autowired
    private SuccessKilledDao successKilledDao;

    //md5鹽值字串，用於混淆md5;
    private final String salt="jnqw&o4ut922v#y54vq34U#*mn4v";
    @Override
    public List<Seckill> getSeckillList() {
        return seckillDao.queryAll(0,4);
    }

    @Override
    public Seckill getById(long seckillId) {
        return seckillDao.queryById(seckillId);
    }

    @Override
    public Exposer exportSeckillUrl(long seckillId) {
        Seckill seckill = seckillDao.queryById(seckillId);
        if(seckill == null){
            return new Exposer(false,seckillId);
        }
        Date startTime = seckill.getStartTime();
        Date endTime = seckill.getEndTime();
        //系統當前時間
        Date nowTime = new Date();
        if(nowTime.getTime() < startTime.getTime() || nowTime.getTime()>endTime.getTime()){
            return new Exposer(false,seckillId,nowTime.getTime(),startTime.getTime(),endTime.getTime());
        }
        String md5 = getMD5(seckillId);
        return new Exposer(true,md5,seckillId);
    }

    private String getMD5(long seckillId){
        String base = seckillId+"/"+salt;
        //通過鹽值轉化為加密資料
        String md5 = DigestUtils.md5DigestAsHex(base.getBytes());
        return md5;
    }
    //秒殺是否成功，成功：減庫存，增加明細；失敗：丟擲異常，事務回滾
    /*使用註解控制事務方法的優點：
    1、開發團隊達成一致約定，明確標註事務方法的程式設計風格
    2、保證事務方法的執行時間儘可能短，不要穿插其他網路操作（RPC/HTTP請求），或者剝離到事務方法外部
    3、不是所有的方法都需要事務，如只有一條修改操作或只讀操作不需要事務控制*/
    @Transactional
    @Override
    public SeckillExecution executeSeckill(long seckillId, long userPhone, String md5) throws SeckillException, RepeatKillException, SeckillCloseException {
        if(md5 == null || !md5.equals(getMD5(seckillId))){
            throw new SeckillException("秒殺資料被重寫了 (seckill data rewrite)");//秒殺資料被重寫了
        }
        //執行秒殺邏輯：減庫存+增加購買明細
        Date nowTime = new Date();
        try{
            //減庫存
            int updateCount = seckillDao.reduceNumber(seckillId,nowTime);
            if(updateCount <= 0){
                //沒有更新庫存記錄，說明秒殺結束
                throw new SeckillCloseException("說明秒殺結束(seckill is closed)");
            }else {
                //否則更新庫存成功，秒殺成功，增加明細
                int insertCount = successKilledDao.insertSuccessKilled(seckillId,userPhone);
               //看是否該明細被重複插入，即使用者是否重複秒殺
                if(insertCount <= 0){
                    throw new RepeatKillException("重複秒殺（seckill repeated）");
                }else{
                    //秒殺成功，得到成功插入的明細記錄，並返回秒殺資訊
                    SuccessKilled successKilled = successKilledDao.queryByIdWithSeckill(seckillId,userPhone);
                    return new SeckillExecution(seckillId,SeckillStateEnum.SUCCESS,successKilled);
                }
            }

        }catch (SeckillCloseException e1){
            throw e1;
        }catch (RepeatKillException e2){
            throw e2;
        }catch (Exception e){
            logger.error(e.getMessage(),e);
            //所以編譯期異常轉化為執行期異常
            throw new SeckillException(""+e.getMessage());
        }
    }
}

對Service類使用@Service註解表明這是一個Service類，注入SpringIOC容器被管理。
對要使用的例項使用@Autowired宣告，實現例項的獲取，並自動注入。

接下來，我們來運用Spring宣告式事務對我們專案中的事務進行管理。

四、使用Spring宣告式事務配置管理事務 ##、

事務管理流程：事務開啟——》修改SQL1，修改SQL2，修改SQLn——–》提交/回滾事務

現在使用第三方框架管理這個流程，使其擺脫事務編碼，這個叫做宣告式事務，
方式一、早期的spring管理事務是ProxyFactoryBean+XML的方式
方式二、後來添加了tx:advice+aop名稱空間使得一次配置永久生效
方式三、使用註解@Transactional來控制事務，也是推薦的一種方式

為什麼推薦使用註解控制事務呢？

1、開發團隊達成一致約定，明確標註事務方法的程式設計風格
2、保證事務方法的執行時間儘可能短，不要穿插其他網路操作（RPC/HTTP請求），或者剝離到事務方法外部
3、不是所有的方法都需要事務，如只有一條修改操作或者只讀操作不需要事務。
事務方法巢狀，是宣告式事務獨有的概念，主要體現在其傳播行為上。

什麼時候回滾事務？

丟擲執行期異常（RuntimeException）可以回滾，如果丟擲非執行期異常（部分成功、部分失敗），則不會回滾，所以拋異常的時候一定要小心不當的try-catch；

實現：在上面的spring-service中新增對事物的配置
這裡寫圖片描述

<!--配置事務管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
         <!--注入資料庫連線池，在spring-dao.xml中已經配置，此處引用即可-->
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <!--配置基於註解的宣告式事務，預設使用註解來管理事務行為-->

然後，在Service介面實現類的方法中，在需要事務宣告的方法上加上事務的註解：
這裡寫圖片描述

五、Service整合測試

整合測試Dao層和Service層。

建立SeckillServiceTest.java測試類

package dao;


import dto.Exposer;
import dto.SeckillExecution;
import entity.Seckill;
import exception.RepeatKillException;
import exception.SeckillCloseException;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import service.SeckillService;

import java.util.List;

/**
 * @Author:peishunwu
 * @Description:
 * @Date:Created  2018/6/4
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({
        "classpath:spring/spring-dao.xml",
        "classpath:spring/spring-service.xml"
})
public class SeckillServiceTest {
    private final Logger logger = LoggerFactory.getLogger(SeckillServiceTest.class);

    @Autowired
    private SeckillService seckillService;


    @Test
    public void getSeckillListTest()throws Exception{
        List<Seckill> list = seckillService.getSeckillList();
        logger.info("list="+list.toString());
        System.out.println(list.toString());
        for(Seckill sk : list){
            System.out.println(sk);
        }
    }

    //完整的邏輯程式碼整合測試
    @Test
    public void testExportSeckillLogic()throws Exception{
        long id = 1001;
        Exposer exposer = seckillService.exportSeckillUrl(id);
        //判斷秒殺是否開啟，如果開啟則保留地址和鹽值md5開始秒殺
        if(exposer.isExposed()){

            System.out.println(exposer);

            long userPhone = 15718879112L;
            String md5 = exposer.getMd5();
            try{
                SeckillExecution seckillExecution = seckillService.executeSeckill(id,userPhone,md5);
            }catch (RepeatKillException e){
                e.printStackTrace();
            }catch (SeckillCloseException e1){
                e1.printStackTrace();
            }
        }else {
            System.out.println("秒殺未開啟");
        }
    }

    //單獨執行測試
    public void testExecuteSeckill()throws Exception{
        long id = 1001;
        long phone = 15718879112L;
        String md5 = "1da8af7e7ad6829f9eb2e6f18cb45225";
        try {
            SeckillExecution seckillExecution = seckillService.executeSeckill(id, phone, md5);
            logger.info("result={}",seckillExecution);
            System.out.println(seckillExecution);
        }catch (RepeatKillException e)
        {
            e.printStackTrace();
        }catch (SeckillCloseException e1)
        {
            e1.printStackTrace();
        }
    }
}

單元測試getSeckillListTest()和getByIdTest()方法，可以查詢出秒殺的商品列表和秒殺單一商品詳情。

執行testExportSeckillLogic()進行邏輯上的整合測試：首先判斷秒殺狀態，如果在秒殺時間內則生成秒殺連線並返回exposer【 Exposer exposer=seckillService.exportSeckillUrl(id);】，繼續利用生成的URL資訊執行秒殺【SeckillExecutionexecution=seckillService.executeSeckill(id, phone, md5);】，返回一個秒殺結果，輸出秒殺結果即可。

重複秒殺會丟擲異常，不可重複秒殺，為了不使其報錯，這裡try-catch掉即可。

相關推薦

三、高併發秒殺API之Service層設計實現

Dao層設計與實現———-》介面設計和sql編寫 實現程式碼和SQL的分離，方便Review，dao層也叫做資料訪問層，是對遠端儲存系統執行操作的過程，這些操作統一存放在Dao層。 而通過Dao層組成的邏輯則是由Service來完成。 一、秒殺Serv

二、高併發秒殺API之Dao層設計實現

一、Idea建立maven 1、File——-》new———》project 2、選擇maven 點選next！ 3、輸出專案名，包(表示web專案，以後可以spingMVC連起來用) 點選next！ 4、如下圖 maven倉庫可以選擇

Java高併發秒殺API之service層實現（二）

二 service層實現 1.內容 站在使用者的角度設計介面 三個方向 ：方法粒度，引數，返回型別 2.程式碼 SeckillService package org.seckill.service; import java.util.L

【JAVA高併發秒殺API之DAO層】課程筆記

最近在慕課網上學習了【JAVA高併發秒殺API】系列課程，在此整理課程內容！ 課程收穫：1、學習瞭如何通過maven建立web專案，pom.xml 檔案依賴管理。                

SpringBoot實現Java高併發秒殺系統之Service層開發（二）

繼上一篇文章：SpringBoot實現Java高併發秒殺系統之DAO層開發 我們建立了SpringBoot專案並熟悉了秒殺系統的表設計，下面我們將講解一下秒殺系統的核心部分：Service業務層的開發。 Service層又稱為業務層，在Spring階段主要是由@

SpringBoot實現Java高併發秒殺系統之Web層開發（三）

接著上一篇文章：SpringBoot實現Java高併發之Service層開發，今天我們開始講SpringBoot實現Java高併發秒殺系統之Web層開發。 Web層即Controller層，當然我們所說的都是在基於Spring框架的系統上而言的，傳統的SSH專案

慕課網-java高併發秒殺api之高併發優化-總結

1.架構優化 2.spring宣告式事務 宣告式事務：http://www.open-open.com/lib/view/open1414310646012.html 配置並使用Spring宣告式事務 在spring-service.xml中新增上配置事務管理器 <

Java高併發秒殺API之高併發優化（四）

四 高併發優化 1.分析 1.詳情頁 部署到cdn上，這樣使用者訪問的是cdn不是伺服器了。 使用者在上網時通過運營商訪問最近的都會網路，都會網路訪問主幹網。 2.獲取系統時間 不用優化 訪問一次記憶體大概 10ns 無法使用cdn，適合伺服

SpringBoot實現Java高併發秒殺系統之DAO層開發（一）

秒殺系統在如今電商專案中是很常見的，最近在學習電商專案時講到了秒殺系統的實現，於是打算使用SpringBoot框架學習一下秒殺系統（本專案基於慕課網的一套免費視訊教程：Java高併發秒殺API，視訊教程中講解的很詳細，非常感謝這位講師）。也是因為最近學習了Spr

SSM專案實戰（一）--- 高併發秒殺系統之DAO層

專案為慕課網上 搞定Java SSM框架開發的綜合案例–實現一個秒殺系統案例。 1.首先搭建專案 使用Maven構建來管理依賴項，pom.xml檔案： 此pom.xml可作為大多數ssm專案依賴的參考 <project xmlns="http:

Java高併發秒殺API(三)之Web層

1. 設計前的分析 Web層內容相關 前端互動設計 Restful規範 SpringMVC Bootstrap + jQuery 前端頁面流程 詳情頁流程邏輯 為什麼要獲取標準系統時間（伺服器的時間

Java高併發秒殺API(二)之Service層

1. 設計前的分析 分層的必要性 DAO層工作演變為:介面設計+SQL編寫（不需要其他雜七雜八的功能） 程式碼和SQL的分離,方便review（瀏覽） DAO拼接等邏輯在Service層完成（DAO只需負責SQL語句，其他都由Servi

Java高併發秒殺API(四)之高併發優化

1. 高併發優化分析 關於併發 併發性上不去是因為當多個執行緒同時訪問一行資料時，產生了事務，因此產生寫鎖，每當一個獲取了事務的執行緒把鎖釋放，另一個排隊執行緒才能拿到寫鎖，QPS(Query Per Second每秒查詢率)和事務執行的時間

SpringBoot實現Java高併發秒殺系統之併發優化

秒殺系統架構的設計和優化分析，以我一個小菜雞，目前是說不出來的o(╥﹏╥)o。 因此呢，我這裡僅從本專案已經實現的優化來介紹一下： 本專案中做到了以下優化： 秒殺介面採用md5加密方式防刷。 訂單表使用聯合主鍵方式，限制一個使用者只能購買該商品一次。 配合Spring事務

2017.4.26 慕課網--Java 高併發秒殺API（一）

Java高併發秒殺API系列（一）                  -----------------業務分析及Dao層 第一章 課程介紹 1.1 內容介紹及業務分析 （1）課程內容 1 SSM框架的整合使用 2 秒殺類系統需求理解和實現 3 常用技術解決高併發問題 （

JAVA高併發秒殺API專案的學習筆記

設計Restful介面 SpringMVC整合Spring 在web.xml中配置DispatcherServlet建立web包建立spring-web.xml配置檔案 在spring-web.xml進行SpringMVC的配置 開啟SpringMVC註解模式servl

02 整合IDEA+Maven+SSM框架的高併發的商品秒殺專案之Service層

首先在編寫Service層程式碼前，我們應該首先要知道這一層到底是幹什麼的。Service層主要負責業務模組的邏輯應用設計。同樣是首先設計介面，再設計其實現的類，接著在Spring的配置檔案中配置其實現的關聯。這樣我們就可以在應用中呼叫Service介面來進行業

五、高併發秒殺系統高併發優化

前面的四篇部落格已經將基本的餓秒殺系統完成，本人按照教程一步一步敲程式碼、測試完成。現在將學習如何在上面的基礎上對這個秒殺系統進行優化。 這篇將學習一下內容： 1、高併發系統優化思路分析 2、高併發優化技巧 動靜態資源分離： CND（內容分發網路

Java高併發秒殺系統API之SSM框架整合swagger與AdminLTE

初衷與整理描述 Java高併發秒殺系統API是來源於網上教程的一個Java專案，也是我接觸Java的第一個專案。本來是一枚c#碼農，公司計劃部分業務轉java,於是我利用業務時間自學Java才有了本文，本來接觸之初聽別人說，c#要轉java很容易，我也信

高併發秒殺系統架構設計 · 搶購、微信紅包、一元奪寶

秒殺業務在各業務中已然非常流行，這裡我將網際網路行業中的秒殺定義為：在非常短的時間內，將一件商品分成多份進行購買的行為。微信搶紅包、一元奪寶、雙11大促搶購等業務本質上都可視作秒殺業務。而最近大熱的搶紅包的難度在於這是和錢打交道的秒殺場景，對於事務的要求性更高。秒殺業務的