九、营销模块

最新推荐文章于 2024-10-10 09:56:47 发布

风斩晚霞

最新推荐文章于 2024-10-10 09:56:47 发布

阅读量532

点赞数

分类专栏：硅谷课堂文章标签： mybatis java spring

本文链接：https://blog.csdn.net/qq_45992768/article/details/130806575

版权

硅谷课堂专栏收录该内容

15 篇文章 0 订阅

订阅专栏

在service的module中建立service_activity模块：

创建对应的配置文件：


server.port=8303


spring.application.name=service-activity

spring.profiles.active=dev

spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/glkt_activity?characterEncoding=utf-8&useSSL=false
spring.datasource.username=root
spring.datasource.password=123456lxl

spring.jackson.date-format=yyyy-MM-dd HH:mm:ss
spring.jackson.time-zone=GMT+8

mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

mybatis-plus.mapper-locations=classpath:com/atguigu/ggkt/activity/mapper/xml/*.xml

spring.cloud.nacos.discovery.server-addr=127.0.0.1:8848

实现配置类（分页配置）：

package com.lxl.ggkt.activity.config;

import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@MapperScan("com.lxl.ggkt.activity.mapper")
public class ActivityConfig {

    /**
     * 分页插件
     */
    @Bean
    public PaginationInterceptor paginationInterceptor() {
        return new PaginationInterceptor();
    }
}

优惠券相关接口（获取优惠券，新增优惠券，修改优惠券，删除优惠券，删除一组优惠券，优惠券分页列表，已经使用的优惠券分页列表）CouponInfoController：

package com.lxl.ggkt.activity.controller;


import com.lxl.ggkt.activity.service.CouponInfoService;
import com.lxl.ggkt.model.activity.CouponInfo;
import com.lxl.ggkt.model.activity.CouponUse;
import com.lxl.ggkt.result.Result;
import com.lxl.ggkt.vo.activity.CouponUseQueryVo;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * <p>
 * 优惠券信息 前端控制器
 * </p>
 *
 * @author atguigu
 * @since 2022-04-29
 */
@RestController
@RequestMapping("/admin/activity/couponInfo")
public class CouponInfoController {

    @Autowired
    private CouponInfoService couponInfoService;

    @ApiOperation(value = "获取优惠券")
    @GetMapping("get/{id}")
    public Result get(@PathVariable String id) {
        CouponInfo couponInfo = couponInfoService.getById(id);
        return Result.ok(couponInfo);
    }

    @ApiOperation(value = "新增优惠券")
    @PostMapping("save")
    public Result save(@RequestBody CouponInfo couponInfo) {
        couponInfoService.save(couponInfo);
        return Result.ok(null);
    }

    @ApiOperation(value = "修改优惠券")
    @PutMapping("update")
    public Result updateById(@RequestBody CouponInfo couponInfo) {
        couponInfoService.updateById(couponInfo);
        return Result.ok(null);
    }

    @ApiOperation(value = "删除优惠券")
    @DeleteMapping("remove/{id}")
    public Result remove(@PathVariable String id) {
        couponInfoService.removeById(id);
        return Result.ok(null);
    }

    @ApiOperation(value="根据id列表删除优惠券")
    @DeleteMapping("batchRemove")
    public Result batchRemove(@RequestBody List<String> idList){
        couponInfoService.removeByIds(idList);
        return Result.ok(null);
    }

    //优惠券分页列表方法
    @ApiOperation(value = "获取分页列表")
    @GetMapping("{page}/{limit}")
    public Result index(
            @ApiParam(name = "page", value = "当前页码", required = true)
            @PathVariable Long page,
            @ApiParam(name = "limit", value = "每页记录数", required = true)
            @PathVariable Long limit) {
        Page<CouponInfo> pageParam = new Page<>(page,limit);
        IPage<CouponInfo> pageModel = couponInfoService.page(pageParam);
        return Result.ok(pageModel);
    }

    //获取已经使用优惠券列表（条件查询分页）
    @ApiOperation(value = "获取分页列表")
    @GetMapping("couponUse/{page}/{limit}")
    public Result index(
            @ApiParam(name = "page", value = "当前页码", required = true)
            @PathVariable Long page,
            @ApiParam(name = "limit", value = "每页记录数", required = true)
            @PathVariable Long limit,
            @ApiParam(name = "couponUseVo", value = "查询对象", required = false)
                    CouponUseQueryVo couponUseQueryVo) {
        Page<CouponUse> pageParam = new Page<>(page,limit);
        IPage<CouponUse> pageModel =
                couponInfoService.selectCouponUsePage(pageParam,couponUseQueryVo);
        return Result.ok(pageModel);
    }

}

优惠券信息相关方法（涉及用户信息远程调用为后期的需求设计）CouponInfoServiceImpl：

package com.lxl.ggkt.activity.service.impl;

import com.lxl.ggkt.activity.service.CouponUseService;
import com.lxl.ggkt.client.user.UserInfoFeignClient;
import com.lxl.ggkt.model.activity.CouponInfo;
import com.lxl.ggkt.activity.mapper.CouponInfoMapper;
import com.lxl.ggkt.activity.service.CouponInfoService;
import com.lxl.ggkt.model.activity.CouponUse;
import com.lxl.ggkt.model.user.UserInfo;
import com.lxl.ggkt.vo.activity.CouponUseQueryVo;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

import java.util.Date;
import java.util.List;

/**
 * <p>
 * 优惠券信息 服务实现类
 * </p>
 *
 * @author lxl
 * @since 2022-04-29
 */
@Service
public class CouponInfoServiceImpl extends ServiceImpl<CouponInfoMapper, CouponInfo> implements CouponInfoService {

    @Autowired
    private CouponUseService couponUseService;

    @Autowired
    private UserInfoFeignClient userInfoFeignClient;

    //获取已经使用优惠券列表（条件查询分页）
    @Override
    public IPage<CouponUse> selectCouponUsePage(Page<CouponUse> pageParam,
                                                CouponUseQueryVo couponUseQueryVo) {
        //获取条件
        Long couponId = couponUseQueryVo.getCouponId();
        String couponStatus = couponUseQueryVo.getCouponStatus();
        String getTimeBegin = couponUseQueryVo.getGetTimeBegin();
        String getTimeEnd = couponUseQueryVo.getGetTimeEnd();
        //封装条件
        QueryWrapper<CouponUse> wrapper = new QueryWrapper<>();
        if(!StringUtils.isEmpty(couponId)) {
            wrapper.eq("coupon_id",couponId);
        }
        if(!StringUtils.isEmpty(couponStatus)) {
            wrapper.eq("coupon_status",couponStatus);
        }
        if(!StringUtils.isEmpty(getTimeBegin)) {
            wrapper.ge("get_time",getTimeBegin);
        }
        if(!StringUtils.isEmpty(getTimeEnd)) {
            wrapper.le("get_time",getTimeEnd);
        }
        //调用方法条件分页查询
        IPage<CouponUse> pageModel = couponUseService.page(pageParam, wrapper);
        List<CouponUse> couponUseList = pageModel.getRecords();
        //遍历
        couponUseList.stream().forEach(item->{
            this.getUserInfoById(item);
        });
        return pageModel;
    }

    //更新优惠券
    @Override
    public void updateCouponInfoUseStatus(Long couponUseId, Long orderId) {
        CouponUse couponUse = new CouponUse();
        couponUse.setId(couponUseId);
        couponUse.setOrderId(orderId);
        couponUse.setCouponStatus("1");
        couponUse.setUsingTime(new Date());
        couponUseService.updateById(couponUse);
    }

    //根据用户id，通过远程调用得到用户信息
    private CouponUse getUserInfoById(CouponUse couponUse) {
        //获取用户id
        Long userId = couponUse.getUserId();
        if(!StringUtils.isEmpty(userId)) {
            //远程调用
            UserInfo userInfo = userInfoFeignClient.getById(userId);
            if(userInfo != null) {
                couponUse.getParam().put("nickName",userInfo.getNickName());
                couponUse.getParam().put("phone",userInfo.getPhone());
            }
        }
        return couponUse;
    }
}

封装类（优惠券的相关信息）CouponInfo：

package com.lxl.ggkt.model.activity;

import com.lxl.ggkt.model.base.BaseEntity;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

import java.math.BigDecimal;
import java.util.Date;

@Data
@ApiModel(description = "CouponInfo")
@TableName("coupon_info")
public class CouponInfo extends BaseEntity {

	private static final long serialVersionUID = 1L;

	@ApiModelProperty(value = "购物券类型 1 现金券")
	@TableField("coupon_type")
	private String couponType;

	@ApiModelProperty(value = "优惠卷名字")
	@TableField("coupon_name")
	private String couponName;

	@ApiModelProperty(value = "金额")
	@TableField("amount")
	private BigDecimal amount;

	@ApiModelProperty(value = "使用门槛 0->没门槛")
	@TableField("condition_amount")
	private BigDecimal conditionAmount;

	@ApiModelProperty(value = "可以领取的开始日期")
	@TableField("start_time")
	@JsonFormat(pattern = "yyyy-MM-dd")
	private Date startTime;

	@ApiModelProperty(value = "可以领取的结束日期")
	@TableField("end_time")
	@JsonFormat(pattern = "yyyy-MM-dd")
	private Date endTime;

	@ApiModelProperty(value = "使用范围[1->全场通用]")
	@TableField("range_type")
	private String rangeType;

	@ApiModelProperty(value = "使用范围描述")
	@TableField("rule_desc")
	private String ruleDesc;

	@ApiModelProperty(value = "发行数量")
	@TableField("publish_count")
	private Integer publishCount;

	@ApiModelProperty(value = "每人限领张数")
	@TableField("per_limit")
	private Integer perLimit;

	@ApiModelProperty(value = "已使用数量")
	@TableField("use_count")
	private Integer useCount;

	@ApiModelProperty(value = "领取数量")
	@TableField("receive_count")
	private Integer receiveCount;

	@ApiModelProperty(value = "过期时间")
	@TableField("expire_time")
	@JsonFormat(pattern = "yyyy-MM-dd")
	private Date expireTime;

	@ApiModelProperty(value = "发布状态[0-未发布，1-已发布]")
	@TableField("publish_status")
	private Boolean publishStatus;

	@ApiModelProperty(value = "使用状态")
	@TableField(exist = false)
	private String couponStatus;

	@ApiModelProperty(value = "优惠券领取表id")
	@TableField(exist = false)
	private Long couponUseId;

	@ApiModelProperty(value = "领取时间")
	@TableField(exist = false)
	@JsonFormat(pattern = "yyyy-MM-dd")
	private Date getTime;

}

封装类（优惠券被使用的信息）CouponUseQueryVo：

package com.lxl.ggkt.vo.activity;

import lombok.Data;
import io.swagger.annotations.ApiModelProperty;

@Data
public class CouponUseQueryVo {
	
	@ApiModelProperty(value = "购物券ID")
	private Long couponId;
	@ApiModelProperty(value = "购物券状态（1：未使用 2：已使用）")
	private String couponStatus;

	@ApiModelProperty(value = "获取时间")
	private String getTimeBegin;

	@ApiModelProperty(value = "使用时间")
	private String getTimeEnd;

}

获取优惠券详情时，也需要同时获得使用者的手机和昵称，因此本功能需要远程调用来实现。

创建service_user模块：

创建启动类：

package com.lxl.ggkt.user;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.context.annotation.ComponentScan;

@SpringBootApplication
@EnableDiscoveryClient
@MapperScan("com.lxl.ggkt.user.mapper")
@ComponentScan(basePackages = "com.lxl")
public class ServiceUserApplication {

    public static void main(String[] args) {
        SpringApplication.run(ServiceUserApplication.class, args);
    }

}

创建配置文件（wechat为后续公众号开发使用）：


server.port=8304

spring.application.name=service-user

spring.profiles.active=dev

spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/glkt_user?characterEncoding=utf-8&useSSL=false
spring.datasource.username=root
spring.datasource.password=123456lxl

spring.jackson.date-format=yyyy-MM-dd HH:mm:ss
spring.jackson.time-zone=GMT+8

mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

spring.cloud.nacos.discovery.server-addr=127.0.0.1:8848

wechat.mpAppId: wxd4e0bcc0aa6b50d0

wechat.mpAppSecret: ad5712c888df46205b11fb77cddd0f0a

wechat.userInfoUrl: http://ggktlxl.free.idcfengye.com/api/user/wechat/userInfo

配置网关路径：

spring.cloud.gateway.routes[2].id=service-user

spring.cloud.gateway.routes[2].uri=lb://service-user

spring.cloud.gateway.routes[2].predicates= Path=/*/user/**

创建模块定义远程接口：

在service下建立service_client，在service_client下建立service_user_client

导入feign依赖来实现服务调用：

        <!-- 服务调用feign -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
            <scope>provided </scope>
        </dependency>

定义远程调用接口UserInfoFeignClient：

package com.lxl.ggkt.client.user;

import com.lxl.ggkt.model.user.UserInfo;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;

@FeignClient(value = "service-user")
public interface UserInfoFeignClient {

    @GetMapping("/admin/user/userInfo/inner/getById/{id}")
    public UserInfo getById(@PathVariable Long id);
}

同时将依赖引入service_activity：

        <dependency>
            <groupId>com.lxl</groupId>
            <artifactId>service_user_client</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>

最后完成service_activity的路由配置：

spring.cloud.gateway.routes[3].id=service-activity

spring.cloud.gateway.routes[3].uri=lb://service-activity

spring.cloud.gateway.routes[3].predicates= Path=/*/activity/**

根据id获取用户信息接口UserInfoController：

package com.lxl.ggkt.user.controller;


import com.lxl.ggkt.model.user.UserInfo;
import com.lxl.ggkt.user.service.UserInfoService;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RestController;

/**
 * <p>
 * 用户表 前端控制器
 * </p>
 *
 * @author atguigu
 * @since 2022-04-29
 */
@RestController
@RequestMapping("/admin/user/userInfo")
public class UserInfoController {

    @Autowired
    private UserInfoService userInfoService;

    @ApiOperation(value = "获取")
    @GetMapping("inner/getById/{id}")
    public UserInfo getById(@PathVariable Long id) {
        return userInfoService.getById(id);
    }
}

UserInfoServiceImpl：

package com.lxl.ggkt.user.service.impl;

import com.lxl.ggkt.model.user.UserInfo;
import com.lxl.ggkt.user.mapper.UserInfoMapper;
import com.lxl.ggkt.user.service.UserInfoService;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;

/**
 * <p>
 * 用户表 服务实现类
 * </p>
 *
 * @author lxl
 * @since 2022-04-29
 */
@Service
public class UserInfoServiceImpl extends ServiceImpl<UserInfoMapper, UserInfo> implements UserInfoService {
    @Override
    public UserInfo getUserInfoOpenid(String openId) {
        QueryWrapper<UserInfo> wrapper = new QueryWrapper<>();
        wrapper.eq("open_id",openId);
        UserInfo userInfo = baseMapper.selectOne(wrapper);

        return userInfo;
    }

}