睿乐购电商课程设计——用户模块

原創 antRain 2020-07-06 21:13

睿乐购电商课程设计——用户模块

mapper

  • 用户dao层
package com.ysu.shop.mapper;

import com.ysu.shop.pojo.User;
import org.apache.ibatis.annotations.*;
import org.apache.ibatis.annotations.Insert;

import java.util.List;
import java.util.Map;

// 使用泛型类型时忽略没有指定相应的类型
@SuppressWarnings("rawtypes")
public interface UserMapper {

        @Delete("DELETE FROM user WHERE id=#{id};")
        int delUser(int id);

        // 插入一条user
        @Insert("insert into " + "user(username, password, phone,email,role,question,answer,create_time,update_time)"
                        + "values (#{username}, #{password}, #{phone},#{email},"
                        + "#{role}, #{question},#{answer},NOW(), NOW() );")
        int insertUser(User user);

        // 按旧密码修改密码
        @Update("UPDATE user SET password=#{password_new},update_time=NOW() WHERE username=#{username} AND password=#{password_old};")
        int updatePasswordByOldPassword(String username, String password_old, String password_new);

        // 按用户名修改密码
        @Update("UPDATE user SET password=#{password_new},update_time=NOW() WHERE username=#{username};")
        int updatePasswordByUsername(String username, String password_new);

        // 按用户名修改信息
        @Update("UPDATE user SET email=#{email},phone=#{phone},question=#{question},answer=#{"
                        + "answer},update_time=NOW() WHERE username=#{username};")
        int updateUserByUsername(User user);

        // 按账号密码查找user
        @Select("SELECT * FROM user WHERE username=#{username} AND password=#{password} ;")
        User login(String username, String password);

        // 按用户名查找user
        @Select("SELECT * FROM user WHERE username=#{username};")
        User queryByUsername(String username);

        // 按用户名查找user
        @Select("SELECT * FROM user WHERE email=#{email};")
        User queryByEmail(String email);

        // 按用户名查找user
        @Select("SELECT * FROM user WHERE id=#{id};")
        User queryById(int id);

        // 判断问题
        @Select("SELECT * FROM user WHERE username=#{username} AND question=#{question} AND answer=#{answer};")
        User answer(String username, String question, String answer);

        // 修改密码

        @Select("SELECT * FROM user WHERE username=#{username};")
        List<User> queryAll();

        @Select(" <script>" + " SELECT * FROM user " + " where role != 'A' " + "limit #{start},#{limit} "
                        + " </script>")
        List<User> getBatch(Map params);

        @Select("select count(*) from user")
        int getTotal();

        @Select("SELECT * FROM user WHERE token = #{userToken}")
        User getUserByToken(String userToken);

        @Update("UPDATE user SET token=#{token},update_time=NOW() WHERE id=#{id};")
        int updateUserToken(int id, String token);

        @Update("UPDATE user SET password=#{password},update_time=NOW() WHERE username=#{username} AND token=#{token};")
        int forgetResetPassword(String username, String password, String token);

        @Select("SELECT * FROM user WHERE id like CONCAT('%',#{msg},'%') " +
        " or username like CONCAT('%',#{msg},'%') limit #{start},#{limit};" )
        List<User> queryAllByName(Map params);

        @Select("SELECT count(*) FROM user WHERE id like CONCAT('%',#{msg},'%') " +
        " or username like CONCAT('%',#{msg},'%');" )
        int queryAllByNameNum(Map params);
}
  • 收货地址dao层
package com.ysu.shop.mapper;

import com.ysu.shop.pojo.Address;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;

import java.util.List;
import java.util.Map;

@SuppressWarnings("rawtypes")
public interface AddressMapper {


    /*
     * 插入一条地址
     * */
    @Insert("insert into "+
            "address( user_id, receiver_name, receiver_phone,receiver_province,receiver_city,receiver_district," +
            "receiver_address,receiver_zip,create_time,update_time) "+
            "values(#{user_id}, #{receiver_name}, #{receiver_phone},"+
            "#{receiver_province},#{receiver_city},#{receiver_district},#{receiver_address},#{receiver_zip},NOW(),NOW());")
    int insertAddress(Address address);



    /*
     * 根据订单表里面的shipping_id删除一个地址
     * */
    @Delete("DELETE address FROM  address,orders WHERE address.user_id=orders.user_id AND orders.shipping_id=#{shipping_Id}")
    int delAddressByShipping_id(int shippingId);

    /*
     * 根据user_id修改地址
     * */
    @Update("UPDATE address SET receiver_province=#{receiver_province},receiver_city=#{receiver_city},"+
            "receiver_district=#{receiver_district}, receiver_address=#{receiver_address} ," +
            "receiver_zip=#{receiver_zip},update_time=NOW() WHERE id=#{id};")
    int updateAddressById(Address address);

    /*
     * 根据shipping_id查找地址
     * */
    @Select("SELECT * FROM order,address WHERE address.user_id = order.user_id AND order.shipping_id=#{shippingId};")
    Address selectByShipping_Id(int shippingId);


    /*
     * 查看地址列表
     * */
    @Select("SELECT * FROM address WHERE user_id=#{userId} ;")
    List<Address> queryAll(int userId);




    @Select(" <script>" +
            " SELECT * FROM address " +
            "<if test=\"offset!=null and limit!=null\">"+
            "limit #{offset},#{limit}"+
            "</if>"+
            " </script>")
    List<Address> getBatch(Map params);

    @Select("select count(*) from address")
    int getTotal();

      /**
        * @author:
        * @methodsName:
        * @description: 得到某一个用户的收货地址条数
        * @param:
        * @return:
        * @date: 2020/6/21
        * @throws:
        */
    @Select("select count(*) from address where user_id=#{user_id};")
    int getUserAddressTotal(int id);

  /**
    * @author:
    * @methodsName: 用户删除一条地址记录
    * @description:
    * @param:
    * @return:
    * @date: 2020/6/21 0021
    * @throws:
    */
    @Delete("delete from address where id=#{id};")
    int delById(int id);

    @Select("select * from address where id=#{id};")
    Address getAddressById(int id);
}

service

  • 用户业务层
package com.ysu.shop.service.impl;

import com.ysu.shop.mapper.UserMapper;
import com.ysu.shop.pojo.User;
import com.ysu.shop.service.UserService;
import com.ysu.shop.util.*;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.Date;
import java.util.List;
import java.util.Map;

@Service
@SuppressWarnings({"unchecked", "rawtypes"})
public class UserServiceImpl implements UserService {

    @Resource
    private UserMapper userMapper;

    public String getNewToken(String sessionId, Integer userId) {
        String src = sessionId + userId + NumberUtil.genRandomNum(4);
        return SystemUtil.genToken(src);
    }

    @Override
    public User getUserByToken(String token) {
        return userMapper.getUserByToken(token);
    }

    @Override
    public User login(String username, String password) {
        String shaPassword = ShaUtil.getSHA256(password);
        User user = userMapper.login(username, shaPassword);
        if (user != null) {
            String token = getNewToken(System.currentTimeMillis() + "", user.getId());
            if (userMapper.updateUserToken(user.getId(), token) > 0) {
                // 返回数据时带上token
                user.setToken(token);
                return user;
            }
        }
        return null;
    }

    @Override
    public int insert(User user) {
        user.setPassword(ShaUtil.getSHA256(user.getPassword()));
        return userMapper.insertUser(user);
    }

    @Override
    public User queryById(int id) {
        return userMapper.queryById(id);
    }

    @Override
    public User queryByUsername(String username) {
        return userMapper.queryByUsername(username);
    }

    @Override
    public int delById(int id) {
        return delById(id);
    }

    @Override
    public int update(User user) {
        return userMapper.updateUserByUsername(user);
    }

    @Override
    public int update(String username, String password_old, String password_new) {
        password_new = ShaUtil.getSHA256(password_new);
        password_old = ShaUtil.getSHA256(password_old);
        return userMapper.updatePasswordByOldPassword(username, password_old, password_new);
    }

    @Override
    public PageResult getUserPage(PageUtil pageUtil) {
        // 当前页码中的数据列表
        List<User> users = userMapper.getBatch(pageUtil);
        // 数据总条数 用于计算分页数据
        int total = userMapper.getTotal();
        PageResult pageResult = new PageResult(users, total, pageUtil.getLimit(), pageUtil.getPage());
        return pageResult;
    }

    @Override
    public int checkValid(String type, String value) {
        System.out.println(type);
        if ("username".equals(type)) {
            return userMapper.queryByUsername(value) == null ? 0 : 1;
        } else {
            return userMapper.queryByEmail(value) == null ? 0 : 1;
        }
    }

    /**
     * @Description: 检查问题的答案是否一致，一致则更新token,并作为下次修改密码的依据
     * @Date: 2020/6/19 0019
     * @Param:
     * @return:
     **/
    @Override
    public User forgetCheckAnswer(String username, String question, String answer) {
        User user = userMapper.answer(username, question, answer);
        if (user != null) {
            String token = getNewToken(System.currentTimeMillis() + "", user.getId());
            if (userMapper.updateUserToken(user.getId(), token) > 0) {
                // 返回数据时带上token
                user.setToken(token);
                return user;
            }
        }
        return null;
    }

    @Override
    public int forgetResetPassword(String username, String password, String token) {
        User user = getUserByToken(token);
        if (user == null)
            return 0;
        if ((new Date().getTime() - user.getUpdate_time().getTime()) / (1000 * 60) > 5) {
            return 0;
        }
        password = ShaUtil.getSHA256(password);
        return userMapper.forgetResetPassword(username, password, token);
    }

    @Override
    public PageResult queryByName(Map params) {
        PageUtil pageUtil = new PageUtil(params);
        List<User> goods = userMapper.queryAllByName(pageUtil);
        int total = userMapper.queryAllByNameNum(pageUtil);
        return new PageResult(goods, total, pageUtil.getLimit(), pageUtil.getPage());
    }

}
  • 收货地址业务层
package com.ysu.shop.service.impl;

import com.ysu.shop.mapper.AddressMapper;
import com.ysu.shop.pojo.Address;
import com.ysu.shop.service.AddressService;
import com.ysu.shop.util.PageResult;
import com.ysu.shop.util.PageUtil;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.List;

@Service
public class AddressServiceImpl implements AddressService {


    @Resource
    private AddressMapper addressMapper;


    @Override
    public int addAddress(Address address){
        return addressMapper.insertAddress(address);
    }

    @Override
    public int delAddressByShoppingId(int shippingId){

        return addressMapper.delAddressByShipping_id(shippingId);
    }


    @Override
    public int updateAddressByToken(Address address){
        return addressMapper.updateAddressById(address);
    }

    @Override
    public Address getAddressByShoppingId(int shippingId){
        return addressMapper.selectByShipping_Id(shippingId);
    }

    @Override
    public PageResult getAddressPage(PageUtil pageUtil){
        //当前页码中的数据列表
        List<Address> address = addressMapper.getBatch(pageUtil);
        //数据总条数 用于计算分页数据
        int total = addressMapper.getTotal();
        PageResult pageResult = new PageResult(address, total, pageUtil.getLimit(), pageUtil.getPage());
        return pageResult;
    }

    @Override
    public int getUserAddressNum(int id) {
        return addressMapper.getUserAddressTotal(id);
    }

    @Override
    public int delById(int id) {
        return addressMapper.delById(id);
    }

    @Override
    public List<Address> getAddressByUser(int id) {
        return addressMapper.queryAll(id);
    }

    @Override
    public Address getAddressById(int id) {
        return addressMapper.getAddressById(id);
    }

}

control

  • 前端用户访问
package com.ysu.shop.controller;

import com.alibaba.fastjson.JSONObject;
import com.ysu.shop.annotation.TokenToUser;
import com.ysu.shop.exception.MyException;
import com.ysu.shop.exception.ParamValidException;
import com.ysu.shop.pojo.User;
import com.ysu.shop.service.UserService;
import com.ysu.shop.util.CheckUtil;
import com.ysu.shop.util.Constants;
import com.ysu.shop.util.Result;
import com.ysu.shop.util.ResultGenerator;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.*;

import io.swagger.annotations.*;
import springfox.documentation.annotations.ApiIgnore;

import javax.annotation.Resource;

@RestController
@RequestMapping("/user")
@SuppressWarnings("rawtypes")
@Transactional(noRollbackFor = { MyException.class }, rollbackFor = Exception.class)
@Api(value = "/user", tags = "前台用户接口")
public class UserController {

    private Logger log = LoggerFactory.getLogger(UserController.class);

    @Resource
    private UserService userService;

    /**
     * @Description: 用户登录
     * @Date: 2020/6/19 0019
     * @Param:
     * @return:
     **/
    @ApiOperation(value = "前台用户登录", notes = "前台用户查看商品信息不需要登录")
    @ApiImplicitParams({ @ApiImplicitParam(name = "password", value = "密码", required = true, paramType = "body"),
            @ApiImplicitParam(name = "username", value = "用户名", required = true, paramType = "body") })
    @ApiResponses({ @ApiResponse(code = 406, message = "用户名或密码不能为空"), @ApiResponse(code = 1, message = "用户名或密码不正确"),
            @ApiResponse(code = 200, message = "SUCCESS") })
    @PostMapping("/login")
    public Result login(@ApiIgnore @RequestBody JSONObject jsonParam) {
        // System.out.println(jsonParam);
        String username = jsonParam.getString("username");
        String password = jsonParam.getString("password");
        // System.out.println(username+"---"+password);
        if (StringUtils.isEmpty(username) || StringUtils.isEmpty(password)) {
            return ResultGenerator.getErrorResult(Constants.RESULT_CODE_PARAM_ERROR, "用户名或密码不能为空");
        }
        User user = userService.login(username, password);
        if (user == null) {
            return ResultGenerator.getErrorResult("用户名或密码不正确");
        }
        return ResultGenerator.getSuccessResult(user);
    }

    /**
     * @Description: 用户注册
     * @Date: 2020/6/19 0019
     * @Param:
     * @return:
     **/
    @ApiOperation(value = "前台用户注册", notes = "默认为普通用户")
    @ApiImplicitParams({ @ApiImplicitParam(name = "password", value = "密码", required = true, paramType = "body"),
            @ApiImplicitParam(name = "username", value = "用户名", required = true, paramType = "body"),
            @ApiImplicitParam(name = "phone", value = "联系电话", required = true, paramType = "body"),
            @ApiImplicitParam(name = "email", value = "电子邮箱地址", required = true, paramType = "body"),
            @ApiImplicitParam(name = "question", value = "密保问题", required = true, paramType = "body"),
            @ApiImplicitParam(name = "answer", value = "密保答案", required = true, paramType = "body")

    })
    @ApiResponses({ @ApiResponse(code = 500, message = "用户已存在"), @ApiResponse(code = 1, message = "用户名已存在"),
            @ApiResponse(code = 200, message = "注册成功"), @ApiResponse(code = 406, message = "参数异常！") })
    @PostMapping("/register")
    public Result register(@ApiIgnore @RequestBody User user) {
        if (user == null) {
            throw new ParamValidException("用户信息不能为空");
        }
        log.debug(user.toString());
        int r = userService.checkValid("username", user.getUsername());
        if (r != 0) {
            return ResultGenerator.getErrorResult("用户名已存在");
        }
        user.setRole("U");
        r = userService.insert(user);
        if (r == 0)
            return ResultGenerator.getFailResult("用户已存在 ");
        return ResultGenerator.getSuccessResult("注册成功");
    }

    public Object updateField(Object newValue, Object oldValue) {
        if (!StringUtils.isEmpty(newValue))
            return newValue;
        return oldValue;
    }

    /**
     * @Description: 修改用户信息，先从token获取user,对有带有@TokenToUser 注解的表示需要先登录，才能正常进行
     * @Date: 2020/6/18
     * @Param:
     * @return:
     **/
    @ApiOperation(value = "用户更新个人信息", notes = "需要先登录")
    @ApiImplicitParams({ @ApiImplicitParam(name = "phone", value = "联系电话", required = true, paramType = "body"),
            @ApiImplicitParam(name = "email", value = "电子邮箱地址", required = true, paramType = "body"),
            @ApiImplicitParam(name = "question", value = "密保问题", required = true, paramType = "body"),
            @ApiImplicitParam(name = "answer", value = "密保答案", required = true, paramType = "body"),
            @ApiImplicitParam(name = "token", value = "获取用户信息", required = true, paramType = "header") })
    @ApiResponses({ @ApiResponse(code = 1, message = "更新失败"), @ApiResponse(code = 200, message = "更新个人信息成功"), })
    @PutMapping("/updateInformation")
    public Result updateInformation(@ApiIgnore @RequestBody User user, @TokenToUser User oldUser) {
        CheckUtil.checkUserLogin(oldUser);
        oldUser.setAnswer((String) updateField(user.getAnswer(), oldUser.getAnswer()));
        oldUser.setEmail((String) updateField(user.getEmail(), oldUser.getEmail()));
        oldUser.setPhone((String) updateField(user.getPhone(), oldUser.getPhone()));
        oldUser.setQuestion((String) updateField(user.getQuestion(), oldUser.getQuestion()));
        int r = userService.update(oldUser);
        if (r == 0) {
            return ResultGenerator.getErrorResult("更新失败");
        }
        return ResultGenerator.getSuccessResult("更新个人信息成功");
    }

    /**
     * @Description: 通过请求头的token获取用户信息，修改密码
     * @Date: 2020/6/19 0019
     * @Param:
     * @return:
     **/
    @ApiOperation(value = "重置密码", notes = "登录用户操作")
    @ApiImplicitParams({ @ApiImplicitParam(name = "password_new", value = "新密码", required = true, paramType = "body"),
            @ApiImplicitParam(name = "password_old", value = "旧密码", required = true, paramType = "body"),
            @ApiImplicitParam(name = "token", value = "获取用户信息", required = true, paramType = "header") })
    @ApiResponses({ @ApiResponse(code = 1, message = "旧密码输入错误"), @ApiResponse(code = 200, message = "修改密码成功"), })
    @PutMapping("/resetPassword")
    public Result resetPassword(@ApiIgnore @RequestBody JSONObject jsonObject, @ApiIgnore @TokenToUser User oldUser) {
        CheckUtil.checkUserLogin(oldUser);
        String password = jsonObject.getString("password_new");
        String oldPassword = jsonObject.getString("password_old");
        int r = userService.update(oldUser.getUsername(), oldPassword, password);
        if (r == 0) {
            return ResultGenerator.getErrorResult("旧密码输入错误");
        }
        return ResultGenerator.getSuccessResult("修改密码成功");
    }

    @ApiOperation(value = "通过得到个人用户信息", notes = "弃用")
    @ApiImplicitParams({ @ApiImplicitParam(name = "id", value = "个人id", required = true, paramType = "path"), })
    @ApiResponses({ @ApiResponse(code = 1, message = "该用户不存在"),
            @ApiResponse(code = 200, message = "SUCCESS", response = User.class), })
    @GetMapping("/get/{id}")
    @Deprecated
    @Transactional(readOnly = true)
    public Result getUser(@PathVariable int id) {
        User user = userService.queryById(id);
        if (user == null) {
            return ResultGenerator.getErrorResult("该用户不存在");
        }
        return ResultGenerator.getSuccessResult(user);
    }

    /**
     * @Description: 得到用户信息
     * @Date: 2020/6/19
     * @Param:
     * @return:
     **/
    @ApiOperation(value = "得到个人用户信息", notes = "用户需要登录")
    @ApiImplicitParams({ @ApiImplicitParam(name = "token", value = "获取用户信息", required = true, paramType = "header") })
    @ApiResponses({ @ApiResponse(code = 402, message = "用户未登录"),
            @ApiResponse(code = 200, message = "SUCCESS", response = User.class), })
    @GetMapping("/getInformation")
    @Transactional(readOnly = true)
    public Result getUser(@ApiIgnore @TokenToUser User oldUser) {
        CheckUtil.checkUserLogin(oldUser);
        return ResultGenerator.getSuccessResult(oldUser);
    }

    /**
     * @Description: 根据id删除用户
     * @Date: 2020/6/19 0019
     * @Param:
     * @return:
     **/
    @ApiOperation(value = "删除个人用户", notes = "弃用")
    @ApiImplicitParams({ @ApiImplicitParam(name = "id", value = "个人id", required = true, paramType = "path")})
    @ApiResponses({ @ApiResponse(code = 1, message = "删除失败"), @ApiResponse(code = 200, message = "删除成功") })
    @DeleteMapping("/del/{id}")
    @Deprecated
    public Result delUser(@PathVariable int id) {
        int r = userService.delById(id);
        if (r == 0) {
            return ResultGenerator.getErrorResult("删除失败");
        }
        return ResultGenerator.getSuccessResult("删除成功");
    }

    /**
     * @Description: 用户名，邮箱是否在数据库存在
     * @Date: 2020/6/19 0019
     * @Param:
     * @return:
     **/
    @ApiOperation(value = "校验信息", notes = "注册时检查用户名和邮箱是否存在")
    @ApiImplicitParams({ 
        @ApiImplicitParam(name = "str", value = "需要校验的信息", required = true, paramType = "body"),
        @ApiImplicitParam(name = "type", value = "需要校验的信息的类型", required = true, paramType = "body"),
     })
    @ApiResponses({ 
        @ApiResponse(code = 1, message = "用户名已存在"), 
        @ApiResponse(code = 200, message = "校验成功"),
        @ApiResponse(code = 406, message = "参数不能为空")
    })
    @PostMapping("/checkValid")
    public Result checkValid(@ApiIgnore @RequestBody JSONObject jsonParam) {
        String value = jsonParam.getString("str");
        String type = jsonParam.getString("type");
        if (StringUtils.isEmpty(value) || StringUtils.isEmpty(type)) {
            return ResultGenerator.getErrorByParams("参数不能为空");
        }
        int r = userService.checkValid(type, value);
        if (r != 0) {
            if("username".equals(type)){
                return ResultGenerator.getErrorResult("该用户名已存在");
            }
            return ResultGenerator.getErrorResult("该邮箱已存在");
        }
        return ResultGenerator.getSuccessResult("校验成功");
    }

    @ApiOperation(value = "得到个人用户信息", notes = "用户需要登录")
    @ApiImplicitParams({ @ApiImplicitParam(name = "token", value = "获取用户信息", required = true, paramType = "header") })
    @ApiResponses({ @ApiResponse(code = 402, message = "用户未登录"),
            @ApiResponse(code = 200, message = "SUCCESS", response = User.class), })
    @GetMapping("/getUserInfo")
    @Transactional(readOnly = true)
    public Result getUserInfo(@TokenToUser User oldUser) {
        CheckUtil.checkUserLogin(oldUser);
        oldUser.setId(null);
        oldUser.setPassword(null);
        oldUser.setQuestion(null);
        oldUser.setAnswer(null);
        return ResultGenerator.getSuccessResult(oldUser);
    }

    @ApiOperation(value = "忘记密码的时候需要得到密保问题", notes = "根据用户名得到")
    @ApiImplicitParams({ @ApiImplicitParam(name = "username", value = "用户名", required = true, paramType = "query") })
    @ApiResponses({ 
        @ApiResponse(code = 406, message = "参数不能为空"),
        @ApiResponse(code = 200, message = "SUCCESS", response = String.class),
        @ApiResponse(code = 1, message = "你不能设置找回密码问题，联系客服解决") 
    })
    @GetMapping("/forgetGetQuestion")
    @Transactional(readOnly = true)
    public Result forgetGetQuestion(String username) {
        if (StringUtils.isEmpty(username)) {
            return ResultGenerator.getErrorByParams("参数不能为空");
        }
        User user = userService.queryByUsername(username);
        if (user == null || StringUtils.isEmpty(user.getQuestion())) {
            return ResultGenerator.getErrorResult("你不能设置找回密码问题，联系客服解决");
        }
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("question", user.getQuestion());
        return ResultGenerator.getSuccessResult(jsonObject);

    }

    @ApiOperation(value = "忘记密码的时候需要检查答案", notes = "正确返回一个token值，重置密码需要")
    @ApiImplicitParams({ 
        @ApiImplicitParam(name = "answer", value = "密保答案", required = true, paramType = "body"),
        @ApiImplicitParam(name = "username", value = "用户名", required = true, paramType = "body"),
        @ApiImplicitParam(name = "question", value = "密保问题", required = true, paramType = "body"),
    })
    @ApiResponses({ 
        @ApiResponse(code = 406, message = "参数不能为空"),
        @ApiResponse(code = 200, message = "SUCCESS", response = String.class),
        @ApiResponse(code = 1, message = "问题答案错误") 
    })
    @PostMapping("/forgetCheckAnswer")
    public Result forgetCheckAnswer(@ApiIgnore @RequestBody JSONObject jsonParam) {
        String answer = jsonParam.getString("answer");
        String username = jsonParam.getString("username");
        String question = jsonParam.getString("question");
        if (StringUtils.isEmpty(answer) || StringUtils.isEmpty(username) || StringUtils.isEmpty(question)) {
            return ResultGenerator.getErrorByParams("参数不能为空");
        }
        User user = userService.forgetCheckAnswer(username, question, answer);
        if (user == null) {
            return ResultGenerator.getErrorResult("问题答案错误");
        }
        return ResultGenerator.getSuccessResult((Object) user.getToken());
    }

    @ApiOperation(value = "忘记密码的时候需要检查答案", notes = "正确返回一个token值，重置密码需要")
    @ApiImplicitParams({ 
        @ApiImplicitParam(name = "password_new", value = "新密码", required = true, paramType = "body"),
        @ApiImplicitParam(name = "username", value = "用户名", required = true, paramType = "body"),
        @ApiImplicitParam(name = "forget_token", value = "修改密码的凭证", required = true, paramType = "body"),
    })
    @ApiResponses({ 
        @ApiResponse(code = 406, message = "参数不能为空"),
        @ApiResponse(code = 200, message = "修改密码成功"),
        @ApiResponse(code = 1, message = "token已经失效") 
    })
    @PostMapping("/forgetResetPassword")
    public Result forgetResetPassword(@ApiIgnore @RequestBody JSONObject jsonParam) {
        String username = jsonParam.getString("username");
        String password_new = jsonParam.getString("password_new");
        String forget_token = jsonParam.getString("forget_token");
        if (StringUtils.isEmpty(username) || StringUtils.isEmpty(password_new) || StringUtils.isEmpty(forget_token)) {
            return ResultGenerator.getErrorByParams("参数不能为空");
        }
        int r = userService.forgetResetPassword(username, password_new, forget_token);
        if (r == 0) {
            return ResultGenerator.getErrorResult("token已经失效");
        }
        return ResultGenerator.getSuccessResult("修改密码成功");
    }
}
  • 收货地址访问
package com.ysu.shop.controller;

import com.ysu.shop.annotation.TokenToUser;
import com.ysu.shop.exception.AddressLimitException;
import com.ysu.shop.exception.MyException;
import com.ysu.shop.pojo.Address;
import com.ysu.shop.pojo.User;
import com.ysu.shop.service.AddressService;
import com.ysu.shop.util.CheckUtil;
import com.ysu.shop.util.Constants;
import com.ysu.shop.util.Result;
import com.ysu.shop.util.ResultGenerator;
import io.swagger.annotations.*;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import springfox.documentation.annotations.ApiIgnore;
import javax.annotation.Resource;

@Api(value = "/user/address", tags = "前台地址接口")
@RestController
@RequestMapping("/user/address")
// 使用泛型类型时忽略没有指定相应的类型
@SuppressWarnings("rawtypes")
@Transactional(noRollbackFor={MyException.class},rollbackFor = Exception.class)
public class AddressController {

    private Logger log = LoggerFactory.getLogger(AddressController.class);

    @Resource
    private AddressService addressService;

    private int addressNumLimit(int id){
        int r = addressService.getUserAddressNum(id);
        if (r >= Constants.USER_ADDRESS_NUM_LIMIT) {
          throw new AddressLimitException("现有地址数已超限");
        }
        return r;
    }

    @ApiOperation(value="前台用户获取自己的所有地址的数目",notes="用户根据登录状态获取所有的地址")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "token", value = "获取用户信息", required = true, paramType = "header")
    })
    @ApiResponses({
            @ApiResponse(code = 402, message = "用户未登录"),
            @ApiResponse(code = 200, message = "SUCCESS",response = Integer.class)
    })
    @GetMapping("/total")
    @Transactional(readOnly = true)
    public Result getAddressTotal(@ApiIgnore   @TokenToUser User oldUser){
        CheckUtil.checkUserLogin(oldUser);
        return ResultGenerator.getSuccessResult(addressNumLimit(oldUser.getId()));
    }


    @ApiOperation(value="前台用户删除地址",notes="前台用户根据id删除地址")
    @ApiImplicitParams({
            @ApiImplicitParam(name="id",value="地址id",required=true,paramType="path",dataType="Integer"),
            @ApiImplicitParam(name = "token", value = "获取用户信息", required = true, paramType = "header")
    })
    @ApiResponses({
            @ApiResponse(code = 402, message = "用户未登录"),
            @ApiResponse(code = 200, message = "SUCCESS"),
            @ApiResponse(code = 1, message = "删除失败")
    })
    @DeleteMapping("/del/{id}")
    public Result del(@PathVariable int id,@ApiIgnore @TokenToUser User oldUser){
        CheckUtil.checkUserLogin(oldUser);
        int r = addressService.delById(id);
        if (r == 0) {
            return ResultGenerator.getErrorResult("删除失败");
        }
        return ResultGenerator.getSuccessResult("删除成功");
    }


    @ApiOperation(value="用户添加地址",notes="前台用户添加一个自己的地址")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "token", value = "获取用户信息", required = true, paramType = "header"),
            @ApiImplicitParam(name = "receiver_province", value = "收件人省份", required = true, paramType = "body"),
            @ApiImplicitParam(name = "receiver_city", value = "收件人市", required = true, paramType = "body"),
            @ApiImplicitParam(name = "receiver_district", value = "收件人区县", required = true, paramType = "body"),
            @ApiImplicitParam(name = "receiver_address", value = "详细地址", required = true, paramType = "body"),
            @ApiImplicitParam(name = "receiver_zip", value = "邮编", required = true, paramType = "body")
    })
    @ApiResponses({
            @ApiResponse(code = 402, message = "用户未登录"),
            @ApiResponse(code = 1, message = "添加失败"),
            @ApiResponse(code = 200, message = "SUCCESS")
    })
    @PostMapping("/add")
    public Result add(@ApiIgnore @RequestBody Address address , @ApiIgnore @TokenToUser User oldUser){
        CheckUtil.checkUserLogin(oldUser);
        address.setUser_id(oldUser.getId());
        address.setReceiver_name(oldUser.getUsername());
        address.setReceiver_phone(oldUser.getPhone());
        int r = addressService.addAddress(address);
        if (r == 0) {
            return ResultGenerator.getErrorResult("添加失败");
        }
        return ResultGenerator.getSuccessResult("添加成功");
    }

    @ApiOperation(value="更新地址",notes="前台用户根据地址id更新地址")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "token", value = "获取用户信息", required = true, paramType = "header"),
            @ApiImplicitParam(name = "id", value = "地址id", required = true, paramType = "body"),
            @ApiImplicitParam(name = "receiver_province", value = "收件人省份", required = true, paramType = "body"),
            @ApiImplicitParam(name = "receiver_city", value = "收件人市", required = true, paramType = "body"),
            @ApiImplicitParam(name = "receiver_district", value = "收件人区县", required = true, paramType = "body"),
            @ApiImplicitParam(name = "receiver_address", value = "详细地址", required = true, paramType = "body"),
            @ApiImplicitParam(name = "receiver_zip", value = "邮编", required = true, paramType = "body")
    })
    @ApiResponses({
            @ApiResponse(code = 402, message = "用户未登录"),
            @ApiResponse(code = 1, message = "修改失败"),
            @ApiResponse(code = 200, message = "SUCCESS")
    })
    @PutMapping("/update")
    public Result update(@RequestBody Address address ,@ApiIgnore @TokenToUser User oldUser){
        CheckUtil.checkUserLogin(oldUser);
        System.out.println(address);
        int r = addressService.updateAddressByToken(address);
        if (r == 0) {
            return ResultGenerator.getErrorResult("修改失败");
        }
        return ResultGenerator.getSuccessResult("修改成功"); 
    }

    @ApiOperation(value="获取所有地址",notes="根据登录状态获取所有的地址")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "token", value = "获取用户信息", required = true, paramType = "header")
    })
    @ApiResponses({
            @ApiResponse(code = 402, message = "用户未登录"),
            @ApiResponse(code = 200, message = "SUCCESS",response = Address.class)
    })
    @GetMapping("/getAll")
    @Transactional(readOnly = true)
    public Result add(@ApiIgnore @TokenToUser User oldUser){
        CheckUtil.checkUserLogin(oldUser);
        return ResultGenerator.getSuccessResult(addressService.getAddressByUser(oldUser.getId())); 
    }  

    @ApiOperation(value="根据id获取地址信息",notes="前台用户根据id获取地址信息")
    @ApiImplicitParams({
            @ApiImplicitParam(name="id",value="地址id",required=true,paramType="path",dataType="Integer"),
            @ApiImplicitParam(name = "token", value = "获取用户信息", required = true, paramType = "header")
    })
    @ApiResponses({
            @ApiResponse(code = 402, message = "用户未登录"),
            @ApiResponse(code = 1, message = "未查找到该记录"),
            @ApiResponse(code = 200, message = "SUCCESS",response = Address.class)
    })
    @GetMapping("/get/{id}")
    @Transactional(readOnly = true)
    public Result getAddress(@PathVariable int id,@ApiIgnore @TokenToUser User oldUser){
        CheckUtil.checkUserLogin(oldUser);
        log.debug("get---id"+id);
        Address address = addressService.getAddressById(id); 
        if (address == null){
            return ResultGenerator.getErrorResult("未查找到该记录");
        }
        return ResultGenerator.getSuccessResult(address);
    }
}
發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

【入门教程】5分钟教你快速学会集成Java springboot ~

介紹 Apache DolphinScheduler是一個分佈式易擴展的開源分佈式調度系統，支持海量數據處理，具有任務流程調度、任務流程編排、任務監控告警、工作流引擎等功能。 本文將介紹如何將Apache DolphinScheduler集

原創 2024-06-06 21:22:11

Java日志通关（四） - Logback 介绍

一、配置入口 Logback支持XML、Groovy的配置方式，以XML來說，它會默認查找resources目錄下的logback-test.xml（用於測試）/logback.xml文件。 而如果你使用的Spring Boot，那麼你還可

夜黑人模糊灬 2024-06-06 13:45:20

什么时候需要用到 @EnableWebSecurity 注解？

有小夥伴在學習 Spring Security 的遇到一個問題： 箭頭所指的位置報紅，也就是 Spring 容器中沒有找到一個類型爲 HttpSecurity 的 Bean。 小夥伴說如果他在配置類上加 @EnableWebSecurit

原創 2024-06-05 13:11:40

Spring Security 注册过滤器注意事项

前兩天和小夥伴聊了 Spring Security+JWT 實現無狀態登錄，然後有小夥伴反饋了一個問題，感覺這是一個我們平時寫代碼容易忽略的問題，寫一篇文章和小夥伴們聊一聊。 一 問題復原 先來說問題吧，在 Spring Security+

原創 2024-06-04 03:48:39

com.fasterxml.jackson.databind.JsonMappingException: Invalid UTF-8 start byte 0xb1

在windows環境，springboot 處理提交的json數據報錯“com.fasterxml.jackson.databind.JsonMappingException: Invalid UTF-8 start byte 0xb1”。

原創 2024-05-30 22:15:03

关于在SpringBoot3.2中使用grpc插件生成*ServiceGrpc.java报错找不到符号的一种解决方案

今天想在Springboot多模塊項目中讓兩個子模塊通過rpc交互，引入了grpc相關依賴，加好了插件，編譯生成了代碼，結果生成的*ServiceGrpc.java就報錯“”找不到符號”了，一看是找不到這個註解： @javax.annot

原創 2024-05-27 13:48:34

RequestBodyAdvice 详细介绍与使用实现例子介绍

通過類之間的關係圖,讀懂spring boot原理 RequestBodyAdvice接口用於對Controller方法接收的請求體進行全局處理，可以在請求體被讀取之前或之後對請求體進行修改、包裝或添加一些額外的處理邏輯。下面是Req

原創 2024-05-27 10:53:58

@ResponseBody是怎么起作用的

前言 　　最近參與的項目中，接口中返回的日期格式不對，發現項目中配置了fastjson作爲spring的數據轉換器，於是使用了fastjson的字段格式化轉換註解 發現不起作用。這讓我很疑惑，然後在fastjson的相關代碼中打斷點發現請

微學網絡 2024-05-27 10:53:54

Springboot 对返回结果ReturnValueHandler 处理实现原理与实现说明

若您想要自定義處理 Spring MVC 中方法的返回結果，您可以使用 HandlerMethodReturnValueHandler 接口進行實現。以下是一個示例： 首先，創建一個實現 HandlerMethodReturnValueHa

原創 2024-05-27 10:53:53

Spring优雅使用log4j2日志

1-前言 Spring框架本身提供了對日誌的集成，對logback的支持非常好，但是對log4j和log4j2的支持就沒那麼好。 在同步打印日誌的場景下logback擁有最高的日誌吞吐量《Logback Throughput Benchma

原創 2024-05-22 23:12:10

为什么不推荐在Spring Boot中使用@Value加载配置

@Value註解相信很多Spring Boot的開發者都已經有接觸了，通過使用該註解，我們可以快速的把配置信息加載到Spring的Bean中。 比如下面這樣，就可以輕鬆的把配置文件中key爲com.didispace.title配置信息加載

原創 2024-05-21 21:46:20

Spring boot自动装配实现原理

自動裝配原理分析 條件註冊機制 spring-context模塊中有兩個組件：Condition接口和@Conditional註解，在@Conditional註解中可以指定一組Condition實現， 通常@Conditional是和@Co

原創 2024-05-16 23:48:07

教你如何搞定springboot集成kafka

本文分享自華爲雲社區《手拉手入門springboot+kafka》，作者：QGS。 安裝kafka 啓動Kafka本地環境需Java 8+以上 Kafka是一種高吞吐量的分佈式發佈訂閱消息系統，它可以處理消費者在網站中的所有動作流數據。

原創 2024-05-16 22:58:25

Koupleless 内核系列｜模块化隔离与共享带来的收益与挑战

文｜趙真靈（花名：有濟） Koupleless 項目負責人螞蟻集團技術專家 本文 3724 字    閱讀 10 分鐘 聯繫作者/加入共建/使用產品 本篇文章屬於「Koupleless 進階系列文章」之一，默認讀者對 Koupleless

原創 2024-05-15 23:18:46

Spring cloud bootstrap context机制

Bootstrap Application Context Spring cloud程序在啓動階段，如果開啓了bootstrap啓動過程，則啓動時首先會創建一個bootstrap context，這個容器是項目主容器的父容器，它們共享一個E

原創 2024-05-15 11:50:16