7.4 Spring AOP 개념 및 예시

AOP：Aspect-Oriented Programming。AOP 는 OOP 의 보완 으로 GOF 의 연장선 에 있다.우 리 는 디자인 모델 이 대상 을 대상 으로 디자인 한 경험 에 대한 정리 라 는 것 을 알 고 있다. 디자인 모델 이 끊임없이 추구 하 는 것 은 바로 호출 자 와 호출 자 간 의 결합 이다.디자인 모델 이 있 으 면 우 리 는 대상 을 대상 으로 하 는 특성 을 더욱 효과적으로 이용 하여 전체 소프트웨어 디자인 을 더욱 유연 하고 우아 하 게 할 수 있다.그러나 디자인 모델 은 대상 을 대상 으로 하 는 사상 을 바탕 으로 형 성 된 것 으로 대상 차원 의 것 에 관심 을 가지 고 대상 행위 내부 문 제 를 해결 하 는 데 부족 하 다.AOP 의 등장 은 바로 대상 을 향 한 사상 에 완벽 한 보충 을 한 것 이다.
AOP 하면 우 리 는 소프트웨어 의 세로 와 가로 문 제 를 제기 해 야 한다.세로 구 조 를 보면 바로 우리 소프트웨어 시스템 의 각 모듈 로 우리 의 핵심 업무 (예 를 들 어 상품 주문, 카 트 조회) 를 처리 하 는 것 을 책임 진다.가로 구 조 를 보면 우 리 는 거의 모든 시스템 에 공공 모듈 (예 를 들 어 권한, 로그 모듈 등) 을 포함한다.이러한 공공 모듈 은 우리 각 핵심 업무 에 분포 되 어 있다 (예 를 들 어 상품 명 세 를 주문 하고 조회 하 는 과정 은 모두 사용자 권한 을 검사 하고 시스템 로 그 를 기록 해 야 한다).이렇게 되면 개발 과정 에서 공공 모듈 의 처리 에 곳곳에서 관심 을 가 져 야 할 뿐만 아니 라 개발 후 유지 하 는 것 도 매우 번거롭다.AOP 가 생 긴 후에 응용 프로그램의 상업 논 리 를 지원 하 는 유 니 버 설 서비스 와 분리 시 켜 개발 자 들 이 핵심 업무 개발 에 더 많은 관심 을 가 질 수 있 도록 한다.
AOP 의 주요 응용 장면
AOP 는 시스템 개발 에서 매우 광범 위 하 게 응용 되 고 흔히 볼 수 있 는 장면 은 다음 과 같다.

사무 처리

로그 처리

이상 처리

권한 제어

시스템 성능 모니터링

기타

AOP 의 핵심 개념
1. 가로로 자 르 는 관심 사 는 어떤 방법 을 차단 하고 차단 한 후에 어떻게 처리 하 는 지 를 가로로 자 르 는 관심 사 라 고 한다.
2. 절단면 (aspect) 류 는 물체 특징 에 대한 추상 이 고 절단면 은 바로 횡단면 에 대한 추상 이다.
3. 연결 점 (joinpoint) 이 차단 되 는 점. Spring 은 방법 유형의 연결 점 만 지원 하기 때문에 Spring 에서 연결 점 은 차단 되 는 방법 을 말 합 니 다. 실제 연결 점 은 필드 나 구조 기 일 수도 있 습 니 다.
4. 접점 (pointcut) 에서 연결 점 을 차단 하 는 정의
5. 알림 (advice) 이란 연결 점 을 차단 한 후에 실행 할 코드 를 말 합 니 다. 알림 은 전치, 후 치, 이상, 최종, 서 라운드 알림 등 다섯 가지 로 나 눌 수 있 습 니 다.
6. 대상 에이전트 의 대상
7. 짜 기 (weave) 는 절단면 을 대상 에 적용 하고 대리 대상 을 만 드 는 과정
8. 도입 (introduction) 은 코드 를 수정 하지 않 는 전제 에서 런 타임 에 동적 으로 방법 이나 필드 를 추가 할 수 있 습 니 다.
Spring 의 AOP 지원
스프링 중 AOP 에이 전 트 는 스프링 의 IOC 용기 가 생 성 · 관 리 를 맡 고 그 의존 관계 도 IOC 용기 가 관리한다.따라서 AOP 에이 전 트 는 용기 에 있 는 다른 bean 인 스 턴 스 를 직접 사용 할 수 있 으 며, 이러한 관 계 는 IOC 용기 의 의존 주입 에 의 해 제 공 될 수 있다.Spring 프 록 시 생 성 규칙 은:
1. 기본적으로 자바 동적 프 록 시 를 사용 하여 AOP 프 록 시 를 만 듭 니 다. 그러면 모든 인터페이스 인 스 턴 스 에 프 록 시 를 만 들 수 있 습 니 다.
2. 프 록 시 클래스 가 프 록 시 인터페이스 가 아 닐 때 Spring 은 CGLIB 프 록 시 로 전환 되 고 CGLIB 를 강제로 사용 할 수 있 습 니 다.
AOP 프로 그래 밍 은 사실 매우 간단 한 일이 다. AOP 프로 그래 밍 을 보면 프로그래머 는 세 부분 만 참여 해 야 한다.

1. 일반 업무 구성 요소 정의

2. 접점 을 정의 하고 하나의 접점 은 여러 개의 업무 구성 요 소 를 가로로 자 를 수 있 습 니 다

3. 증강 처 리 를 정의 합 니 다. 증강 처 리 는 AOP 프레임 워 크 에서 일반 업무 구성 요소 로 짜 인 처리 동작 이기 때문에 AOP 프로 그래 밍 을 하 는 관건 은 접점 과 정의 강화 처 리 를 정의 하 는 것 입 니 다. 적당 한 접점 과 강화 처 리 를 정의 하면 AOP 프레임 워 크 는 자동 으로 AOP 대 리 를 생 성 합 니 다. 즉, 대리 대상 의 방법 = 강화 처리 + 피 대리 대상 의 방법 입 니 다.

Spring 기반 AOP 단순 구현
여 기 는 주석 방식 으로 AOP 를 실현 하여 현재 의 사용 에 더욱 가깝다.
pom. xml 의존 도 추가

 
        UTF-8
        4.3.3.RELEASE
    

    
        
            org.springframework
            spring-core
            ${spring.version}
        

        
            org.springframework
            spring-beans
            ${spring.version}
        
        
            org.springframework
            spring-aspects
            ${spring.version}
        

        
            org.springframework
            spring-aop
            ${spring.version}
        
        
            org.springframework
            spring-context
            ${spring.version}
        
        
            org.aspectj
            aspectjweaver
            1.8.9
        
    

코어, beans, context, op 을 포함 하여 spring 의 jar 가방 을 참조 해 야 합 니 다. aspectjweaver 이것 도 참조 해 야 합 니 다.
들 어 갈 업무 클래스 를 정의 합 니 다. 새로 추 가 된 방법 을 간단하게 정의 하면 됩 니 다.

@Service
public class UserService {

    public void add() {
        System.out.println("      ");
    }
}

applicationContext.xml

이 중에서 가장 핵심 적 인 두 마디 는...

AOP 를 사용 하고 입력 클래스 를 정의 합 니 다 com.critc.aop.LogAspect정의 절단면 프로그램 LogAspect. java

@Aspect
public class LogAspect {

    /**
     *        
     */
    @Before("execution(* com.critc.service..*.*(..)) ")
    private void beforeMethod() {
        System.out.println("the Method begins........");
    }

    /**
     *        
     */
    @After("execution(* com.critc.service..*.*(..)) ")
    private void afterMethod() {
        // TODO Auto-generated method stub
        System.out.println("The Method after ................");
    }

    /**
     *      
     * @param joinPoint
     * @param result
     */
    @AfterReturning(value = "execution(* com.critc.service..*.*(..)) ", returning = "result")
    public void AfterReturning(JoinPoint joinPoint, Object result) {
        System.out.println("The Method after ................" + result);
    }

    /**
     *       
     * @param joinPoint
     * @param e
     */
    @AfterThrowing(value = "execution(* com.critc.service..*.*(..)) ", throwing = "e")
    public void AfterThrowing(JoinPoint joinPoint, Exception e) {
        System.out.println("The Method afterThrowing................"
                + e.getMessage().toString());
    }

    /**
     *     
     * @param pjp
     * @return
     */
    @Around(value = "execution(* com.critc.service..*.*(..)) ")
    public Object aroundTest(ProceedingJoinPoint pjp) {
        String methodName = pjp.getSignature().getName();
        Object object = null;
        try {
            //     
            System.out.println("The Method " + methodName + "before................");
            // object = pjp.proceed();
            object = "view/index";
            //     
            System.out.println(object);
        } catch (Throwable e) {
            // TODO Auto-generated catch block
            //     
            System.out.println(e.getMessage().toString());
        }
        System.out.println("The Method " + methodName + "after................");
        return object;
    }
}

위의 이 예 는 op 의 대략적인 예 를 들 어 다음 에 나 는 Spring AOP 가 실제 에서 의 응용, 예 를 들 어 이상 처리, 로그 처리, 권한 제어 등 을 상세 하 게 설명 할 것 이다.
원본 코드 다운로드
본 공정 상세 소스 코드