用户模块

功能：

1.登录

controller层实现：

从前端获取传入的用户名和密码，然后通过service进行具体的业务层校验，如果通过校验，则将此时的sessionId作为token值写入cookie中，然后将登录信息写入redis中，key是sessionId，value是具体的登录信息，并设置有效期。

    @RequestMapping(value = "login.do", method = RequestMethod.POST)
    @ResponseBody
    public ServerResponse<User> login(String username, String password, HttpSession session, HttpServletResponse httpServletResponse) {
        ServerResponse<User> response = iUserService.login(username, password);
        if(response.isSuccess()) {
            CookieUtil.writeLoginToken(httpServletResponse, session.getId());
            //sessionId是key，用户的登录信息是value，存在redis中
            //sessionId是tomcat中自动生成的，针对当前项目，每启动一次，sessionId就变一次
            //设置session超时时间
            RedisShardedPoolUtil.setEx(session.getId(), JsonUtil.obj2String(response.getData()), Const.RedisCacheExtime.REDIS_SESSION_EXTIME);

        }
        return response;
    }

service层实现：

先校验用户名是否存在，如果存在，再将输入的密码进行md5加密，再去校验密码是否正确，再返回校验结果。

    public ServerResponse<User> login(String username, String password) {
        //校验用户名是否存在，如果存在，查询结果会返回1，因为用户名唯一；否则返回0
        int resultCount = userMapper.checkUsername(username);
        if (resultCount == 0) {
            return ServerResponse.createByErrorMessage("用户名不存在");
        }
        //密码登录MD5，将密码加密后再与数据库中的密码进行比对，因为数据库中存的不是明文密码，是md5加密后的密码
        String md5Password = MD5Util.MD5EncodeUtf8(password);
        //这里不是根据用户名校验密码是否正确，而是将用户名和密码同时传入dao层，在数据库中一起校验是否有当前用户存在，如果存在表明校验通过返回该用户对象
        User user = userMapper.selectLogin(username, md5Password);
        if (user == null) {
            return ServerResponse.createByErrorMessage("密码错误");
        }
        //将返回给controller的密码置空，是为了不让其显示出来
        user.setPassword(StringUtils.EMPTY);
        //校验通过，返回user对象给controller进行显示
        return ServerResponse.createBySuccess("登录成功", user);
    }

2.注册

controller层实现：

@RequestMapping(value = "register.do", method = RequestMethod.POST)
    @ResponseBody
    public ServerResponse<String> register(User user) {
        return iUserService.register(user);
    }

service层实现：

先校验用户名和email的唯一性，这个唯一性是由service层保证的，而不是数据库层面由unique决定的，然后对密码进行加密后，进入dao层插入数据库进行持久化操作。

    public ServerResponse<String> register(User user) {
        //因为下面的校验用户名和email具有相同的逻辑，所以可以集成放在一个函数中，即checkValid函数，用第二个参数辨别传入的是用户名还是email，然后再校验
        //校验用户名是否已经存在
        ServerResponse validResponse = this.checkValid(user.getUsername(), Const.USERNAME);
        if (!validResponse.isSuccess()) {
            return validResponse;
        }
        //校验email是否已经存在
        validResponse = this.checkValid(user.getEmail(), Const.EMAIL);
        if (!validResponse.isSuccess()) {
            return validResponse;
        }
        //设置用户角色
        //这里是由前端决定注册的是普通用户还是管理员角色，因为不同的角色前端跳转的后台url是不一样的，以此后台来区分角色，所以这里直接将角色赋为customer。
        user.setRole(Const.Role.ROLE_CUSTOMER);
        //MD5加密，加密后再存入数据库       user.setPassword(MD5Util.MD5EncodeUtf8(user.getPassword()));
        //进入dao层进行插入操作
        int resultCount = userMapper.insert(user);
        if (resultCount == 0) {
            return ServerResponse.createByErrorMessage("注册失败");
        }
        return ServerResponse.createBySuccessMessage("注册成功");
    }

3.提交问题答案：

controler层实现：

    @RequestMapping(value = "forget_check_answer.do", method = RequestMethod.POST)
    @ResponseBody
    public ServerResponse<String> forgetCheckAnswer(String username, String question, String answer) {
        return iUserService.checkAnswer(username, question, answer);
    }

service层实现：

先校验问题的答案是否正确，如果正确，则生成一个UUID作为token值，存入redis中缓存，并设置有效期，然后将token值返回。

    public ServerResponse<String> checkAnswer(String username, String question, String answer) {
        //校验问题答案是否正确
        int resultCount = userMapper.checkAnswer(username, question, answer);
        if(resultCount > 0) {
            //说明问题及问题答案是这个用户的，并且是正确的
            //利用UUID创建无重复token
            String forgetToken = UUID.randomUUID().toString();
            //把token放入本地cache中，然后设置其有效期
        //    TokenCache.setKey(TokenCache.TOKEN_PREFIX + username, forgetToken);

            RedisShardedPoolUtil.setEx(Const.TOKEN_PREFIX + username, forgetToken, 60 * 60 * 12);

            //为什么这里调用的是泛型参数函数而不是string参数函数
            //因为函数名不同啊。。。
            return ServerResponse.createBySuccess(forgetToken);
        }
        return ServerResponse.createByErrorMessage("问题的答案错误");
    }

4.重置密码：

　　1）登录状态下重置密码

　　2）忘记密码后重置密码：如果不传入token，则很容易发生横向越权，即可以传任意用户名，然后将其密码重置，不需要通过问题校验。

controler层实现：

    @RequestMapping(value = "forget_reset_password.do", method = RequestMethod.POST)
    @ResponseBody
    public ServerResponse<String> forgetResetPassword(String username, String passwordNew, String forgetToken) {
        return iUserService.forgetResetPassword(username, passwordNew, forgetToken);
    }

service层实现：

先校验token是否正确传入，然后校验用户名是否存在（因为是忘记密码重置），然后从redis中取出缓存的token值进行比对，如果相同则说明是同一用户，对新密码进行加密，然后持久化到数据库。

    public ServerResponse<String> forgetResetPassword(String username, String passwordNew, String forgetToken) {
        //校验token是否已经传递过来
        if(StringUtils.isBlank(forgetToken)) {
            return ServerResponse.createByErrorMessage("参数错误，token需要传递");
        }
        //校验用户名是否存在
        ServerResponse validResponse = this.checkValid(username, Const.USERNAME);
        if(validResponse.isSuccess()) {
            //用户不存在
            return ServerResponse.createByErrorMessage("用户不存在");
        }
        //从cache中获取token，根据key拿到value值
    //    String token = TokenCache.getKey(TokenCache.TOKEN_PREFIX + username);

        String token = RedisShardedPoolUtil.get(Const.TOKEN_PREFIX + username);

        //校验cache中的token是否有效
        if(StringUtils.isBlank(token)) {
            return ServerResponse.createByErrorMessage("token无效或者过期");
        }
        //校验传入的forgetToken和token是否相同
        //这里用stringUtils可以避免string.equals中string出现null的问题，即使这里传入null也是可以接受的，不会报错
        if(StringUtils.equals(forgetToken, token)) {
            //将新输入的密码进行md5加密后再更新到数据库中
            String md5Password = MD5Util.MD5EncodeUtf8(passwordNew);
            int rowCount = userMapper.updatePasswordByUsername(username, md5Password);
            if(rowCount > 0) {
                return ServerResponse.createBySuccessMessage("修改密码成功");
            }
        }
        else {
            return ServerResponse.createByErrorMessage("token错误，请重新获取重置密码的token");
        }
        return ServerResponse.createByErrorMessage("修改密码失败");
    }

5.获取用户信息

controller层实现：

先从cookie中获取是否登录信息，然后拿到这个sessionId后，去redis中根据这个sessionId，拿到user对象，根据userId从数据库中获取到具体的用户信息，返回给前端。

    @RequestMapping(value = "get_information.do", method = RequestMethod.POST)
    @ResponseBody
    public ServerResponse<User> getInformation(HttpServletRequest request) {

        String loginToken = CookieUtil.readLoginToken(request);
        if(StringUtils.isEmpty(loginToken)) {
            return ServerResponse.createByErrorMessage("用户未登录，无法获取当前用户的信息");
        }
        String userJsonStr = RedisShardedPoolUtil.get(loginToken);
        User currentUser = JsonUtil.string2Obj(userJsonStr, User.class);

        if(currentUser == null) {
            return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(), "未登录，需要强制登录status=10");
        }
        return iUserService.getInformation(currentUser.getId());
    }

6.更新用户信息

7.退出登录

掌握：

1.横向越权、纵向越权安全漏洞

2.MD5明文加密及增加salt盐值

3.Guava缓存的使用

4.高复用服务响应对象的设计思想及抽象封装

/**
 * Created by cq on 2017/10/31.
 */
@JsonSerialize(include = JsonSerialize.Inclusion.NON_NULL)
//保证序列化json的时候，如果是null的对象，key也会消失
//比如在创建失败的时候，只需要将status和msg显示出来，但是如果不加上面的注解会将data也显示出来，其值会显示null
public class ServerResponse<T> implements Serializable{

    private int status;
    private String msg;
    private T data;

    private ServerResponse(int status) {
        this.status = status;
    }
    //如果第二个参数不是string类型调用下面这个构造器
    private ServerResponse(int status, T data) {
        this.status = status;
        this.data = data;
    }
    //如果第二个参数是string类型调用下面这个构造器
    private ServerResponse(int status, String msg) {
        this.status = status;
        this.msg = msg;
    }
    private ServerResponse(int status, String msg, T data) {
        this.status = status;
        this.msg = msg;
        this.data = data;
    }

    @JsonIgnore
    //使之不在json序列化结果当中
    //判断响应是否成功
    public boolean isSuccess() {
        return this.status == ResponseCode.SUCCESS.getCode();
    }

    //下面三个get开头的public方法在json序列化时都会显示出来供前端看到
    //数据格式显示也就如下：
    /*
    * {status:xxx,
    * msg:xx,
    * data:xxx}
    * */
    public int getStatus() {
        return status;
    }

    public T getData() {
        return data;
    }

    public String getMsg() {
        return msg;
    }

    //成功
    //返回值是泛型<T>,传入0表示创建是成功的
    public static <T> ServerResponse<T> createBySuccess() {
        return new ServerResponse<T>(ResponseCode.SUCCESS.getCode());
    }

    //创建成功传入一个msg再返回
    public static <T> ServerResponse<T> createBySuccessMessage(String msg) {
        return new ServerResponse<T>(ResponseCode.SUCCESS.getCode(), msg);
    }

    //创建成功传入data再返回
    public static <T> ServerResponse<T> createBySuccess(T data) {
        return new ServerResponse<T>(ResponseCode.SUCCESS.getCode(), data);
    }

    //如果参数是string类型，但是应该把其赋给data而不是msg该怎么做？
    //调用下面的public方法同时传入msg和data即可
    //创建成功传入一个msg和data再返回
    public static <T> ServerResponse<T> createBySuccess(String msg, T data) {
        return new ServerResponse<T>(ResponseCode.SUCCESS.getCode(), msg, data);
    }

    //失败
    public static <T> ServerResponse<T> createByError() {
        return new ServerResponse<T>(ResponseCode.ERROR.getCode(), ResponseCode.ERROR.getDesc());
    }

    //创建失败传入一个错误提示信息errorMessage
    public static <T> ServerResponse<T> createByErrorMessage(String errorMessage) {
        return new ServerResponse<T>(ResponseCode.ERROR.getCode(), errorMessage);
    }

    //创建失败手动传入一个code和errorMessage
    public static <T> ServerResponse<T> createByErrorCodeMessage(int errorCode, String errorMessage) {
        return new ServerResponse<T>(errorCode, errorMessage);
    }

}

5.session的使用

6.json注解使用