• 1、SpringBoot实现登录拦截的原理
  • 1.1、实现HandlerInterceptor接口
  • 1.2、实现WebMvcConfigurer接口，注册拦截器
  • 1.3、保持登录状态
• 2、代码实现及示例
• 3、效果验证
  • 3.1、访问localhost:8081/index页面：
  • 3.2、正确输入用户名和密码登录
  • 3.3、再次访问localhost:8081/index

对于管理系统或其他需要用户登录的系统，登录验证都是必不可少的环节，在SpringBoot开发的项目中，通过实现拦截器来实现用户登录拦截并验证。

1、SpringBoot实现登录拦截的原理

SpringBoot通过实现HandlerInterceptor接口实现拦截器，通过实现WebMvcConfigurer接口实现一个配置类，在配置类中注入拦截器，最后再通过@Configuration注解注入配置.

1.1、实现HandlerInterceptor接口

实现HandlerInterceptor接口需要实现3个方法：preHandle、postHandle、afterCompletion.

3个方法各自的功能如下：

package blog.interceptor;

import blog.entity.User;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

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

public class UserLoginInterceptor implements HandlerInterceptor {

    /***
     * 在请求处理之前进行调用(Controller方法调用之前)
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("执行了拦截器的preHandle方法");
        try {
            HttpSession session = request.getSession();
            //统一拦截（查询当前session是否存在user）(这里user会在每次登录成功后，写入session)
            User user = (User) session.getAttribute("user");
            if (user != null) {
                return true;
            }
            response.sendRedirect(request.getContextPath() + "login");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
        //如果设置为false时，被请求时，拦截器执行到此处将不会继续操作
        //如果设置为true时，请求将会继续执行后面的操作
    }

    /***
     * 请求处理之后进行调用，但是在视图被渲染之前（Controller方法调用之后）
     */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("执行了拦截器的postHandle方法");
    }

    /***
     * 整个请求结束之后被调用，也就是在DispatchServlet渲染了对应的视图之后执行（主要用于进行资源清理工作）
     */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("执行了拦截器的afterCompletion方法");
    }
}

preHandle在Controller之前执行，因此拦截器的功能主要就是在这个部分实现：

• 检查session中是否有user对象存在；
• 如果存在，就返回true，那么Controller就会继续后面的操作；
• 如果不存在，就会重定向到登录界面。就是通过这个拦截器，使得Controller在执行之前，都执行一遍preHandle.

1.2、实现WebMvcConfigurer接口，注册拦截器

实现WebMvcConfigurer接口来实现一个配置类，将上面实现的拦截器的一个对象注册到这个配置类中.

package blog.config;

import blog.interceptor.UserLoginInterceptor;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class LoginConfig implements WebMvcConfigurer {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        //注册TestInterceptor拦截器
        InterceptorRegistration registration = registry.addInterceptor(new UserLoginInterceptor());
        registration.addPathPatterns("/**"); //所有路径都被拦截
        registration.excludePathPatterns(    //添加不拦截路径
                "/login",                    //登录路径
                "/**/*.html",                //html静态资源
                "/**/*.js",                  //js静态资源
                "/**/*.css"                  //css静态资源
        );
    }
}

将拦截器注册到了拦截器列表中，并且指明了拦截哪些访问路径，不拦截哪些访问路径，不拦截哪些资源文件；最后再以@Configuration注解将配置注入。

1.3、保持登录状态

只需一次登录，如果登录过，下一次再访问的时候就无需再次进行登录拦截，可以直接访问网站里面的内容了。

在正确登录之后，就将user保存到session中，再次访问页面的时候，登录拦截器就可以找到这个user对象，就不需要再次拦截到登录界面了.

@RequestMapping(value = {"", "/", "/index"}, method = RequestMethod.GET)
public String index(Model model, HttpServletRequest request) {
    User user = (User) request.getSession().getAttribute("user");
    model.addAttribute("user", user);
    return "users/index";
}

@RequestMapping(value = {"/login"}, method = RequestMethod.GET)
public String loginIndex() {
    return "users/login";
}

@RequestMapping(value = {"/login"}, method = RequestMethod.POST)
public String login(@RequestParam(name = "username")String username, @RequestParam(name = "password")String password,
                    Model model, HttpServletRequest request) {
    User user = userService.getPwdByUsername(username);
    String pwd = user.getPassword();
    String password1 = MD5Utils.md5Code(password).toUpperCase();
    String password2 = MD5Utils.md5Code(password1).toUpperCase();
    if (pwd.equals(password2)) {
        model.addAttribute("user", user);
        request.getSession().setAttribute("user", user);
        return "redirect:/index";
    } else {
        return "users/failed";
    }
}

2、代码实现及示例

代码实现如上所示。

在登录成功之后，将user信息保存到session中，下一次登录时浏览器根据自己的SESSIONID就可以找到对应的session，就不要再次登录了，可以从Chrome浏览器中看到。

3、效果验证

3.1、访问localhost:8081/index页面：

被重定向到了localhost:8081/login，实现了登录拦截。

3.2、正确输入用户名和密码登录

3.3、再次访问localhost:8081/index

没有再次被登录拦截器拦截，证明可以保持登录。

springboot拦截器配置(登录拦截)

对拦截器进行分析解刨,七步之内保证配置完毕.

前言

为啥使用拦截器嘞?
因为有些项目后端总有些接口是对用户不开放的,只有输入正确的账号和密码才可以进行访问,假如用户拿到了你后端的一些接口,你不设置拦截器,那么用户在url中输入接口即可访问,这样很不安全,所以要配置一个拦截器,对一些请求进行拦截.

一、编写拦截器实现类

实现HandlerInterceptor接口,重写里面三个比较常用的方法,实现本身的业务逻辑代码,第一个最重要的是拦截器,其他两个是对性能的优化.

 @Override
    public boolean preHandle(HttpServletRequest req, HttpServletResponse resp, Object handler){
        System.out.println("执行了preHandle方法");
        try {
            //统一拦截,查询当前session是否存在user,这里user每次登录后会存入session
            ruserBean user= (ruserBean) req.getSession().getAttribute("vip");//后端给前端传递的数据名称
            if (user!=null){
                return true;
            }
            resp.sendRedirect("/gotologin");//对拦截到的进行重定向
        }catch (IOException io){
            io.printStackTrace();
        }
        return false;//如果设置为false时,被请求时,拦截器执行到此不再执行,相反会继续执行下面的操作
    }

第一步是对拦截的内容做统一拦截,并返回给浏览器数据结果.对拦截到的进行重定向,始终回到登录界面

 @Override
    public void postHandle(HttpServletRequest req, HttpServletResponse resp, Object handler, ModelAndView modelAndView){
        System.out.println("执行了Posthandler方法");//请求处理以后进行调用,Controller方法之后
    }

上面这一步是在请求处理完成之后进行的调用(Controller方法之后)

 @Override
    public void afterCompletion(HttpServletRequest req, HttpServletResponse resp, Object handler, Exception ex){
        System.out.println("执行了afterCompletion");
        //在整个请求结束之后,渲染了对应的视图以后执行,主要用于资源清理工作
    }

最后一步是在请求结束之后被调用,渲染对应的视图之后执行,一般是用于资源清理.

二、拦截器配置文件

对拦截器的配置文件进行编写,并继承WebMvcConfigurer类,并重写重要方法:addInterceptors.

@Configuration
public class LoginConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry){
        //注册TestInterceptor拦截器
        InterceptorRegistration registration=registry.addInterceptor(new SSLoginFilter());
        registration.addPathPatterns("/**");

开头不要忘了加上注解(@Configuration),这一步主要作用于对拦截的内容进行配置,我这里是将所有请求进行拦截,可根据自身项目做拦截.

registration.excludePathPatterns("/gotologin",
				"/admin",
				"/**/*.html",
				"/**/*.css",
                "/**/*.js",
                "/**/*.gif",
                "/**/*.ico");//添加不被拦截的路径,有很多静态资源

这一步是配置不被拦截的路径,如果有配置指定拦截路径,可以忽略这一步,这一步针对全部拦截的,不被拦截的资源内容多半为登录路径和静态资源路径,这一步也是根据自己的项目去配置要放行的资源,一定要注意不要忘了或者漏一个,因为拦截的全部,那样的话加载不到就很烦!

小结

就这样一个后端拦截器就已经配置完毕,拦截器针对的路径,只要是在url中输入的路径都会进行拦截,其实大家在用自己写的项目不去部署到服务器,供大众浏览的情况下,完全没有必要去设置拦截器.
今天的内容到此结束,有哪里不足或者更好的建议,欢迎留言吐槽,如果有哪里不懂的可以私信博主,博主将一一回复,感谢认可,感谢支持!

Java后端人员，业余搞着玩，不对的地方请见谅。

1、build.gradle 配置

在app/build.gradle中配置如下

导入gradle的插件包

//buildscript中的声明是gradle脚本自身需要使用的资源,而在build.gradle文件中直接声明的依赖项、仓库地址等信息是项目自身需要的资源。放在文件开头。
buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath 'org.aspectj:aspectjtools:1.8.9'
        classpath 'org.aspectj:aspectjweaver:1.8.9'
    }
}

导入jar包

dependencies {
    implementation 'org.aspectj:aspectjrt:1.9.6' //引入 aspectj
}

 使 AspectJ 配置生效

import org.aspectj.bridge.IMessage
import org.aspectj.bridge.MessageHandler
import org.aspectj.tools.ajc.Main

// 获取log打印工具和构建配置
final def log = project.logger
final def variants = project.android.applicationVariants
variants.all { variant ->
    if (!variant.buildType.isDebuggable()) {
        // 判断是否debug，如果打release把return去掉就可以
        log.debug("Skipping non-debuggable build type '${variant.buildType.name}'.")
        // return;
    }
    // 使aspectj配置生效
    JavaCompile javaCompile = variant.javaCompile
    javaCompile.doLast {
        String[] args = ["-showWeaveInfo",
                         "-1.8",
                         "-inpath", javaCompile.destinationDir.toString(),
                         "-aspectpath", javaCompile.classpath.asPath,
                         "-d", javaCompile.destinationDir.toString(),
                         "-classpath", javaCompile.classpath.asPath,
                         "-bootclasspath", project.android.bootClasspath.join(File.pathSeparator)]
        log.debug "ajc args: " + Arrays.toString(args)

        MessageHandler handler = new MessageHandler(true);
        new Main().run(args, handler);
        //在编译时打印信息如警告、error等等
        for (IMessage message : handler.getMessages(null, true)) {
            switch (message.getKind()) {
                case IMessage.ABORT:
                case IMessage.ERROR:
                case IMessage.FAIL:
                    log.error message.message, message.thrown
                    break;
                case IMessage.WARNING:
                    log.warn message.message, message.thrown
                    break;
                case IMessage.INFO:
                    log.info message.message, message.thrown
                    break;
                case IMessage.DEBUG:
                    log.debug message.message, message.thrown
                    break;
            }
        }
    }
}

2、自定义注解

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**自定义注解*/
@Retention(RetentionPolicy.RUNTIME)//定义我们自己写的注解何时有效
@Target(ElementType.METHOD)//定义我们写的注解可以描述的成员
public @interface LoginFilter {

    //在注解里加了个loginDefine，就是为了给用户提供自定义实现，如根据loginDefine值不同做不同的登录处理。
    int loginDefine() default 0;

}

3、配置切面

import android.content.Context;

import com.app.pest.anno.LoginFilter;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MemberSignature;
import org.aspectj.lang.reflect.MethodSignature;

/**
 * 登录切面处理
 */

@Aspect//此注解描述的类为切面类，其内部可以定义切入点表达式和通知方法
public class LoginFilterAspect {
    private static final String TAG = "LoginFilterAspect";

    //@annotation(包名.注解名)
    @Pointcut("@annotation(com.app.pest.anno.LoginFilter)")
    public void LoginFilter() {//承载切入点表达式的定义，方法不写任何内容
    }


    // @Around("@annotation(com.app.pest.anno.LoginFilter)")
    @Around("LoginFilter()")
    public void aroundLoginPoint(ProceedingJoinPoint joinPoint) throws Throwable {
        //获取用户实现的ILogin类，如果没有初始化就抛出异常。
        ILoginFilter iLoginFilter = LoginAssistant.getInstance().getILoginFilter();
        if (iLoginFilter == null) {
            throw new RuntimeException("LoginManger没有初始化");
        }
        //先得到方法的签名methodSignature，然后得到@LoginFilter注解，如果注解为空，就不再往下走。
        Signature signature = joinPoint.getSignature();
        if (!(signature instanceof MemberSignature)) {
            throw new RuntimeException("该注解只能用于方法上");
        }
        MethodSignature methodSignature = (MethodSignature) signature;
        LoginFilter loginFilter = methodSignature.getMethod().getAnnotation(LoginFilter.class);
        if (loginFilter == null) {
            return;
        }
        Context mContext = LoginAssistant.getInstance().getApplicationContext();
        //调用iLogin的isLogin()方法判断是否登录，这个isLogin是留给使用者自己实现的，如果登录，就会继续执行方法体调用方法直到完成，如果没有登录，执行下一个
        if (iLoginFilter.isLogin(mContext)) {//已经登录
            joinPoint.proceed();//执行目标方法
        } else {
            iLoginFilter.login(mContext, loginFilter.loginDefine());
        }

    }
}

4、使用登录拦截器

在需要拦截的方法上加上注解即可

    @LoginFilter(loginDefine = 0)
    @Override
    //跳转到需要拦截登录的Activity
    public void onClick(View v) {
        startActivity(new Intent(this, SecondActivity.class));
    }

踩坑

okhttp3的4.9.x版本让aop失效，降低版本就行了。

implementation 'com.squareup.okhttp3:okhttp:4.8.1' //引入 okhttp

源码：

https://github.com/antporter/pest