制定规则

编程中想给自己的程序制定一种规则：当满足某种条件时运行某部分的代码。枚举可以完成较简单的这种规则，今天记录一个稍复杂的规则。
以用户参与多个活动为例，这几个活动都需要用户填入一些基本信息，但随后会进行不同的动作，这时我们就需要制定一个规则，在不同的条件下让用户进行不同的动作，具体代码如下：

/**
 * 活动用户组装服务实现类
 */
@Service
public class UserActionImpl extends BaseService implements UserAction {

@Transactional
@Override
public long add(ActivityUserAddReqModelactivityUserAddReqModel) throws BaseException {
log.begin("开始增加活动用户activityUserAddReqModel=%s", activityUserAddReqModel);

*// 用户输入基本信息代码 略*
boolean isLaunch = false;//用户成功参与后isLaunch =true

*// 增加活动规则*
Map<String, Object> params = new HashMap<>();//map型，你可以传入多个、多种类型的参数。
params.put("isLaunch", isLaunch); //此时的isLaunch是布尔型
activityRuleService.afterLaunch(activityUserAddReqModel.getActivityId(),activityUserAddReqModel.getUserAccountUuid(), params);//activityRuleService是规则的服务类，afterLaunch是这个服务类中的一个方法，在这里的含义为：用户成功之后进入规则。
return result;
}
}

/**
 * 活动规则服务类
 */
public interface ActivityRuleService {

    /**
     * 活动发起后
     *
     * @param activityId 活动id
     * @param userAccountUuid 用户账号随机id
     * @param params 参数
     * @throws BaseException
     */
    void afterLaunch(Long activityId, String userAccountUuid, Map<String, Object> params) throws BaseException;

活动规则服务类可以由多个实现类实现，如下图所示：

这里有一个ActivityRuleService活动规则服务类，ActivityRuleServiceImpl和DefaultActivityRuleService实现它，根据活动id来确定走哪个实现类。

活动规则枚举：

public enum ActivityRuleEnum {

    /**
     * 好声音
     */
    GOOD_VOICE(3L) {
        @Override
        public ActivityRuleService getActivityRuleService() {
            return SystemListener.getBean(GoodVoiceRuleServiceImpl.class);//这里有监听
        }
    },

    /**
     * 感谢信
     */
    THANK_LETTER(5L) {
        @Override
        public ActivityRuleService getActivityRuleService() {
            return SystemListener.getBean(ThankLetterRuleServiceImpl.class);
        }
    },

    /**
     * 城市大比拼
     */
    CITY_COMPETITION(7L) {
        public ActivityRuleService getActivityRuleService() {
            return SystemListener.getBean(CityCompetitionRuleServiceImpl.class);
        }
    };

    private Long activityId;
    private static Map<Long, ActivityRuleEnum> enumMap = new HashMap<>();

    static {
        EnumSet<ActivityRuleEnum> set = EnumSet.allOf(ActivityRuleEnum.class);
        for (ActivityRuleEnum each : set) {
            enumMap.put(each.getActivityId(), each);
        }
    }

    ActivityRuleEnum(Long activityId) {
        this.activityId = activityId;
    }

    public Long getActivityId() {
        return activityId;
    }

    /**
     * @return 获取活动规则的服务
     */
    public abstract ActivityRuleService getActivityRuleService();

    /**
     * @param value 厂商值
     * @return 获取活动规则枚举
     */
    public static ActivityRuleEnum getActivityRuleEnum(Long value) {
        return enumMap.get(value);
    }

/**
 * 系统监听类
 */
@WebListener
public class SystemListener implements ServletContextListener {

    private static ApplicationContext applicationContext;

    @Override
    public void contextInitialized(ServletContextEvent event) {
        ServletContext application = event.getServletContext();
        applicationContext = WebApplicationContextUtils.getRequiredWebApplicationContext(application);

        StaticValue.realPath = application.getRealPath("");
        StaticValue.contextPath = application.getContextPath();

        application.setAttribute(CommonConstant.CONTEXT_PATH, StaticValue.contextPath);
        this.subclassInit();
    }

    @Override
    public void contextDestroyed(ServletContextEvent event) {

    }

    /**
     * 子类可继承实现
     */
    protected void subclassInit() {

    }

    /**
     * @return 获取spring上下文
     */
    public static ApplicationContext getApplicationContext() {
        return applicationContext;
    }

    /**
     * 设置应用上下文
     *
     * @param applicationContext 应用上下文
     */
    public static void setApplicationContext(ApplicationContext applicationContext) {
        if (SystemListener.applicationContext == null) {
            SystemListener.applicationContext = applicationContext;
        }
    }

    /**
     * @param beanName     名字
     * @param requiredType class类型
     * @param <T>          类
     * @return bean对象
     */
    public static <T> T getBean(String beanName, Class<T> requiredType) {
        return applicationContext == null ? null : applicationContext.getBean(beanName, requiredType);
    }

    /**
     * @param requiredType class类型
     * @param <T>          类
     * @return bean对象
     */
    public static <T> T getBean(Class<T> requiredType) {
        return applicationContext == null ? null : applicationContext.getBean(requiredType);
    }
}

下面就根据不同的规则去实现：

/**
 * 活动规则服务实现类
 */
@Service
@Primary
public class ActivityRuleServiceImpl extends BaseService implements ActivityRuleService {

    private static Log log = LogFactory.getLog(ActivityRuleServiceImpl.class);

    @Override
    public void afterLaunch(Long activityId, String userAccountUuid, Map<String, Object> params) throws BaseException {
        log.info("活动发起完成规则activityId=%s，userAccountUuid=%s，params=%s", activityId, userAccountUuid, params);
        ActivityRuleEnum activityRuleEnum = ActivityRuleEnum.getActivityRuleEnum(activityId);
        if (activityRuleEnum != null) {
            ActivityRuleService activityRuleService = activityRuleEnum.getActivityRuleService();
            activityRuleService.afterLaunch(activityId, userAccountUuid, params);
        }
    }

    @Override
    public int getPraiseCountAfterReward(Long activityId, int praiseCount, Map<String, Object> params) throws BaseException {
        log.info("活动打赏完成规则activityId=%s，praiseCount=%s，params=%s", activityId, praiseCount, params);
        ActivityRuleEnum activityRuleEnum = ActivityRuleEnum.getActivityRuleEnum(activityId);
        if (activityRuleEnum != null) {
            ActivityRuleService activityRuleService = activityRuleEnum.getActivityRuleService();
            return activityRuleService.getPraiseCountAfterReward(activityId, praiseCount, params);
        }
        return praiseCount;
    }
}

/**
 * 默认活动规则服务类
 */
@Service
public class DefaultActivityRuleService implements ActivityRuleService {

    @Override
    public void afterLaunch(Long activityId, String userAccountUuid, Map<String, Object> params) throws BaseException {

    }

    @Override
    public int getPraiseCountAfterReward(Long activityId, int praiseCount, Map<String, Object> params) throws BaseException {
        return praiseCount;
    }
}

/**
 * 感谢信活动规则服务实现类
 */
@Service
public class ThankLetterRuleServiceImpl extends DefaultActivityRuleService implements ActivityRuleService {

    private static Log log = LogFactory.getLog(ThankLetterRuleServiceImpl.class);

    private static final String TYPE_CODE = "userEntryInfo";

    @Autowired
    private UserService userService;

    @Autowired
    private ActivityUserService activityUserService;

    @Autowired
    private ActivityUserDetailService activityUserDetailService;

    @Override
    public void afterLaunch(Long activityId, String userAccountUuid, Map<String, Object> params) throws BaseException {
        log.info("感谢信活动规则");

        // 查询用户的信息
        BaseUser baseUser = userService.getByUserAccountUuid(userAccountUuid);
        Date entryDate = baseUser.getEntryDate();
        if (entryDate == null) {
            log.info("入行日期为空");
            return;
        }

        // 查询活动用户的信息
        BaseActivityUser baseActivityUser = activityUserService.getByUserAccountUuidAndActivityId(userAccountUuid, activityId);

        // 获取当前的年份
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(entryDate);
        int year = calendar.get(Calendar.YEAR);

        // 获取当前相差的天数
        String now = DateUtils.format(DateUtils.YYYY_MM_DD);
        String entryDateString = DateUtils.format(entryDate, DateUtils.YYYY_MM_DD);
        Long subtractMillisecond = DateUtils.getSubtractMillisecond(now, entryDateString, DateUtils.YYYY_MM_DD);
        int day = (int) (subtractMillisecond / (1000L * 60 * 60 * 24));

        // 获取相差的月份并计算百分比
        // Integer month = DateUtils.getSubtractMonth(entryDateString, "1970-01-01", DateUtils.YYYY_MM_DD);
        // Double ratio = DoubleUtils.format(99.99D - month * 0.156);

        // 保存活动用户详情信息
        List<BaseActivityUserDetail> baseActivityUserDetailList = new ArrayList<>();

        // 年份
        long activityUserId = baseActivityUser.getId();
        BaseActivityUserDetail yearUserDetail = getBaseActivityUserDetail(activityUserId, "year", year + "");
        baseActivityUserDetailList.add(yearUserDetail);

        // 天数
        BaseActivityUserDetail dayUserDetail = getBaseActivityUserDetail(activityUserId, "day", day + "");
        baseActivityUserDetailList.add(dayUserDetail);

        // 比率
        String ratio = ThanksLetterRuleFileConfig.getValue(DateUtils.format(entryDate, "yyyy-MM"));
        if (StringUtils.isBlank(ratio)) {
            // 是否早于1970或晚于2017
            if (year < 1970) {
                ratio = "99.99%";
            }
            else if (year > 2017) {
                ratio = "1.88%";
            }
        }
        BaseActivityUserDetail ratioUserDetail = getBaseActivityUserDetail(activityUserId, "ratio", ratio);
        baseActivityUserDetailList.add(ratioUserDetail);
        activityUserDetailService.add(baseActivityUserDetailList);
    }

    @Override
    public int getPraiseCountAfterReward(Long activityId, int praiseCount, Map<String, Object> params) throws BaseException {
        log.info("活动打赏完成规则activityId=%s，praiseCount=%s，params=%s", activityId, praiseCount, params);
        return 0;
    }

    private BaseActivityUserDetail getBaseActivityUserDetail(Long activityUserId, String name, String value) {
        BaseActivityUserDetail result = new BaseActivityUserDetail();
        result.setActivityUserId(activityUserId);
        result.setParamName(name);
        result.setParamValue(value);
        result.setTypeCode(TYPE_CODE);
        return result;
    }

/**
 * 城市大比拼活动规则服务实现类
 */
@Service
public class CityCompetitionRuleServiceImpl extends DefaultActivityRuleService implements ActivityRuleService {

    private static Log log = LogFactory.getLog(CityCompetitionRuleServiceImpl.class);

    @Autowired
    private RankService rankService;

    @Override
    public void afterLaunch(Long activityId, String userAccountUuid, Map<String, Object> params) throws BaseException {
        log.info("城市大比拼活动规则");
        if ((boolean) params.get(Constant.IS_LAUNCH)) {
            rankService.setCityLaunchRank(activityId, userAccountUuid);
        }
    }

}