基于javaweb+mysql的springboot前后端分离网上手机商城平台系统设计和实现(java+vue+redis+springboot+mysql+ssm)

基于javaweb+mysql的springboot前后端分离网上手机商城平台系统设计和实现(java+vue+redis+springboot+mysql+ssm)

运行环境

Java≥8、MySQL≥5.7、Node.js≥10

开发工具

后端：eclipse/idea/myeclipse/sts等均可配置运行

前端：WebStorm/VSCode/HBuilderX等均可

适用

课程设计，大作业，毕业设计，项目练习，学习演示等

功能说明

基于javaweb+mysql的SpringBoot前后端分离网上手机商城平台系统设计和实现(java+vue+redis+springboot+mysql+ssm)

主要模块设计如下： 前后端主要技术：Java springboot springMVC mybatis mysql vue jquery node.js redis

1. 用户注册和登录功能：。

2. 用户信息的管理以及角色的管理、不同用户角色具有不同的功能权限操作。

3. 商品的操作、包括商品列表信息、商品的分离、商品的详情、品牌和规格等操作。

4. 购物车的管理操作：

5. 订单管理操作：

6）用户退货管理

7）手机商品类型的管理

8）手机商品信息的预览、查看、搜索

9）修改密码、退出登录等功能

        if(productService.updateById(product)){
            return CommonResult.success("修改商品成功",product);
        }else{
            return CommonResult.error("修改商品失败");
        }
    }

    @RequestMapping(value = "/product/delete")
    private CommonResult delete(Integer productId) {
        if(productService.deleteById(productId)){
            return CommonResult.success("商品删除成功","productId：" + productId);
        }else{
            return CommonResult.error("商品删除失败");
        }
    }

    /*商品类别*/
    @RequestMapping(value = "/productType/add")
    private CommonResult addType(ProductType productType) {
        if(productTypeService.insertData(productType)){
            return CommonResult.success("商品分类添加成功",productType);
        }else{
            return CommonResult.error("商品分类添加失败");
        }
    }

    @RequestMapping(value = "/productType/update")
    private CommonResult updateType(ProductType productType) {
        if(productTypeService.updateById(productType)){
            return CommonResult.success("商品分类修改成功",productType);
        }else{
            return CommonResult.error("商品分类修改失败");
        }
    }

    @RequestMapping(value = "/productType/deleteById")
    private CommonResult deleteTypeById(Integer typeId) {
        if(productTypeService.deleteById(typeId)){
            return CommonResult.success("商品分类删除成功","typeId: "+typeId);
        }else{
            return CommonResult.error("商品分类删除失败");
        }
    }

    @RequestMapping(value = "/productType/deleteByName")
    private CommonResult deleteTypeByName(String typeName) {
        if(productTypeService.deleteByName(typeName)){
            return CommonResult.success("商品分类删除成功","typeName: "+typeName);

            return CommonResult.error("物流信息查询失败");
        }
    }

    /*查询全部物流信息*/
    @RequestMapping(value = "/logistics/findAllInfo")
    private CommonResult findAllInfo() {
        List<Logistics> logistics = logisticsService.selectAll();
        if(logistics!=null){
            return CommonResult.success("物流信息查询成功",logistics);
        }else{
            return CommonResult.error("物流信息查询失败");
        }
    }

    @RequestMapping(value = "/logistics/addInfo")
    private CommonResult addInfo(Logistics logistics) {
        if(logistics!=null){
            if(logisticsService.insertData(logistics)){
                return CommonResult.success("物流信息添加成功",logistics);
            }else{
                return CommonResult.error("物流信息添加失败");
            }
        }
        return CommonResult.error("物流信息数据不存在");
    }

    @RequestMapping(value = "/logistics/deleteInfo")
    private CommonResult deleteInfo(Integer logisticId) {
        if(logisticId!=null){
            if(logisticsService.deleteById(logisticId)){
                return CommonResult.success("物流信息删除成功",logisticId);
            }else{
                return CommonResult.error("物流信息删除失败");
            }
        }
        return CommonResult.error("物流信息数据不存在");
    }

    @RequestMapping(value = "/orderDetail/returnInfo")
    private CommonResult returnInfo(String orderNo) {
        ArrayList<Object> resultList = new ArrayList<>();
        Map<String, Object> returnGoods = returnGoodsService.selectOrderNo(orderNo);
        Logistics logistics = logisticsService.selectOrderNo(orderNo);
        if(returnGoods!=null){
            resultList.add(returnGoods);
        }
        if(logistics!=null){
            resultList.add(logistics);
        }

        }
        return CommonResult.error("商品退货数据不存在");
    }

    @RequestMapping(value = "/returnGoods/updateReturn")
    private CommonResult updateReturn(ReturnGoods returnGoods) {
        if(returnGoods!=null){
            returnGoods.setDealTime(new Date());
            if(returnGoodsService.updateById(returnGoods)){
                return CommonResult.success("更新成功",returnGoods);
            }else{
                return CommonResult.error("更新失败");
            }
        }
        return CommonResult.error("商品退货数据不存在");
    }

    /*我的订单 查询退货订单信息*/
    @RequestMapping(value = "/returnGoods/findReturnInfo")
    private CommonResult findReturnInfo(String userNumber) {
        if(userNumber!=null){
            List<Map<String, Object>> data = returnGoodsService.selectAllOrder(userNumber);
            return CommonResult.success("商品退货订单查询成功",data);
        }
        return CommonResult.error("商品退货数据不存在");
    }

    /*拒绝买家退货*/
    @RequestMapping(value = "/returnGoods/refuseReturn")
    private CommonResult refuseReturn(Integer returnId,String operatorNumber,String operatorName) {
        if(returnId!=null){
            ReturnGoods returnGoods = returnGoodsService.selectById(returnId);
            returnGoods.setReturnState("已拒绝");
            returnGoods.setDealTime(new Date());
            returnGoods.setOperatorNumber(operatorNumber);
            returnGoods.setOperatorName(operatorName);
            String orderNo = returnGoods.getOrderNo();
            Integer orderId = orderService.selectIdByKey(orderNo);
            Order order = new Order();
            order.setOrderId(orderId);
            order.setOrderState("已拒绝");
            if(orderService.updateById(order)){
                if(returnGoodsService.updateById(returnGoods)){
                    return CommonResult.success("更新成功",returnGoods);
                }else{
                    return CommonResult.error("更新失败");
                }
            }else {

        }
    }

    @RequestMapping(value = "/productType/deleteByName")
    private CommonResult deleteTypeByName(String typeName) {
        if(productTypeService.deleteByName(typeName)){
            return CommonResult.success("商品分类删除成功","typeName: "+typeName);
        }else{
            return CommonResult.error("商品分类删除失败");
        }
    }

    @RequestMapping(value = "/productType/existsTypeName")
    private CommonResult existsTypeName(Integer typeId,String typeName) {
        Boolean isExist = productTypeService.existsWithTypeName(typeId,typeName);
        if(isExist!=null){
            return CommonResult.success("查询成功",isExist);
        }else{
            return CommonResult.error("查询失败");
        }
    }

    @RequestMapping(value = "/productType/findAll")
    private CommonResult findAllType() {
        List<ProductType> productTypes = productTypeService.selectAll();
        if(productTypes!=null){
            return CommonResult.success("商品分类查询成功",productTypes);
        }else{
            return CommonResult.error("商品分类查询失败");
        }
    }

    @RequestMapping(value = "/productType/findAllName")
    private CommonResult findAllTypeName() {
        List<String> names = productTypeService.selectAllName();
        if(names!=null){
            return CommonResult.success("商品分类名称查询成功",names);
        }else{
            return CommonResult.error("商品分类名称查询失败");
        }
    }

    /*商品品牌*/
    @RequestMapping(value = "/productBrand/add")

        this.roleService = roleService;
    }

    /*根据id查询用户*/
    @RequestMapping(value = "/role/findById")
    private CommonResult findById(Integer roleId) {
        Role role = roleService.selectById(roleId);
        if(role!=null){
            return CommonResult.success("查询成功",role);
        }else{
            return CommonResult.error("查询失败");
        }
    }
    /*根据角色名称查询角色*/
    @RequestMapping(value = "/role/findByKey")
    private CommonResult findByKey(String roleName) {
        Role role = roleService.selectByKey(roleName);
        if(role!=null){
            return  CommonResult.success("查询成功",role);
        }else{
            return CommonResult.error("查询失败");
        }
    }
    /*根据key查询用户*/
    @RequestMapping(value = "/role/existRoleName")
    private CommonResult existRoleName(Integer roleId,String roleName) {
        Boolean isExist = roleService.existsRoleName(roleId,roleName);
        if(isExist!=null){
            return  CommonResult.success("查询成功",isExist);
        }else{
            return CommonResult.error("查询失败");
        }
    }

    /*查询所有角色信息*/
    @RequestMapping(value = "/role/findAll")
    private CommonResult findAll() {
        List<Role> roles = roleService.selectAll();
        if(roles!=null){
            return CommonResult.success("查询成功",roles);

            }else{
                return CommonResult.error("删除失败");
            }
        }
        return CommonResult.error("商品退货数据不存在");
    }

    /*查询物流信息*/
    @RequestMapping(value = "/logistics/findInfoById")
    private CommonResult findInfoById(Integer logisticId) {
        Logistics logistics = logisticsService.selectById(logisticId);
        if(logistics!=null){
            return CommonResult.success("物流信息查询成功",logistics);
        }else{
            return CommonResult.error("物流信息查询失败");
        }
    }

    /*查询全部物流信息*/
    @RequestMapping(value = "/logistics/findAllInfo")
    private CommonResult findAllInfo() {
        List<Logistics> logistics = logisticsService.selectAll();
        if(logistics!=null){
            return CommonResult.success("物流信息查询成功",logistics);
        }else{
            return CommonResult.error("物流信息查询失败");
        }
    }

    @RequestMapping(value = "/logistics/addInfo")
    private CommonResult addInfo(Logistics logistics) {
        if(logistics!=null){
            if(logisticsService.insertData(logistics)){
                return CommonResult.success("物流信息添加成功",logistics);
            }else{
                return CommonResult.error("物流信息添加失败");
            }
        }
        return CommonResult.error("物流信息数据不存在");
    }

    @RequestMapping(value = "/logistics/deleteInfo")
    private CommonResult deleteInfo(Integer logisticId) {
        if(logisticId!=null){
            if(logisticsService.deleteById(logisticId)){
                return CommonResult.success("物流信息删除成功",logisticId);
            }else{

            }
        }
        return CommonResult.error("商品退货数据不存在");
    }

    /*买家快递寄回*/
    @RequestMapping(value = "/returnGoods/sendBack")
    private CommonResult sendBack(Integer returnId) {
        if(returnId!=null){
            ReturnGoods returnGoods = new ReturnGoods();
            returnGoods.setReturnId(returnId);
            returnGoods.setReturnState("待收货");
            returnGoods.setDealTime(new Date());
            if(returnGoodsService.updateById(returnGoods)){
                return CommonResult.success("更新成功",returnGoods);
            }else{
                return CommonResult.error("更新失败");
            }
        }
        return CommonResult.error("商品退货数据不完整");
    }

    /*商家收到寄回的商品*/
    @RequestMapping(value = "/returnGoods/receipt")
    private CommonResult receipt(Integer returnId) {
        if(returnId!=null){
            ReturnGoods returnGoods = new ReturnGoods();
            returnGoods.setReturnId(returnId);
            returnGoods.setReturnState("退货完成");
            returnGoods.setDealTime(new Date());
            if(returnGoodsService.updateById(returnGoods)){
                return CommonResult.success("更新成功",returnGoods);
            }else{
                return CommonResult.error("更新失败");
            }
        }
        return CommonResult.error("商品退货数据不完整");
    }

    @RequestMapping(value = "/returnGoods/deleteReturn")
    private CommonResult deleteReturn(Integer returnId) {
        if(returnId!=null){
            if(returnGoodsService.deleteById(returnId)){
                return CommonResult.success("删除成功",returnId);
            }else{
                return CommonResult.error("删除失败");
            }

/**
 * @email qiudb.top@aliyun.com
 * @description 登录、退出、修改个人信息等业务操作
 */
@RestController
@CrossOrigin
public class OperateController {
    private final Logger logger = LoggerFactory.getLogger(this.getClass());
    final RoleService roleService;
    final UserService userService;
    final UserRoleService userRoleService;
    public OperateController(UserService userService, RoleService roleService, UserRoleService userRoleService) {
        this.userService = userService;
        this.roleService = roleService;
        this.userRoleService = userRoleService;
    }

    //未登录时，将被转发到此请求上
    @RequestMapping("/notLogin")
    private CommonResult toLogin(){
        return new CommonResult(401,"请登录！");
    }

    /**
     * 登录操作
     * @param username  用户登录的帐号
     * @param password  用户登录的密码
     * @param rememberMe shiro框架的 记住我 功能
     */
    @RequestMapping(value = "/login",produces = {"application/json;charset=UTF-8"})
    private CommonResult doLogin(String username,String password,boolean rememberMe) {
        try {
            if (username == null) {
                throw new AuthenticationException();
            }
            if (password == null) {
                throw new IncorrectCredentialsException();

            String orderNo = returnGoods.getOrderNo();
            Integer orderId = orderService.selectIdByKey(orderNo);
            Order order = new Order();
            order.setOrderId(orderId);
            order.setReturnState(true);
            order.setOrderState("已退款");
            Logistics logistics = logisticsService.selectOrderNo(orderNo);
            if(logistics!=null){
                logisticsService.deleteById(logistics.getLogisticId());
            }
            if(orderService.updateById(order)){
                if(returnGoodsService.updateById(returnGoods)){
                    return CommonResult.success("更新成功",returnGoods);
                }else{
                    return CommonResult.error("更新失败");
                }
            }else{
                return CommonResult.error("更新失败");
            }
        }
        return CommonResult.error("商品退款数据不存在");
    }

    /*拒绝买家退款申请*/
    @RequestMapping(value = "/returnGoods/rejectRefund")
    private CommonResult rejectRefund(Integer returnId,String operatorNumber,String operatorName) {
        if(returnId!=null){
            ReturnGoods returnGoods = returnGoodsService.selectById(returnId);
            returnGoods.setReturnState("拒绝退款");
            returnGoods.setDealTime(new Date());
            returnGoods.setOperatorNumber(operatorNumber);
            returnGoods.setOperatorName(operatorName);
            String orderNo = returnGoods.getOrderNo();
            Integer orderId = orderService.selectIdByKey(orderNo);
            Order order = new Order();
            order.setOrderId(orderId);
            order.setOrderState("待发货");
            if(orderService.updateById(order)){
                if(returnGoodsService.updateById(returnGoods)){
                    return CommonResult.success("更新成功",returnGoods);
                }else{
                    return CommonResult.error("更新失败");
                }
            }else {
                return CommonResult.error("更新失败");
            }
        }
        return CommonResult.error("商品退款数据不存在");
    }

    /*同意买家退货*/
    @RequestMapping(value = "/returnGoods/dealWithReturn")

/**
 * @email qiudb.top@aliyun.com
 * @description 订单相关业务
 */

@RestController
@CrossOrigin
public class OrderController {
    final OrderService orderService;
    final ProductService productService;
    final LogisticsService logisticsService;
    final RedisTemplate<String,String> redisTemplate;
    public OrderController(RedisTemplate<String,String> redisTemplate,OrderService orderService,LogisticsService logisticsService,ProductService productService) {
        this.orderService = orderService;
        this.productService = productService;
        this.logisticsService = logisticsService;
        this.redisTemplate = redisTemplate;
    }

    @RequestMapping(value = "/order/findById")
    private CommonResult findOrderById(Integer orderId) {
        Order order= orderService.selectById(orderId);
        if(orderId!=null){
            return CommonResult.success("订单信息查询成功",order);
        }else{
            return CommonResult.error("订单信息查询失败");
        }
    }
    @RequestMapping(value = "/order/findOrderInfo")
    private CommonResult findOrderInfo(String userAccount) {
        List<Map<String, Object>> orderMap = orderService.selectAllOrder(userAccount);
        if(orderMap!=null){
            return CommonResult.success("订单信息查询成功",orderMap);

            return CommonResult.error("全部商品信息查询失败");
        }
    }
    @RequestMapping(value = "/product/findAllByType")
    private CommonResult findAllByType() {
        List<Map<String, Object>> maps = productService.selectAllByType();
        if(maps!=null){
            return CommonResult.success("商品分类信息查询成功",maps);
        }else{
            return CommonResult.error("商品分类信息查询失败");
        }
    }

    @RequestMapping(value = "/product/add")
    private CommonResult add(Product product) {
        System.out.println(product);
        if(productService.insertData(product)){
            return CommonResult.success("添加商品成功",product);
        }else{
            return CommonResult.error("添加商品失败");
        }
    }

    @RequestMapping(value = "/product/update")
    private CommonResult update(Product product) {
        if(product.getIsNew()!=null && product.getIsNew()){
            product.setSaleTime(new Date());
        }
        if(productService.updateById(product)){
            return CommonResult.success("修改商品成功",product);
        }else{
            return CommonResult.error("修改商品失败");
        }
    }

    @RequestMapping(value = "/product/delete")
    private CommonResult delete(Integer productId) {
        if(productService.deleteById(productId)){
            return CommonResult.success("商品删除成功","productId：" + productId);
        }else{
            return CommonResult.error("商品删除失败");
        }
    }

    /*商品类别*/

            return CommonResult.error("商品轮播图添加失败");
        }
    }

    @RequestMapping(value = "/banner/update")
    private CommonResult updateType(Banner banner) {
        if(bannerService.updateById(banner)){
            return CommonResult.success("商品轮播图修改成功",banner);
        }else{
            return CommonResult.error("商品轮播图修改失败");
        }
    }

    @RequestMapping(value = "/banner/deleteById")
    private CommonResult deleteTypeById(Integer bannerId) {
        if(bannerService.deleteById(bannerId)){
            return CommonResult.success("商品轮播图删除成功","bannerId: "+bannerId);
        }else{
            return CommonResult.error("商品轮播图删除失败");
        }
    }

    @RequestMapping(value = "/banner/findAll")
    private CommonResult findAllType() {
        List<Banner> banners = bannerService.selectAll();
        if(banners!=null){
            return CommonResult.success("商品轮播图查询成功",banners);
        }else{
            return CommonResult.error("商品轮播图查询失败");
        }
    }

    @RequestMapping(value = "/banner/findById")
    private CommonResult findById(Integer bannerId) {
        Banner banner = bannerService.selectById(bannerId);
        if(banner!=null){
            return CommonResult.success("商品轮播图查询成功",banner);
        }else{
            return CommonResult.error("商品轮播图查询失败");
        }
    }

}

    }

    @ResponseBody
    @PostMapping(value = "/vip", produces = "text/html;charset=utf-8")
    public String create(@RequestParam("orderNo") String orderNo,
                         @RequestParam("orderName") String orderName,
                         @RequestParam("payPrice") String payPrice,
                         @RequestParam("serialNumber") String serialNumber) {

        //开通vip的序列号暂时存入redis中
        redisTemplate.opsForValue().set(orderNo,serialNumber,2, TimeUnit.HOURS);
        //发起支付
        return alipayService.create(orderNo, orderName, payPrice);
    }

    /*
    https://qiustudy.utools.club/alipay/refund?orderNo=10060&payPrice=4000
     */
    @ResponseBody
    @RequestMapping(value = "/refund")
    public CommonResult refund(@RequestParam("orderNo") String orderNo,
                               @RequestParam("payPrice") String payPrice) {
        //发起支付
        try {
            alipayService.refund(orderNo,payPrice);
        } catch (AlipayApiException e) {
            log.info("【支付宝支付】退款失败 error={}", e.toString());
        }
        return CommonResult.success("退款成功");
    }

    @GetMapping(value = "/paySuccess")
    @ResponseBody
    public void success(@RequestParam Map<String, String> map,HttpServletResponse response) {
        try{
            String tradeNo =map.get("out_trade_no");
            if(tradeNo.contains("Vip")){

        this.aliYunSmsService = aliYunSmsService;
        this.redisTemplate = redisTemplate;
    }

    /**
     * 发送一个简单的文本邮件
     *
     * @param sendTo 收件人
     */
    @RequestMapping(value = "/util/send")
    public String sendmail(String sendTo) {
        mailService.sendSimpleMail(sendTo, "主题：你好普通邮件", "内容：第一封邮件");
        return "发送成功！";
    }

    /**
     * 发送一个邮箱随机验证码
     *
     * @param sendTo 收件人
     */
    @RequestMapping(value = "/allow/sendHtmlCode")
    public CommonResult sendHtmlCode(String sendTo) {
//        long startTime = System.currentTimeMillis(); //获取开始时间
        try {
            String code = MyUtils.getCode(6);
//            long oneTime = System.currentTimeMillis(); //获取第一阶段时间
            Map<String, Object> data = new HashMap<>();
            data.put("code", code);
            data.put("year", Calendar.getInstance().get(Calendar.YEAR));
            redisTemplate.opsForValue().set(sendTo, code, 10, TimeUnit.MINUTES);
            System.out.println("验证码是：" + code);
//          long twoTime = System.currentTimeMillis(); //获取第二阶段时间
            mailService.sendTemplateMail(sendTo, "操作验证码", "mail", data);
//          long threeTime = System.currentTimeMillis(); //获取第三阶段时间
//          MyUtils.speedTest(startTime,oneTime,twoTime,threeTime);
            return CommonResult.success("验证码已发送，网络有延迟请稍等~");
        } catch (Exception e) {
            return CommonResult.error("发送验证码时发生异常,请稍后重试！");
        }
    }

        if(specsName!=null){
            return CommonResult.success("查询成功",specsName);
        }else{
            return CommonResult.error("查询失败");
        }
    }

    @RequestMapping(value = "/productSpecs/add")
    private CommonResult add(ProductSpecs productSpecs) {
        if(productSpecs!=null){
            if(productSpecsService.insertData(productSpecs)){
                return CommonResult.success("添加成功",productSpecs);
            }else{
                return CommonResult.error("添加失败");
            }
        }
        return CommonResult.error("数据不存在");
    }

    @RequestMapping(value = "/productSpecs/addBatch")
    private CommonResult addBatch(Integer productId,Integer[] specsIds) {
        System.out.println(productId);
        System.out.println(Arrays.toString(specsIds));
        if(specsIds!=null){
            ProductSpecs productSpecs;
            List<ProductSpecs> productSpecsList = new ArrayList<>();
            for (Integer specsId : specsIds) {
                productSpecs = new ProductSpecs();
                productSpecs.setProductId(productId);
                productSpecs.setSpecsId(specsId);
                productSpecsList.add(productSpecs);
            }
            for (ProductSpecs specs : productSpecsList) {
                System.out.println(specs);
            }
            if(productSpecsService.insertBatch(productSpecsList)){
                return CommonResult.success("添加成功",productSpecsList);
            }else{
                return CommonResult.error("添加失败");
            }
        }
        return CommonResult.error("数据不存在");
    }

        return CommonResult.error("退货原因数据不存在");
    }

    @RequestMapping(value = "/returnReason/deleteReason")
    private CommonResult updateReason(Integer reasonId) {
        if(reasonId!=null){
            if(returnReasonService.deleteById(reasonId)){
                return CommonResult.success("删除成功",reasonId);
            }else{
                return CommonResult.error("删除失败");
            }
        }
        return CommonResult.error("退货原因数据不存在");
    }

    /*查询商品退货信息*/
    @RequestMapping(value = "/returnGoods/findReturnById")
    private CommonResult findReturnById(Integer returnId) {
        ReturnGoods returnGoods = returnGoodsService.selectById(returnId);
        if(returnGoods!=null){
            return CommonResult.success("退货商品查询成功",returnGoods);
        }else{
            return CommonResult.error("退货商品查询失败");
        }
    }
    /*查询全部退货商品*/
    @RequestMapping(value = "/returnGoods/findAllReturn")
    private CommonResult findAllReturn() {
        List<ReturnGoods> returnGoods = returnGoodsService.selectAll();
        if(returnGoods!=null){
            return CommonResult.success("退货商品查询成功",returnGoods);
        }else{
            return CommonResult.error("退货商品查询失败");
        }
    }

    @RequestMapping(value = "/returnGoods/findCount")
    private CommonResult findCount() {
        Integer count = returnGoodsService.selectCount();
        if(count!=null){

        if(isExist!=null){
            return CommonResult.success("查询成功",isExist);
        }else{
            return CommonResult.error("查询失败");
        }
    }

    /*判断手机号phone是否存在  目前被用于绑定手机号时，确认手机号已被绑定*/
    @RequestMapping(value = "/allow/existPhone")
    private CommonResult existPhone(String telephone) {
        Boolean isExist = userService.existsWithPrimaryPhone(telephone);
        if(isExist!=null){
            return CommonResult.success("手机号查询成功",isExist);
        }else{
            return CommonResult.error("手机号查询失败");
        }
    }
public static void main(String[] args) {
	System.out.println("23");
	 SimpleHash md5 = new SimpleHash("MD5", "admin", ByteSource.Util.bytes("1325554003@qq.com"), 2);
     System.out.println(md5.toHex());
}
    /*重置密码、找回密码*/
    @RequestMapping(value = "/allow/resetpwd")
    private CommonResult resetPwd(String accountNumber,String password) {
        if(accountNumber!=null && password!=null){
//            SimpleHash md5 = new SimpleHash("MD5", password, ByteSource.Util.bytes(accountNumber), 2);
//            password=md5.toHex();
            Integer id = userService.selectIdByKey(accountNumber);
            User user = new User();
            user.setUserId(id);
            user.setPassword(password);
            if(userService.updateById(user)){
                return CommonResult.success("重置密码成功",user);
            }else{
                return CommonResult.error("重置密码失败");
            }
        }
        return CommonResult.error("用户数据不存在");
    }

    /*用于注册新用户*/
    @RequestMapping(value = "/allow/add")
    private CommonResult add(User user) {
        if(user.getPassword()!=null && user.getUserName()!=null){
//            SimpleHash md5 = new SimpleHash("MD5", user.getPassword(), ByteSource.Util.bytes(user.getAccountNumber()), 2);
//            user.setPassword(md5.toHex());

    //删除vip信息
    @RequestMapping(value = "/vip/deleteVip")
    private CommonResult deleteVip(Integer vipId) {
        if(vipService.deleteById(vipId)){
            return CommonResult.success("删除成功",vipId);
        }else{
            return CommonResult.error("删除失败");
        }
    }
}

@CrossOrigin
@RequestMapping("/alipay")
@Slf4j
@Controller
public class AlipayController {
    private final AlipayService alipayService;
    private final OrderService orderService;
    private final RedisTemplate<String,String> redisTemplate;
    private final String hostAddress;
    public AlipayController(AlipayService alipayService,OrderService orderService,RedisTemplate<String,String> redisTemplate) {
        this.alipayService = alipayService;
        this.orderService = orderService;
        this.redisTemplate = redisTemplate;
        this.hostAddress= PropertiesUtil.getServerHost() +":"+PropertiesUtil.getPort();