积分商城系统设计

企业开发 2023-04-08 16:34:54 阅读次数: 0

随着互联网、移动联网、大数据的快速发展，积分商城系统的应用也是越来越广泛啦，各种购物都有会与各种的积分有一定的关联。

积分商城系统架构要完成一个积分运作的闭环，即：商家发放积分，消费者用户获得积分，用户利用积分兑换商品，礼品，优惠券等，积分再次回到商家或平台形成这么一个循环的闭环。

系统特点

1、制定完善完整的积分兑换规则，提高兑换订单处理效率，增加适量低积分商品，礼品等。吸引消费者积极使用积分，提高积分商品的吸引度，增强消费者粘度。

2、整个积分商城的积分兑换尽量线上完成，如：消费者用积分兑换商品、礼品，线上生成订单，使用快递物流进行发货，直接送到客户手中。无需到线下实体店领取。

3、有效控制商品，礼品的兑换有期间，尽量使用商品，礼品长期都可以持续兑换，避免搞运动式的兑换活动。

系统设计

1、店铺创建活动，通过活动促销兑换商品。活动会定义规则。用户满足活动规则才允许兑换商品。活动规则的匹配我们 使用QLExpress规则引擎，详情设计参考后面代码。

2、分布式ID，前期采用数据库方式 生成ID （不采用自增长ID），为以后数据库拆分准备。生成方式参考后面代码。

3、积分兑换商品需要生成兑换单，对订单数据需要进行分表处理，目前订单表根据主键ID分表，共256张表。

4、对订单数据的查询请求，使用ES 方式查询。

5、定义CommandHandler 模版，统一业务代码处理风格。参考后面代码。

 QLExpress

一个轻量级的类java语法规则引擎，作为一个嵌入式规则引擎在业务系统中使用。让业务规则定义简便而不失灵活。让业务人员就可以定义业务规则。支持标准的JAVA语法，还可以支持自定义操作符号、操作符号重载、函数定义、宏定义、数据延迟加载等。https://github.com/alibaba/QLExpress

POM坐标

        <!-- QLExpress -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>QLExpress</artifactId>
            <version>3.2.0</version>
        </dependency>

QLExpressContext 定义

public class QLExpressContext extends HashMap<String, Object> implements IExpressContext<String, Object> {
    private ApplicationContext applicationContext;

    public QLExpressContext(Map<String, Object> properties, ApplicationContext context) {
        super(properties);
        this.applicationContext = context;
    }

    @Override
    public Object get(Object name) {
        Object result;
        result = super.get(name);
        try {
            if (result == null && this.applicationContext != null && this.applicationContext.containsBean((String) name)) {

                result = this.applicationContext.getBean((String) name);
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        return result;
    }

    @Override
    public Object put(String name, Object object) {
        super.put(name, object);
        return object;
    }
}

QLExpressHandler 定义 

@Component
public class QLExpressHandler implements InitializingBean, ApplicationContextAware {

    private ExpressRunner runner;

    private ApplicationContext applicationContext;

    public Object execute(String statement, Map<String, Object> context) throws Exception {
        IExpressContext expressContext = new QLExpressContext(context != null ? context : Collections.EMPTY_MAP, applicationContext);
        return runner.execute(statement, expressContext, null, true, false);
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        runner = new ExpressRunner(false, false);

        Map<String, RuleHandler> beanMap = applicationContext.getBeansOfType(RuleHandler.class);

        beanMap.values().forEach(bean -> {
            Method[] methods = bean.getClass().getDeclaredMethods();

            for (Method method : methods) {
                QlRule qlRule = method.getAnnotation(QlRule.class);

                try {
                    runner.addFunctionOfClassMethod(qlRule.methodName(), bean.getClass().getName(), method.getName(),
                            method.getParameterTypes(), null);
                } catch (Exception ex) {

                }

            }
        });
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }
}

 规则类定义

public interface RuleHandler {
}
/**
 * QLRule 注解，Spring启动时扫描
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface QlRule {

    /**
     * 方法名称
     */
    String methodName();

    /**
     * 方法描述
     */
    String desc() default "";
}
@Component
public class Activity implements RuleHandler {

    @QlRule(methodName = "checkUserName", desc = "")
    public boolean checkUserName(String name) {
        return Objects.equals("yangyanping", name);
    }
}

 单元测试

public class QlTest extends BootBaseTest {

    @Autowired
    private QLExpressHandler qlExpressHandler;

    @Test
    public void testQl() throws Exception {

        String script = "com.ql.Activity; return checkUserName(name);";

        Map<String, Object> context = new HashMap<>();
        context.put("name", "xiyangyang");
        Object result = qlExpressHandler.execute(script, context);
        System.out.println("xiyangyang=" + result);

        context.put("name", "yangyanping");
        result = qlExpressHandler.execute(script, context);
        System.out.println("yangyanping=" + result);
    }
}

输出结果

xiyangyang=false
yangyanping=true

分表 实现

 DbTableUtil 计算分表的index 

public class DbTableUtil {
    private static final int TABLE_SIZE = 256;

    public static String getTableIndex(Object shardKey, int sliceSize) {
        int hashValue = Math.abs(shardKey.hashCode());
        int tableIndex = hashValue % sliceSize + 1;

        // 对整数进行格式化 占位符格式为： %[index$][标识]*[最小宽度]转换符
        return String.format("%04d", tableIndex);
    }

    public static String hash(long key, int sliceSize) {
        long hashValue = Math.abs(key);
        int tableIndex = (int) (hashValue % sliceSize + 1);

        // 对整数进行格式化 占位符格式为： %[index$][标识]*[最小宽度]转换符
        return String.format("%04d", tableIndex);
    }

    public static String hash(long key) {
        return hash(key, TABLE_SIZE);
    }
}

分布式ID 

 sequence表

字段 name 保存数据表的名称，字段value 保存表当前最大ID。

CREATE TABLE `sys`.`sequence` (
  `name` VARCHAR(64) NOT NULL COMMENT '表名称',
  `value` BIGINT(20) NOT NULL COMMENT '当前值',
  PRIMARY KEY (`name`))
ENGINE = InnoDB
DEFAULT CHARACTER SET = utf8
COMMENT = 'sequence 表';

SequenceUtil 设计

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.Map;
import javax.sql.DataSource;

import lombok.Data;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

@Data
public class Sequence {
    private static final Log log = LogFactory.getLog(Sequence.class);

    /**
     * 容量大小
     */
    private int blockSize = 100;

    /**
     * 初始值大小
     */
    private long startValue = 0L;

    /**
     * 数据源
     */
    private DataSource dataSource;

    private Map<String, Step> stepMap = new HashMap<>();

    public Sequence() {
    }

    public synchronized long get(String sequenceName) {
        Step step = this.stepMap.get(sequenceName);
        if (step == null) {
            step = new Sequence.Step(this.startValue, this.startValue + (long) this.blockSize);
            this.stepMap.put(sequenceName, step);
        } else if (step.currentValue < step.endValue) {
            return step.incrementAndGet();
        }

        for (int i = 0; i < this.blockSize; ++i) {
            if (this.getNextBlock(sequenceName, step)) {
                return step.incrementAndGet();
            }
        }

        throw new RuntimeException("get error.");
    }

    private boolean getNextBlock(String sequenceName, Step step) {
        Long value = this.getPersistenceValue(sequenceName);
        if (value == null) {
            try {
                value = this.newPersistenceValue(sequenceName);
            } catch (Exception var5) {
                log.error("newPersistenceValue error!");
                value = this.getPersistenceValue(sequenceName);
            }
        }

        boolean b = this.saveValue(value, sequenceName) == 1;
        if (b) {
            step.setCurrentValue(value);
            step.setEndValue(value + (long) this.blockSize);
        }

        return b;
    }

    private int saveValue(long value, String sequenceName) {
        Connection connection = null;
        PreparedStatement statement = null;

        int var8;
        try {
            connection = this.dataSource.getConnection();
            statement = connection.prepareStatement("update sequence_value set value = ?  where name = ? and value = ?");
            statement.setLong(1, value + (long) this.blockSize);
            statement.setString(2, sequenceName);
            statement.setLong(3, value);
            var8 = statement.executeUpdate();
        } catch (Exception var18) {
            log.error("newPersistenceValue error!", var18);
            throw new RuntimeException("newPersistenceValue error!", var18);
        } finally {
            this.close(null,statement, connection);
        }

        return var8;
    }

    private Long getPersistenceValue(String sequenceName) {
        Connection connection = null;
        PreparedStatement statement = null;
        ResultSet resultSet = null;

        try {
            connection = this.dataSource.getConnection();
            statement = connection.prepareStatement("select value from sequence_value where name = ?");
            statement.setString(1, sequenceName);
            resultSet = statement.executeQuery();
            if (resultSet.next()) {
                Long value = resultSet.getLong("value");
                return value;
            }
        } catch (Exception var23) {
            log.error("getPersistenceValue error!", var23);
            throw new RuntimeException("getPersistenceValue error!", var23);
        } finally {
            this.close(resultSet,statement, connection);
        }

        return null;
    }

    private Long newPersistenceValue(String sequenceName) {
        Connection connection = null;
        PreparedStatement statement = null;

        try {
            connection = this.dataSource.getConnection();
            statement = connection.prepareStatement("insert into sequence_value (value,name) values (?,?)");
            statement.setLong(1, this.startValue);
            statement.setString(2, sequenceName);
            statement.executeUpdate();
        } catch (Exception var15) {
            log.error("newPersistenceValue error!", var15);
            throw new RuntimeException("newPersistenceValue error!", var15);
        } finally {
            this.close(null,statement, connection);
        }

        return this.startValue;
    }

    private void close(ResultSet resultSet, PreparedStatement statement, Connection connection) {
        if (resultSet != null) {
            try {
                resultSet.close();
            } catch (SQLException var22) {
                log.error("close resultset error!", var22);
            }
        }

        if (statement != null) {
            try {
                statement.close();
            } catch (SQLException var14) {
                log.error("close statement error!", var14);
            }
        }

        if (connection != null) {
            try {
                connection.close();
            } catch (SQLException var13) {
                log.error("close connection error!", var13);
            }
        }
    }

    /**
     * 步长定义
     */
    @Data
    static class Step {
        /**
         * 初始值
         */
        private long currentValue;

        /**
         * 截止值
         */
        private long endValue;

        Step(long currentValue, long endValue) {
            this.currentValue = currentValue;
            this.endValue = endValue;
        }

        public long incrementAndGet() {
            return ++this.currentValue;
        }
    }
}
@Data
public class SequenceUtil {
    private Map<String, Sequence> sequenceMap;
    private Sequence defaultSequence;

    public long get(String name) {
        Sequence sequence = null;
        if (this.sequenceMap != null) {
            sequence = this.sequenceMap.get(name);
        }

        if (sequence == null) {
            if (this.defaultSequence != null) {
                return this.defaultSequence.get(name);
            } else {
                throw new RuntimeException("sequence " + name + " undefined!");
            }
        } else {
            return sequence.get(name);
        }
    }
}

CommandHandler 模版类定义

 ApiResult

import lombok.Getter;
import lombok.Setter;

import java.util.Objects;

/**
 * 结果包装类定义
 * @author yangyanping
 * @date 2022-08-01
 */
public class ApiResult<T> {
    private final String SUCCESS_CODE = "0000";

    /**
     * 码表
     */
    @Getter
    @Setter
    private String code;

    /**
     * 错误信息
     */
    @Getter
    @Setter
    private String errMsg;

    /**
     * 数据
     */
    @Getter
    @Setter
    private T data;

    public ApiResult success() {
        return success(null);
    }

    public ApiResult success(T data) {
        ApiResult<T> apiResult = new ApiResult<>();
        apiResult.setCode(SUCCESS_CODE);
        apiResult.setData(data);

        return apiResult;
    }

    public ApiResult failuer(String code, String errMsg) {
        ApiResult<T> apiResult = new ApiResult<>();
        apiResult.setCode(code);
        apiResult.setErrMsg(errMsg);

        return apiResult;
    }

    /**
     * 是否成功
     */
    public boolean checkSuccess() {
        return Objects.equals(SUCCESS_CODE, this.code);
    }
}

CommandHandler 类定义 

/**
 * CommandHandler 接口定义
 * @param <P> 请求参数
 * @param <R> 请求接口
 * @param <H> 请求头
 */
public interface CommandHandler<P,R,H> {
    /**
     * 业务处理器
     */
    ApiResult<R> doHandler(P param, H header);
}

AbstractCommandHandler 模版处理器定义

/**
 * 抽象处理器类定义
 * @author yangyanping
 * @date 2022-08-01
 */
public abstract class AbstractCommandHandler<P, R, H> implements CommandHandler<P, R, H> {
    /**
     * 执行处理器
     */
    @Override
    public ApiResult<R> doHandler(P param, H header) {
        ApiResult<R> apiResult = new ApiResult<>();
        long startTime = System.currentTimeMillis();

        try {
            this.checkHeader(header);
            this.checkParam(param);

            R result = this.doExecute(param, header);
            apiResult.setData(result);
            apiResult.setCode(ApiResult.SUCCESS_CODE);
        } catch (Exception ex) {
            apiResult.setCode("0001");
            apiResult.setErrMsg(ex.getMessage());
        } finally {
            System.out.println("cost time " + (System.currentTimeMillis() - startTime) + "ms");
        }

        return apiResult;
    }

    /**
     * 检查参数
     */
    protected abstract void checkParam(P param);

    /**
     * 检查header
     */
    protected abstract void checkHeader(H header);

    /**
     * 执行
     */
    protected abstract R doExecute(P param, H header);
}

AbstractShopCommandHandler 增加token验证

/**
 * 商城处理器类定义
 */
public abstract class AbstractShopCommandHandler<P, R> extends AbstractCommandHandler<P, R, Protocol> {

    /**
     * 验证权限
     */
    protected void checkHeader(Protocol header) {
        /// todo 从表system_toke_config 验证 appName 和 token
    }
}

系统token 表

CREATE TABLE `sys`.`system_toke_config` (
  `id` INT UNSIGNED NOT NULL COMMENT '主键',
  `app_name` VARCHAR(64) NOT NULL COMMENT '应用名称',
  `token` VARCHAR(128) NOT NULL COMMENT '请求token',
  `remark` VARCHAR(64) NOT NULL DEFAULT '' COMMENT '备注',
  PRIMARY KEY (`id`))
ENGINE = InnoDB
DEFAULT CHARACTER SET = utf8
COMMENT = '系统token配置表';

猜你喜欢

转载自blog.csdn.net/yangyanping20108/article/details/126100570
今日推荐
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
Java自定义时间格式
同步整形电路
在开发中最最最常用的字符串的属性大集合
Linux 查看端口占用并杀掉
Java基础四：ArrayList
多线程之死锁就是这么简单
mysql 基础命令集
awk 命令详解
Centos6.3编译安装nginx+php步骤
OCR （Optical Character Recognition，光学字符识别）
每日归档
更多
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022