HandlerInterceptorAdapter实现简单拦截

package ;

import ;
import ;
import ;
import .MD5Util;
import ;
import ;
import ;
import ;
import ;
import .;
import ;
import ;
import ;
import ;
import ;
import ;


import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;


/**
 * Created by on 2016/10/11 0020.
 */
public class AccessAuthInterceptor extends HandlerInterceptorAdapter {


    private static Logger logger = (LogHandler.LOG_SCHEMA_AUTH);


    @Autowired
    AccessService accessService;
    @Autowired
    UserService userService;




    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        ("Access Auth Interceptor - 进入拦截器");
        //记录访问开始时间
        ("access_begin_time", ());
        if (handler instanceof HandlerMethod) {
            HandlerMethod method = (HandlerMethod) handler;
            AccessAuth accessAuth = ();
            if (!(accessAuth) && ()) {
            } else {
                ("Access Auth Interceptor - 拦截器跳出");
                return true;
            }
        }
        ("Authorized Access - 拦截器开始");
        //return true;
        //request basic paramter
        String req_uid = (Constants.MOBILE_UID);
        String req_access_token = (Constants.MOBILE_ACCESS_TOKEN);
        ("req uid  " + req_uid);
        ("req access_token  " + req_access_token);
        //0.参数解析
        if (!(req_access_token) && !(req_uid) && req_access_token.length() == 87) {
            //fx+f+ts+token+v   2314d7e2ea7b4fe99b28042739f1af26 1 1477292375598 91a5e51dcc1028398394ee7889d20b46 000001000
            String req_token = req_access_token.substring(46, 78);
            String req_timestamp = req_access_token.substring(33, 46);
            String req_fx = req_access_token.substring(0, 32);
            String req_from = req_access_token.substring(32, 33);
            String req_version = req_access_token.substring(78, 87);
            ("req token  " + req_token);
            ("req timestamp  " + req_timestamp);
            ("req fx  " + req_fx);
            ("req from  " + req_from);
            ("req version  " + req_version);
            // 非空验证
            if ((req_uid, req_token, req_timestamp, req_fx, req_from, req_version)) {
                // ts时间戳
                if ((req_timestamp)) {
                    // 用户权限
                    if ((req_uid, req_token, req_from)) {
                        //
                        if ((req_uid, req_token, req_timestamp, req_fx, req_from, req_version)) {
                            //为aspect构造属性值
                            (Constants.MOBILE_UID, req_uid);
                            (Constants.MOBILE_TOKEN, req_token);
                            (Constants.MOBILE_TIMESTAMP, req_timestamp);
                            (Constants.MOBILE_FX, req_fx);
                            (Constants.MOBILE_FROM, req_from);
                            (Constants.MOBILE_VERSION, req_version);
                            (Constants.MOBILE_URI, ());
                            (Constants.MOBILE_IP, (request));
                            return true;
                        } else {
                            out(response, ResultCode.AUTH_FAIL);
                            return false;
                        }
                    } else {
                        out(response, ResultCode.AUTH_RELOGIN);
                        return false;
                    }
                } else {
                    out(response, ResultCode.AUTH_FAIL);
                    return false;
                }
            } else {
                out(response, ResultCode.AUTH_FAIL);
                return false;
            }
        } else {
            ("Access Auth Interceptor - 请求参数不完整");
            out(response, ResultCode.AUTH_FAIL);
            return false;
        }
    }


    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        ("Access Auth Interceptor - interceptor auth execution time 拦截器验证执行时间：" + (() - (("access_begin_time").toString())) + "ms");
    }


    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        ("Access Auth Interceptor - controller execution time 控制器方法执行时间：" + (() - (("access_begin_time").toString())) + "ms");
    }




    @Override
    public void afterConcurrentHandlingStarted(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        (request, response, handler);
    }


    /**
     * 验证移动端参数非空
     *
     * @param req_uid
     * @param req_token
     * @param req_timestamp
     * @param req_fx
     * @param req_from
     * @param req_version
     * @return
     */
    private static final boolean checkMobileEmpty(String req_uid, String req_token, String req_timestamp, String req_fx, String req_from, String req_version) {
        if (!(req_uid) && !(req_token) && !(req_timestamp) && !(req_fx) && !(req_from) && !(req_version)) {
            return true;
        } else {
            ("Access Auth Interceptor - 解析参数不完整");
            return false;
        }
    }


    /**
     * 验证时间戳ts
     *
     * @param req_timestamp
     * @return
     */
    private static final boolean checkTs(String req_timestamp) {
        if ((req_timestamp) < () - 10 * 60 * 1000) {
            ("Authorized Access - 超时访问");
            return false;
        } else {
            return true;
        }
    }


    /**
     * 验证token信息
     *
     * @param req_uid
     * @param req_token
     * @return
     */
    private final boolean checkUserAuth(String req_uid, String req_token, String req_side) {
        try {
            //1.验证uid是否存在
            ("Access Auth Interceptor - UserAuth  [uid] = "+req_uid+" [token] = "+req_token+" [side] = "+req_side);
            BaseUser baseUser = ((req_uid));
            if (!(baseUser)) {
                //2.验证token及side
                AccessToken accessToken = ((req_uid));
                if (!(accessToken) && !(()) && req_token.equalsIgnoreCase(()) && !(()) && req_side.equals(() + "")) {
                    return true;
                } else {
                    ("Access Auth Interceptor - UserAuth token is null 权限验证失败 [uid] = "+req_uid+" [token] = "+req_token+" [side] = "+req_side);
                    return false;
                }
            } else {
                ("Access Auth Interceptor - UserAuth User is null 权限验证失败 [uid] = "+req_uid+" [token] = "+req_token+" [side] = "+req_side);
                return false;
            }
            /*RedisUtil redisUtil = ();
            String cache_token = (Constants.CACHE_MOBILE_AUTH_TOKEN_PREFIX + req_uid);
            String cache_side = (Constants.CACHE_MOBILE_AUTH_SIDE_PREFIX + req_uid);
            //data token
            String com_token = "";
            String com_side = "";
            if (!(cache_token) && !(cache_side)) {
                com_token = cache_token;
                com_side = cache_side;
                ("token and side cache");
            } else {
                ("token and side no cache");
                AccessToken accessToken = ((req_uid));
                if (!(accessToken) && !(()) && !(())) {
                    com_token = ();
                    com_side = ()+"";
                    (Constants.CACHE_MOBILE_AUTH_TOKEN_PREFIX + req_uid, com_token);
                    (Constants.CACHE_MOBILE_AUTH_SIDE_PREFIX + req_uid, com_side);
                    ("token and side set cache from database");
                }
            }*/
        } catch (Exception e) {
            ("Access Auth Interceptor - UserAuth权限验证失败，程序异常");
            return false;
        }
    }


    /**
     * 验证
     *
     * @param req_uid
     * @param req_token
     * @param req_timestamp
     * @param req_fx
     * @return
     */
    private static final boolean check(String req_uid, String req_token, String req_timestamp, String req_fx, String req_from, String req_version) {
        ("MD5加密 ：" + MD5Util.MD5(req_uid + "_" + req_timestamp + "_" + req_from + "_" + req_version + "_" + req_token).toLowerCase());
        if (req_fx.equalsIgnoreCase(MD5Util.MD5(req_uid + "_" + req_timestamp + "_" + req_from + "_" + req_version + "_" + req_token))) {
            return true;
        } else {
            ("Access Auth Interceptor - 签名验证失败");
            return false;
        }
    }


    /**
     * 错误信息
     *
     * @param resultCode
     * @return
     */
    private static final Map<String, Object> resultFail(ResultCode resultCode) {
        Map<String, Object> map = new HashMap<String, Object>();
        ("code", ());
        ("msg", ());
        return map;
    }


    /**
     * 返回输出json
     *
     * @param response
     * @param resultCode
     */
    private static final void out(HttpServletResponse response, ResultCode resultCode) {
        ObjectMapper objectMapper = new ObjectMapper();
        ("UTF-8");
        ("application/json; charset=utf-8");
        PrintWriter out = null;
        try {
            out = ();
            ((resultFail(resultCode)));
        } catch (IOException e) {
            ();
        } finally {
            if (out != null) {
                ();
            }
        }
    }


    /**
     * 获取http请求的真实IP地址
     *
     * @param request
     * @return
     */
    private static String getIPAddr(HttpServletRequest request) {
        if (request == null)
            return null;
        String ip = ("X-Forwarded-For");
        if (ip == null || () == 0 || "unknown".equalsIgnoreCase(ip))
            ip = ("Proxy-Client-IP");
        if (ip == null || () == 0 || "unknown".equalsIgnoreCase(ip))
            ip = ("WL-Proxy-Client-IP");
        if (ip == null || () == 0 || "unknown".equalsIgnoreCase(ip))
            ip = ("HTTP_CLIENT_IP");
        if (ip == null || () == 0 || "unknown".equalsIgnoreCase(ip))
            ip = ("HTTP_X_FORWARDED_FOR");
        if (ip == null || () == 0 || "unknown".equalsIgnoreCase(ip))
            ip = ();
        if ("127.0.0.1".equals(ip) || "0:0:0:0:0:0:0:1".equals(ip))
            try {
                ip = ().getHostAddress();
            } catch (UnknownHostException unknownhostexception) {
            }
        return ip;
    }


    public static void main(String[] args) {
    }


}