SpringBoot 는 어떻게 사용자 정의 주 해 를 통 해 권한 검 사 를 실현 하 는 지 상세 하 게 설명 합 니 다.

머리말
최근 에 인 터 페 이 스 를 개 발 했 는데 완 성 된 후에 자체 측정 을 준비 할 때 차단기 에 의 해 차단 되 었 습 니 다.힌트:(AUTH-NO) ！어떻게 이 럴 수 있 습 니까?
그래서 저 는 이 제시 어 를 전체적으로 검색 한 결과 Aspect 류 에 나타 나 고@interface 를 접점 으로 했 습 니 다.여기 서 Spring AOP 를 절단면 으로 하 는 방식 으로 권한 통 제 를 했 습 니 다.
SpringBoot 는 사용자 정의 주 해 를 통 해 로그 인쇄 를 할 수 있 습 니 다.SpringBoot 는 사용자 정의 주 해 를 통 해 로그 인쇄 를 실현 합 니 다.
본문
Spring AOP
Spring AOP 는 절단면 을 향 한 것 으로 OOP 대상 을 향 한 연장 이다.
AOP 메커니즘 은 개발 자가 업무 프로 세 스에 서 통용 되 는 기능 을 추출 하여 기능 코드 를 단독으로 작성 하도록 할 수 있다.업무 프로 세 스 를 실행 하 는 과정 에서 Spring 프레임 워 크 는 업무 프로 세 스 의 요구 에 따라 독립 적 으로 작 성 된 기능 코드 를 프로 세 스 의 적당 한 위치 에 자동 으로 삽입 합 니 다.
저 희 는 AOP 체 제 를 통 해 Authentication 권한 검사,Caching 캐 시,Context passing 내용 전달,Error handling 오류 처리,로그 인쇄 등 기능 을 실현 할 수 있 습 니 다.여기 서 Spring AOP 로 권한 검 사 를 어떻게 하 는 지 말씀 드 리 겠 습 니 다.
SpringBoot 는 사용자 정의 주 해 를 통 해 권한 검 사 를 실현 합 니 다.
Maven 의존

<!--lombok-->
<dependency>
 <groupId>org.projectlombok</groupId>
 <artifactId>lombok</artifactId>
 <version>1.18.2</version>
 <optional>true</optional>
</dependency>

<!--Spring AOP-->
<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

MyPermission Tag.class 사용자 정의 주석

@Retention:주 해 를 수식 하 는 데 사용 되 며 주해 의 주해 로 원 주해 라 고 합 니 다.

@Target:대상 의 역할 범 위 를 설명 하 는 데 사용

/**
 *         
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MyPermissionTag {
 String value() default "";
 String name() default "";
}

여기 서 특별히@Retention 에 대해 말씀 드 리 겠 습 니 다.생명주기 에 따라 3 가지 로 나 눌 수 있 습 니 다.

Retention Policy.SOURCE:주 해 는 원본 파일 에 만 남아 있 습 니 다.자바 파일 이 class 파일 로 컴 파일 될 때 주 해 는 버 려 집 니 다(실행 시 동적 으로 주 해 를 가 져 옵 니 다).

Retention Policy.CLASS:주 해 는 class 파일 에 저장 되 지만 jvm 에서 class 파일 을 불 러 올 때 버 려 집 니 다.이것 은 기본 수명 주기 입 니 다.(컴 파일 할 때 사전 처리 작업 을 합 니 다)

Retention Policy.RUNTIME:주 해 는 class 파일 에 저 장 될 뿐만 아니 라 jvm 에서 class 파일 을 불 러 온 후에 도 존재 합 니 다(검사 적 인 작업 을 합 니 다).

이 세 개의 생명 주 기 는 각각 자바 소스 파일(자바 파일)->class 파일->메모리 의 바이트 코드 에 대응 합 니 다.
AuthorInterceptor 권한 검사 의 절단면
단면 적 인 집행 방법 과 그 집행 순 서 를 간단하게 소개 합 니 다.

@Around 알림 방법 으로 대상 방법 을 봉인

@Before 알림 방법 은 목표 방법 이 호출 되 기 전에 실 행 됩 니 다

@After 알림 방법 은 목표 방법 이 되 돌아 오 거나 이상 한 후에 실 행 됩 니 다

@AfterReturning 알림 방법 은 대상 방법 이 되 돌아 올 때 실 행 됩 니 다

@Afterthrowing 알림 방법 은 목표 방법 에 이상 을 던 졌 을 때 실 행 됩 니 다

여기 서 정상 으로 돌아 가 는 상황 을 예 로 들 면:(마지막 단 계 를 이상 하 게 바 꾸 면 됩 니 다)

AuthInterceptor.class
시작 클래스 에서 이 class 를 스 캔 하고 추가 하 는 것 을 주의 하 십시오@EnableAspectJAutoProxy(proxyTargetClass = true)

@Slf4j
@Aspect
@Component
public class AuthInterceptor {


 /**
 *     
 *
 * @param point
 */
 @Before("@annotation(com.luo.common.tag.MyPermissionTag)")
 public void beforeProReq(JoinPoint point) {
 log.info("    -  ");
 Request req = getOperationRequest(point.getArgs());
 if (req != null) {
  //    
  log.info("    -    ACCOUNT:{}", req.getAccount());


  log.info("    -    ACCOUNT:{}", req.getAccount());
 }
 log.info("    -  ");
 }


 @Around("@annotation(com.luo.common.tag.MyPermissionTag)")
 public Object authCheck(ProceedingJoinPoint pjp) throws Throwable {
 log.info("    -  ");
 //    
 ReqMethod reqMethod = getPermissionTag(pjp);


 MyPermissionTag myPermissionTag =reqMethod.perTag;
 log.info(myPermissionTag.value()); //      
 log.info("    -  -     :{}", reqMethod.getMethodName());


 if("true".equals(myPermissionTag.value().toString())){
  //    
  Response notGoRes = new Response();
  Request req = getOperationRequest(pjp.getArgs());
  //       
  if (req == null) {
  notGoRes.setErrorMsg("(AUTH)           ！");
  log.info("(AUTH-NO)           ！");
  return notGoRes;
  }else {//                    


  log.info("      :"+req);




  }
 }else {
  log.info("       ");
 }


 return pjp.proceed();
 }




 /**
 *    request         
 * @param args
 * @return
 */
 private Request getOperationRequest(Object[] args) {
 if (args == null || args.length <= 0) {
  log.error("AUTH    ：           ！");
  return null;
 }
 Object obj = args[0];
 if (obj instanceof Request) {
  log.info("AUTH    ：        OperationRequest  ");
  return (Request) obj;
 }
 return null;
 }




 /**
 *          
 *          +    (   key+value  )
 * @param pjp
 * @return
 * @throws SecurityException
 * @throws NoSuchMethodException
 */
 private ReqMethod getPermissionTag(ProceedingJoinPoint pjp) throws NoSuchMethodException, SecurityException {
 Signature signature = pjp.getSignature();
 MethodSignature methodSignature = (MethodSignature) signature;
 Method targetMethod = methodSignature.getMethod();
 Method realMethod = pjp.getTarget().getClass().getDeclaredMethod(signature.getName(), targetMethod.getParameterTypes());
 MyPermissionTag permissionTag = realMethod.getAnnotation(MyPermissionTag.class);
 return new ReqMethod(permissionTag, realMethod.getName());
 }


 @Setter
 @Getter
 class ReqMethod {


 private MyPermissionTag perTag;
 private String methodName;


 public ReqMethod(MyPermissionTag perTag, String methodName) {
  this.perTag = perTag;
  this.methodName = methodName;
 }


 }
}

검증 하 다.
테스트 인터페이스

@PostMapping("/helloluo")
@MyPermissionTag(value = "true")
public String helloluo(UserPojoReq userPojoReq){
 return "Hello World";
}

송신 요청

검증 하 다.

총결산
SpringBoot 가 어떻게 사용자 정의 주 해 를 통 해 권한 검 사 를 실현 하 는 지 에 관 한 이 글 은 여기까지 소개 되 었 습 니 다.더 많은 SpringBoot 사용자 정의 주 해 를 통 해 권한 검사 내용 을 확인 할 수 있 습 니 다.이전 글 을 검색 하거나 아래 의 관련 글 을 계속 찾 아 보 세 요.앞으로 많은 지원 바 랍 니 다!