A través de la lectura anterior, todos deben tener una comprensión simple de las anotaciones y ser capaces de realizar aplicaciones sencillas. Déjame contarte sobre el uso de anotaciones.
De hecho, la anotación siempre cambiante sigue siendo así, es decir, la anotación se obtiene a través de la reflexión, y luego se analiza la anotación, para realizar el procesamiento lógico.
No sé si lo has encontrado alguna vez. Se agrega una anotación a una clase de controlador, y luego todos los métodos realizarán el filtrado de permisos o la autenticación. Cuando encontré esto por primera vez, solo había una sensación --- - -----¡Impresionante!
Lo que pienso en mi corazón es digno de ser un gran dios, ¡haz todo lo que quieras!
De hecho, mirando hacia atrás ahora, se trata de un análisis de interceptación y anotación, que da cuenta de filtrado o interceptación de solicitudes, y no hay conocimientos particularmente avanzados. Aún así, no es difícil para los que se están reuniendo y los que son difíciles no, realmente profundice en él. Encontrará, ¡oh, resultó ser así!
A continuación, utilizo el procesamiento del interceptor en Spring para realizar el filtrado de anotaciones en los métodos.
Crea un nuevo interceptor.
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE,ElementType.METHOD})
public @interface TestAnno {
//多个或者多种过滤，也可以直接使用下面的单种
String[] values() default {TestConstant.BOSS,TestConstant.STAFF};
// String value();
}Esta anotación es fácil de entender, es una colección de arreglos, defina los permisos como BOSS o STAFF, por conveniencia, creé una interfaz para almacenar constantes
package com.example.demoproject.constant;
public interface TestConstant {
String BOSS = "boss";
String STAFF = "staff";
}
Lo siguiente es construir un interceptor, por supuesto que necesito construir un bean interceptor. Debido a que el interceptor de carga está antes de que se cargue ApplicationContext, la adición directa de @Service o @Component no se puede inyectar correctamente. Así que cree una configuración para cargar el interceptor en el contenedor Spring.
package com.example.demoproject.filter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport;
@Configuration
public class InterceptorConfig extends WebMvcConfigurationSupport {
@Bean
public TestInterceptor testInterceptor(){
return new TestInterceptor();
}
@Override
public void addInterceptors(InterceptorRegistry registry){
// 拦截所以请求
registry.addInterceptor(this.testInterceptor()).addPathPatterns("/**");
}
}
Esta clase de configuración es para cargar un Bean de TestInterceptor y luego agregar este interceptor a la colección de interceptores.
El siguiente paso es implementar este interceptor. Veamos primero el controlador
package com.example.demoproject.controller;
import com.example.demoproject.annotion.TestAnno;
import com.example.demoproject.constant.TestConstant;
import com.example.demoproject.emun.TestEnum;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.HashMap;
import java.util.Map;
@RestController
@TestAnno(values = TestConstant.BOSS)
public class TestController {
@PostMapping("/test")
@TestAnno(values = TestConstant.STAFF)
public Map<String,String> get(){
Map<String,String> map = new HashMap();
map.put("response","success");
return map;
}
}
Debido a que esta anotación se puede agregar a métodos y clases, agregué una demostración (@Target ({ElementType.TYPE, ElementType.METHOD}))
Bien, veamos la implementación del interceptor:
package com.example.demoproject.filter;
import com.alibaba.fastjson.JSON;
import com.example.demoproject.annotion.TestAnno;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletMapping;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.lang.invoke.MethodHandle;
import java.lang.reflect.Method;
public class TestInterceptor implements HandlerInterceptor {
// 在业务处理器处理请求之前被调用
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception{
if(handler instanceof HandlerMethod){
HandlerMethod handlerMethod = (HandlerMethod)handler;
Method method = handlerMethod.getMethod();
System.out.println(method);
Class<?> aClass = method.getDeclaringClass();
TestAnno anno = aClass.getAnnotation(TestAnno.class);
System.out.println("anno:"+ JSON.toJSONString(anno.values()));
TestAnno anno1 = method.getAnnotation(TestAnno.class);
System.out.println("anno1:"+ JSON.toJSONString(anno1.values()));
System.out.println("--------------");
String name = request.getParameter("name");
System.out.println("name:"+name);
}
// System.out.println("输出request"+JSON.toJSON(request));
return true;
}
// 在业务处理器处理请求完成之后，生成视图之前执行
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView)
throws Exception{
}
// 在DispatcherServlet完全处理完请求之后被调用，可用于清理资源
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
throws Exception{
}
}
Los interceptores deben ser conocidos por todos, así que no los presentaré mucho El procesamiento principal aquí es preHandle, que se procesa antes que el método. Este método tiene un valor de retorno, tipo booleano, devuelve verdadero, continúa bajando, devuelve falso y se intercepta directamente.
Como se puede ver en el código, podemos obtener el método y la clase solicitados, y luego obtener sus anotaciones, y luego podemos juzgar si las anotaciones son consistentes con las expectativas, y luego la lógica del juicio (no escribí esta parte, necesita ser procesado de acuerdo con la situación real), si la verificación falla, devuelve falso, si la verificación pasa, devuelve verdadero.
En este caso, una solicitud de interceptación de anotaciones o una estructura de autoridad de filtrado está completa, ¿no es solo eso?
Si se siente bien, solo dale un pulgar hacia arriba ~