攻略服务

/**
 * 攻略
 */
@Setter
@Getter
@TableName("strategy")
public class Strategy implements Serializable {

    public static final int ABROAD_NO = 0;  //国内
    public static final int ABROAD_YES = 1;  //国外

    public static final int STATE_NORMAL = 0;  //带发布
    public static final int STATE_PUBLISH = 1; //发布

    @TableId(type = IdType.AUTO)
    private Long id;
    
    private Long destId;  //关联的目的地
    private String destName;
    private Long themeId; //关联主题
    private String themeName;
    private Long catalogId;  //关联的分类
    private String catalogName;
    private String title;  //标题
    private String subTitle; //副标题
    private String summary;  //内容摘要
    private String coverUrl;  //封面
    private Date createTime;  //创建时间
    private Integer isabroad;  //是否是国外
    private Integer viewnum;  //点击数
    private Integer replynum;  //攻略评论数
    private Integer favornum; //收藏数
    private Integer sharenum; //分享数
    private Integer thumbsupnum; //点赞个数
    private Integer state;  //状态

    @TableField(exist = false)
    private boolean favorite;

    @TableField(exist = false)
    private StrategyContent content; //攻略内容
}

@Setter
@Getter
@TableName("strategy_content")
public class StrategyContent implements Serializable {
    private Long id;
    private String content;
}

/**
 * 攻略统计表
 */
@Setter
@Getter
@TableName("strategy_rank")
public class StrategyRank {

    public static final int TYPE_ABROAD = 1;  //国外
    public static final int TYPE_CHINA = 2;   //国内
    public static final int TYPE_HOT = 3;     //热门

    private Long id;
    private Long destId;  //目的地id
    private String destName; //目的地名称
    private Long strategyId; //攻略id
    private String strategyTitle; //攻略标题
    private int type; //排行类型
    private Date statisTime; //归档统计时间
    private Long statisnum; //归档统计数
}

/**
 * 阿里云OSS工具类
 *
 * @author swcode
 * @since 2023/10/26 13:30
 */
public class OssUtil {
    /**
     * 访问域名
     */
    private final static String ossAccessDomainUrl;
    /**
     * bucket 名称
     */
    private final static String ossBucketName;
    /**
     * 封装了 accessKeyId 和 accessKeySecret 的客户端对象
     */
    private final static OSSClient client;

    static {
        // 面试题: 如何实现在一个非Spring容器管理的对象中, 从Spring容器中拿到其他Bean对象.
        // Environment 对象的作用就是管理 Spring 容器运行时的各种配置内容
        Environment environment = SpringContextUtil.getBean(Environment.class);
        String endpointUrl = environment.getProperty("aliyun.oss.endpoint");
        ossBucketName = environment.getProperty("aliyun.oss.bucket-name");
        ossAccessDomainUrl = environment.getProperty("aliyun.oss.domain");
        String keyId = environment.getProperty("aliyun.accessKey.id");
        String keySecret = environment.getProperty("aliyun.accessKey.secret");
        client = new OSSClient(endpointUrl, CredentialsProviderFactory.newDefaultCredentialProvider(keyId, keySecret),
                new ClientConfiguration());
    }

    /**
     * @param fileName 用户文件名称
     * @return 实际的cos上文件名称
     */
    private static String getRealFileName(String saveFolder, String fileName) {
        return StringUtils.isNotEmpty(saveFolder) ? saveFolder + "/" + fileName : fileName;
    }

    public static String upload(String saveFolder, String contentType, String fileName, InputStream input) {
        if (StringUtils.isEmpty(fileName) || StringUtils.isEmpty(contentType) || null == input) {
            return null;
        }
        ObjectMetadata objectMeta = new ObjectMetadata();
        objectMeta.setContentType(contentType);
        String filePath = getRealFileName(saveFolder, fileName);
        try {
            client.putObject(ossBucketName, filePath, input, objectMeta);
            return ossAccessDomainUrl + filePath;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        } finally {
            try {
                input.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public static String upload(String saveFolder, String contentType, String fileName, long contentLength, InputStream input) {
        if (StringUtils.isEmpty(fileName) || StringUtils.isEmpty(contentType) || contentLength <= 0 || null == input) {
            return null;
        }
        ObjectMetadata objectMeta = new ObjectMetadata();
        objectMeta.setContentLength(contentLength);
        objectMeta.setContentType(contentType);
        String filePath = getRealFileName(saveFolder, fileName);
        try {
            client.putObject(ossBucketName, filePath, input, objectMeta);
            return ossAccessDomainUrl + filePath;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        } finally {
            try {
                input.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public static String upload(String saveFolder, String fileMainName, MultipartFile multipartFile) {
        if (null != multipartFile && !multipartFile.isEmpty()) {
            try {
                String filename = multipartFile.getOriginalFilename();
                String extFileName;
                if (StringUtils.isNotEmpty(filename)) {
                    extFileName = filename.substring(filename.lastIndexOf("."));
                } else {
                    extFileName = ".jpg";
                }
                return upload(saveFolder, multipartFile.getContentType(), fileMainName + extFileName, multipartFile.getSize(), multipartFile.getInputStream());
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    public static String upload4SpecialName(String saveFolder, String fileName, MultipartFile multipartFile) {
        if (null != multipartFile && !multipartFile.isEmpty()) {
            try {
                return upload(saveFolder, multipartFile.getContentType(), fileName, multipartFile.getSize(), multipartFile.getInputStream());
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    public static String uploadImgByBase64(String saveFolder, String fileName, String base64ImgContent) {
        if (StringUtils.isEmpty(fileName) || StringUtils.isEmpty(base64ImgContent)) {
            return null;
        }
        try {
            Matcher matcher = Pattern.compile("^data.(.*?);base64,").matcher(base64ImgContent);
            if (matcher.find()) {
                base64ImgContent = base64ImgContent.replace(matcher.group(), "");
            }
            byte[] bytes = Base64Utils.decodeFromString(base64ImgContent);
            return upload(saveFolder, "image/jpg", fileName, bytes.length, new ByteArrayInputStream(bytes));
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    public static void delete(String fileUrl) {
        if (StringUtils.isEmpty(fileUrl)) {
            return;
        }
        try {
            fileUrl = fileUrl.replaceFirst(ossAccessDomainUrl, "");
            client.deleteObject(ossBucketName, fileUrl);
        } catch (OSSException | ClientException e) {
            e.printStackTrace();
        }
    }

    public static String getByFileName(String pathFile) {
        return ossAccessDomainUrl + client.getObject(ossBucketName, pathFile).getKey();
    }
}

/**
 * Spring工具类,获取Spring上下文对象等
 *
 * @author swcode
 * @since 2023/10/26 13:31
 */
@Component
public class SpringContextUtil implements ApplicationContextAware {

    private static ApplicationContext applicationContext = null;

    /**
     * 1. SpringContextUtil 被 JVM 加载时, applicationContext 作为静态属性, 就被初始化了, 但是此时是 null 值
     * 2. 当 Spring 容器初始化以后, 会管理 SpringContextUtil Bean 对象
     * 3. 当 Spring 创建 SpringContextUtil 实例对象时,
     * 在初始化阶段会自动调用实现了 ApplicationContextAware 的 setApplicationContext 方法,
     * 此时该类中原本静态容器属性就从 null 变成了容器对象
     * 4. 当容器启动成功后, 其他业务代码通过该类的静态成员, 就可以直接的访问容器对象, 从容器对象中获取其他 Bean 对象
     */
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        if (SpringContextUtil.applicationContext == null) {
            SpringContextUtil.applicationContext = applicationContext;
            System.out.println("----------" + applicationContext);
        }
    }

    public static ApplicationContext getApplicationContext() {
        return applicationContext;
    }

    public static Object getBean(String name) {
        return getApplicationContext().getBean(name);
    }

    public static <T> T getBean(Class<T> clazz) {
        return getApplicationContext().getBean(clazz);
    }

    public static <T> T getBean(String name, Class<T> clazz) {
        return getApplicationContext().getBean(name, clazz);
    }
}

@PostMapping("/uploadImg")
public JSONObject uploadImg(MultipartFile upload) {
    JSONObject result = new JSONObject();
    if (upload == null) {
        result.put("uploaded", 0);
        JSONObject error = new JSONObject();
        error.put("message", "请选择要上传的文件！");
        result.put("error", error);
        return result;
    }
    String filename = upload.getOriginalFilename();
    String mainFilename = "";
    if (StringUtils.hasText(filename)) {
        mainFilename = filename.substring(0, filename.lastIndexOf(".")) + "_" + System.currentTimeMillis();
    } else {
        mainFilename = System.currentTimeMillis() + "";
    }
    // 返回阿里云可访问的地址
    String url = OssUtil.upload("images", mainFilename, upload);

    result.put("uploaded", 1);
    result.put("fileName", upload.getOriginalFilename());
    result.put("url", url);
    return result;
}

@Service
public class StrategyServiceImpl extends ServiceImpl<StrategyMapper, Strategy> implements StrategyService {
    
    private final StrategyContentMapper strategyContentMapper;
    
    public StrategyServiceImpl(StrategyContentMapper strategyContentMapper) {
        this.strategyContentMapper = strategyContentMapper;
    }
    
    @Override
    public Strategy getById(Serializable id) {
        Strategy strategy = super.getById(id);
        StrategyContent strategyContent = strategyContentMapper.selectById(id);
        strategy.setContent(strategyContent);
        return strategy;
    }
}

@GetMapping("/detail")
public R<Strategy> getById(Long id) {
    return R.ok(strategyService.getById(id));
}

public interface StrategyMapper extends BaseMapper<Strategy> {
    List<StrategyCondition> selectDestCondition(@Param("abroad") int abroad);
    List<StrategyCondition> selectThemeCondition();
}

/**
 * 查询目的地过滤条件
 * @param abroad 是否国内
 * @return 过滤条件
 */
List<StrategyCondition> findDestCondition(int abroad);

/**
 * 查询主题过滤条件
 * @return 过滤条件
 */
List<StrategyCondition> findThemeCondition();

/**
 * 查询目的地过滤条件
 *
 * @param abroad 是否国内
 * @return 过滤条件
 */
@Override
public List<StrategyCondition> findDestCondition(int abroad) {
    return getBaseMapper().selectDestCondition(abroad);
}

/**
 * 查询主题过滤条件
 *
 * @return 过滤条件
 */
@Override
public List<StrategyCondition> findThemeCondition() {
    return getBaseMapper().selectThemeCondition();
}

@GetMapping("/conditions")
public R<Map<String, List<StrategyCondition>>> getConditions() {
    Map<String, List<StrategyCondition>> result = new HashMap<>();
    List<StrategyCondition> chinaCondition = strategyService.findDestCondition(Strategy.ABROAD_NO);
    List<StrategyCondition> abroadCondition = strategyService.findDestCondition(Strategy.ABROAD_YES);
    List<StrategyCondition> themeCondition = strategyService.findThemeCondition();

    result.put("chinaCondition", chinaCondition);
    result.put("abroadCondition", abroadCondition);
    result.put("themeCondition", themeCondition);

    return R.ok(result);
}

@Getter
@Setter
public class StrategyQuery extends QueryObject {
    public static final int CONDITION_THEME = 3;

    private Long destId; // 目的地ID
    private Long themeId; // 主题ID
    private Long refid; // 筛选条件ID => 目的地ID｜主题ID
    private Integer type; // 筛选条件类型 => 目的地｜主题
    private String orderBy;
}

/**
 * 条件分页查询攻略
 *
 * @param query 查询条件
 * @return 攻略
 */
Page<Strategy> pageStrategy(StrategyQuery query);

/**
 * 条件分页查询攻略
 *
 * @param query 查询条件
 * @return 攻略
 */
@Override
public Page<Strategy> pageStrategy(StrategyQuery query) {
    // 兼容标签查询
    if ((query.getType() != null && query.getType() != -1)&& (query.getRefid() != null && query.getRefid() != -1)) {
        // 多条件标签筛选，目的地或者主题查询
        if (query.getType() == StrategyQuery.CONDITION_THEME) {
            query.setThemeId(query.getRefid());
        } else {
            query.setDestId(query.getRefid());
        }
    }

    // 目的地和主题筛选
    return super.page(
            new Page<>(query.getCurrent(), query.getSize()),
            Wrappers.<Strategy>lambdaQuery()
                    .eq(query.getDestId() != null, Strategy::getDestId, query.getDestId())
                    .eq(!Objects.isNull(query.getThemeId()), Strategy::getThemeId, query.getThemeId())
                    .orderByDesc(query.getOrderBy() != null && query.getOrderBy().equals("viewnum"), Strategy::getViewnum)
                    .orderByDesc(query.getOrderBy() != null && query.getOrderBy().equals("create_time"), Strategy::getCreateTime)

    );
}

@GetMapping("/query")
public R<Page<Strategy>> pageList(StrategyQuery query) {
    return R.ok(strategyService.pageStrategy(query));
}

@Service
public class StrategyServiceImpl extends ServiceImpl<StrategyMapper, Strategy> implements StrategyService {

    private final StrategyCatalogService strategyCatalogService;
    private final DestinationService destinationService;
    private final StrategyThemeService strategyThemeService;
    private final StrategyContentMapper strategyContentMapper;

    public StrategyServiceImpl(StrategyCatalogService strategyCatalogService, DestinationService destinationService, StrategyThemeService strategyThemeService, StrategyContentMapper strategyContentMapper) {
        this.strategyCatalogService = strategyCatalogService;
        this.destinationService = destinationService;
        this.strategyThemeService = strategyThemeService;
        this.strategyContentMapper = strategyContentMapper;
    }

    private Boolean doSaveOrUpdate(Strategy strategy) {
        // 有封面数据且是base64时才做上传处理
        if (StringUtils.hasText(strategy.getCoverUrl()) && !strategy.getCoverUrl().startsWith("http")) {
            // 上传封面图片，得到URL后，重新设置到cover属性中
            String fiilename = UUID.randomUUID().toString();
            // 可以解析base64得到格式，这里直接写死
            String url = OssUtil.uploadImgByBase64("images/strategies", fiilename + ".jpg", strategy.getCoverUrl());
            strategy.setCoverUrl(url);

        }
        // 补充分类名称
        StrategyCatalog catalog = strategyCatalogService.getById(strategy.getCatalogId());
        if (catalog == null) {
            throw new BizException(R.CODE_ERROR_PARAM, "分类参数异常");
        }
        strategy.setCatalogName(catalog.getName());
        // 根据分类目的地id/名称，设置到目的地中
        strategy.setDestId(catalog.getDestId());
        strategy.setDestName(catalog.getDestName());
        // 判断目的地是否是国外
        List<Destination> toasts = destinationService.toasts(catalog.getDestId());
        if (toasts.get(0).getId() == 1) {
            strategy.setIsabroad(Strategy.ABROAD_NO);
        } else {
            strategy.setIsabroad(Strategy.ABROAD_YES);
        }
        // 查询主题，填充主题名称
        StrategyTheme theme = strategyThemeService.getById(strategy.getThemeId());
        if (theme == null) {
            throw new BizException(R.CODE_ERROR_PARAM, "主题参数异常");
        }
        strategy.setThemeName(theme.getName());

        if (strategy.getId() == null) {
            // 设置创建时间
            strategy.setCreateTime(new Date());
            // 设置各种数量为0
            strategy.setViewnum(0);
            strategy.setSharenum(0);
            strategy.setThumbsupnum(0);
            strategy.setReplynum(0);
            strategy.setFavornum(0);
            // 重新设置状态
            strategy.setState(Strategy.STATE_NORMAL);
            // 保存攻略对象，得到自增ID
            boolean save = super.save(strategy);
            // 将攻略ID设置到内容对象中，保存内容对象
            StrategyContent content = strategy.getContent();
            content.setId(strategy.getId());
            return save && strategyContentMapper.insert(content) > 0;
        }
        // 更新操作
        boolean ret = super.updateById(strategy);
        StrategyContent content = strategy.getContent();
        content.setId(strategy.getId());
        int row = strategyContentMapper.updateById(content);
        return ret && row > 0;
    }
}

/**
 * 保存攻略
 *
 * @param strategy 攻略参数对象
 */
@Transactional(rollbackFor = Exception.class)
@Override
public boolean save(Strategy strategy) {
    // 同一类，事务调用非事务，事务都生效
    return doSaveOrUpdate(strategy);
}

/**
 * 更新攻略
 *
 * @param strategy 攻略参数对象
 */
@Transactional(rollbackFor = Exception.class)
@Override
public boolean updateById(Strategy strategy) {
    return doSaveOrUpdate(strategy);
}

@PostMapping("/save")
public R<?> save(Strategy strategy) {
    return R.ok(strategyService.save(strategy));
}

@PostMapping("/update")
public R<?> update(Strategy strategy) {
    strategyService.updateById(strategy);
    return R.ok();
}

/**
 * 根据攻略ID，返回攻略内容
 *
 * @param id 攻略ID
 * @return 攻略内容
 */
StrategyContent getContentById(Long id);

/**
 * 根据攻略ID，返回攻略内容
 *
 * @param id 攻略ID
 * @return 攻略内容
 */
@Override
public StrategyContent getContentById(Long id) {
    return strategyContentMapper.selectById(id);
}

@GetMapping("/content")
public R<StrategyContent> getContentById(Long id) {
    return R.ok(strategyService.getContentById(id));
}

public interface StrategyMapper extends BaseMapper<Strategy> {
    List<StrategyCatalog> selectGroupsByDestId(@Param("destId") Long destId);
}

/**
 * 根据目的地ID，分组查询攻略分类下的攻略
 *
 * @param destId 目的地ID
 * @return 分类及其下的攻略
 */
List<StrategyCatalog> findGroupsByDestId(Long destId);

/**
 * 根据目的地ID，分组查询攻略分类下的攻略
 *
 * @param destId 目的地ID
 * @return 分类及其下的攻略
 */
@Override
public List<StrategyCatalog> findGroupsByDestId(Long destId) {
    return baseMapper.selectGroupsByDestId(destId);
}

@GetMapping("/groups")
public R<List<StrategyCatalog>> groupByCatalog(Long destId) {
    return R.ok(strategyService.findGroupsByDestId(destId));
}

/**
 * 启用 Spring 任务调度
 */
@EnableScheduling
@MapperScan("com.swx.data.mapper")
@SpringBootApplication
public class DataApplication {
    public static void main(String[] args) {
        SpringApplication.run(DataApplication.class, args);
    }
}

public interface StrategyMapper extends BaseMapper<Strategy> {
    List<StrategyRank> selectStrategyRankByAbroad(@Param("abroad") Integer abroad);
    List<StrategyRank> selectStrategyRankHotList();
}

public interface StrategyRankMapper extends BaseMapper<StrategyRank> {
    int batchInsert(@Param("strategyRanks") List<StrategyRank> strategyRanks);
}

/**
 * 攻略排行数据统计任务
 */
@Slf4j
@Service
public class StrategyRankStatisticJob {

    private final StrategyMapper strategyMapper;
    private final StrategyRankMapper strategyRankMapper;

    public StrategyRankStatisticJob(StrategyMapper strategyMapper, StrategyRankMapper strategyRankMapper) {
        this.strategyMapper = strategyMapper;
        this.strategyRankMapper = strategyRankMapper;
    }

    /**
     * 每10分钟执行统计任务
     */
    @Transactional(rollbackFor = Exception.class)
    // @Scheduled(cron = "0 */10 * * * *")
    @Scheduled(cron = "0 * * * * *")
    public void statisticRank() {
        log.info("[攻略排行统计] 排行数据统计开始 >>>>>>>>>");
        Date now = new Date();
        // 删除这一次之前的所有数据
        strategyRankMapper.delete(Wrappers.<StrategyRank>lambdaQuery().lt(StrategyRank::getStatisTime, now));
        log.info("[攻略排行统计] 删除旧的排行数据 >>>>>>>>>");
        // 统计国内
        doStatistic(now, StrategyRank.TYPE_CHINA, () -> strategyMapper.selectStrategyRankByAbroad(Strategy.ABROAD_NO));

        // 统计国外
        doStatistic(now, StrategyRank.TYPE_ABROAD, () -> strategyMapper.selectStrategyRankByAbroad(Strategy.ABROAD_YES));

        // 统计热门
        doStatistic(now, StrategyRank.TYPE_HOT, strategyMapper::selectStrategyRankHotList);
    }

    public void doStatistic(Date now, Integer type, Supplier<List<StrategyRank>> rankSupplier) {
        List<StrategyRank> strategyRanks = rankSupplier.get();
        log.info("[攻略排行统计] 排行数据统计：type={}, ranks={}", type, strategyRanks.size());
        for (StrategyRank strategyRank : strategyRanks) {
            strategyRank.setType(type);
            strategyRank.setStatisTime(now);
        }
        // 保存到排名表中
        strategyRankMapper.batchInsert(strategyRanks);
    }
}

public interface StrategyRankService extends IService<StrategyRank> {
    /**
     * 根据类型获取排名
     *
     * @param type 类型
     * @return 排名
     */
    List<StrategyRank> selectLastRanksByType(int type);
}

@Service
public class StrategyRankServiceImpl extends ServiceImpl<StrategyRankMapper, StrategyRank> implements StrategyRankService {

    @Override
    public List<StrategyRank> selectLastRanksByType(int type) {
        return list(Wrappers.<StrategyRank>lambdaQuery()
                .eq(StrategyRank::getType, type)
                .orderByDesc(StrategyRank::getStatisTime)
                .last("limit 10")
        );
    }
}

@RestController
@RequestMapping("/strategies")
public class StrategyController {

    private final StrategyRankService strategyRankService;

    public StrategyController(StrategyRankService strategyRankService) {
        this.strategyRankService = strategyRankService;
    }

	@GetMapping("/ranks")
    public R<JSONObject> ranks() {
        List<StrategyRank> chinaRank = strategyRankService.selectLastRanksByType(StrategyRank.TYPE_CHINA);
        List<StrategyRank> abroadRank = strategyRankService.selectLastRanksByType(StrategyRank.TYPE_CHINA);
        List<StrategyRank> hotRank = strategyRankService.selectLastRanksByType(StrategyRank.TYPE_HOT);
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("abroadRank", abroadRank);
        jsonObject.put("chinaRank", chinaRank);
        jsonObject.put("hotRank", hotRank);
        return R.ok(jsonObject);
    }
}

@PostMapping("/delete/{id}")
public R<?> delete(@PathVariable Long id) {
    strategyService.removeById(id);
    return R.ok();
}

/**
 * 根据目的地ID，查询浏览量最高的前3篇攻略
 *
 * @param destId 目的地
 * @return 浏览量最高的前3篇攻略
 */
List<Strategy> findViewnumTop3(Long destId);

/**
 * 根据目的地ID，查询浏览量最高的前3篇攻略
 *
 * @param destId 目的地
 * @return 浏览量最高的前3篇攻略
 */
@Override
public List<Strategy> findViewnumTop3(Long destId) {
    return super.list(Wrappers.<Strategy>lambdaQuery()
            .eq(Strategy::getDestId, destId)
            .orderByDesc(Strategy::getViewnum)
            .last("limit 3")
    );
}

@GetMapping("/viewnumTop3")
public R<List<Strategy>> viewnumTop3(Long destId) {
    return R.ok(strategyService.findViewnumTop3(destId));
}