Die Entwicklung der Benutzeranmeldeberechtigungen hat sich von der vorherigen Selbstüberprüfung der Benutzeranmeldeberechtigungen in jeder Methode zum einheitlichen Prozess zur Benutzeranmeldeüberprüfung entwickelt.
Sehen wir uns zunächst die Implementierungsmethode der Überprüfung der ersten Benutzeranmeldung an:
@RestController
@RequestMapping("/user")
public class UserController {
/**
* 某⽅法 1
*/
@RequestMapping("/m1")
public Object method(HttpServletRequest request) {
// 有 session 就获取，没有不会创建
HttpSession session = request.getSession(false);
if (session != null && session.getAttribute("userinfo") != null) {
// 说明已经登录，业务处理
return true;
} else {
// 未登录
return false;
}
}
/**
* 某⽅法 2
*/
@RequestMapping("/m2")
public Object method2(HttpServletRequest request) {
// 有 session 就获取，没有不会创建
HttpSession session = request.getSession(false);
if (session != null && session.getAttribute("userinfo") != null) {
// 说明已经登录，业务处理
return true;
} else {
// 未登录
return false;
}
}
// 其他⽅法...
}Wie aus dem obigen Code ersichtlich ist, verfügt jede Methode über dieselben Berechtigungen zur Überprüfung der Benutzeranmeldung. Die Nachteile sind:
Jede Methode muss eine separate Methode zur Überprüfung der Benutzeranmeldung schreiben. Auch wenn sie in eine öffentliche Methode gekapselt ist, muss sie dennoch Parameter zum Aufrufen und zur Beurteilung in der Methode übergeben.
Je mehr Controller Sie hinzufügen, desto mehr Methoden müssen Sie zur Überprüfung der Benutzeranmeldung aufrufen, was die späteren Änderungskosten und Wartungskosten erhöht.
Diese Methoden zur Überprüfung der Benutzeranmeldung haben nichts mit dem als nächstes zu implementierenden Unternehmen zu tun, aber jede Methode muss einmal geschrieben werden.
Daher ist es dringend erforderlich, eine öffentliche AOP-Methode für die einheitliche Überprüfung der Benutzeranmeldeberechtigung bereitzustellen.
1 Es gibt keine Möglichkeit, das HttpSession-Objekt abzurufen.
2. Wir müssen einige Methoden abfangen, andere jedoch nicht. In diesem Fall sind die Regeln zum Ausschließen von Methoden nicht abfangbar definiere es.
Wie kann man das lösen?
1.3 Spring Interceptor
Für die oben genannten Probleme bietet Spring einen spezifischen Implementierungs-Interceptor: HandlerInterceptor. Vorverarbeitung vor der Ausführung bestimmter Methoden) Methode.
Die spezifische Implementierung ist wie folgt.
Ergänzende Filter:
Filter werden vom Webcontainer bereitgestellt. Die Auslösezeit liegt vor der des Interceptors. Er wird vor der Initialisierung von Spring ausgeführt, sodass Probleme wie die Validierung der Benutzeranmeldeberechtigung nicht behandelt werden können. 1.3.1 Vorbereitung folgt:
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
@Aspect
@Component
public class UserAspect {
// 定义切点⽅法 controller 包下、⼦孙包下所有类的所有⽅法
@Pointcut("execution(* com.example.demo.controller..*.*(..))")
public void pointcut(){ }
// 前置⽅法
@Before("pointcut()")
public void doBefore(){
}
// 环绕⽅法
@Around("pointcut()")
public Object doAround(ProceedingJoinPoint joinPoint){
Object obj = null;
System.out.println("Around ⽅法开始执⾏");
try {
// 执⾏拦截⽅法
obj = joinPoint.proceed();
} catch (Throwable throwable) {
throwable.printStackTrace();
}
System.out.println("Around ⽅法结束执⾏");
return obj;
}
}Gibt den booleschen Typ zurück.
entspricht einer Sicherheitsebene: Wenn
falsch ist, kann es nicht weiter ausgeführt werden; wenn es wahr ist, kann es ausgeführt werden.
1.3.3 Fügen Sie den benutzerdefinierten Interceptor zur Systemkonfiguration hinzu.
Fügen Sie den im vorherigen Schritt definierten Interceptor zu den Systemkonfigurationsinformationen hinzu. Der spezifische Implementierungscode lautet wie folgt:package com.example.demo.controller;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
@RestController
@RequestMapping("/user")
@Slf4j
public class UserController {
@RequestMapping("/login")
public boolean login(HttpServletRequest request,
String username, String password) {
// // 1.非空判断
// if (username != null && username != "" &&
// password != null && username != "") {
// // 2.验证用户名和密码是否正确
// }
// 1.非空判断
if (StringUtils.hasLength(username) && StringUtils.hasLength(password)) {
// 2.验证用户名和密码是否正确
if ("admin".equals(username) && "admin".equals(password)) {
// 登录成功
HttpSession session = request.getSession();
session.setAttribute("userinfo", "admin");
return true;
} else {
// 用户名或密码输入错误
return false;
}
}
return false;
}
@RequestMapping("/getinfo")
public String getInfo() {
log.debug("执行了 getinfo 方法");
return "执行了 getinfo 方法";
}
@RequestMapping("/reg")
public String reg() {
log.debug("执行了 reg 方法");
return "执行了 reg 方法";
}
}
package com.example.demo.config;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
/**
* 登录拦截器
*/
@Component
@Slf4j
public class LoginInterceptor implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
// 登录判断业务
HttpSession session = request.getSession(false);
if (session != null && session.getAttribute("userinfo") != null) {
return true;
}
log.error("当前用户没有访问权限");
response.setStatus(401);
return false;
}
}package com.example.demo.config;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
@Configuration // 一定不要忘记
public class MyConfig implements WebMvcConfigurer {
@Autowired
private LoginInterceptor loginInterceptor;
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(loginInterceptor)
.addPathPatterns("/**") // 拦截所有请求
.excludePathPatterns("/user/login") // 排除不拦截的 url
// .excludePathPatterns("/**/*.html")
// .excludePathPatterns("/**/*.js")
// .excludePathPatterns("/**/*.css")
.excludePathPatterns("/user/reg"); // 排除不拦截的 url
}
}
excludePathPatterns: Zeigt URLs an, die ausgeschlossen werden müssen.
Hinweis: Die oben genannten Abfangregeln können die in diesem Projekt verwendeten URLs abfangen, einschließlich statischer Dateien (Bilddateien, JS, CSS usw.). 1.4 Prinzip der Interceptor-Implementierung
Aufrufsequenz unter normalen Umständen:
Mit dem Interceptor wird jedoch die entsprechende Geschäftsverarbeitung durchgeführt, bevor der Controller aufgerufen wird. Darstellung:1.4.1 Implementierungsprinzip Quellcode-Analyse
⽽ Alle Methoden führen die doDispatch-Planungsmethode in DispatcherServlet aus. Der doDispatch-Quellcode lautet wie folgt:
package com.example.demo.common;
import org.springframework.beans.factory.annotation.Autowired;
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;
import java.util.ArrayList;
import java.util.List;
@Configuration
public class AppConfig implements WebMvcConfigurer {
// 不拦截的 url 集合
List<String> excludes = new ArrayList<String>() {{
add("/**/*.html");
add("/js/**");
add("/editor.md/**");
add("/css/**");
add("/img/**"); // 放行 static/img 下的所有文件
add("/user/login"); // 放行登录接口
add("/user/reg"); // 放行注册接口
add("/art/detail"); // 放行文章详情接口
add("/art/list"); // 放行文章分页列表接口
add("/art/totalpage"); // 放行文章分页总页数接口
}};
@Autowired
private LoginInterceptor loginInterceptor;
@Override
public void addInterceptors(InterceptorRegistry registry) {
// 配置拦截器
InterceptorRegistration registration =
registry.addInterceptor(loginInterceptor);
registration.addPathPatterns("/**");
registration.excludePathPatterns(excludes);
}
}Aus dem obigen Quellcode ist ersichtlich, dass vor Beginn der Ausführung des Controllers zuerst die Vorverarbeitung aufgerufen wird. Die Methode applyPreHandle und der Implementierungsquellcode der applyPreHandle-Methode lauten wie folgt:
@Configuration // 一定不要忘记
public class MyConfig implements WebMvcConfigurer {
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(new LoginInterceptor())
.addPathPatterns("/**") // 拦截所有请求
.excludePathPatterns("/user/login") // 排除不拦截的 url
// .excludePathPatterns("/**/*.html")
// .excludePathPatterns("/**/*.js")
// .excludePathPatterns("/**/*.css")
// .excludePathPatterns("/**/*.jpg")
// .excludePathPatterns("/**/login")
.excludePathPatterns("/user/reg"); // 排除不拦截的 url
}
}Wie aus dem obigen Quellcode ersichtlich ist, werden alle Interceptoren HandlerInterceptor in applyPreHandle abgerufen und die preHandle-Methode im Interceptor ausgeführt wird das sein, was wir zuvor definiert haben Der Interceptor entspricht, wie in der folgenden Abbildung gezeigt: 
此时⽤户登录权限的验证⽅法就会执⾏，这就是拦截器的实现原理。 1.4.2 拦截器小结 通过上⾯的源码分析，我们可以看出，Spring 中的拦截器也是通过动态代理和环绕通知的思想实现的，⼤体的调⽤流程如下： 所有请求地址添加 api 前缀： 其中第⼆个参数是⼀个表达式，设置为 true 表示启动前缀。 统⼀异常处理使⽤的是 @ControllerAdvice + @ExceptionHandler 来实现的，@ControllerAdvice 表示控制器通知类，@ExceptionHandler 是异常处理器，两个结合表示当出现异常的时候执⾏某个通知，也就是执⾏某个⽅法事件，具体实现代码如下： 方法名和返回值可以⾃定义，重要的是 @ControllerAdvice 和 @ExceptionHandler 注解。 以上⽅法表示，如果出现了异常就返回给前端⼀个 HashMap 的对象，其中包含的字段如代码中定义的那样。 我们可以针对不同的异常，返回不同的结果，⽐以下代码所示： 当有多个异常通知时，匹配顺序为当前类及其子类向上依次匹配，案例演示： 在 UserController 中设置⼀个空指针异常，实现代码如下： 以上程序的执⾏结果如下： 此时若出现异常就不会报错了，代码会继续执行，但是会把自定义的异常信息返回给前端！ 统一完数据返回格式后： 统一异常处理不用配置路径，是拦截整个项目中的所有异常。 统⼀数据返回格式的优点有很多，比如以下几个： ⽅便前端程序员更好的接收和解析后端数据接⼝返回的数据。 降低前端程序员和后端程序员的沟通成本，按照某个格式实现就⾏了，因为所有接⼝都是这样返回的。 有利于项⽬统⼀数据的维护和修改。 有利于后端技术部⻔的统⼀规范的标准制定，不会出现稀奇古怪的返回内容。 统⼀的数据返回格式可以使用 @ControllerAdvice + ResponseBodyAdvice接口 的方式实现，具体实现代码如下： 统一处理后，此时所有返回的都是 json 格式的数据了。 若方法的返回类型为 String，统一数据返回格式封装后，返回会报错！？ 转换器的问题，解决方案： 实际开发中这种统一数据返回格式的方式并不常用。因为它会将所有返回都再次进行封装，过于霸道了 ~ 而通常我们会写一个统一封装的类，让程序猿在返回时统一返回这个类 (软性约束)，例如： 同时搭配统一数据返回格式： 通过对 @ControllerAdvice 源码的分析我们可以知道上⾯统⼀异常和统⼀数据返回的执⾏流程，我们先从 @ControllerAdvice 的源码看起，点击 @ControllerAdvice 实现源码如下： 从上述源码可以看出 @ControllerAdvice 派⽣于 @Component 组件，⽽所有组件初始化都会调用 InitializingBean 接⼝。 所以接下来我们来看 InitializingBean 有哪些实现类？在查询的过程中我们发现了，其中 Spring MVC中的实现⼦类是 RequestMappingHandlerAdapter，它⾥⾯有⼀个⽅法 afterPropertiesSet() ⽅法，表示所有的参数设置完成之后执⾏的⽅法，如下图所示： ⽽这个⽅法中有⼀个 initControllerAdviceCache ⽅法，查询此⽅法的源码如下： Wir haben festgestellt, dass bei der Ausführung dieser Methode alle @ControllerAdvice-Klassen im Container gesucht und verwendet werden. Wenn jedoch ein Ereignis auftritt, wird beispielsweise die entsprechende Advice-Methode aufgerufen, bevor Daten zurückgegeben werden Datenkapselung: Wenn beispielsweise eine Ausnahme auftritt, wird die Advice-Methodenimplementierung der Ausnahme aufgerufen. Das obige ist der detaillierte Inhalt vonSo implementieren Sie eine einheitliche Funktionsverarbeitung in SpringBoot. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
1.5 扩展：统一访问前缀添加
@Configuration
public class AppConfig implements WebMvcConfigurer {
// 所有的接⼝添加 api 前缀
@Override
public void configurePathMatch(PathMatchConfigurer configurer) {
configurer.addPathPrefix("api", c -> true);
}
}二、统一异常处理
package com.example.demo.config;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
import java.util.HashMap;
/**
* 统一处理异常
*/
@ControllerAdvice
public class ErrorAdive {
@ExceptionHandler(Exception.class)
@ResponseBody
public HashMap<String, Object> exceptionAdvie(Exception e) {
HashMap<String, Object> result = new HashMap<>();
result.put("code", "-1");
result.put("msg", e.getMessage());
return result;
}
@ExceptionHandler(ArithmeticException.class)
@ResponseBody
public HashMap<String, Object> arithmeticAdvie(ArithmeticException e) {
HashMap<String, Object> result = new HashMap<>();
result.put("code", "-2");
result.put("msg", e.getMessage());
return result;
}
}import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
import java.util.HashMap;
@ControllerAdvice
@ResponseBody
public class ExceptionAdvice {
@ExceptionHandler(Exception.class)
public Object exceptionAdvice(Exception e) {
HashMap<String, Object> result = new HashMap<>();
result.put("success", -1);
result.put("message", "总的异常信息：" + e.getMessage());
result.put("data", null);
return result;
}
@ExceptionHandler(NullPointerException.class)
public Object nullPointerexceptionAdvice(NullPointerException e) {
HashMap<String, Object> result = new HashMap<>();
result.put("success", -1);
result.put("message", "空指针异常：" + e.getMessage());
result.put("data", null);
return result;
}
} @RestController
@RequestMapping("/u")
public class UserController {
@RequestMapping("/index")
public String index() {
Object obj = null;
int i = obj.hashCode();
return "Hello,User Index.";
}
}
package com.example.demo.common;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
/**
* 异常类的统一处理
*/
@ControllerAdvice
@ResponseBody
public class ExceptionAdvice {
@ExceptionHandler(Exception.class)
public Object exceptionAdvice(Exception e) {
return AjaxResult.fail(-1, e.getMessage());
}
}三、统一数据返回格式
3.1 为什么需要统一数据返回格式
3.2 统一数据返回格式的实现
import org.springframework.core.MethodParameter;
import org.springframework.http.MediaType;
import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyA
dvice;
import java.util.HashMap;
/**
* 统一返回数据的处理
*/
@ControllerAdvice
public class ResponseAdvice implements ResponseBodyAdvice {
/**
* 内容是否需要重写（通过此⽅法可以选择性部分控制器和⽅法进⾏重写）
* 返回 true 表示重写
*/
@Override
public boolean supports(MethodParameter returnType, Class converterTyp
e) {
return true;
}
/**
* ⽅法返回之前调⽤此⽅法
*/
@Override
public Object beforeBodyWrite(Object body, MethodParameter returnType,
MediaType selectedContentType,
Class selectedConverterType, ServerHttpR
equest request,
ServerHttpResponse response) {
// 构造统⼀返回对象
HashMap<String, Object> result = new HashMap<>();
result.put("state", 1);
result.put("msg", "");
result.put("data", body);
return result;
}
}
package com.example.demo.common;
import java.util.HashMap;
/**
* 自定义的统一返回对象
*/
public class AjaxResult {
/**
* 业务执行成功时进行返回的方法
*
* @param data
* @return
*/
public static HashMap<String, Object> success(Object data) {
HashMap<String, Object> result = new HashMap<>();
result.put("code", 200);
result.put("msg", "");
result.put("data", data);
return result;
}
/**
* 业务执行成功时进行返回的方法
*
* @param data
* @return
*/
public static HashMap<String, Object> success(String msg, Object data) {
HashMap<String, Object> result = new HashMap<>();
result.put("code", 200);
result.put("msg", msg);
result.put("data", data);
return result;
}
/**
* 业务执行失败返回的数据格式
*
* @param code
* @param msg
* @return
*/
public static HashMap<String, Object> fail(int code, String msg) {
HashMap<String, Object> result = new HashMap<>();
result.put("code", code);
result.put("msg", msg);
result.put("data", "");
return result;
}
/**
* 业务执行失败返回的数据格式
*
* @param code
* @param msg
* @return
*/
public static HashMap<String, Object> fail(int code, String msg, Object data) {
HashMap<String, Object> result = new HashMap<>();
result.put("code", code);
result.put("msg", msg);
result.put("data", data);
return result;
}
}package com.example.demo.common;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.SneakyThrows;
import org.springframework.core.MethodParameter;
import org.springframework.http.MediaType;
import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;
import java.util.HashMap;
/**
* 统一数据返回封装
*/
@ControllerAdvice
public class ResponseAdvice implements ResponseBodyAdvice {
@Override
public boolean supports(MethodParameter returnType, Class converterType) {
return true;
}
@SneakyThrows
@Override
public Object beforeBodyWrite(Object body, MethodParameter returnType, MediaType selectedContentType, Class selectedConverterType, ServerHttpRequest request, ServerHttpResponse response) {
if (body instanceof HashMap) { // 本身已经是封装好的对象
return body;
}
if (body instanceof String) { // 返回类型是 String（特殊）
ObjectMapper objectMapper = new ObjectMapper();
return objectMapper.writeValueAsString(AjaxResult.success(body));
}
return AjaxResult.success(body);
}
}3.3 @ControllerAdvice 源码分析（了解）
Schritte zur SpringBoot-Projekterstellung
Was ist der Unterschied zwischen j2ee und springboot?
Was tun, wenn Chrome keine Plugins laden kann?
Git macht den eingereichten Commit rückgängig
Was soll ich tun, wenn gpedit.msc nicht geöffnet werden kann?
Was ist eine Suchmaschine?
Die PHPStudy-Datenbank kann die Lösung nicht starten
So reinigen Sie das zu volle Laufwerk C des Computers
