[Spring] joinpoint

after

package aopEx01;

public class Aop {
	
	//핵심 로직 실행 전에 호출될 공통 모듈
	public void beforeAdvice() {
		System.out.println("핵심 로직 실행 전에 호출되는 공통 모듈");
	}
	
	public void afterAdvice() {
		System.out.println("핵심 로직 실행 후에 호출되는 공통 모듈");
	}
}

 

package aopEx01_target1;

public class B {
	public void method1() {
		System.out.println("클래스 B의 method1 핵심 로직 실행중");
	}
	public void method2() {
		System.out.println("클래스 B의 method2 핵심 로직 실행중");
	}
}

 

 

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd">

	<bean id="aop" class="aopEx01.Aop" /> <!-- aspect 클래스 객체 생성 -->
	
	<aop:config><!-- aop 설정 정보 영역 -->
		<aop:aspect id="aop1" ref="aop"><!-- ioc 보유 객체 중 aspect 등록 -->
		<!-- within() : 클래스 단위로 사용 가능 -->
			<aop:pointcut expression="within(aopEx01_target1.A)" id="pointcut01"/><!-- target 상세 정보 등록 -->
			<!--  
			joinpoint 세가지(세부적으로는 5가지)
			1.before : 핵심로직 실행 전
			2.after  : 핵심로직 실행 후
				2-1. after-throwing : 핵심로직 실행 시 에러발생 후
				2-2. after-returning: 핵심로직 정상 종류 후
			3.around : 핵심로직 실행 전 후(오류발생해도 안해도 무조건 실행)
			-->
			<aop:before method="beforeAdvice" pointcut-ref="pointcut01"/>
			
			<aop:pointcut expression="within(aopEx01_target1.B)" id="pointcut02"/><!-- target 상세 정보 등록 -->
			<aop:after method="afterAdvice" pointcut-ref="pointcut02"/>
		</aop:aspect>
	</aop:config>
	
	<context:component-scan base-package="aopEx01_target1" />
</beans>

 

 

package aopEx01_main;

import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.GenericApplicationContext;
import org.springframework.context.support.GenericXmlApplicationContext;

import aopEx01.Aop;
import aopEx01_target1.*;

public class Main {

	public static void main(String[] args) {
		
		A a = new A();
		a.method();
		a.method2();
		System.out.println("---------------------");
		
		AbstractApplicationContext ctx = 
				new GenericXmlApplicationContext("classpath:applicationcontext.xml");
		
		A aop = ctx.getBean("a",A.class);
		aop.method();
		aop.method2();
		System.out.println("---------------------");
		
		B b = ctx.getBean("b",B.class);
		b.method1();
		b.method2();
	}

}

 

클래스 B의 method1 핵심 로직 실행중 핵심 로직 실행 후에 호출되는 공통 모듈 클래스 B의 method2 핵심 로직 실행중 핵심 로직 실행 후에 호출되는 공통 모듈

---

after-throwing

package aopEx01;
/*
* 현재 클래스는 여러가지 공통 모듈(메소드)을 관리하는 클래스

* aop 사용시 공통 관심사 별로 클래스를 분류 기능들을 메소드로 관리하게 된다

* aop 프로그래밍을 하기 위해서는 aspect과 target 전부 ioc 컨테이너가 생성한 객체들끼리만
  적용이 가능하다 

<aop 용어 정리>
1.aspect : 관심사라는 의미로 같은 관심사별 공통 모듈을 담고 있는 그룹 또는 클래스를 의미 
2.target : aspect를 적용할 클래스 또는 메소드를 의미함 
3.advice : 실질적으로 어떤 일을 해야할 지에 대한 것으로 부가 기능을 담을 구현체
4.joinpoint : 공통기능이 적용되어야 하는 핵심 기능의 시점
5.pointcut : joinpoint의 상세한 스펙을 의미
*/
public class Aop {
	
	//핵심 로직 실행 전에 호출될 공통 모듈
	public void beforeAdvice() {
		System.out.println("핵심 로직 실행 전에 호출되는 공통 모듈");
	}
	
	public void afterAdvice() {
		System.out.println("핵심 로직 실행 후에 호출되는 공통 모듈");
	}
	
	/*
	2-1. after-throwing : 핵심로직 실행 시 에러발생 후
	2-2. after-returning: 핵심로직 정상 종류 후
	*/
	public void afterThrowingAdvice() {
		System.out.println("핵심 로직이 에러가 발생하여 종료 되었습니다");
	}
	
	
}

 

package aopEx01_target1;

import org.springframework.stereotype.Component;

@Component
public class C {
	public void method1() throws Exception {
		System.out.println("클래스 C method1 핵심 로직 실행중");
		System.out.println(10/0);
	}
	
}

 

 

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd">

	<bean id="aop" class="aopEx01.Aop" /> <!-- aspect 클래스 객체 생성 -->
	
	<aop:config><!-- aop 설정 정보 영역 -->
		<aop:aspect id="aop1" ref="aop"><!-- ioc 보유 객체 중 aspect 등록 -->
		<!-- within() : 클래스 단위로 사용 가능 -->
			<aop:pointcut expression="within(aopEx01_target1.A)" id="pointcut01"/><!-- target 상세 정보 등록 -->
			<!--  
			joinpoint 세가지(세부적으로는 5가지)
			1.before : 핵심로직 실행 전
			2.after  : 핵심로직 실행 후
				2-1. after-throwing : 핵심로직 실행 시 에러발생 후
				2-2. after-returning: 핵심로직 정상 종류 후
			3.around : 핵심로직 실행 전 후(오류발생해도 안해도 무조건 실행)
			-->
			<aop:before method="beforeAdvice" pointcut-ref="pointcut01"/>
			<!-- B클래스 -->
			<aop:pointcut expression="within(aopEx01_target1.B)" id="pointcut02"/><!-- target 상세 정보 등록 -->
			<aop:after method="afterAdvice" pointcut-ref="pointcut02"/>
			
			<!-- C클래스 -->
			<aop:pointcut expression="within(aopEx01_target1.C)" id="pointcut03"/><!-- target 상세 정보 등록 -->
			<aop:after-throwing method="afterThrowingAdvice" pointcut-ref="pointcut03"/>
		</aop:aspect>
	</aop:config>
	
	<context:component-scan base-package="aopEx01_target1" />
</beans>

 

package aopEx01_main;

import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.GenericApplicationContext;
import org.springframework.context.support.GenericXmlApplicationContext;

import aopEx01.Aop;
import aopEx01_target1.*;

public class Main {

	public static void main(String[] args) throws Exception {
		
		A a = new A();
		a.method();
		a.method2();
		System.out.println("---------------------");
		
		AbstractApplicationContext ctx = 
				new GenericXmlApplicationContext("classpath:applicationcontext.xml");
		
		A aop = ctx.getBean("a",A.class);
		aop.method();
		aop.method2();
		System.out.println("---------------------");
		
		B b = ctx.getBean("b",B.class);
		b.method1();
		b.method2();
		System.out.println("---------------------");
		
		C c = ctx.getBean("c",C.class);
		c.method1();
		System.out.println("---------------------");
		
		
		
	}

}

 

 

---

after-returning

package aopEx01;
/*
* 현재 클래스는 여러가지 공통 모듈(메소드)을 관리하는 클래스

* aop 사용시 공통 관심사 별로 클래스를 분류 기능들을 메소드로 관리하게 된다

* aop 프로그래밍을 하기 위해서는 aspect과 target 전부 ioc 컨테이너가 생성한 객체들끼리만
  적용이 가능하다 

<aop 용어 정리>
1.aspect : 관심사라는 의미로 같은 관심사별 공통 모듈을 담고 있는 그룹 또는 클래스를 의미 
2.target : aspect를 적용할 클래스 또는 메소드를 의미함 
3.advice : 실질적으로 어떤 일을 해야할 지에 대한 것으로 부가 기능을 담을 구현체
4.joinpoint : 공통기능이 적용되어야 하는 핵심 기능의 시점
5.pointcut : joinpoint의 상세한 스펙을 의미
*/
public class Aop {
	
	//핵심 로직 실행 전에 호출될 공통 모듈
	public void beforeAdvice() {
		System.out.println("핵심 로직 실행 전에 호출되는 공통 모듈");
	}
	
	public void afterAdvice() {
		System.out.println("핵심 로직 실행 후에 호출되는 공통 모듈");
	}
	
	/*
	2-1. after-throwing : 핵심로직 실행 시 에러발생 후
	2-2. after-returning: 핵심로직 정상 종류 후
	*/
	public void afterThrowingAdvice() {
		System.out.println("핵심 로직이 에러가 발생하여 종료 되었습니다");
	}
	
	public void afterReturningAdvice() {
		System.out.println("핵심로직이 정상 종료되었습니다");
	}
}

 

 

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd">

	<bean id="aop" class="aopEx01.Aop" /> <!-- aspect 클래스 객체 생성 -->
	
	<aop:config><!-- aop 설정 정보 영역 -->
		<aop:aspect id="aop1" ref="aop"><!-- ioc 보유 객체 중 aspect 등록 -->
			<!-- within() : 클래스 단위로 사용 가능 -->
			<aop:pointcut expression="within(aopEx01_target1.A)" id="pointcut01"/><!-- target 상세 정보 등록 -->
			<!--  
			joinpoint 세가지(세부적으로는 5가지)
			1.before : 핵심로직 실행 전
			2.after  : 핵심로직 실행 후
				2-1. after-throwing : 핵심로직 실행 시 에러발생 후
				2-2. after-returning: 핵심로직 정상 종류 후
			3.around : 핵심로직 실행 전 후(오류발생해도 안해도 무조건 실행)
			-->
			<aop:before method="beforeAdvice" pointcut-ref="pointcut01"/>
			<!-- B클래스 -->
			<aop:pointcut expression="within(aopEx01_target1.B)" id="pointcut02"/><!-- target 상세 정보 등록 -->
			<aop:after method="afterAdvice" pointcut-ref="pointcut02"/>
			
			<!-- C클래스 -->
			<aop:pointcut expression="within(aopEx01_target1.C)" id="pointcut03"/><!-- target 상세 정보 등록 -->
			<aop:after-throwing method="afterThrowingAdvice" pointcut-ref="pointcut03"/>
			<aop:after-returning method="afterReturningAdvice" pointcut-ref="pointcut03"/>
		</aop:aspect>
	</aop:config>
	
	<context:component-scan base-package="aopEx01_target1" />
</beans>

 

package aopEx01_target1;

import org.springframework.stereotype.Component;

@Component
public class C {
	public void method1() throws Exception {
		System.out.println("클래스 C method1 핵심 로직 실행중");
		/* System.out.println(10/0); */
	}
	
}

 

 

 

package aopEx01_main;

import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.GenericApplicationContext;
import org.springframework.context.support.GenericXmlApplicationContext;

import aopEx01.Aop;
import aopEx01_target1.*;

public class Main {

	public static void main(String[] args) throws Exception {
		
		A a = new A();
		a.method();
		a.method2();
		System.out.println("---------------------");
		
		AbstractApplicationContext ctx = 
				new GenericXmlApplicationContext("classpath:applicationcontext.xml");
		
		A aop = ctx.getBean("a",A.class);
		aop.method();
		aop.method2();
		System.out.println("---------------------");
		
		B b = ctx.getBean("b",B.class);
		b.method1();
		b.method2();
		System.out.println("---------------------");
		
		C c = ctx.getBean("c",C.class);
		c.method1();
		System.out.println("---------------------");
		
		
		
	}

}

 

 

클래스 C method1 핵심 로직 실행중 핵심로직이 정상 종료되었습니다

 

 

포인트컷 03에 after 추가

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd">

	<bean id="aop" class="aopEx01.Aop" /> <!-- aspect 클래스 객체 생성 -->
	
	<aop:config><!-- aop 설정 정보 영역 -->
		<aop:aspect id="aop1" ref="aop"><!-- ioc 보유 객체 중 aspect 등록 -->
			<!-- within() : 클래스 단위로 사용 가능 -->
			<aop:pointcut expression="within(aopEx01_target1.A)" id="pointcut01"/><!-- target 상세 정보 등록 -->
			<!--  
			joinpoint 세가지(세부적으로는 5가지)
			1.before : 핵심로직 실행 전
			2.after  : 핵심로직 실행 후
				2-1. after-throwing : 핵심로직 실행 시 에러발생 후
				2-2. after-returning: 핵심로직 정상 종류 후
			3.around : 핵심로직 실행 전 후(오류발생해도 안해도 무조건 실행)
			-->
			<aop:before method="beforeAdvice" pointcut-ref="pointcut01"/>
			<!-- B클래스 -->
			<aop:pointcut expression="within(aopEx01_target1.B)" id="pointcut02"/><!-- target 상세 정보 등록 -->
			<aop:after method="afterAdvice" pointcut-ref="pointcut03"/>
			
			<!-- C클래스 -->
			<aop:pointcut expression="within(aopEx01_target1.C)" id="pointcut03"/><!-- target 상세 정보 등록 -->
			<aop:after-throwing method="afterThrowingAdvice" pointcut-ref="pointcut03"/>
			<aop:after-returning method="afterReturningAdvice" pointcut-ref="pointcut03"/>
		</aop:aspect>
	</aop:config>
	
	<context:component-scan base-package="aopEx01_target1" />
</beans>

 

 

정상종료 시에도 나오고

클래스 C method1 핵심 로직 실행중 핵심 로직 실행 후에 호출되는 공통 모듈 핵심로직이 정상 종료되었습니다

 

에러 발생 시에도 나온다

클래스 C method1 핵심 로직 실행중 핵심 로직 실행 후에 호출되는 공통 모듈 핵심 로직이 에러가 발생하여 종료 되었습니다

 

---

around

public Object aroundAdvice(ProceedingJoinPoint joinpoint) throws Throwable {
    System.out.println("핵심로직 실행전");
    try {
        System.out.println("핵심로직 실행전2");
        Object obj = joinpoint.proceed(); //핵심로직 실행
        return obj;
    }finally {
        System.out.println("핵심로직 실행후");
    }
}

 

package aopEx01_target1;

import org.springframework.stereotype.Component;

@Component
public class D {
	public void method() {
		System.out.println("클래스 D method 핵심로직 실행중...");
	}
}

 

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd">

	<bean id="aop" class="aopEx01.Aop" /> <!-- aspect 클래스 객체 생성 -->
	
	<aop:config><!-- aop 설정 정보 영역 -->
		<aop:aspect id="aop1" ref="aop"><!-- ioc 보유 객체 중 aspect 등록 -->
			<!-- D클래스 -->
			<aop:pointcut expression="within(aopEx01_target1.D)" id="pointcut04"/><!-- target 상세 정보 등록 -->
			<aop:around method="aroundAdvice" pointcut-ref="pointcut04"/>
		</aop:aspect>
	</aop:config>
	
	<context:component-scan base-package="aopEx01_target1" />
</beans>

 

D d = ctx.getBean("d",D.class);
d.method();

 

 

핵심로직 실행전 핵심로직 실행전2 클래스 D method 핵심로직 실행중... 핵심로직 실행후