@AspectJ 어노테이션을 이용한 Spring AOP, AOP 네임스페이스 aspectj-autoproxy, 자바설정(Jav…

@AspectJ 어노테이션을 이용한 Spring AOP, AOP 네임스페이스 aspectj-autoproxy, 자바설정(JavaConfig),자바동영상/스프링동영상/자바교육/스프링교육/스프링프레임워크/스프링학원/자바학원/자바/JAVA

 

***** 예제는 첨부 파일을 참조 하세요~~~~ 

 

@AspectJ Annotation 이용한 AOP

 

n  Spring AOP JDK 1.5 이상인 경우 어노테이션을 이용하여 어드바이스를 선언 할 수 있다.

n  @AspectJ 방식은 AspectJ 5 버전에서 소개되었으며, Spring 2.0 버전부터 AspectJ 5 어노테이션을 지원한다

n  타겟 메소드에 어드바이스를 적용할 때는 AspectJ의 위빙 메커니즘이 아니라 자체 프록시 메커니즘을 이용한다.

n  @AspectJ를 사용하기 위해서 XML설정 파일에 <aop:aspectj-autoproxy/> 태그를 설정에 추가해야하며 자바설정을 이용하여 사용하는 경우에는 @EnableAspectJAutoProxy를 추가한다.

n  Aspect는 횡단 관심사를 모듈화 한것이며 Advice, Advisor, Pointcut등으로 구성되어 있다.

n  클래스에@Aspect 어노테이션을 추가하여 Aspect를 생성해야 한다. Aspect Spring XML 구성을 통해 구성된 일반 클래스이거나 Spring AspectJ 통합을 사용하여 @Aspect 주석을 사용하여 클래스를 Aspect로 정의 할 수 있다.

n  @Pointcut으로 포인트컷을 정의하거나 @Before, @After등 충고를 정의할 때 AspectJ Expression을 정의하여 포인트컷을 지정할 수 있다.

 

@AspectJ Annotation 이용한 AOP – Aspect 선언

 

n  자바설정을 이용하여 AspectJ를 사용하는 방법

     @Configuration

     @EnableAspectJAutoProxy

     public class AppConfig {    }

 

@Aspect

public class UserAspect {

        // USerService+ : 인스턴스의 타입이 UserService 이거나 하위타입을 의미

           @Before("execution(* x.y.z.UserService+.*(..))")

           public void userAdvice(){

                      System.out.println("find my advice before your task.");

           }

}

 

@Configuration

@EnableAspectJAutoProxy

//@ComponentScan(basePackages={"패키지명"})

public class AspectJAutoProxyConfig {

  @Bean

  public UserService userService(){

            return new UserService();

  }

  @Bean         

  public UserAspect userAspect(){

            return new UserAspect();

  }

}

 

n  XML설정을 이용하여 AspectJ를 사용하는 방법

     <aop:aspectj-autoproxy/>

 

<aop:aspectj-autoproxy/>

<bean id="myAspect" class=“ojc.aop.OjcAspect“/>

 

package ojc.aop;

import org.aspectj.lang.annotation.Aspect;

@Aspect 

public class OjcAspect {  ……  }

 

XML절정은 @Component를 이용하면 아래처럼 가능하다.

(XML에서 빈으로 정의하지 않을 경우 @Component, @Service, @Named와 같은 Annotation

기술하면 된다.)

 

<aop:aspectj-autoproxy/>

 

package ojc.aop;

import org.aspectj.lang.annotation.Aspect;

@Aspect 

@Component

public class OjcAspect {  ……  }

 

@AspectJ Annotation 이용한 AOP – Advice 선언

 

Before advice : Before advice@Before 어노테이션을 사용한다.

 

After returning advice : After returing 충고는 정상적으로 메소드가 실행된 후 수행된다. After returning 충고는 @AfterReturing 어노테이션을 사용한다.

 

After throwing advice : After throwing 충고는 메소드가 수행 중 예외사항을 반환하고 종료하는 경우 수행된다. After throwing 충고는 @AfterThrowing 어노테이션을 사용한다.

 

After (finally) advice : After (finally) 충고는 메소드 수행 종료 후(오류가 발생하더라도) 무조건 수행된다. After (finally) 충고는 @After 어노테이션을 사용한다. 자바의 finally…

 

Around advice : Around 충고는 메소드 수행 전후에 수행된다. Around 충고는 @Around 어노테이션을 사용한다.

 

@Around 충고는 대상 메소드의 반환 값(return value)를 변경 가능하지만, After returning 충고는 반환 값을 참조 가능하지만 변경할 수는 없다.

 

n  사전충고(@Before)

@Before 어노테이션을 사용하며 포인트컷 메소드가 실행되기 전에 충고가 적용된다.

 

@Aspect

public class BeforeExample {

 

    @Before(“x.y.MyClass.dataAccessOperation()")

    public void doAccessCheck1() {

        // ...

    }

 

    @Before("execution(* x.y.MyClass.*(..))")

    public void doAccessCheck2() {

        // ...

    }

}

 

n  사후충고(@AfterReturning)

@AfterReturning 어노테이션을 사용하며 포인트컷 메소드가 리턴(정상종료)된 후 충고가 적용된다.

 

@Aspect

public class AfterReturningExample {

 

    @AfterReturning(“x.y.MyClass.dataAccessOperation()")

    public void doAccessCheck1() {

        // ...

    }

 

   // 리턴값을 retVal로 받음, returning 속성의 값은 어드바이스 메소드의 파라미터와 이름이

   // 같아야 한다.

   @AfterReturning(

        pointcut=“x.y.MyClass.dataAccessOperation()",

        returning="retVal")

    public void doAccessCheck2(Object retVal) {

        // ... 이부분에서 retVal 사용가능

    }

}

 

 

n  예외충고(@AfterThrowing)

@AfterThrowing 어노테이션을 사용하며 포인트컷 메소드에서 예외가 발생할 때 충고가 적용된다.

 

@Aspect

public class AfterThrowingExample {

 

    @AfterThrowing(“x.y.MyClass.dataAccessOperation()")

    public void doRecoveryActions1() {

        // ...

    }

   // 리턴값을 retVal로 받음, throwing 속성의 값은 어드바이스 메소드의 파라미터와 이름이

   // 같아야 하며 예외가 그 변수로 넘어온다.

   @AfterThrowing(

        pointcut=“x.y.MyClass.dataAccessOperation()",

        throwing="ex")

    public void doRecoveryActions2(DataAccessException ex) {

        // ...

}

}

 

n  사후충고(@After)

@After 어노테이션을 사용한다. 포인트컷 메소드가 실행된 후(정상종료 여부와 관계없이) 충고가 적용된다.

 

@Aspect

public class AfterExample {

    @After(“x.y.MyClass.dataAccessOperation()")

    public void doReleaseLock() {

        // ...

    }

}

 

n  주변충고(@Around)

@Around 어노테이션을 사용하며 포인트컷 메소드가 실행 되기 전, 리턴 된 후에 충고가 적용된다.

 

어드바이스 메소드의 첫번째 파라미터는 ProceedingJoinPoint가 되어야 한다. proceed() 메소드를 통해 타겟 클래스의 원래 메소드를 호출, proceed() 메소드를 호출하면서 Object[] 형태로 파라미터를 전달할 수도 있다. proceed() 메소드는 기술 안 할 수도 있고, 한번, 여러 번 호출할 수도 있으므로 원래 메소드에 대한 여러 형태의 제어가 가능하다. 물론 원래 메소드의 리턴 값을 바꿔치기 하는 것도 가능하다.

 

@Aspect

public class AroundExample {

 

     @Around(“x.y.MyClass.businessService()")

    public Object doBasicProfiling(ProceedingJoinPoint pjp) throws Throwable {

        // start stopwatch

        Object retVal = pjp.proceed();

        // stop stopwatch

        return retVal;

    }

}

 

@AspectJ Annotation 이용한 AOP – Pointcut 선언

 

n  @Pointcut 어노테이션을 사용한다.

 

@Pointcut("execution(* onj.aop.*.*(..))")      // pointcut expression

private void mypointcut() {   }                // pointcut signature

 

@Before("mypointcut ()")

public void myBeforeAdvice(JoinPointjoinPoint, int intValue) { ... }

 

 

n  포인트컷 지정자(Pointcut Designators)

execution: 메소드 실행 결합점(join points)과 일치시키는데 사용된다.

within: 특정 타입에 속하는 결합점을 정의한다.

this: 빈 참조가 주어진 타입의 인스턴스를 갖는 결합점을 정의한다.

target: 대상 객체가 주어진 타입을 갖는 결합점을 정의한다.

args: 인자가 주어진 타입의 인스턴스인 결합점을 정의한다.

 

@target: 타겟 클래스가 주어진 타입의 어노테이션을 갖는 결합점을 정의한다.

@args: 전달된 인자의 런타임 타입이 주어진 타입의 어노테이션을 갖는 결합점을 정의한다.

@within: 주어진 어노테이션을 갖는 타입 내 결합점을 정의한다.

@annotation: 실행 메소드가 인자로 주어진 어노테이션을 갖는 결합점을 정의한다.

 

//메소드가 어떤 패키지에 있던지 public 메소드라면 충고적용

@Pointcut("execution(public * *(..))")

private void anyPublicOperation() {}

 

//메소드가 onj 패키지 또는 부 패키지안의 타입이라면 충고적용

@Pointcut("within(onj..*)")

private void inTrading() {}

 

//위 두포인트컷의 AND 조건을 만족하는 경우 충고가 적용

@Pointcut("anyPublicOperation() && inTrading()")

private void tradingOperation() {}

 

//메소드가 onj.dao 패키지 또는 부 패키지안의 타입이라면 충고적용

@Pointcut("within(onj.dao..*)")

 public void inDataAccessLayer() {}

 

[Aspect 클래스 작성 예]

@Aspect //애스팩트 클래스임을 표시

public class MyAdvice {

   @Pointcut("execution(* onj.edu.aop11..hello*(int)) && args(intValue)")

   public void helloExec(int intValue) {}

 

   @Pointcut("bean(myDependency*)")

   public void inMyDependency() {}

 

   //@AspectJ &&, aop 네임스페이스는 and

   @Before("helloExec(intValue) && inMyDependency()")

   public void myBeforeAdvice(JoinPointjoinPoint, int intValue) { ... }

 

   //Around Advice

   @Around("helloExec(intValue)")

   public myAroundAdvice(ProceedingJoinPoint joinPoint, int intValue) throws Throwable { ... }

  

   //......

}

 

@AspectJ Annotation 이용한 AOP – aspectj expression

 

 

execution(public * *(..)) : 리턴타입 괸계없고 public 메소드(인자가 0에서 N)가 포인트 컷

 

execution(* onj.spring.aop.*.*(..)) : onj.spring.aop 패키지의 모든 메소드가 포인트 컷

 

execution(* onj.spring.aop..*.*(..)) : onj.spring.aop 패키지와 하위 패키지의 모든 메소드가 포인트 컷

 

execution(public void insert*(..)) : public에 리턴값, 패키지명 없고 메서드 이름은 insert로 시작, 인자 값은 0개 이상인 메서드가 포인트 컷

 

execution(* onj.spring.aop.*.*()) : 리턴형 관계없고 onj.spring.aop 패키지의 모든 클래스, 인자 값이 없는 모든 메서드가 포인트 컷

 

execution(* onj.spring.aop..*.*(..)) : 리턴형 관계없고 onj.spring.aop 패키지 및 하위 패키지에 있는 모든 클래스,  인자값이 0개 이상인 메서드가 포인트 컷

 

execution(* delete*(*)) : 메서드 이름이 delete으로 시작하는 인자 값이 1개인 메서드가 포인트 컷

 

execution(* delete*(*,*)) : 메서드 이름이 delete로 시작하는 인자 값이 2개인 메서드가 포인트 컷

 

execution(* onj*(Integer, ..)) : 메서드 이름이 onj로 시작하고 첫번째 인자 값의 타입이 Integer, 1개 이상의 매개변수를 갖는 메서드가 포인트 컷

 

within(onj.spring.aop.*) : onj.spring.aop 패키지 내의 모든 메소드가 포인트 컷

 

within(onj.spring.aop..*) : onj.spring.aop패키지 및 하위 패키지의 모든 메소드가 포인트 컷

 

bean(oraclejava*) : 이름이 oraclejava로 시작되는 모든 빈의 메소드가 포인트 컷

 

bean(*dataSource) || bean(*DataSource) : 빈 이름이 “dataSource” “DataSource” 으로 끝나는 모든 빈의 메소드가 포인트 컷

 

!bean(onjoraclejava) : onjoraclejava빈을 제외한 모든 빈의 메소드가 포인트

 

this(onj.aop.SmallMartInterface) : 현재 실행중인 인스턴스가  SmallMartInterface 이름의 빈과 타입이 같은 경우 포인트컷, SmallMart인터페이스를 구현했다면 모든 메소드가 포인트컷  

                        

target(onj.aop.SmallMartInterface) : 타겟 오브젝트가 SmallMartInterface를 구현했다면 모든 메소드가 포인트컷

 

args(java.io.Serializable) : 메소드가 매개변수가 하나이고 Serializable인터페이스를  타입이라면 포인트컷

 

@target(org.springframework.transaction.annotation.Transactional) : 타겟 오브젝트가 org.springframework.transaction.annotation.Transactional  어노테이션(@Transactional)을 가진다면 포인트컷

 

@within(org.springframework.transaction.annotation.Transactional) : 타겟 오브젝트의 선언된 타입이 @Trtansactional 어노테이션을 가진다면 포인트컷

 

@annotation(org.springframework.transaction.annotation.Transactional) : 실행 메소드가  @Transactional 어노테이션을 가진다면 포인트컷

 

@args(x.y.AnnotationRequired) : 파라미터를 하나 가지며 넘어오는 아규먼트의 런타임 타입이 @AnnotationRequired 타입이라면  포인트컷

 

 

***** 예제는 첨부 파일을 참조 하세요~~~~

 

#AOP네임스페이스, #스프링AOP, #aop:config, #@AspectJ, #AspectJ #스프링포인트컷, #스프링충고, #포인트컷, #스프링pointcut, #스프링AOP, #스프링advice, #SpringAOP, #스프링DI, #스프링IoC, #SpringDI, #SpringIoC, #자바스프링, #Spring동영상, #Spring강의, #스프링프레임워크, #스프링교육, #스프링학원, #스프링강좌, #스프링강의, #자바학원, #자바, #스프링동영상, #자바동영상, #스프링프레임워크교육, #스프링프레임워크강의, #스프링프레임워크학원 

, , , , , , , , , , , , , , , , , , , , , , , , ,

Comments