crm登录拦截器与返回对象重构

1.service层接口实现根据主键查询用户

package com.shsxt.crm.system.service;

import com.shsxt.crm.system.model.UserModel;
import com.shsxt.crm.system.pojo.User;

/**
 * 用户service
 * Created by Administrator on 2019/8/26.
 */
public interface UserServiceI {

    /**
     * 根据用户名查询用户
     * @param user
     * @return
     */
    UserModel userLogin(User user,String rememberMe);


    /**
     * 修改密码
     */
    void updateUserPwd(Integer id,String oldPassword,String newPassword,String confirmPassword);

    /**
     * 根据主键查询id
     * @param id
     * @return
     */
    User selectUserById(Integer id);
}

2.service层实现类

package com.shsxt.crm.system.service.impl;

import com.shsxt.crm.base.util.AssertUtil;
import com.shsxt.crm.base.util.Base64Util;
import com.shsxt.crm.base.util.Md5Util;
import com.shsxt.crm.system.dao.UserMapper;
import com.shsxt.crm.system.model.UserModel;
import com.shsxt.crm.system.pojo.User;
import com.shsxt.crm.system.service.UserServiceI;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * 用户service
 * Created by Administrator on 2019/8/26.
 */
@Service
public class UserServiceImpl implements UserServiceI {

    @Autowired
    private UserMapper userMapper;

    /**
     * 根据用户名查询用户===优化
     *
     * @return
     */
    @Override
    public UserModel userLogin(User user, String rememberMe) {
        /**
         * 1.校验数据的合法性
         * 2.根据用户名查询用户
         * 3.密码对比
         */
        String userName = user.getUserName();
        String userPwd = user.getUserPwd();
        //1.校验数据合法性
        //校验用户名
        //优化,增强工具类StringUtils.isBlank()
        AssertUtil.isTrue(StringUtils.isBlank(userName), "用户名不能为空");
        AssertUtil.isTrue(StringUtils.isBlank(userPwd), "密码不能为空");
        //用户名存在,根据用户名查询用户信息
        User u = userMapper.selectUserByUserName(user.getUserName().trim());

        //判断用户是否存在
        AssertUtil.isTrue(null == u, "该用户名不存在");
        //用户存在,比对密码
        AssertUtil.isTrue(!u.getUserPwd().equals(Md5Util.encode(userPwd)), "密码输入错误");
        //登录成功,构建返回对象
        return buildUserModel(u, userPwd, rememberMe);
    }

    /**
     * 修改密码
     *
     * @param id
     * @param oldPassword
     * @param newPassword
     * @param confirmPassword
     */
    @Override
    public void updateUserPwd(Integer id, String oldPassword, String newPassword, String confirmPassword) {
        //数据的合法性校验
        AssertUtil.isTrue(StringUtils.isBlank(oldPassword), "原密码不可以为空");
        AssertUtil.isTrue(StringUtils.isBlank(newPassword), "新密码不可以为空");
        //直接比对两次密码
        AssertUtil.isTrue(!newPassword.equals(confirmPassword), "两次密码不一致");

        //根据主键查询用户
        User user = userMapper.selectByPrimaryKey(id);
        AssertUtil.isTrue(null == user, "用户未登录或不存在");
        //密码比对
        AssertUtil.isTrue(!user.getUserPwd().equals(Md5Util.encode(oldPassword)), "原密码输入错误");
        //根据主键修改用户密码
        user.setUserPwd(Md5Util.encode(newPassword));
        AssertUtil.isTrue(userMapper.updateByPrimaryKeySelective(user) < 1, "修改密码失败");

    }

    /**
     * 根据主键查询id
     * @param id
     * @return
     */
    @Override
    public User selectUserById(Integer id) {
        return userMapper.selectByPrimaryKey(id);
    }

    //构建返回对象模型
    private UserModel buildUserModel(User user, String userPwd, String rememberMe) {
        UserModel userModel = new UserModel();
        //拷贝属性,将user属性拷贝到userModel
        BeanUtils.copyProperties(user, userModel);
        //处理加密的属性,将加密的属性放入对象模型中
        userModel.setUserIdStr(Base64Util.encoder(String.valueOf(user.getId())));
        //前台传值不为空时
        if (StringUtils.isNotBlank(rememberMe))
            //如果记住我有值,则将密码放入对象模型中
            userModel.setUserInfo(Base64Util.encoder(userPwd));
        return userModel;
    }
}

3.建立登录异常类

package com.shsxt.crm.base.exception;

import com.shsxt.crm.base.constants.CrmConstants;

/**
 * 登录异常
 */
public class LoginException extends RuntimeException {

    private Integer code = CrmConstants.OPS_FAILED_CODE;
    private String message = "用户未登录或不存在";

    public LoginException() {
    }

    public LoginException(Integer code, String message) {
        super(message);
        this.code = code;
        this.message = message;
    }

    public LoginException(Integer code) {
        super("用户未登录或不存在");
        this.code = code;
    }

    public LoginException(String message) {
        super(message);
        this.message = message;
    }

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

}

4.修改断言工具类

package com.shsxt.crm.base.util;

import com.shsxt.crm.base.exception.LoginException;
import com.shsxt.crm.base.exception.ParamsException;

/**
 * 断言工具类
 */
public class AssertUtil {

    public static void isTrue(boolean flag) {
        if (flag)
            throw new ParamsException();
    }

    public static void isTrue(boolean flag, String message) {
        if (flag)
            throw new ParamsException(message);
    }

    public static void isTrue(boolean flag, Integer code, String message) {
        if (flag)
            throw new ParamsException(code, message);
    }
    public static void isNotLogin(boolean flag) {
        if (flag)
            throw new LoginException();
    }

    public static void isNotLogin(boolean flag, String message) {
        if (flag)
            throw new LoginException(message);
    }

    public static void isNotLogin(boolean flag, Integer code, String message) {
        if (flag)
            throw new LoginException(code, message);
    }

}

5.建立登录拦截器

package com.shsxt.crm.base.interceptor;

import com.shsxt.crm.base.util.AssertUtil;
import com.shsxt.crm.base.util.Base64Util;
import com.shsxt.crm.base.util.CookieUtil;
import com.shsxt.crm.system.pojo.User;
import com.shsxt.crm.system.service.UserServiceI;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * 登录拦截器
 * Created by Administrator on 2019/8/29.
 */
public class LoginInterceptor  extends HandlerInterceptorAdapter{

    //获取用户信息
    @Autowired
    private UserServiceI userServiceI;

    @Override
    public boolean preHandle(HttpServletRequest request,
                             HttpServletResponse response,
                             Object handler) throws Exception {
        //获取用户id
        String userIdStr= CookieUtil.getCookieValue(request,"userIdStr");
        //判断
        AssertUtil.isNotLogin(StringUtils.isBlank(userIdStr));
        //根据主键查询用户信息
        User user=userServiceI.selectUserById(Integer.valueOf(Base64Util.decoder(userIdStr)));
        //判断
        AssertUtil.isNotLogin(null==user);
        return true;
    }
}

6.配置拦截器springmvc

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 启用spring mvc 注解 -->
    <mvc:annotation-driven/>

    <!-- 设置使用注解的类所在的package(基本包)-->
    <context:component-scan base-package="com.shsxt"/>

    <!-- 静态资源映射 location是本地静态资源路径 mapping是映射的url地址，访问时就使用该地址 -->
    <mvc:resources location="/WEB-INF/static/" mapping="/**"/>

    <!-- 配置 freemarker 模板 -->
    <bean id="freemarkerConfig"
          class="org.springframework.web.servlet.view.freemarker.FreeMarkerConfigurer">
        <property name="templateLoaderPath" value="/WEB-INF/views/"/>
        <property name="defaultEncoding" value="UTF-8"/>
    </bean>

    <!-- 配置 freemarker 视图解析器 -->
    <bean class="org.springframework.web.servlet.view.freemarker.FreeMarkerViewResolver">
        <property name="prefix" value=""/>
        <property name="suffix" value=".ftl"/>
        <property name="contentType" value="text/html;charset=UTF-8"/>
    </bean>

    <!--配置拦截器-->
    <mvc:interceptors>
        <mvc:interceptor>
            <!-- 要拦截的路径 -->
            <mvc:mapping path="/**"/>
            <!-- 不拦截的路径 -->
            <mvc:exclude-mapping path="/login"/>
            <mvc:exclude-mapping path="/user/login"/>
            <mvc:exclude-mapping path="/user/logout"/>
            <mvc:exclude-mapping path="/css"/>
            <mvc:exclude-mapping path="/js"/>
            <mvc:exclude-mapping path="/images"/>
            <mvc:exclude-mapping path="/jquery-easyui-1.3.3"/>
            <bean class="com.shsxt.crm.base.interceptor.LoginInterceptor"/>
        </mvc:interceptor>
    </mvc:interceptors>
</beans>

7.重构 BaseResult.java

package com.shsxt.crm.base;

import com.shsxt.crm.base.constants.CrmConstants;

import java.io.Serializable;

/**
 * 公共返回对象
 */
public class BaseResult implements Serializable {

    // 状态编码
    private Integer code ;
    // 状态描述
    private String message ;
    // 返回对象
    private Object result;

    public static BaseResult success(){
        return new BaseResult(CrmConstants.OPS_SUCCESS_CODE,
                CrmConstants.OPS_SUCCESS_MESSAGE);
    }
    public static BaseResult success(String message){
        return new BaseResult(CrmConstants.OPS_SUCCESS_CODE, message);
    }
    public static BaseResult success(String message,Object result){
        return new BaseResult(CrmConstants.OPS_SUCCESS_CODE,message,result);
    }
    public static BaseResult error() {
        return new BaseResult(CrmConstants.OPS_FAILED_CODE,
                CrmConstants.OPS_FAILED_MESSAGE);
    }

    public static BaseResult error(String message) {
        return new BaseResult(CrmConstants.OPS_FAILED_CODE, message);
    }

    public static BaseResult error(String message, Object result) {
        return new BaseResult(CrmConstants.OPS_FAILED_CODE, message, result);
    }

    public BaseResult() {
    }

    public BaseResult(String message) {
        this.message = message;
    }

    public BaseResult(Integer code, String message) {
        this.code = code;
        this.message = message;
    }

    public BaseResult(Integer code, Object result) {
        this.code = code;
        this.result = result;
    }

    public BaseResult(String message, Object result) {
        this.message = message;
        this.result = result;
    }

    public BaseResult(Integer code, String message, Object result) {
        this.code = code;
        this.message = message;
        this.result = result;
    }

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public Object getResult() {
        return result;
    }

    public void setResult(Object result) {
        this.result = result;
    }
}

8.构建 BaseController.java

package com.shsxt.crm.base;

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

import javax.servlet.http.HttpServletRequest;

/**
 * 公共Controller
 */
public class BaseController {

    /**
     * 在所有Controller方法执行前执行
     *
     * @param request
     */
    @ModelAttribute
    public void preMethod(HttpServletRequest request) {
        request.setAttribute("ctx", request.getContextPath());
    }

}

9.重构 Controller.java

package com.shsxt.crm.system.controller;

import com.shsxt.crm.base.BaseController;
import com.shsxt.crm.base.BaseResult;
import com.shsxt.crm.base.util.Base64Util;
import com.shsxt.crm.base.util.CookieUtil;
import com.shsxt.crm.system.model.UserModel;
import com.shsxt.crm.system.pojo.User;
import com.shsxt.crm.system.service.UserServiceI;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.servlet.http.HttpServletRequest;

/**
 * 用户controller
 * Created by Administrator on 2019/8/26.
 */
@Controller
@RequestMapping("/user")
public class UserController extends BaseController{

    @Autowired
    private UserServiceI userServiceI;

    /**
     * 用户登录
     *
     * @param request
     * @return
     */
    @RequestMapping("/login")
    @ResponseBody
    public BaseResult userLogin(HttpServletRequest request, User user, String rememberMe) {
        UserModel userModel = userServiceI.userLogin(user, rememberMe);
        //将用户信息存入session
        request.getSession().setAttribute("user", userModel);
        return BaseResult.success("登录成功",userModel);
    }

    /**
     * 安全退出
     *
     * @param request
     * @return
     */
    @RequestMapping("/logout")
    public String userLogout(HttpServletRequest request) {
        //清除session信息
        request.getSession().removeAttribute("user");
        return "login";
    }

    @RequestMapping("/updateUserPwd")
    @ResponseBody
    public BaseResult updateUserPwd(HttpServletRequest request, String oldPassword,
                                    String newPassword, String confirmPassword) {
        //从cookie获取用户加密id
        String userIdStr = CookieUtil.getCookieValue(request, "userIdStr");
        //将获取的加密id解密
        Integer id = Integer.valueOf(Base64Util.decoder(userIdStr));
        //修改密码
        userServiceI.updateUserPwd(id, oldPassword, newPassword, confirmPassword);
        return BaseResult.success("修改成功");
    }
}

package com.shsxt.crm.system.controller;

import com.shsxt.crm.base.BaseController;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

import javax.servlet.http.HttpServletRequest;

/**
 * 跳转页面
 * Created by Administrator on 2019/8/26.
 */
@Controller
public class pageController extends BaseController{
    /**
     * 跳转到登录页面
     * @return
     */
    @RequestMapping("/login")
    public  String login(){
        return "login";
    }
    /**
     * 跳转首页
     */
    @RequestMapping("/index")
    public  String index() {
        return "index";
    }
}

10,修改全局异常类

package com.shsxt.crm.base.exception;

import com.alibaba.fastjson.JSON;
import com.shsxt.crm.base.BaseResult;
import com.shsxt.crm.base.constants.CrmConstants;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerExceptionResolver;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;

/**
 * 全局异常类
 */
@Component
public class GlobalExceptionResolver implements HandlerExceptionResolver {

    /**
     * 异常处理
     *
     * @param request       请求对象
     * @param response      响应对象
     * @param handler       请求的目标方法对象 json方法 跳转页面方法
     * @param e             异常对象
     * @return
     */
    @Override
    public ModelAndView resolveException(HttpServletRequest request,
                                         HttpServletResponse response,
                                         Object handler, Exception e) {

        // 构建默认返回对象
        ModelAndView mv = buildModelAndView(request, e);

        // 判断是否是系统异常
        if (!(handler instanceof HandlerMethod))
            return mv;

        // 判断请求的方法是json还是跳转页面
        // 强转对象类型
        HandlerMethod method = (HandlerMethod) handler;
        // 获取ResponseBody注解
        ResponseBody responseBody = method.getMethodAnnotation(ResponseBody.class);
        // json请求
        if (null != responseBody) {
            BaseResult baseResult = new BaseResult(CrmConstants.OPS_FAILED_CODE,
                    CrmConstants.OPS_FAILED_MESSAGE);

            // 判断是否是参数异常
            if (e instanceof ParamsException) {
                ParamsException pe = (ParamsException) e;
                baseResult.setCode(pe.getCode());
                baseResult.setMessage(pe.getMessage());
            }
            // 判断是否是登录异常
            if (e instanceof LoginException) {
                LoginException le = (LoginException) e;
                baseResult.setCode(le.getCode());
                baseResult.setMessage(le.getMessage());
            }

            // 设置请求数据头信息
            // 初始化 Response 构建JSON对象
            response.setCharacterEncoding("utf-8");
            response.setContentType("application/json;charset=utf-8");
            PrintWriter pw = null;
            try {
                pw = response.getWriter();
                pw.write(JSON.toJSONString(baseResult));
                pw.flush();
            } catch (IOException ex) {
                ex.printStackTrace();
            } finally {
                if (null != pw)
                    pw.close();
            }
            return null;
        } else {
            // 跳转页面
            // 判断是否是参数异常
            if (e instanceof ParamsException) {
                ParamsException pe = (ParamsException) e;
                mv.addObject("errorMsg", pe.getMessage());
                mv.addObject("errorCode",pe.getCode());
            }
            // 判断是否是登录异常
            if (e instanceof LoginException) {
                LoginException le = (LoginException) e;
                mv.addObject("errorMsg",le.getMessage());
                mv.addObject("errorCode",le.getCode());
            }
        }
        return mv;
    }

    // 构建默认的返回对象
    private ModelAndView buildModelAndView(HttpServletRequest request, Exception e) {
        request.setAttribute("ctx", request.getContextPath());
        request.setAttribute("uri", request.getRequestURI());
        ModelAndView mv = new ModelAndView();
        mv.setViewName("error");
        mv.addObject("errorMsg", CrmConstants.OPS_FAILED_MESSAGE);
        mv.addObject("errorCode",CrmConstants.OPS_FAILED_CODE);
        return mv;
    }

}