java b2b2c多用户开源商城系统基于脚本引擎的促销架构源码分享

需求分析

• 在分享源码之前，先将b2b2c系统中促销模块需求整理、明确，方便源码的理解。

业务需求

• b2b2c电子商务系统中促销活动相关规则需以脚本数据的方式存放至redis缓存，在购物车与结算页面计算商品价格时从redis缓存中获取促销规则信息，实现商品价格的计算。

技术需求

1. 促销规则脚本需要使用freemarker模板引擎，需向其中设置内置变量。
2. 渲染脚本和调用脚本的方法放入工具类中，方便随时调用。

架构思路

一、脚本生成规则

1、需要生成脚本引擎的促销活动包括：满减满赠、单品立减、第二件半价、团购、限时抢购、拼团、优惠券和积分兑换。

2、根据促销活动规则的不同，生成脚本引擎的时机也不同，大致可分为四类：

第一类：满减满赠、单品立减、第二件半价和优惠券，这四种是在活动生效时生成脚本。需要设置延时任务，活动生效自动生成脚本。

第二类：拼团，由于拼团活动生效后，也可以再次添加或修改参与拼团活动的商品，并且平台可以关闭和开启拼团活动，因此与第一类稍有不同，除活动生效时需要生成脚本外，上述这些操作也要生成或更新脚本。

第三类：团购、限时抢购，这两种促销活动是平台发布商家选择商品进行参与的，参与的商品需要商家进行审核，因此是在审核通过时生成脚本。

第四类：积分兑换，积分兑换针对的是商品，因此是在商家新增和修改商品信息时，生成或更新脚本。

3、促销活动生成的脚本都需要放入缓存中，以便于减少查库操作。

4、清除缓存中无用的脚本引擎：除积分兑换外，其他促销活动都需要利用延时任务，在促销活动失效时，将缓存中的脚本数据清除掉。积分兑换在商家关闭商品的积分兑换操作时才对缓存中的脚本数据进行删除。

二、脚本生成流程图

三、缓存数据结构

1、根据促销活动的不同规则，分为三种缓存数据结构，分别是：SKU级别缓存、店铺级别缓存和优惠券级别缓存。
2、结构图：
　SKU级别缓存结构和店铺级别缓存结构级别一致，如下：
　
　而优惠券级别的缓存结构如下：
　
3、缓存结构说明
　
(1)、SKU级别缓存：

缓存key：{SKUPROMOTION} 加上SKU的ID，例如：{SKU_PROMOTION}_100。

缓存value：是一个泛型为PromotionScriptVO的List集合。

(2)、店铺级别缓存：

缓存key：{CARTPROMOTION} 加上店铺的ID，例如：{CART_PROMOTION}_100。

缓存value：是一个泛型为PromotionScriptVO的List集合。

(3)、优惠券级别缓存：

缓存key：{COUPONPROMOTION} 加上优惠券的ID，例如：{COUPON_PROMOTION}_100。

缓存value：是一个String类型的脚本字符串。

4、促销活动存储的缓存结构区分

(1)、针对满减满赠、单品立减、第二件半价这三种促销活动，如果商家在发布活动时选择的是全部商品参与，那么则存储的是店铺级别的缓存结构，如果选择的是部分商品参与，那么则存储的是SKU级别的缓存结构。

(2)、针对拼团、团购、显示抢购和积分兑换这些促销活动，都是存储的SKU级别的缓存结构。

(3)、针对优惠券，无论是店铺优惠券还是平台优惠券，存储的都是优惠券级别的缓存结构。

四、脚本规范

1、调用脚本传入的变量规范：

$sku说明：

2、各个促销活动脚本中的方法说明

满减满赠、优惠券促销活动脚本方法

单品立减、第二件半价、团购、限时抢购、团购活动脚本方法

积分兑换活动脚本方法

源码分享

由于促销活动类型较多，此处只以团购活动为例进行相关代码的分享。
ScriptUtil
促销脚本渲染与调用工具类

import com.enation.app.javashop.framework.logs.Logger;
import com.enation.app.javashop.framework.logs.LoggerFactory;
import freemarker.template.Configuration;
import freemarker.template.Template;

import javax.script.Invocable;
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;
import java.io.IOException;
import java.io.StringWriter;
import java.util.*;

/**
 * 脚本生成工具类
 * @author duanmingyu
 * @version v1.0
 * @since v7.2.0
 * @date 2020-01-06
 */
public class ScriptUtil {

    private static final Logger log = LoggerFactory.getLogger(ScriptUtil.class);

    /**
     * 渲染并读取脚本内容
     * @param name 脚本模板名称（例：test.js，test.html，test.ftl等）
     * @param model 渲染脚本需要的数据内容
     * @return
     */
    public static String renderScript(String name, Map<String, Object> model) {
        StringWriter stringWriter = new StringWriter();

        try {
            Configuration cfg = new Configuration(Configuration.VERSION_2_3_28);

            cfg.setClassLoaderForTemplateLoading(Thread.currentThread().getContextClassLoader(),"/script_tpl");
            cfg.setDefaultEncoding("UTF-8");
            cfg.setNumberFormat("#.##");

            Template temp = cfg.getTemplate(name);

            temp.process(model, stringWriter);

            stringWriter.flush();

            return stringWriter.toString();

        } catch (Exception e) {
            log.error(e.getMessage());
        } finally {
            try {
                stringWriter.close();
            } catch (IOException ex) {
                log.error(ex.getMessage());
            }
        }

        return null;
    }

    /**
     * @Description:执行script脚本
     * @param method script方法名
     * @param params 参数
     * @param script 脚本
     * @return: 返回执行结果
     * @Author: liuyulei
     * @Date: 2020/1/7
     */
    public static Object executeScript(String method,Map<String,Object> params,String script)  {
        if (StringUtil.isEmpty(script)){
            log.debug("script is " + script);
            return new Object();
        }

        try {
            ScriptEngineManager manager = new ScriptEngineManager();
            ScriptEngine engine = manager.getEngineByName("javascript");


            log.debug("脚本参数：");
            for (String key:params.keySet()) {
                log.debug(key + "=" + params.get(key));
                engine.put(key, params.get(key));
            }

            engine.eval(script);
            log.debug("script 脚本 :");
            log.debug(script);

            Invocable invocable = (Invocable) engine;

            return invocable.invokeFunction(method);
        } catch (ScriptException e) {
            log.error(e.getMessage(),e);
        } catch (NoSuchMethodException e) {
            log.error(e.getMessage(),e);
        }
        return new Object();
    }
}

groupbuy.ftl
团购活动脚本模板

<#--
 验证促销活动是否在有效期内
 @param promotionActive 活动信息对象(内置常量)
        .startTime 获取开始时间
        .endTime 活动结束时间
 @param $currentTime 当前时间(变量)
 @returns {boolean}
 -->
function validTime(){
    if (${promotionActive.startTime} <= $currentTime && $currentTime <= ${promotionActive.endTime}) {
        return true;
    }
    return false;
}

<#--
活动金额计算
@param promotionActive 活动信息对象(内置常量)
       .price 商品促销活动价格
@param $sku 商品SKU信息对象(变量)
       .$num 商品数量
@returns {*}
-->
function countPrice() {
    var resultPrice = $sku.$num * ${promotionActive.price};
    return resultPrice < 0 ? 0 : resultPrice.toString();
}

PromotionScriptVO
促销活动脚本数据结构实体

import com.fasterxml.jackson.databind.PropertyNamingStrategy;
import com.fasterxml.jackson.databind.annotation.JsonNaming;
import io.swagger.annotations.ApiModelProperty;
import org.apache.commons.lang.builder.EqualsBuilder;
import org.apache.commons.lang.builder.HashCodeBuilder;

import java.io.Serializable;

/**
 * @description: 促销脚本VO
 * @author: liuyulei
 * @create: 2020-01-09 09:43
 * @version:1.0
 * @since:7.1.5
 **/
@JsonNaming(value = PropertyNamingStrategy.SnakeCaseStrategy.class)
public class PromotionScriptVO implements Serializable {
    private static final long serialVersionUID = 3566902764098210013L;

    @ApiModelProperty(value = "促销活动id")
    private Integer promotionId;

    @ApiModelProperty(value = "促销活动名称")
    private String promotionName;

    @ApiModelProperty(value = "促销活动类型")
    private String promotionType;

    @ApiModelProperty(value = "是否可以被分组")
    private Boolean isGrouped;

    @ApiModelProperty(value = "促销脚本",hidden = true)
    private String promotionScript;

    @ApiModelProperty(value = "商品skuID")
    private Integer skuId;


    public Integer getPromotionId() {
        return promotionId;
    }

    public void setPromotionId(Integer promotionId) {
        this.promotionId = promotionId;
    }

    public String getPromotionName() {
        return promotionName;
    }

    public void setPromotionName(String promotionName) {
        this.promotionName = promotionName;
    }

    public String getPromotionType() {
        return promotionType;
    }

    public void setPromotionType(String promotionType) {
        this.promotionType = promotionType;
    }

    public Boolean getIsGrouped() {
        return isGrouped;
    }

    public void setIsGrouped(Boolean grouped) {
        isGrouped = grouped;
    }

    public String getPromotionScript() {
        return promotionScript;
    }

    public void setPromotionScript(String promotionScript) {
        this.promotionScript = promotionScript;
    }

    public Integer getSkuId() {
        return skuId;
    }

    public void setSkuId(Integer skuId) {
        this.skuId = skuId;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }

        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        PromotionScriptVO that = (PromotionScriptVO) o;

        return new EqualsBuilder()
                .append(promotionId, that.promotionId)
                .append(promotionName, that.promotionName)
                .append(promotionType, that.promotionType)
                .append(isGrouped, that.isGrouped)
                .isEquals();
    }

    @Override
    public int hashCode() {
        return new HashCodeBuilder(17, 37)
                .append(promotionId)
                .append(promotionName)
                .append(promotionType)
                .append(isGrouped)
                .toHashCode();
    }

    @Override
    public String toString() {
        return "PromotionScriptVO{" +
                "promotionId=" + promotionId +
                ", promotionName='" + promotionName + '\'' +
                ", promotionType='" + promotionType + '\'' +
                ", isGrouped=" + isGrouped +
                ", promotionScript='" + promotionScript + '\'' +
                ", skuId=" + skuId +
                '}';
    }
}

GroupbuyScriptManager
团购促销活动脚本业务接口

import com.enation.app.javashop.core.promotion.tool.model.dos.PromotionGoodsDO;

import java.util.List;

/**
 * 团购促销活动脚本业务接口
 * @author duanmingyu
 * @version v1.0
 * @since v7.2.0
 * 2020-02-18
 */
public interface GroupbuyScriptManager {

    /**
     * 创建参与团购促销活动商品的脚本数据信息
     * @param promotionId 团购促销活动ID
     * @param goodsList 参与团购促销活动的商品集合
     */
    void createCacheScript(Integer promotionId, List<PromotionGoodsDO> goodsList);

    /**
     * 删除商品存放在缓存中的团购促销活动相关的脚本数据信息
     * @param promotionId 团购促销活动ID
     * @param goodsList 参与团购促销活动的商品集合
     */
    void deleteCacheScript(Integer promotionId, List<PromotionGoodsDO> goodsList);
}

GroupbuyScriptManagerImpl
团购促销活动脚本业务接口实现

import com.enation.app.javashop.core.base.CachePrefix;
import com.enation.app.javashop.core.promotion.groupbuy.model.dos.GroupbuyActiveDO;
import com.enation.app.javashop.core.promotion.groupbuy.service.GroupbuyActiveManager;
import com.enation.app.javashop.core.promotion.groupbuy.service.GroupbuyScriptManager;
import com.enation.app.javashop.core.promotion.tool.model.dos.PromotionGoodsDO;
import com.enation.app.javashop.core.promotion.tool.model.enums.PromotionTypeEnum;
import com.enation.app.javashop.core.promotion.tool.model.vo.PromotionScriptVO;
import com.enation.app.javashop.framework.cache.Cache;
import com.enation.app.javashop.framework.logs.Logger;
import com.enation.app.javashop.framework.logs.LoggerFactory;
import com.enation.app.javashop.framework.util.ScriptUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 团购促销活动脚本业务接口
 * @author duanmingyu
 * @version v1.0
 * @since v7.2.0
 * 2020-02-18
 */
@Service
public class GroupbuyScriptManagerImpl implements GroupbuyScriptManager {

    protected final Logger logger = LoggerFactory.getLogger(this.getClass());

    @Autowired
    private Cache cache;

    @Autowired
    private GroupbuyActiveManager groupbuyActiveManager;

    @Override
    public void createCacheScript(Integer promotionId, List<PromotionGoodsDO> goodsList) {
        //如果参与团购促销活动的商品集合不为空并且集合长度不为0
        if (goodsList != null && goodsList.size() != 0) {
            //获取团购活动详细信息
            GroupbuyActiveDO groupbuyActiveDO = this.groupbuyActiveManager.getModel(promotionId);

            //批量放入缓存的数据集合
            Map<String, List<PromotionScriptVO>> cacheMap = new HashMap<>();

            //循环参与团购活动的商品集合，将脚本放入缓存中
            for (PromotionGoodsDO goods : goodsList) {

                //缓存key
                String cacheKey = CachePrefix.SKU_PROMOTION.getPrefix() + goods.getSkuId();

                //获取拼团活动脚本信息
                PromotionScriptVO scriptVO = new PromotionScriptVO();

                //渲染并读取团购促销活动脚本信息
                String script = renderScript(groupbuyActiveDO.getStartTime().toString(), groupbuyActiveDO.getEndTime().toString(), goods.getPrice());

                scriptVO.setPromotionScript(script);
                scriptVO.setPromotionId(promotionId);
                scriptVO.setPromotionType(PromotionTypeEnum.GROUPBUY.name());
                scriptVO.setIsGrouped(false);
                scriptVO.setPromotionName("团购");
                scriptVO.setSkuId(goods.getSkuId());

                //从缓存中读取脚本信息
                List<PromotionScriptVO> scriptList = (List<PromotionScriptVO>) cache.get(cacheKey);
                if (scriptList == null) {
                    scriptList = new ArrayList<>();
                }

                scriptList.add(scriptVO);

                cacheMap.put(cacheKey, scriptList);
            }

            //将sku促销脚本数据批量放入缓存中
            cache.multiSet(cacheMap);
        }
    }

    @Override
    public void deleteCacheScript(Integer promotionId, List<PromotionGoodsDO> goodsList) {
        //如果参与团购促销活动的商品集合不为空并且集合长度不为0
        if (goodsList != null && goodsList.size() != 0) {
            //需要批量更新的缓存数据集合
            Map<String, List<PromotionScriptVO>> updateCacheMap = new HashMap<>();

            //需要批量删除的缓存key集合
            List<String> delKeyList = new ArrayList<>();

            for (PromotionGoodsDO goods : goodsList) {
                //缓存key
                String cacheKey = CachePrefix.SKU_PROMOTION.getPrefix() + goods.getSkuId();

                //从缓存中读取促销脚本缓存
                List<PromotionScriptVO> scriptCacheList = (List<PromotionScriptVO>) cache.get(cacheKey);

                if (scriptCacheList != null && scriptCacheList.size() != 0) {
                    //循环促销脚本缓存数据集合
                    for (PromotionScriptVO script : scriptCacheList) {
                        //如果脚本数据的促销活动信息与当前修改的促销活动信息一致，那么就将此信息删除
                        if (PromotionTypeEnum.GROUPBUY.name().equals(script.getPromotionType())
                                && script.getPromotionId().intValue() == promotionId.intValue()) {
                            scriptCacheList.remove(script);
                            break;
                        }
                    }

                    if (scriptCacheList.size() == 0) {
                        delKeyList.add(cacheKey);
                    } else {
                        updateCacheMap.put(cacheKey, scriptCacheList);
                    }
                }
            }

            cache.multiDel(delKeyList);
            cache.multiSet(updateCacheMap);
        }
    }

    /**
     * 渲染并读取团购促销活动脚本信息
     * @param startTime 活动开始时间
     * @param endTime 活动结束时间
     * @param price 限时抢购商品价格
     * @return
     */
    private String renderScript(String startTime, String endTime, Double price) {
        Map<String, Object> model = new HashMap<>();

        Map<String, Object> params = new HashMap<>();
        params.put("startTime", startTime);
        params.put("endTime", endTime);
        params.put("price", price);

        model.put("promotionActive", params);

        String path = "groupbuy.ftl";
        String script = ScriptUtil.renderScript(path, model);

        logger.debug("生成团购促销活动脚本：" + script);

        return script;
    }
}

以上是Javashop中基于脚本引擎的促销活动架构思路与部分源码分享。
易族智汇（Javashop）原创文章

转载：https://blog.csdn.net/kingapex1/article/details/105514819