Ich habe im Frühjahr etwas über Interceptor gelernt, also werde ich einen Artikel schreiben.
Die Interceptor-Klasse in Spring ist eine Klasse, die verwendet wird, wenn beispielsweise "Ich möchte eine Klasse implementieren, die eine allgemeine Verarbeitung ausführt, bevor der Controller aufgerufen wird". Beispielsweise wird es verwendet, wenn Sie den zugreifenden Benutzer authentifizieren möchten, bevor Sie die Anforderung zuordnen.
Ich werde die implementierte Klasse kurz erklären.
TestInterceptor.java
import java.lang.reflect.Method;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
import com.example.annotation.NonAuth;
import com.example.models.TestUser;
import com.example.service.UserPermissionService;
public class TestInterceptor extends HandlerInterceptorAdapter{
@Autowired
UserPermissionService service;
@Override
public boolean preHandle(
HttpServletRequest request,
HttpServletResponse response,
Object handler) throws Exception {
//False, wenn die Anforderung nicht zugeordnet werden kann
if( handler instanceof HandlerMethod ) {
// @Überprüfen Sie, ob NonAuth gewährt wird
HandlerMethod hm = (HandlerMethod) handler;
Method method = hm.getMethod();
NonAuth annotation = AnnotationUtils.findAnnotation(method, NonAuth.class);
if (annotation != null) {
return true;
}
//Benutzerauthentifizierung
HttpSession session = request.getSession(false);
try {
TestUser user = (TestUser)session.getAttribute("user");
if(!service.checkPermission(user)) {
response.sendRedirect("/error");
return false;
}
}catch(NullPointerException e){
response.sendRedirect("/error");
return false;
}
return true;
}
response.sendRedirect("/error");
return false;
}
}
-Die Interceptor-Klasse muss von HandlerInterceptorAdaptor erben. -PreHandle () ist eine Methode, die aufgerufen wird, bevor der Controller-Prozess aufgerufen wird. Sie können auch postHandle () überschreiben, das nach Abschluss der Verarbeitung durch den Controller aufgerufen wird, und afterCompletion (), das nach Abschluss einer Reihe von Anforderungsverarbeitungen aufgerufen wird.
BeanConfiguration.java
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.HandlerInterceptor;
import com.example.interceptor.TestInterceptor;
import com.example.service.TestService;
@Configuration
public class BeanConfiguration {
@Bean
public HandlerInterceptor testInterceptor() throws Exception{
return new TestInterceptor();
}
}
-Definieren Sie die Interceptor-Klasse als Bean.
WebMvcConfig.java
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
@Configuration
public class WebMvcConfig implements WebMvcConfigurer {
@Autowired
HandlerInterceptor testInterceptor;
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(testInterceptor);
}
}
-Interceptor ist eine Klasse, die WebMvcConfigurer erbt und von addInterceptors () von Spring erkannt werden muss. Rufen Sie die Interceptor-Klasse mit Autowired auf.
TestInterceptorController.java
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import com.example.annotation.NonAuth;
import com.example.models.TestUser;
@Controller
@RequestMapping("/interceptor")
public class TestInterceptorController {
@RequestMapping(value="/index",method = RequestMethod.GET)
@NonAuth
public String index(Model model, HttpServletRequest request) {
TestUser user = new TestUser();
user.setName("Tanaka");
HttpSession session = request.getSession(false);
if (session == null){
session = request.getSession(true);
session.setAttribute("user", user);
}else {
session.setAttribute("user", user);
}
return "test/index";
}
@RequestMapping(value="/test", method=RequestMethod.GET)
public String test(Model model) {
model.addAttribute("msg", "HelloWorld!");
return "test/test";
}
}
Das ist die grobe Implementierungsklasse.
-Wenn Sie Fehler in Spring behandeln möchten, definieren Sie eine Klasse, die ErrorController erbt (eine von Spring bereitgestellte Klasse).
ErrorController
import org.springframework.boot.web.servlet.error.ErrorController;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import com.example.annotation.NonAuth;
@Controller
public class ErrController implements ErrorController {
private static final String PATH = "/error";
@RequestMapping("/404")
@NonAuth
String notFoundError() {
return "test/error";
}
@RequestMapping(PATH)
@NonAuth
String home() {
return "test/error";
}
@Override
@NonAuth
public String getErrorPath() {
return PATH;
}
}
Returns: true if the execution chain should proceed with the next interceptor or the handler itself. Else, DispatcherServlet assumes that this interceptor has already dealt with the response itself. True, wenn die Ausführungskette zum nächsten Interceptor oder zum Handler selbst weitergeleitet werden muss. Andernfalls geht DispatcherServlet davon aus, dass dieser Interceptor die Antwort selbst bereits verarbeitet hat.
Ich bin nicht sicher, was Sie in "Wenn nicht ..." sagen, aber ich denke, das DispatcherServlet wird wahrscheinlich davon ausgehen, dass eine Antwort bereits zurückgegeben wurde, wenn sie mit preHandle (ansonsten dem Controller) zurückgegeben wird. Bedeutet "wenn nicht" "wenn falsch", da die Methode von gestartet wurde?). Wenn Sie die Controller-Methode nicht aufrufen möchten, schreiben Sie return false.
-Ich überprüfe, ob der Handler eine HandlerMethod in der Interceptor-Klasse ist, da der Handler nicht unbedingt eine HandlerMethod ist.
Referenz: Interceptor mit Springboot einrichten Verarbeitung vor und nach der Controller-Methode in Interceptor einfügen Verarbeiten Sie die Controller-Methode mit einer bestimmten Spring Boot-Anmerkung vorab WebMvcConfigurer-Memorandum von Spring Boot 2.0 (Spring 5) Fehlerbildschirm mit Springboot anzeigen Ich war süchtig nach Spring Boot (ca. 1.2) [Von Zeit zu Zeit aktualisiert] RedirectusingSpringbootinterceptor Die Methode, die zu preHandle kommt, ist nicht immer die HandlerMethod
Recommended Posts