SSM框架學習之高並發秒殺業務--筆記3-- Service層

上一節中已經包DAO層編寫完成了，所謂的DAO層就是所有和數據訪問的部分都應該放在這個層里，它負責與數據庫打交道。對於一個web項目來說，大概由這幾部分組成：

1. 前台的顯示層。

2. 分發處理請求的web層，這一層來用一些MVC框架。

3. 負責業務邏輯處理的Service層。

4. 負責與數據庫交互的DAO層

這樣有利於代碼的分離，以前上課時各種聽不懂，但書上有句話記得很清楚，那就是代碼的設計原則應該是“低耦合，高內聚”，MVC框架的設計正好體現了這個原則。廢話不多說，開始編碼。

第一步：Service接口的設計與實現

在org.seckill目錄下新建service包用來存放我們要編寫的service接口和實現類，新建exception包用來存放這個項目中我們自己定義業務的異常，新建dto包來存放業務數據傳輸對象。雖然老師這么說，但是后兩個包的具體用處還不是很理解，先繼續往下做，做完后再來分析。目錄結構

做到這里我又卡殼了，不知道該怎么繼續，不對照視頻的話還是有點生疏。那么就靜下心好好思考下吧。對於一個項目來說，主要的是完成各種用戶所需的功能，這些功能對應到程序中的就是各種接口和函數的定義，有的方法要有數據交互即有的方法要去存取修改數據庫。對於這些功能來說，都是在處理用戶的各種請求，服務器收到請求后，所做的第一件事情便是判斷該怎么處理這個請求呢？該用什么樣的方法來實現用戶這個請求所需要的功能呢？那么這一步就是一個"判斷—分發"的過程，使請求轉向服務器后端相應的方法去處理，這個功能主要是有MVC框架來完成。那么請求被轉到后端相應的方法去處理，對吧？那么對於請求的處理，即是一個業務功能的實現，一個方法的實現的話，本質上就是給一個方法（函數）一些東西（參數），然后再返回執行后的結果。對於方法來說可以分為兩部分：1. 業務邏輯 2. 數據交換。 也就是說方法在細分成這兩部分的話 可以得到     “方法—業務邏輯   方法—數據交換”  這兩個，那么我們可以將其相分離，業務邏輯的歸業務層，數據交換的歸DAO層，這樣可以很好的分離代碼，簡而言之就是權責分明的部門體系，各管各的，需要用到別的部門提供的服務時把這個部門的幾個相關的人叫過來就行了。

以上是作為菜鳥的我的一些理解，那么現在再想想下部該怎么做呢？有上面思考可以知道，無論是DAO還是Service層的設計，圍繞的是方法（接口）的設計，因為這就是項目要實現的功能，當你不知道要怎么往下做的時候，可以回想下自己到底想要做什么？我想要實現什么樣的功能呢？

在service包下建SeckillService接口，用來定義和Seckill(即秒殺商品)有關的業務操作(方法)。

SeckillService接口

package org.seckill.service;

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

import java.util.List;

/**
 * 業務接口:站在"使用者"角度設計接口
 * 三個方面：方法定一粒度，參數，返回類型/異常
 * Created by yuxue on 2016/10/15.
 */
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
     */
    SeckillExecution executeSeckill(long seckillId, long userPhone, String md5)
        throws SeckillException,RepeatKillException,SeckillCloseException;

    /**
     * 執行秒殺操作by 存儲過程
     * @param seckillId
     * @param userPhone
     * @param md5
     */
    SeckillExecution executeSeckillProdure(long seckillId, long userPhone, String md5);
}

關於這段的代碼的說明：

1.關於exportSeckillUrl(long seckillId)這個方法，這個方法的功能是：當用戶點商品詳情頁面想要秒殺商品時，如果在秒殺時間范圍之內就顯示就輸出秒殺接口地址讓前端顯示，否則輸出系統時間和秒殺時間。這里中要的是它的返回值，是個Exposer類的實例，Exposer是定義在dto包下的：

業務數據傳輸對象Exposer

package org.seckill.dto;

/**暴露秒殺地址DTO
 * Created by yuxue on 2016/10/15.
 */
public class Exposer {

    //是否開啟秒殺
    private boolean exposed;

    //一種加密措施
    private String md5;

    //id
    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.now = now;
        this.seckillId=seckillId;
        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;
    }

    @Override
    public String toString() {
        return "Exposer{" +
                "exposed=" + exposed +
                ", md5='" + md5 + '\'' +
                ", seckillId=" + seckillId +
                ", now=" + now +
                ", start=" + start +
                ", end=" + end +
                '}';
    }
}

前面說了，dto包是用來存放業務數據傳輸對象的，其中大部分與業務不相關，只是service返回的數據的封裝。對於exportSeckillUrl(long seckillId)這個方法，向前端輸出秒殺接口地址或者系統時間和這個商品的秒殺開始/結束時間，這里麻煩的一點便在於此，對於一個業務方法來說，他的返回可能比較復雜，會有多種數據成分，那么這時候需要將這些數據封裝成業務數據傳輸對象，這便是dto包里面的類的作用。對於這里的業務數據傳輸對象Exposer，封裝的信息有:1. 商品是否開啟標志位。2.加密字段MD5，這個字段由商品的id通過MD5加密算法生成，目的是防止數據被用戶使用的第三方工具篡改以及直接拼出秒殺地址。3. 商品的id，系統時間以及秒殺開始，結束時間。對應於這些字段定義了3個構造方法，對應不同的構造情況，因為可以秒殺以及不可以秒殺這兩種情況下需要向前端提供的數據不一樣。

接下來要分析的是executeSeckill(long seckillId, long userPhone, String md5)這個方法，這個方法負責具體的執行秒殺操作，返回的類型也是個業務數據傳輸對象SeckillExecution,這里為什么不直接返回個布爾型數據來表示執行秒殺操作成功與否呢？為什么要用個復雜的封裝類型呢？我自己理解是：對於一個方法的返回值的設計，你要看是誰調用了這個方法。在web項目中，調用Service層的業務的是web層，這層的具體任務就根據前端的請求調用相應的service來處理，處理完之后從service層中拿處理結果數據給前端顯示。對於執行秒殺操作這個業務方法，他的具體方法負責執行秒殺操作，對於調用它的web層，應給他提供執行秒殺操作后的相關信息，好讓它傳給前端顯示，所以這里如果只提供一個表示執行秒殺操作成功與否的布爾型值的話是肯定不夠的。

SeckillExecution

package org.seckill.dto;

import org.seckill.entity.SuccessKilled;
import org.seckill.enums.SeckillStatEnum;

/**封裝秒殺后執行的結果
 * Created by yuxue on 2016/10/15.
 */
public class SeckillExecution {

    private long seckillId;

    //秒殺執行結果狀態
    private int state;

    //狀態展示
    private String stateInfo;

    //秒殺成功對象
    private SuccessKilled successKilled;

    public SeckillExecution(long seckillId, SeckillStatEnum statEnum, SuccessKilled successKilled) {
        this.seckillId = seckillId;
        this.state = statEnum.getState();
        this.stateInfo = statEnum.getStateInfo();
        this.successKilled = successKilled;
    }

    public SeckillExecution(long seckillId, SeckillStatEnum statEnum) {
        this.seckillId = seckillId;
        this.state = statEnum.getState();
        this.stateInfo = statEnum.getStateInfo();
    }

    @Override
    public String toString() {
        return "SeckillExecution{" +
                "seckillId=" + seckillId +
                ", state=" + state +
                ", stateInfo='" + stateInfo + '\'' +
                ", successKilled=" + successKilled +
                '}';
    }

    public long getSeckillId() {
        return seckillId;
    }

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

    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 SuccessKilled getSuccessKilled() {
        return successKilled;
    }

    public void setSuccessKilled(SuccessKilled successKilled) {
        this.successKilled = successKilled;
    }
}

還有一點是這里把執行秒殺操作后的相關信息單獨封裝成對象，里面有各個秒殺商品的秒殺執行結果狀態，狀態展示等信息，這樣前端在顯示商品秒殺信息的時候直接從這里去取就好了，不必再通過其他的方法去service層一個一個字段的取，使得數據之間耦合度低。

SeckillExecution里有不同的構造方法，這是為了對應不同的情況，比如說如果商品秒殺成功了，那么則需要秒殺商品的id，狀態展示，以及秒殺成功對象這三個字段，如果秒殺失敗，則只需要秒殺商品的id，狀態展示便可以了。

這里的秒殺執行結果狀態使用枚舉類演示的，開發過程有個原則就是如果程序中用到了一些常量，那么最好將這些常量放到一處，在程序中引用這些常量即可，這樣便於修改。

在在org.seckill目錄下新建enums包，存放我們建的枚舉類。

枚舉類SeckillStatEnum

package org.seckill.enums;

/**
 * 使用枚舉表述常量數據
 * Created by yuxue on 2016/10/15.
 */
public enum SeckillStatEnum {
    //枚舉的使用
    SUCCESS(1,"秒殺成功"),
    END(0,"秒殺結束"),
    REPEAT_KILL(-1,"重復秒殺"),
    INNER_ERROR(-2,"系統異常"),
    DATA_REWRITE(-3,"數據篡改");

    private int state;

    private String stateInfo;

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

    public int getState() {
        return state;
    }

    public String getStateInfo() {
        return stateInfo;
    }

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

接口和枚舉定義完了，現在到了接口的實現

SeckillServiceImpl

package org.seckill.service.impl;

import org.seckill.dao.SeckillDao;
import org.seckill.dao.SuccessKilledDao;
import org.seckill.dto.Exposer;
import org.seckill.dto.SeckillExecution;
import org.seckill.entity.Seckill;
import org.seckill.entity.SuccessKilled;
import org.seckill.enums.SeckillStateEnum;
import org.seckill.exception.RepeatKillException;
import org.seckill.exception.SeckillCloseException;
import org.seckill.exception.SeckillException;
import org.seckill.service.SeckillService;
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 java.util.Date;
import java.util.List;

/**
 * Created by yuxue on 2016/11/7.
 */
@Service
public class SeckillServiceImpl implements SeckillService{
    private Logger logger = LoggerFactory.getLogger(this.getClass());

    @Autowired
    SeckillDao seckillDao;
    @Autowired
    SuccessKilledDao successKilledDao;

    //md5鹽值字符串，用於混淆MD5
    private String salty="sfsafas((888__```";

    public List<Seckill> getSeckillList( ) {
        return seckillDao.queryAllSeckill(0,4);
    }

    public Seckill querySeckill(int seckillId) {
        return seckillDao.queryById(seckillId);
    }

    //暴露秒殺接口地址的實現
    public Exposer exportSeckillUrl(long seckillId) {
        Seckill seckill=seckillDao.queryById(seckillId);
        if(seckill==null){
            return new Exposer(false,seckillId);
        }
        Date now=new Date();
        Date start=seckill.getStartTime();
        Date end=seckill.getEndTime();
        if(now.getTime()<start.getTime()||now.getTime()>end.getTime()){
            return new Exposer(false,seckillId,now,start,end);
        }
        String md5=getMD5(seckillId);
        return new Exposer(true,md5,seckillId);
    }

    //根據秒殺商品id來生成MD5密鑰
    private String getMD5(long seckillId){
        //拼接規則
        String base=seckillId+"/"+salty;
        String MD5= DigestUtils.md5DigestAsHex(base.getBytes());
        return MD5;
    }

    //執行秒殺方法的實現
    @Transactional
    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 now=new Date();
        try {
            int count = seckillDao.reduceNumber(seckillId, now);
            if (count <= 0) {
                throw new SeckillCloseException("秒殺關閉");
            } else {
                int update = successKilledDao.insertSuccessSeckilled(seckillId, userPhone);
                if (update <= 0) {
                    throw new RepeatKillException("重復秒殺");
                }else{
                    SuccessKilled successKilled=successKilledDao.queryByIdWithSeckill(seckillId, userPhone);
                    return new SeckillExecution(seckillId, SeckillStateEnum.SUCCESS,successKilled);
                }
            }
        }catch (SeckillCloseException e){
            throw e;
        }catch (RepeatKillException e){
            throw e;
        }catch (Exception e){
            logger.error(e.getMessage(),e);
            throw new SeckillException("Seckill inner error"+e.getMessage());
        }
    }
}

分析：

1. private Logger logger = LoggerFactory.getLogger(this.getClass()); 使用日志。

2. String MD5= DigestUtils.md5DigestAsHex(base.getBytes());使用java提供的API來生成MD5密鑰

3. 定義了3種異常SeckillException, RepeatKillException, SeckillCloseException分別是秒殺異常，重復秒殺，秒殺關閉。注意這里並不是程序的運行異常，是我們自定義的業務異常，這是一種思路：將業務中可能出現的我們不允許的部分如重復秒殺

等作為異常拋出再對應與相對的異常捕捉，分類處理。這個項目里首先是將所有的業務異常定義為SeckillException，在以它為父類細化為RepeatKillException和SeckillCloseException這兩個異常。

4. @Transactional注解將執行秒殺這個方法聲明為一個事務。

在org.seckill目錄下新建exception包用來存放我們的自定義的異常

SeckillException

package org.seckill.exception;

/**
 * 秒殺相關業務異常
 * Created by yuxue on 2016/10/15.
 */
public class SeckillException extends RuntimeException{
    public SeckillException(String message) {
        super(message);
    }

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

注意這里要繼承RuntimeException，因為對於java事務來說只有運行時異常時它才會回滾。

RepeatKillException 

package org.seckill.exception;

/**重復秒殺異常（運行期異常）
 *
 *
 * Spring事務只會接收運行期異常並回滾
 * Created by yuxue on 2016/10/15.
 */
public class RepeatKillException extends SeckillException{

    public RepeatKillException(String message){
        super(message);
    }

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

SeckillCloseException

package org.seckill.exception;

/**
 * Created by yuxue on 2016/10/15.
 */
public class SeckillCloseException extends SeckillException{
    public SeckillCloseException(String message) {
        super(message);
    }

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

 

第二步：基於Spring托管Service實現類，使用聲明式事務

讓Spring的IOC容器托管Service實現類，主要的是一些配置工作。通過對象工廠和依賴管理來達到一致性的訪問接口。

在resources目錄的spring文件目錄下新建spring-service.xml配置文件，區別於spring-dao.xml，表明這個配置文件是用來配置service層的。

spring-service.xml

<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-3.0.xsd">
    <!--掃描service包下所有使用注解的類型-->
    <context:component-scan base-package="org.seckill.service"/>

    <!--配置事務管理-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="datasource"/>
    </bean>

    <!--配置基於注解的聲明式事務
        默認使用注解來管理事務行為
    -->
    <tx:annotation-driven transaction-manager="transactionManager"/>

</beans>

 使用注解控制事務方法的優點以及注意的事項：

 1. 開發團隊一致的約定。

 2. 保證事務方法的執行時間經可能的短，不要穿插其他網絡操作RPC/HTTP請求或者剝離到事務方法外部，使得這個事務方法是個比較干凈的對數據庫的操作。

 3. 不是所有的方法都需要事務，如只有一條修改操作，只讀操作不需要事務控制。

 

第三步: Service層集成測試

 下面是測試用例SeckillServiceTest

package org.seckill.service;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.seckill.dto.Exposer;
import org.seckill.dto.SeckillExecution;
import org.seckill.entity.Seckill;
import org.seckill.exception.RepeatKillException;
import org.seckill.exception.SeckillCloseException;
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 java.util.List;

import static org.junit.Assert.*;

/**
 * Created by yuxue on 2016/10/15.
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({
        "classpath:spring/spring-dao.xml",
        "classpath:spring/spring-service.xml"})
public class SeckillServiceTest {
    private final Logger logger= LoggerFactory.getLogger(this.getClass());

    @Autowired
    private SeckillService seckillService;
    @Test
    public void getSeckillList() throws Exception {
        List<Seckill> list=seckillService.getSeckillList();
        logger.info("list={}",list);//這里的｛｝是個占位符
    }

    @Test
    public void getById() throws Exception {
        long id=1004;
        Seckill seckill=seckillService.getById(id);
        logger.info("seckill={}",seckill);
    }

    //集成測試代碼完整邏輯，注意可重復執行
    @Test
    public void exportSeckillLogic() throws Exception {
        long id=1005;
        Exposer exposer=seckillService.exportSeckillUrl(id);
        if(exposer.isExposed()) {
            logger.info("exposer={}", exposer);
            long phone=243242343L;
            String md5=exposer.getMd5();
            try{
                SeckillExecution seckillExecution=seckillService.executeSeckill(id,phone,md5);
                logger.info("result={}",seckillExecution);
            }catch (RepeatKillException e){
                logger.error(e.getMessage());
            }catch(SeckillCloseException e){
                logger.error(e.getMessage());
            }
        }else{
            logger.warn("exposer={}",exposer);
        }
    }
}

關於遇到的問題：

在自動注入seckillService時我把接口寫成了實現類SeckillServiceImpl結果報錯了，即spring在這里要注入接口，而注入接口的實現類就會報錯，如果在SeckillServiceImpl中將implements SeckillService刪除的話便能執行通過。網上搜了下這其中的原因，總結如下：

1. Spring的依賴注入功能使用Spring的動態代理機制來實現，而spring動態代理功能的實現是基於Java的動態代理機制的，jdk規定動態代理必須用接口,反而類注入則要通過cglib進行動態代理。

2. 為什么在SeckillServiceImpl中將implements SeckillService刪除的話便能執行通過？這里或許要涉及到在有接口和無接口情況下，Spring動態代理機制執行的不同。於是自己嘗試了下，其結果：

    (1)如果有接口，則注入后類型是

    

    說明是由Java的動態代理機制Proxy.newProxyInstance()方法創建一個代理對象來代理指定的類，個方法有三個參數：newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)，第一個參數為要代理的類，第二     個參數為這個類的接口（。。），第三個暫且不管，說明java實現動態代理的時候要求必須有接口類。

    (2)如果沒有用接口，即在SeckillServiceImpl中將implements SeckillService刪除然后用private SeckillServiceImpl這種方式注入的話，則注入后類型是

    

    可見如果是實現類的方式的話，Spring的動態代理機制是使用cglib進行動態代理的，關於這其中具體的技術細節還要日后仔細分析才行。

Service層的學習總結：

這節真的學到了好多好多啊，照着視頻敲的確沒什么問題，自己手打就會各種出錯，再次強調：學編程一定要自己手敲代碼，這樣才能發現自己不懂的地方。這節中的一些分析是基於我個人的理解，因為我是個菜鳥所以可能有些錯誤，所以希望技術大神發現的話能指點指點，非常感謝。其中的一些技術細節如動態代理什么的以后還要寫寫博文來仔細分析分析下，多敲敲代碼，多思考，這樣才能提高自己的技術水平。下一節開始web層的設計與開發。