Spring AOP-퀵 가이드
Spring Framework의 주요 구성 요소 중 하나는 Aspect Oriented Programming (AOP)뼈대. Aspect Oriented Programming은 프로그램 로직을 다음과 같은 별개의 부분으로 나누는 것을 수반합니다.so-called concerns. 애플리케이션의 여러 지점에 걸쳐있는 기능을 교차 문제라고합니다. 이들cross-cutting concerns개념적으로 애플리케이션의 비즈니스 로직과 분리되어 있습니다. 로깅, 감사, 선언적 트랜잭션, 보안, 캐싱 등과 같은 측면에 대한 다양한 일반적인 좋은 예가 있습니다.
OOP에서 모듈화의 핵심 단위는 클래스이고 AOP에서는 모듈화 단위가 aspect입니다. 종속성 주입은 애플리케이션 개체를 서로 분리하는 데 도움이되며, AOP는 영향을받는 개체에서 교차 절단 문제를 분리하는 데 도움이됩니다. AOP는 Perl, .NET, Java 등과 같은 프로그래밍 언어의 트리거와 같습니다.
Spring AOP 모듈은 인터셉터가 애플리케이션을 가로 챌 수 있도록합니다. 예를 들어 메서드가 실행될 때 메서드 실행 전후에 추가 기능을 추가 할 수 있습니다.
이 장에서는 Windows 및 Linux 기반 시스템에서 Spring AOP를 설정하는 과정을 안내합니다. Spring AOP는 복잡한 설정 절차없이 몇 가지 간단한 단계를 수행하여 현재 Java 환경 및 MAVEN과 쉽게 설치하고 통합 할 수 있습니다. 설치하는 동안 사용자 관리가 필요합니다.
시스템 요구 사항
JDK | Java SE 2 JDK 1.5 이상 |
기억 | 1GB RAM (권장) |
디스크 공간 | 최소 요구 사항 없음 |
운영 체제 버전 | Windows XP 이상, Linux |
이제 Spring AOP를 설치하는 단계를 살펴 보겠습니다.
1 단계 : Java 설치 확인
먼저 시스템에 Java SDK (Software Development Kit)가 설치되어 있어야합니다. 이를 확인하려면 작업중인 플랫폼에 따라 다음 두 명령 중 하나를 실행하십시오.
Java 설치가 제대로 완료되면 Java 설치의 현재 버전과 사양이 표시됩니다. 다음 표에는 샘플 출력이 나와 있습니다.
플랫폼 | 명령 | 샘플 출력 |
---|---|---|
윈도우 | 명령 콘솔을 열고 입력하십시오- \>java -version |
자바 버전 '1.7.0_60' Java (TM) SE 런타임 환경 (빌드 1.7.0_60-b19) Java Hotspot (TM) 64 비트 서버 VM (빌드 24.60-b09, 혼합 모드) |
리눅스 | 명령 터미널을 열고 입력하십시오- $java -version |
자바 버전 "1.7.0_25" JDK 런타임 환경 열기 (rhel-2.3.10.4.el6_4-x86_64) JDK 64 비트 서버 VM 열기 (빌드 23.7-b01, 혼합 모드) |
이 자습서의 독자는 시스템에 Java SDK 버전 1.7.0_60이 설치되어 있다고 가정합니다.
Java SDK가없는 경우 현재 버전을 https://www.oracle.com/technetwork/java/javase/downloads/index.html 그리고 그것을 설치하십시오.
2 단계 : Java 환경 설정
시스템에서 Java가 설치된 기본 디렉토리 위치를 가리 키도록 환경 변수 JAVA_HOME을 설정하십시오. 예를 들면
Sr. 아니. | 플랫폼 및 설명 |
---|---|
1 | Windows JAVA_HOME을 C : \ ProgramFiles \ java \ jdk1.7.0_60으로 설정합니다. |
2 | Linux JAVA_HOME 내보내기 = / usr / local / java-current |
Java 컴파일러 위치의 전체 경로를 시스템 경로에 추가하십시오.
Sr. 아니. | 플랫폼 및 설명 |
---|---|
1 | Windows 시스템 변수 경로 끝에 문자열 "C : \ Program Files \ Java \ jdk1.7.0_60 \ bin"을 추가합니다. |
2 | Linux 내보내기 PATH = $ PATH : $ JAVA_HOME / bin / |
명령 실행 java -version 위에서 설명한대로 명령 프롬프트에서.
3 단계 : Maven 아카이브 다운로드
Maven 3.3.3 다운로드 https://maven.apache.org/download.cgi
OS | 아카이브 이름 |
---|---|
윈도우 | apache-maven-3.3.3-bin.zip |
리눅스 | apache-maven-3.3.3-bin.tar.gz |
맥 | apache-maven-3.3.3-bin.tar.gz |
4 단계 : Maven 아카이브 추출
Maven 3.3.3을 설치하려는 디렉토리에 아카이브를 추출하십시오. 아카이브에서 하위 디렉토리 apache-maven-3.3.3이 생성됩니다.
OS | 위치 (설치에 따라 다를 수 있음) |
---|---|
윈도우 | C : \ Program Files \ Apache Software Foundation \ apache-maven-3.3.3 |
리눅스 | / usr / local / apache-maven |
맥 | / usr / local / apache-maven |
5 단계 : Maven 환경 변수 설정
환경 변수에 M2_HOME, M2, MAVEN_OPTS를 추가합니다.
OS | 산출 |
---|---|
윈도우 | 시스템 속성을 사용하여 환경 변수를 설정합니다. M2_HOME = C : \ Program Files \ Apache Software Foundation \ apache-maven-3.3.3 M2 = % M2_HOME % \ bin MAVEN_OPTS = -Xms256m -Xmx512m |
리눅스 | 명령 터미널을 열고 환경 변수를 설정합니다. export M2_HOME = /usr/local/apache-maven/apache-maven-3.3.3 내보내기 M2 = $ M2_HOME / bin MAVEN_OPTS 내보내기 = -Xms256m -Xmx512m |
맥 | 명령 터미널을 열고 환경 변수를 설정합니다. export M2_HOME = /usr/local/apache-maven/apache-maven-3.3.3 내보내기 M2 = $ M2_HOME / bin MAVEN_OPTS 내보내기 = -Xms256m -Xmx512m |
6 단계 : 시스템 경로에 Maven Bin 디렉터리 위치 추가
이제 M2 변수를 시스템 경로에 추가하십시오.
OS | 산출 |
---|---|
윈도우 | 시스템 변수 Path의 끝에 문자열; % M2 %를 추가합니다. |
리눅스 | 내보내기 PATH = $ M2 : $ PATH |
맥 | 내보내기 PATH = $ M2 : $ PATH |
7 단계 : Maven 설치 확인
이제 콘솔을 열고 다음을 실행하십시오. mvn 명령.
OS | 직무 | 명령 |
---|---|---|
윈도우 | 명령 콘솔 열기 | c : \> mvn-버전 |
리눅스 | 명령 터미널 열기 | $ mvn-버전 |
맥 | 터미널 열기 | 기계 : <joseph $ mvn --version |
마지막으로, 위 명령의 출력을 확인하십시오.
OS | 산출 |
---|---|
윈도우 | Apache Maven 3.3.3 (7994120775791599e205a5524ec3e0dfe41d4a06; 2015-04-22T17 : 27 : 37 + 05 : 30) Maven 홈 : C : \ Program Files \ Apache Software Foundation \ apache-maven-3.3.3 Java 버전 : 1.7.0_75, 공급 업체 : Oracle Corporation 자바 홈 : C : \ Program Files \ Java \ jdk1.7.0_75 \ jre 기본 로케일 : en_US, 플랫폼 인코딩 : Cp1252 |
리눅스 | Apache Maven 3.3.3 (7994120775791599e205a5524ec3e0dfe41d4a06; 2015-04-22T17 : 27 : 37 + 05 : 30) Maven 홈 : /usr/local/apache-maven/apache-maven-3.3.3 Java 버전 : 1.7.0_75, 공급 업체 : Oracle Corporation 자바 홈 : /usr/local/java-current/jdk1.7.0_75/jre |
맥 | Apache Maven 3.3.3 (7994120775791599e205a5524ec3e0dfe41d4a06; 2015-04-22T17 : 27 : 37 + 05 : 30) Maven 홈 : /usr/local/apache-maven/apache-maven-3.3.3 Java 버전 : 1.7.0_75, 공급 업체 : Oracle Corporation 자바 홈 : /Library/Java/Home/jdk1.7.0_75/jre |
8 단계-Eclipse IDE 설정
이 튜토리얼의 모든 예제는 Eclipse IDE를 사용하여 작성되었습니다. 따라서 컴퓨터에 최신 버전의 Eclipse가 설치되어 있어야합니다.
Eclipse IDE를 설치하려면 다음에서 최신 Eclipse 바이너리를 다운로드하십시오. https://www.eclipse.org/downloads/. 설치를 다운로드 한 후 편리한 위치에 바이너리 배포의 압축을 풉니 다. 예를 들어 Windows의 C : \ eclipse 또는 Linux / Unix의 / usr / local / eclipse에서 마지막으로 PATH 변수를 적절하게 설정합니다.
Eclipse는 Windows 시스템에서 다음 명령을 실행하여 시작하거나 eclipse.exe를 두 번 클릭 할 수 있습니다.
%C:\eclipse\eclipse.exe
Eclipse는 Unix (Solaris, Linux 등) 시스템에서 다음 명령을 실행하여 시작할 수 있습니다.
$/usr/local/eclipse/eclipse
성공적으로 시작한 후 모든 것이 정상이면 다음 결과가 표시됩니다.
이 마지막 단계를 마치면 다음 장에서 보게 될 첫 번째 AOP 예제를 진행할 준비가 된 것입니다.
AOP 작업을 시작하기 전에 AOP 개념과 용어에 익숙해 지도록하겠습니다. 이 용어는 Spring에만 국한되지 않고 AOP와 관련이 있습니다.
Sr. 아니. | 용어 및 설명 |
---|---|
1 | Aspect 교차 절단 요구 사항을 제공하는 API 세트가있는 모듈입니다. 예를 들어, 로깅 모듈은 로깅을 위해 AOP 측면이라고합니다. 응용 프로그램은 요구 사항에 따라 여러 측면을 가질 수 있습니다. |
2 | Join point 이것은 AOP 측면을 플러그인 할 수있는 애플리케이션의 지점을 나타냅니다. 또한 Spring AOP 프레임 워크를 사용하여 작업이 수행되는 애플리케이션의 실제 위치라고 말할 수도 있습니다. |
삼 | Advice 이것은 메소드 실행 전이나 후에 취해야 할 실제 조치입니다. 이것은 Spring AOP 프레임 워크에 의해 프로그램 실행 중에 호출되는 실제 코드 조각입니다. |
4 | PointCut 이것은 어드바이스가 실행되어야하는 하나 이상의 조인 포인트 세트입니다. AOP 예제에서 볼 수 있듯이 표현식이나 패턴을 사용하여 PointCuts를 지정할 수 있습니다. |
5 | Introduction 소개를 통해 기존 클래스에 새 메소드 또는 속성을 추가 할 수 있습니다. |
6 | Target object 하나 이상의 측면에서 권고하는 개체입니다. 이 개체는 항상 프록시 개체입니다. 권고 된 객체라고도합니다. |
7 | Weaving Weaving은 조언 된 객체를 생성하기 위해 다른 응용 프로그램 유형 또는 객체와 측면을 연결하는 프로세스입니다. 이는 컴파일 타임,로드 타임 또는 런타임에 수행 할 수 있습니다. |
Spring 측면은 다음 표에 언급 된 5 가지 종류의 조언과 함께 작동 할 수 있습니다.
Sr. 아니. | 조언 및 설명 |
---|---|
1 | before 메소드 실행 전에 조언을 실행하십시오. |
2 | after 결과에 관계없이 메서드 실행 후에 조언을 실행합니다. |
삼 | after-returning 메소드가 성공적으로 완료된 경우에만 메소드 실행 후 조언을 실행하십시오. |
4 | after-throwing 메서드 실행 후 예외를 throw하여 메서드가 종료되는 경우에만 어드바이스를 실행합니다. |
5 | around 조언 된 메소드가 호출되기 전과 후에 조언을 실행하십시오. |
봄은 @AspectJ annotation style 접근 및 schema-based 사용자 정의 측면을 구현하는 접근 방식.
XML 스키마 기반
Aspect는 XML 기반 구성과 함께 일반 클래스를 사용하여 구현됩니다.
이 섹션에서 설명하는 AOP 네임 스페이스 태그를 사용하려면 다음과 같이 스프링 AOP 스키마를 가져와야합니다.
<?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"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">
<!-- bean definition & AOP specific configuration -->
</beans>
Aspect 선언
안 aspect 다음을 사용하여 선언됩니다. <aop:aspect> 요소이고 백업 빈은 ref 다음과 같이 속성.
<aop:config>
<aop:aspect id = "myAspect" ref = "aBean">
...
</aop:aspect>
</aop:config>
<bean id = "aBean" class = "...">
...
</bean>
여기서 "aBean"은 이전 장에서 본 것처럼 다른 Spring Bean과 마찬가지로 구성되고 종속성이 주입됩니다.
PointCut 선언
ㅏ PointCut서로 다른 조언으로 실행할 관심있는 결합 지점 (즉, 메소드)을 결정하는 데 도움이됩니다. XML 스키마 기반 구성으로 작업하는 동안 PointCut은 다음과 같이 정의됩니다.
<aop:config>
<aop:aspect id = "myAspect" ref = "aBean">
<aop:PointCut id = "businessService"
expression = "execution(* com.xyz.myapp.service.*.*(..))"/>
...
</aop:aspect>
</aop:config>
<bean id = "aBean" class = "...">
...
</bean>
다음 예제는 com.tutorialspoint 패키지 아래의 Student 클래스에서 사용할 수있는 getName () 메서드의 실행과 일치하는 'businessService'라는 PointCut을 정의합니다.
<aop:config>
<aop:aspect id = "myAspect" ref = "aBean">
<aop:PointCut id = "businessService"
expression = "execution(* com.tutorialspoint.Student.getName(..))"/>
...
</aop:aspect>
</aop:config>
<bean id = "aBean" class = "...">
...
</bean>
조언 선언
다음과 같이 <aop : {ADVICE NAME}> 요소를 사용하여 <aop : aspect> 내부에 다섯 가지 조언 중 하나를 선언 할 수 있습니다.
<aop:config>
<aop:aspect id = "myAspect" ref = "aBean">
<aop:PointCut id = "businessService"
expression = "execution(* com.xyz.myapp.service.*.*(..))"/>
<!-- a before advice definition -->
<aop:before PointCut-ref = "businessService"
method = "doRequiredTask"/>
<!-- an after advice definition -->
<aop:after PointCut-ref = "businessService"
method = "doRequiredTask"/>
<!-- an after-returning advice definition -->
<!--The doRequiredTask method must have parameter named retVal -->
<aop:after-returning PointCut-ref = "businessService"
returning = "retVal"
method = "doRequiredTask"/>
<!-- an after-throwing advice definition -->
<!--The doRequiredTask method must have parameter named ex -->
<aop:after-throwing PointCut-ref = "businessService"
throwing = "ex"
method = "doRequiredTask"/>
<!-- an around advice definition -->
<aop:around PointCut-ref = "businessService"
method = "doRequiredTask"/>
...
</aop:aspect>
</aop:config>
<bean id = "aBean" class = "...">
...
</bean>
당신은 같은 것을 사용할 수 있습니다 doRequiredTask또는 다른 조언에 대한 다른 방법. 이러한 메소드는 aspect 모듈의 일부로 정의됩니다.
@AspectJ 기반
@AspectJ는 aspect를 Java 5 주석으로 주석이 달린 일반 Java 클래스로 선언하는 스타일을 나타냅니다. @AspectJ 지원은 XML 스키마 기반 구성 파일에 다음 요소를 포함하여 활성화됩니다.
<aop:aspectj-autoproxy/>
Aspect 선언
Aspects 클래스는 다른 일반 빈과 같으며 다음과 같이 @Aspect로 주석이 달린 것을 제외하고는 다른 클래스와 마찬가지로 메소드와 필드를 가질 수 있습니다.
package org.xyz;
import org.aspectj.lang.annotation.Aspect;
@Aspect
public class AspectModule {
}
다음과 같이 다른 빈처럼 XML로 구성됩니다.
<bean id = "myAspect" class = "org.xyz.AspectModule">
<!-- configure properties of aspect here as normal -->
</bean>
PointCut 선언
ㅏ PointCut서로 다른 조언으로 실행할 관심있는 결합 지점 (즉, 메소드)을 결정하는 데 도움이됩니다. @AspectJ 기반 구성으로 작업하는 동안 PointCut 선언에는 두 부분이 있습니다.
관심있는 메서드 실행을 정확히 결정하는 PointCut 식입니다.
이름과 여러 매개 변수로 구성된 PointCut 서명. 메서드의 실제 본문은 관련이 없으며 실제로 비어 있어야합니다.
다음 예제는 com.xyz.myapp.service 패키지 아래의 클래스에서 사용 가능한 모든 메소드의 실행과 일치하는 'businessService'라는 PointCut을 정의합니다.
import org.aspectj.lang.annotation.PointCut;
@PointCut("execution(* com.xyz.myapp.service.*.*(..))") // expression
private void businessService() {} // signature
다음 예제는 com.tutorialspoint 패키지 아래의 Student 클래스에서 사용할 수있는 getName () 메서드의 실행과 일치하는 'getname'이라는 PointCut을 정의합니다.
import org.aspectj.lang.annotation.PointCut;
@PointCut("execution(* com.tutorialspoint.Student.getName(..))")
private void getname() {}
조언 선언
아래와 같이 @ {ADVICE-NAME} 주석을 사용하여 5 가지 조언 중 하나를 선언 할 수 있습니다. 이는 이미 PointCut 서명 메소드 businessService ()를 정의했다고 가정합니다.
@Before("businessService()")
public void doBeforeTask(){
...
}
@After("businessService()")
public void doAfterTask(){
...
}
@AfterReturning(PointCut = "businessService()", returning = "retVal")
public void doAfterReturnningTask(Object retVal){
// you can intercept retVal here.
...
}
@AfterThrowing(PointCut = "businessService()", throwing = "ex")
public void doAfterThrowingTask(Exception ex){
// you can intercept thrown exception here.
...
}
@Around("businessService()")
public void doAroundTask(){
...
}
조언에 대해 PointCut 인라인을 정의 할 수 있습니다. 다음은 before advice에 대한 인라인 PointCut을 정의하는 예입니다.
@Before("execution(* com.xyz.myapp.service.*.*(..))")
public doBeforeTask(){
...
}
이 장에서는 Spring AOP 프레임 워크를 사용하여 실제 AOP 애플리케이션을 작성합니다. Spring-WS 프레임 워크를 사용하여 첫 번째 예제를 작성하기 전에 Spring Web Services-Environment Setup 장에 설명 된대로 Spring AOP 환경을 올바르게 설정했는지 확인해야합니다 .
이제 AOP 개념을 보여줄 간단한 콘솔 방식의 Spring AOP 애플리케이션을 작성합니다.
프로젝트 생성
Step 1 − 명령 콘솔을 열고 C : \ MVN 디렉토리로 이동하여 다음을 실행합니다. mvn 명령.
C:\MVN>mvn archetype:generate -DgroupId = com.tutorialspoint -DartifactId = Student
-DarchetypeArtifactId = maven-archetype-quickstart -DinteractiveMode = false
Maven이 처리를 시작하고 완전한 Java 애플리케이션 프로젝트 구조를 생성합니다.
[INFO] Scanning for projects...
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Building Maven Stub Project (No POM) 1
[INFO] ------------------------------------------------------------------------
[INFO]
[INFO] >>> maven-archetype-plugin:2.4:generate (default-cli) > generate-sources
@ standalone-pom >>>
[INFO]
[INFO] <<< maven-archetype-plugin:2.4:generate (default-cli) < generate-sources
@ standalone-pom <<<
[INFO]
[INFO] --- maven-archetype-plugin:2.4:generate (default-cli) @ standalone-pom --
-
[INFO] Generating project in Batch mode
Downloading: https://repo.maven.apache.org/maven2/org/apache/maven/archetypes/ma
ven-archetype-quickstart/1.0/maven-archetype-quickstart-1.0.jar
Downloaded: https://repo.maven.apache.org/maven2/org/apache/maven/archetypes/mav
en-archetype-quickstart/1.0/maven-archetype-quickstart-1.0.jar (5 KB at 1.1 KB/s
ec)
Downloading: https://repo.maven.apache.org/maven2/org/apache/maven/archetypes/ma
ven-archetype-quickstart/1.0/maven-archetype-quickstart-1.0.pom
Downloaded: https://repo.maven.apache.org/maven2/org/apache/maven/archetypes/mav
en-archetype-quickstart/1.0/maven-archetype-quickstart-1.0.pom (703 B at 1.2 KB/
sec)
[INFO] -------------------------------------------------------------------------
---
[INFO] Using following parameters for creating project from Old (1.x) Archetype:
maven-archetype-quickstart:1.0
[INFO] -------------------------------------------------------------------------
---
[INFO] Parameter: groupId, Value: com.tutorialspoint
[INFO] Parameter: packageName, Value: com.tutorialspoint
[INFO] Parameter: package, Value: com.tutorialspoint
[INFO] Parameter: artifactId, Value: Student
[INFO] Parameter: basedir, Value: C:\MVN
[INFO] Parameter: version, Value: 1.0-SNAPSHOT
[INFO] project created from Old (1.x) Archetype in dir: C:\MVN\Student
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 01:17 min
[INFO] Finished at: 2017-02-19T21:11:14+05:30
[INFO] Final Memory: 15M/114M
[INFO] ------------------------------------------------------------------------
Step 2− C : / MVN 디렉토리로 이동합니다. student (artifactId에 지정된대로)라는 이름의 Java 애플리케이션 프로젝트가 생성 된 것을 볼 수 있습니다. Spring-AOP 종속성을 포함하도록 POM.xml을 업데이트하십시오. MainApp.java, Student.java 및 Logging.java 파일을 추가합니다.
POM.xml
<project xmlns = "http://maven.apache.org/POM/4.0.0"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://maven.apache.org/POM/4.0.0
http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.tutorialspoint</groupId>
<artifactId>Student</artifactId>
<packaging>jar</packaging>
<version>1.0-SNAPSHOT</version>
<name>Student</name>
<url>http://maven.apache.org</url>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>4.1.0.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>4.1.4.RELEASE</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.6.8</version>
</dependency>
</dependencies>
</project>
package com.tutorialspoint;
public class Logging {
/**
* This is the method which I would like to execute
* before a selected method execution.
*/
public void beforeAdvice() {
System.out.println("Going to setup student profile.");
}
/**
* This is the method which I would like to execute
* after a selected method execution.
*/
public void afterAdvice() {
System.out.println("Student profile has been setup.");
}
/**
* This is the method which I would like to execute
* when any method returns.
*/
public void afterReturningAdvice(Object retVal){
System.out.println("Returning:" + retVal.toString() );
}
/**
* This is the method which I would like to execute
* if there is an exception raised.
*/
public void AfterThrowingAdvice(IllegalArgumentException ex) {
System.out.println("There has been an exception: " + ex.toString());
}
}
다음은의 내용입니다 Student.java 파일.
package com.tutorialspoint;
public class Student {
private Integer age;
private String name;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
System.out.println("Age : " + age );
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
System.out.println("Name : " + name );
return name;
}
public void printThrowException(){
System.out.println("Exception raised");
throw new IllegalArgumentException();
}
}
다음은의 내용입니다 MainApp.java 파일.
package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context =
new ClassPathXmlApplicationContext("Beans.xml");
Student student = (Student) context.getBean("student");
student.getName();
student.getAge();
student.printThrowException();
}
}
Step 3 − 구성 파일 추가 Beans.xml 아래에 src > main > resources 폴더.
<?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"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">
<aop:config>
<aop:aspect id = "log" ref = "logging">
<aop:PointCut id = "selectAll"
expression = "execution(* com.tutorialspoint.*.*(..))"/>
<aop:before PointCut-ref = "selectAll" method = "beforeAdvice"/>
<aop:after PointCut-ref = "selectAll" method = "afterAdvice"/>
<aop:after-returning PointCut-ref = "selectAll"
returning = "retVal"
method = "afterReturningAdvice"/>
<aop:after-throwing PointCut-ref = "selectAll"
throwing = "ex"
method = "AfterThrowingAdvice"/>
</aop:aspect>
</aop:config>
<!-- Definition for student bean -->
<bean id = "student" class = "com.tutorialspoint.Student">
<property name = "name" value = "Zara" />
<property name = "age" value = "11"/>
</bean>
<!-- Definition for logging aspect -->
<bean id = "logging" class = "com.tutorialspoint.Logging"/>
</beans>
Step 4 − 명령 콘솔을 열고 C : \ MVN 디렉토리로 이동하여 다음을 실행합니다. mvn 명령.
C:\MVN>Student> mvn package
Maven은 필요한 라이브러리를 처리하고 다운로드하기 시작합니다.
[INFO] Scanning for projects...
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Building Student 1.0-SNAPSHOT
[INFO] ------------------------------------------------------------------------
Downloading: https://repo.maven.apache.org/maven2/org/apache/maven/plugins/maven
-jar-plugin/2.4/maven-jar-plugin-2.4.pom
Downloaded: https://repo.maven.apache.org/maven2/org/apache/maven/plugins/maven-
jar-plugin/2.4/maven-jar-plugin-2.4.pom (6 KB at 2.2 KB/sec)
Downloading: https://repo.maven.apache.org/maven2/org/apache/maven/plugins/maven
-jar-plugin/2.4/maven-jar-plugin-2.4.jar
Downloaded: https://repo.maven.apache.org/maven2/org/apache/maven/plugins/maven-
jar-plugin/2.4/maven-jar-plugin-2.4.jar (34 KB at 31.6 KB/sec)
Downloading: https://repo.maven.apache.org/maven2/org/springframework/spring-aop
/4.1.0.RELEASE/spring-aop-4.1.0.RELEASE.pom
Downloaded: https://repo.maven.apache.org/maven2/org/springframework/spring-aop/
4.1.0.RELEASE/spring-aop-4.1.0.RELEASE.pom (3 KB at 3.7 KB/sec)
Downloading: https://repo.maven.apache.org/maven2/org/springframework/spring-bea
ns/4.1.0.RELEASE/spring-beans-4.1.0.RELEASE.pom
Downloaded: https://repo.maven.apache.org/maven2/org/springframework/spring-bean
s/4.1.0.RELEASE/spring-beans-4.1.0.RELEASE.pom (3 KB at 4.1 KB/sec)
Downloading: https://repo.maven.apache.org/maven2/org/springframework/spring-cor
e/4.1.0.RELEASE/spring-core-4.1.0.RELEASE.pom
Downloaded: https://repo.maven.apache.org/maven2/org/springframework/spring-core
/4.1.0.RELEASE/spring-core-4.1.0.RELEASE.pom (3 KB at 4.0 KB/sec)
Downloading: https://repo.maven.apache.org/maven2/org/springframework/spring-aop
/4.1.0.RELEASE/spring-aop-4.1.0.RELEASE.jar
Downloading: https://repo.maven.apache.org/maven2/org/springframework/spring-cor
e/4.1.0.RELEASE/spring-core-4.1.0.RELEASE.jar
Downloading: https://repo.maven.apache.org/maven2/org/springframework/spring-bea
ns/4.1.0.RELEASE/spring-beans-4.1.0.RELEASE.jar
Downloaded: https://repo.maven.apache.org/maven2/org/springframework/spring-aop/
4.1.0.RELEASE/spring-aop-4.1.0.RELEASE.jar (351 KB at 43.9 KB/sec)
Downloaded: https://repo.maven.apache.org/maven2/org/springframework/spring-bean
s/4.1.0.RELEASE/spring-beans-4.1.0.RELEASE.jar (685 KB at 37.5 KB/sec)
Downloaded: https://repo.maven.apache.org/maven2/org/springframework/spring-core
/4.1.0.RELEASE/spring-core-4.1.0.RELEASE.jar (982 KB at 47.1 KB/sec)
[INFO]
[INFO] --- maven-resources-plugin:2.6:resources (default-resources) @ Student --
-
[WARNING] Using platform encoding (Cp1252 actually) to copy filtered resources,
i.e. build is platform dependent!
[INFO] skip non existing resourceDirectory C:\MVN\Student\src\main\resources
[INFO]
[INFO] --- maven-compiler-plugin:3.1:compile (default-compile) @ Student ---
[INFO] Changes detected - recompiling the module!
[WARNING] File encoding has not been set, using platform encoding Cp1252, i.e. b
uild is platform dependent!
[INFO] Compiling 1 source file to C:\MVN\Student\target\classes
[INFO]
[INFO] --- maven-resources-plugin:2.6:testResources (default-testResources) @ St
udent ---
[WARNING] Using platform encoding (Cp1252 actually) to copy filtered resources,
i.e. build is platform dependent!
[INFO] skip non existing resourceDirectory C:\MVN\Student\src\test\resources
[INFO]
[INFO] --- maven-compiler-plugin:3.1:testCompile (default-testCompile) @ Student
---
[INFO] Changes detected - recompiling the module!
[WARNING] File encoding has not been set, using platform encoding Cp1252, i.e. b
uild is platform dependent!
[INFO] Compiling 1 source file to C:\MVN\Student\target\test-classes
[INFO]
[INFO] --- maven-surefire-plugin:2.12.4:test (default-test) @ Student ---
[INFO] Surefire report directory: C:\MVN\Student\target\surefire-reports
Downloading: https://repo.maven.apache.org/maven2/org/apache/maven/surefire/sure
fire-junit3/2.12.4/surefire-junit3-2.12.4.pom
Downloaded: https://repo.maven.apache.org/maven2/org/apache/maven/surefire/suref
ire-junit3/2.12.4/surefire-junit3-2.12.4.pom (2 KB at 1.3 KB/sec)
Downloading: https://repo.maven.apache.org/maven2/org/apache/maven/surefire/sure
fire-junit3/2.12.4/surefire-junit3-2.12.4.jar
Downloaded: https://repo.maven.apache.org/maven2/org/apache/maven/surefire/suref
ire-junit3/2.12.4/surefire-junit3-2.12.4.jar (26 KB at 27.7 KB/sec)
-------------------------------------------------------
T E S T S
-------------------------------------------------------
Running com.tutorialspoint.AppTest
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.002 sec
Results :
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
[INFO]
[INFO] --- maven-jar-plugin:2.4:jar (default-jar) @ Student ---
Downloading: https://repo.maven.apache.org/maven2/classworlds/classworlds/1.1-al
pha-2/classworlds-1.1-alpha-2.jar
Downloaded: https://repo.maven.apache.org/maven2/classworlds/classworlds/1.1-alp
ha-2/classworlds-1.1-alpha-2.jar (37 KB at 35.8 KB/sec)
[INFO] Building jar: C:\MVN\Student\target\Student-1.0-SNAPSHOT.jar
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 38.441 s
[INFO] Finished at: 2017-02-19T21:18:59+05:30
[INFO] Final Memory: 18M/109M
[INFO] ------------------------------------------------------------------------
Eclipse에서 프로젝트 가져 오기
Step 1 − Eclipse를 엽니 다.
Step 2 − 선택 File → Import → 선택권.
Step 3− Maven 프로젝트 옵션을 선택합니다. 다음 버튼을 클릭하십시오.
Step 4 − Maven을 사용하여 학생 프로젝트가 생성 된 프로젝트 위치를 선택합니다.
Step 5 − 마침 버튼을 클릭합니다.
프로젝트 실행
소스 및 구성 파일 생성이 완료되면 애플리케이션을 실행합니다. 애플리케이션에서 MainApp.java를 마우스 오른쪽 버튼으로 클릭하고run as Java Application명령. 응용 프로그램에 문제가 없으면 다음 메시지가 인쇄됩니다.
Going to setup student profile.
Name : Zara
Student profile has been setup.
Returning:Zara
Going to setup student profile.
Age : 11
Student profile has been setup.
Returning:11
Going to setup student profile.
Exception raised
Student profile has been setup.
There has been an exception: java.lang.IllegalArgumentException
Exception in thread "main" java.lang.IllegalArgumentException
at com.tutorialspoint.Student.printThrowException(Student.java:25)
at com.tutorialspoint.Student$$FastClassBySpringCGLIB$$7dc55815.invoke(<generated>)
at org.springframework.cglib.proxy.MethodProxy.invoke(MethodProxy.java:204)
at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.invokeJoinpoint(CglibAopProxy.java:717) at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:157) at org.springframework.aop.framework.adapter.MethodBeforeAdviceInterceptor.invoke(MethodBeforeAdviceInterceptor.java:52) at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179) at org.springframework.aop.aspectj.AspectJAfterAdvice.invoke(AspectJAfterAdvice.java:43) at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179) at org.springframework.aop.framework.adapter.AfterReturningAdviceInterceptor.invoke(AfterReturningAdviceInterceptor.java:52) at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179) at org.springframework.aop.aspectj.AspectJAfterThrowingAdvice.invoke(AspectJAfterThrowingAdvice.java:58) at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179) at org.springframework.aop.interceptor.ExposeInvocationInterceptor.invoke(ExposeInvocationInterceptor.java:92) at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179) at org.springframework.aop.framework.CglibAopProxy$DynamicAdvisedInterceptor.intercept(CglibAopProxy.java:653)
at com.tutorialspoint.Student$$EnhancerBySpringCGLIB$$56a970f2.printThrowException(<generated>)
at com.tutorialspoint.MainApp.main(MainApp.java:16)
포인트 가입
JoinPoint는 AOP 측면을 플러그인 할 수있는 애플리케이션의 지점을 나타냅니다. 또한 Spring AOP 프레임 워크를 사용하여 작업이 수행되는 애플리케이션의 실제 위치라고 말할 수도 있습니다. 다음 예를 고려하십시오-
패키지에 포함 된 모든 메서드 클래스.
클래스의 특정 메서드.
PointCut
PointCut은 어드바이스가 실행되어야하는 하나 이상의 JoinPoint 세트입니다. AOP 예제에서 볼 수 있듯이 표현식이나 패턴을 사용하여 PointCuts를 지정할 수 있습니다. Spring에서 PointCut은 특정 JoinPoint를 사용하여 조언을 적용하는 데 도움이됩니다. 다음 예를 고려하십시오-
expression = "execution (* com.tutorialspoint. *. * (..))"
expression = "execution (* com.tutorialspoint.Student.getName (..))"
통사론
<aop:config>
<aop:aspect id = "log" ref = "adviceClass">
<aop:PointCut id = "PointCut-id" expression = "execution( expression )"/>
</aop:aspect>
</aop:config>
어디,
adviceClass − 어드바이스 메소드를 포함하는 클래스의 ref
PointCut-id − PointCut의 ID
execution( expression ) − 어드바이스가 적용될 표현을 다루는 방법.
JoinPoint 및 PointCut과 관련된 위에서 언급 한 개념을 이해하기 위해 몇 가지 PointCut을 구현하는 예제를 작성하겠습니다. 몇 가지 조언으로 예제를 작성하기 위해 작동하는 Eclipse IDE를 준비하고 다음 단계를 사용하여 Spring 애플리케이션을 만듭니다.
단계 | 기술 |
---|---|
1 | Spring AOP-Application 장에서 만든 Student 프로젝트를 업데이트합니다 . |
2 | Bean 구성을 업데이트하고 아래 설명 된대로 애플리케이션을 실행하십시오. |
다음 내용은 Logging.java파일. 이것은 실제로 다양한 지점에서 호출 될 메서드를 정의하는 aspect 모듈의 샘플입니다.
package com.tutorialspoint;
public class Logging {
/**
* This is the method which I would like to execute
* before a selected method execution.
*/
public void beforeAdvice(){
System.out.println("Going to setup student profile.");
}
}
다음은의 내용입니다 Student.java 파일.
package com.tutorialspoint;
public class Student {
private Integer age;
private String name;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
System.out.println("Age : " + age );
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
System.out.println("Name : " + name );
return name;
}
public void printThrowException(){
System.out.println("Exception raised");
throw new IllegalArgumentException();
}
}
다음은의 내용입니다 MainApp.java 파일.
package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context =
new ClassPathXmlApplicationContext("Beans.xml");
Student student = (Student) context.getBean("student");
student.getName();
student.getAge();
}
}
다음은 구성 파일입니다. Beans.xml.
<?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"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">
<aop:config>
<aop:aspect id = "log" ref = "logging">
<aop:PointCut id = "selectAll"
expression = "execution(* com.tutorialspoint.*.*(..))"/>
<aop:before PointCut-ref = "selectAll" method = "beforeAdvice"/>
</aop:aspect>
</aop:config>
<!-- Definition for student bean -->
<bean id = "student" class = "com.tutorialspoint.Student">
<property name = "name" value = "Zara" />
<property name = "age" value = "11"/>
</bean>
<!-- Definition for logging aspect -->
<bean id = "logging" class = "com.tutorialspoint.Logging"/>
</beans>
소스 및 Bean 구성 파일 작성이 완료되면 애플리케이션을 실행하십시오. 응용 프로그램에 문제가 없으면 다음 메시지가 인쇄됩니다.
Going to setup student profile.
Name : Zara
Going to setup student profile.
Age : 11
위에서 정의한 <aop : pointcut>은 com.tutorialspoint 패키지에 정의 된 모든 메소드를 선택합니다. 특정 메서드 전후에 조언을 실행하려는 경우 PointCut 정의에서 별 (*)을 실제 클래스 및 메서드 이름으로 대체하여 실행 범위를 좁히도록 PointCut을 정의 할 수 있습니다. 다음은 개념을 보여주기 위해 수정 된 XML 구성 파일입니다.
<?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"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">
<aop:config>
<aop:aspect id = "log" ref = "logging">
<aop:PointCut id = "selectAll"
expression = "execution(* com.tutorialspoint.Student.getName(..))"/>
<aop:before PointCut-ref = "selectAll" method = "beforeAdvice"/>
</aop:aspect>
</aop:config>
<!-- Definition for student bean -->
<bean id = "student" class = "com.tutorialspoint.Student">
<property name = "name" value = "Zara" />
<property name = "age" value = "11"/>
</bean>
<!-- Definition for logging aspect -->
<bean id = "logging" class = "com.tutorialspoint.Logging"/>
</beans>
프로젝트 실행
소스 및 구성 파일 생성이 완료되면 애플리케이션을 실행합니다. 애플리케이션에서 MainApp.java를 마우스 오른쪽 버튼으로 클릭하고run as Java Application명령. 응용 프로그램에 문제가 없으면 다음 메시지가 인쇄됩니다.
Going to setup student profile.
Name : Zara
Age : 11
Before어드바이스가 메소드 실행 전에 실행되도록하는 어드바이스 유형입니다. 다음은 before advice의 구문입니다.
통사론
<aop:config>
<aop:aspect id = "log" ref = "logging">
<aop:PointCut id = "PointCut-id" expression = "execution( expression )"/>
<aop:before PointCut-ref = "PointCut-id" method = "methodName"/>
</aop:aspect>
</aop:config>
어디,
PointCut-id − PointCut의 ID.
methodName − 호출 된 함수 전에 호출 할 함수의 메서드 이름.
위에서 언급 한 Before Advice 관련 개념을 이해하기 위해 Before Advice를 구현할 예제를 작성해 보겠습니다. 몇 가지 조언으로 예제를 작성하기 위해 작동하는 Eclipse IDE를 준비하고 다음 단계를 사용하여 Spring 애플리케이션을 만듭니다.
단계 | 기술 |
---|---|
1 | Spring AOP-Application 장에서 만든 Student 프로젝트를 업데이트합니다 . |
2 | Bean 구성을 업데이트하고 아래 설명 된대로 애플리케이션을 실행하십시오. |
다음 내용은 Logging.java파일. 이것은 실제로 다양한 지점에서 호출 될 메서드를 정의하는 aspect 모듈의 샘플입니다.
package com.tutorialspoint;
public class Logging {
/**
* This is the method which I would like to execute
* before a selected method execution.
*/
public void beforeAdvice(){
System.out.println("Going to setup student profile.");
}
}
다음은의 내용입니다 Student.java 파일.
package com.tutorialspoint;
public class Student {
private Integer age;
private String name;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
System.out.println("Age : " + age );
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
System.out.println("Name : " + name );
return name;
}
public void printThrowException(){
System.out.println("Exception raised");
throw new IllegalArgumentException();
}
}
다음은의 내용입니다 MainApp.java 파일.
package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context =
new ClassPathXmlApplicationContext("Beans.xml");
Student student = (Student) context.getBean("student");
student.getName();
student.getAge();
}
}
다음은 구성 파일입니다. Beans.xml.
<?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"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">
<aop:config>
<aop:aspect id = "log" ref = "logging">
<aop:PointCut id = "selectAll"
expression = "execution(* com.tutorialspoint.Student.getName(..))"/>
<aop:before PointCut-ref = "selectAll" method = "beforeAdvice"/>
</aop:aspect>
</aop:config>
<!-- Definition for student bean -->
<bean id = "student" class = "com.tutorialspoint.Student">
<property name = "name" value = "Zara" />
<property name = "age" value = "11"/>
</bean>
<!-- Definition for logging aspect -->
<bean id = "logging" class = "com.tutorialspoint.Logging"/>
</beans>
프로젝트 실행
소스 및 구성 파일 생성이 완료되면 애플리케이션을 실행합니다. 애플리케이션에서 MainApp.java를 마우스 오른쪽 버튼으로 클릭하고run as Java Application명령. 응용 프로그램에 문제가 없으면 다음 메시지가 인쇄됩니다.
Going to setup student profile.
Name : Zara
Age : 11
After메소드 실행 후 어드바이스가 실행되도록하는 어드바이스 유형입니다. 다음은 after advice의 구문입니다.
통사론
<aop:config>
<aop:aspect id = "log" ref = "logging">
<aop:PointCut id = "PointCut-id" expression = "execution( expression )"/>
<aop:after PointCut-ref = "PointCut-id" method = "methodName"/>
</aop:aspect>
</aop:config>
어디,
PointCut-id − PointCut의 ID.
methodName − 호출 된 함수 다음에 호출 할 함수의 메서드 이름.
위에서 언급 한 After Advice 관련 개념을 이해하기 위해 After Advice를 구현할 예제를 작성해 보겠습니다. 몇 가지 조언으로 예제를 작성하기 위해 작동하는 Eclipse IDE를 준비하고 다음 단계를 사용하여 Spring 애플리케이션을 만듭니다.
단계 | 기술 |
---|---|
1 | Spring AOP-Application 장에서 만든 Student 프로젝트를 업데이트합니다 . |
2 | Bean 구성을 업데이트하고 아래 설명 된대로 애플리케이션을 실행하십시오. |
다음 내용은 Logging.java파일. 이것은 실제로 다양한 지점에서 호출 될 메서드를 정의하는 aspect 모듈의 샘플입니다.
package com.tutorialspoint;
public class Logging {
/**
* This is the method which I would like to execute
* after a selected method execution.
*/
public void afterAdvice(){
System.out.println("Student profile setup complete.");
}
}
다음은의 내용입니다 Student.java 파일.
package com.tutorialspoint;
public class Student {
private Integer age;
private String name;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
System.out.println("Age : " + age );
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
System.out.println("Name : " + name );
return name;
}
public void printThrowException(){
System.out.println("Exception raised");
throw new IllegalArgumentException();
}
}
다음은의 내용입니다 MainApp.java 파일.
package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context =
new ClassPathXmlApplicationContext("Beans.xml");
Student student = (Student) context.getBean("student");
student.getName();
student.getAge();
}
}
다음은 구성 파일입니다. Beans.xml.
<?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"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">
<aop:config>
<aop:aspect id = "log" ref = "logging">
<aop:PointCut id = "selectAll"
expression = "execution(* com.tutorialspoint.Student.getAge(..))"/>
<aop:after PointCut-ref = "selectAll" method = "afterAdvice"/>
</aop:aspect>
</aop:config>
<!-- Definition for student bean -->
<bean id = "student" class = "com.tutorialspoint.Student">
<property name = "name" value = "Zara" />
<property name = "age" value = "11"/>
</bean>
<!-- Definition for logging aspect -->
<bean id = "logging" class = "com.tutorialspoint.Logging"/>
</beans>
프로젝트 실행
소스 및 구성 파일 생성이 완료되면 애플리케이션을 실행합니다. 애플리케이션에서 MainApp.java를 마우스 오른쪽 버튼으로 클릭하고run as Java Application명령. 응용 프로그램에 문제가 없으면 다음 메시지가 인쇄됩니다.
Name : Zara
Age : 11
Student profile setup complete.
After메소드가 성공적으로 완료된 경우에만 메소드 실행 후에 조언이 실행되도록하는 조언 유형입니다. 다음은 after advice의 구문입니다.
통사론
<aop:config>
<aop:aspect id = "log" ref = "logging">
<aop:PointCut id = "PointCut-id" expression = "execution( expression )"/>
<aop:after-returning PointCut-ref = "PointCut-id"
returning = "retVal" method = "methodName"/>
</aop:aspect>
</aop:config>
어디,
PointCut-id − PointCut의 ID.
methodName − 호출 된 함수가 성공적으로 반환 된 후 호출 할 함수의 메서드 이름입니다.
위에서 언급 한 After Returning Advice 관련 개념을 이해하기 위해 After Returning Advice를 구현할 예제를 작성해 보겠습니다. 몇 가지 조언으로 예제를 작성하기 위해 작동하는 Eclipse IDE를 준비하고 다음 단계를 사용하여 Spring 애플리케이션을 만듭니다.
단계 | 기술 |
---|---|
1 | Spring AOP-Application 장에서 만든 Student 프로젝트를 업데이트합니다 . |
2 | Bean 구성을 업데이트하고 아래 설명 된대로 애플리케이션을 실행하십시오. |
다음 내용은 Logging.java파일. 이것은 실제로 다양한 지점에서 호출 될 메서드를 정의하는 aspect 모듈의 샘플입니다.
package com.tutorialspoint;
public class Logging {
/**
* This is the method which I would like to execute
* when any method returns.
*/
public void afterReturningAdvice(Object retVal){
System.out.println("Returning:" + retVal.toString() );
}
}
다음은의 내용입니다 Student.java 파일.
package com.tutorialspoint;
public class Student {
private Integer age;
private String name;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
System.out.println("Age : " + age );
System.out.println("Exception raised");
throw new IllegalArgumentException();
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
System.out.println("Name : " + name );
return name;
}
public void printThrowException(){
System.out.println("Exception raised");
throw new IllegalArgumentException();
}
}
다음은의 내용입니다 MainApp.java 파일.
package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context =
new ClassPathXmlApplicationContext("Beans.xml");
Student student = (Student) context.getBean("student");
student.getName();
student.getAge();
}
}
다음은 구성 파일입니다. Beans.xml.
<?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"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">
<aop:config>
<aop:aspect id = "log" ref = "logging">
<aop:PointCut id = "selectAll"
expression = "execution(* com.tutorialspoint.*.*(..))"/>
<aop:after-returning PointCut-ref = "selectAll"
method = "afterReturningAdvice" returning = "retVal"/>
</aop:aspect>
</aop:config>
<!-- Definition for student bean -->
<bean id = "student" class = "com.tutorialspoint.Student">
<property name = "name" value = "Zara" />
<property name = "age" value = "11"/>
</bean>
<!-- Definition for logging aspect -->
<bean id = "logging" class = "com.tutorialspoint.Logging"/>
</beans>
프로젝트 실행
소스 및 구성 파일 생성이 완료되면 애플리케이션을 실행합니다. 애플리케이션에서 MainApp.java를 마우스 오른쪽 버튼으로 클릭하고run as Java Application명령. 응용 프로그램에 문제가 없으면 다음 메시지가 인쇄됩니다.
Name : Zara
Returning : Name
Age : 11
Exception raised
After-throwing메소드가 예외를 발생시켜 종료되는 경우에만 메소드 실행 후 조언이 실행되도록하는 조언 유형입니다. 다음은 투척 후 조언의 구문입니다.
통사론
<aop:config>
<aop:aspect id = "log" ref = "logging">
<aop:PointCut id = "PointCut-id" expression = "execution( expression )"/>
<aop:after-throwing PointCut-ref = "PointCut-id" throwing = "ex"
method = "methodName"/>
</aop:aspect>
</aop:config>
어디,
PointCut-id − PointCut의 ID.
ex − 예외가 발생합니다.
methodName − 호출 된 함수가 예외를 throw하고 종료 할 때 호출 할 함수의 메서드 이름입니다.
위에서 언급 한 After Throwing Advice 관련 개념을 이해하기 위해 After Throwing Advice를 구현할 예제를 작성해 보겠습니다. 몇 가지 조언으로 예제를 작성하기 위해 작동하는 Eclipse IDE를 준비하고 다음 단계를 사용하여 Spring 애플리케이션을 만듭니다.
단계 | 기술 |
---|---|
1 | Spring AOP-Application 장에서 만든 Student 프로젝트를 업데이트합니다 . |
2 | Bean 구성을 업데이트하고 아래 설명 된대로 애플리케이션을 실행하십시오. |
다음 내용은 Logging.java파일. 이것은 실제로 다양한 지점에서 호출 될 메서드를 정의하는 aspect 모듈의 샘플입니다.
package com.tutorialspoint;
public class Logging {
/**
* This is the method which I would like to execute
* if there is an exception raised.
*/
public void afterThrowingAdvice(IllegalArgumentException ex) {
System.out.println("There has been an exception: " + ex.toString());
}
}
다음은의 내용입니다 Student.java 파일.
package com.tutorialspoint;
public class Student {
private Integer age;
private String name;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
System.out.println("Age : " + age );
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
System.out.println("Name : " + name );
return name;
}
public void printThrowException(){
System.out.println("Exception raised");
throw new IllegalArgumentException();
}
}
다음은의 내용입니다 MainApp.java 파일.
package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context =
new ClassPathXmlApplicationContext("Beans.xml");
Student student = (Student) context.getBean("student");
student.printThrowException();
}
}
다음은 구성 파일입니다. Beans.xml.
<?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"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">
<aop:config>
<aop:aspect id = "log" ref = "logging">
<aop:PointCut id = "selectAll"
expression = "execution(* com.tutorialspoint.*.*(..))"/>
<aop:after-throwing PointCut-ref = "selectAll"
throwing = "ex" method = "afterThrowingAdvice"/>
</aop:aspect>
</aop:config>
<!-- Definition for student bean -->
<bean id = "student" class = "com.tutorialspoint.Student">
<property name = "name" value = "Zara" />
<property name = "age" value = "11"/>
</bean>
<!-- Definition for logging aspect -->
<bean id = "logging" class = "com.tutorialspoint.Logging"/>
</beans>
프로젝트 실행
소스 및 구성 파일 생성이 완료되면 애플리케이션을 실행합니다. 애플리케이션에서 MainApp.java를 마우스 오른쪽 버튼으로 클릭하고run as Java Application명령. 응용 프로그램에 문제가 없으면 다음 메시지가 인쇄됩니다.
Exception raised
There has been an exception: java.lang.IllegalArgumentException
Exception in thread "main" java.lang.IllegalArgumentException
at com.tutorialspoint.Student.printThrowException(Student.java:25)
at com.tutorialspoint.Student$$FastClassBySpringCGLIB$$7dc55815.invoke(<generated>>)
at org.springframework.cglib.proxy.MethodProxy.invoke(MethodProxy.java:204)
at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.invokeJoinpoint(CglibAopProxy.java:717) at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:157) at org.springframework.aop.aspectj.AspectJAfterThrowingAdvice.invoke(AspectJAfterThrowingAdvice.java:58) at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179) at org.springframework.aop.interceptor.ExposeInvocationInterceptor.invoke(ExposeInvocationInterceptor.java:92) at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179) at org.springframework.aop.framework.CglibAopProxy$DynamicAdvisedInterceptor.intercept(CglibAopProxy.java:653)
at com.tutorialspoint.Student$$EnhancerBySpringCGLIB$$8514cd8.printThrowException(<generated>)
at com.tutorialspoint.MainApp.main(MainApp.java:15)
Around어드바이스가 메소드 실행 전후에 실행되도록하는 어드바이스 유형입니다. 다음은 around advice의 구문입니다.
통사론
<aop:config>
<aop:aspect id = "log" ref = "logging">
<aop:PointCut id = "PointCut-id" expression = "execution( expression )"/>
<aop:around PointCut-ref = "PointCut-id" method = "methodName"/>
</aop:aspect>
</aop:config>
어디,
PointCut-id − PointCut의 ID.
methodName − 호출 된 함수 전에 호출 할 함수의 메서드 이름.
위에서 언급 한 Around Advice 관련 개념을 이해하기 위해 Around Advice를 구현할 예제를 작성해 보겠습니다. 몇 가지 조언으로 예제를 작성하기 위해 작동하는 Eclipse IDE를 준비하고 다음 단계를 사용하여 Spring 애플리케이션을 만듭니다.
단계 | 기술 |
---|---|
1 | Spring AOP-Application 장에서 만든 Student 프로젝트를 업데이트합니다 . |
2 | Bean 구성을 업데이트하고 아래 설명 된대로 애플리케이션을 실행하십시오. |
다음 내용은 Logging.java파일. 이것은 실제로 다양한 지점에서 호출 될 메서드를 정의하는 aspect 모듈의 샘플입니다.
package com.tutorialspoint;
import org.aspectj.lang.ProceedingJoinPoint;
public class Logging {
/**
* This is the method which I would like to execute
* around a selected method execution.
*/
public String aroundAdvice(ProceedingJoinPoint jp) throws Throwable{
System.out.println("Around advice");
Object[] args = jp.getArgs();
if(args.length>0){
System.out.print("Arguments passed: " );
for (int i = 0; i < args.length; i++) {
System.out.print("arg "+(i+1)+": "+args[i]);
}
}
Object result = jp.proceed(args);
System.out.println("Returning " + result);
return result.toString();
}
}
다음은의 내용입니다 Student.java 파일.
package com.tutorialspoint;
public class Student {
private Integer age;
private String name;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
System.out.println("Age : " + age );
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
System.out.println("Name : " + name );
return name;
}
public void printThrowException(){
System.out.println("Exception raised");
throw new IllegalArgumentException();
}
}
다음은의 내용입니다 MainApp.java 파일.
package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context =
new ClassPathXmlApplicationContext("Beans.xml");
Student student = (Student) context.getBean("student");
student.getName();
}
}
다음은 구성 파일입니다. Beans.xml.
<?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"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">
<aop:config>
<aop:aspect id = "log" ref = "logging">
<aop:PointCut id = "selectName"
expression = "execution(* com.tutorialspoint.Student.getName(..))"/>
<aop:around PointCut-ref = "selectName" method = "aroundAdvice"/>
</aop:aspect>
</aop:config>
<!-- Definition for student bean -->
<bean id = "student" class = "com.tutorialspoint.Student">
<property name = "name" value = "Zara" />
<property name = "age" value = "11"/>
</bean>
<!-- Definition for logging aspect -->
<bean id = "logging" class = "com.tutorialspoint.Logging"/>
</beans>
프로젝트 실행
소스 및 구성 파일 생성이 완료되면 애플리케이션을 실행합니다. 애플리케이션에서 MainApp.java를 마우스 오른쪽 버튼으로 클릭하고run as Java Application명령. 응용 프로그램에 문제가 없으면 다음 메시지가 인쇄됩니다.
Around advice
Name : Zara
Returning Zara
Annotation 기반 구성을 사용하여 어드바이스를 구현하는 예제를 작성해 보겠습니다. 이를 위해 작동하는 Eclipse IDE를 준비하고 다음 단계를 사용하여 Spring 애플리케이션을 작성하겠습니다.
단계 | 기술 |
---|---|
1 | Spring AOP-Application 장에서 만든 Student 프로젝트를 업데이트합니다 . |
2 | Bean 구성을 업데이트하고 아래 설명 된대로 애플리케이션을 실행하십시오. |
다음 내용은 Logging.java파일. 이것은 실제로 다양한 지점에서 호출 될 메서드를 정의하는 aspect 모듈의 샘플입니다.
package com.tutorialspoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.PointCut;
@Aspect
public class Logging {
/** Following is the definition for a PointCut to select
* all the methods available. So advice will be called
* for all the methods.
*/
@PointCut("execution(* com.tutorialspoint.*.*(..))")
private void selectAll(){}
/**
* This is the method which I would like to execute
* before a selected method execution.
*/
@Before("selectAll()")
public void beforeAdvice(){
System.out.println("Going to setup student profile.");
}
}
다음은의 내용입니다 Student.java 파일.
package com.tutorialspoint;
public class Student {
private Integer age;
private String name;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
System.out.println("Age : " + age );
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
System.out.println("Name : " + name );
return name;
}
public void printThrowException(){
System.out.println("Exception raised");
throw new IllegalArgumentException();
}
}
다음은의 내용입니다 MainApp.java 파일.
package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context =
new ClassPathXmlApplicationContext("Beans.xml");
Student student = (Student) context.getBean("student");
student.getName();
student.getAge();
}
}
다음은 구성 파일입니다. Beans.xml.
<?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"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">
<aop:aspectj-autoproxy/>
<!-- Definition for student bean -->
<bean id = "student" class = "com.tutorialspoint.Student">
<property name = "name" value = "Zara" />
<property name = "age" value = "11"/>
</bean>
<!-- Definition for logging aspect -->
<bean id = "logging" class = "com.tutorialspoint.Logging"/>
</beans>
프로젝트 실행
소스 및 구성 파일 생성이 완료되면 애플리케이션을 실행합니다. 애플리케이션에서 MainApp.java를 마우스 오른쪽 버튼으로 클릭하고run as Java Application명령. 응용 프로그램에 문제가 없으면 다음 메시지가 인쇄됩니다.
Going to setup student profile.
Name : Zara
Going to setup student profile.
Age : 11
JoinPoint
JoinPoint는 AOP 측면을 플러그인 할 수있는 애플리케이션의 지점을 나타냅니다. 또한 Spring AOP 프레임 워크를 사용하여 작업이 수행되는 애플리케이션의 실제 위치라고 말할 수도 있습니다. 다음 예를 고려하십시오-
패키지에 포함 된 모든 메서드 클래스.
클래스의 특정 메서드.
PointCut
PointCut은 어드바이스가 실행되어야하는 하나 이상의 JoinPoint 세트입니다. AOP 예제에서 볼 수 있듯이 표현식이나 패턴을 사용하여 PointCuts를 지정할 수 있습니다. Spring에서 PointCut은 특정 JoinPoint를 사용하여 조언을 적용하는 데 도움이됩니다. 다음 예를 고려하십시오-
@PointCut ( "execution (* com.tutorialspoint. *. * (..))")
@PointCut ( "execution (* com.tutorialspoint.Student.getName (..))")
통사론
@Aspect
public class Logging {
@PointCut("execution(* com.tutorialspoint.*.*(..))")
private void selectAll(){}
}
어디,
@Aspect − 어드바이스 메소드가 포함 된 클래스로 클래스를 표시하십시오.
@PointCut − 함수를 PointCut으로 표시
execution( expression ) − 어드바이스가 적용될 표현을 다루는 방법.
JoinPoint 및 PointCut과 관련된 위에서 언급 한 개념을 이해하기 위해 몇 가지 PointCut을 구현하는 예제를 작성하겠습니다. 몇 가지 조언으로 예제를 작성하기 위해 작동하는 Eclipse IDE를 준비하고 다음 단계를 사용하여 Spring 애플리케이션을 만듭니다.
단계 | 기술 |
---|---|
1 | Spring AOP-Application 장에서 만든 Student 프로젝트를 업데이트합니다 . |
2 | Bean 구성을 업데이트하고 아래 설명 된대로 애플리케이션을 실행하십시오. |
다음 내용은 Logging.java파일. 이것은 실제로 다양한 지점에서 호출 될 메서드를 정의하는 aspect 모듈의 샘플입니다.
package com.tutorialspoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.PointCut;
import org.aspectj.lang.annotation.Before;
@Aspect
public class Logging {
/** Following is the definition for a PointCut to select
* all the methods available. So advice will be called
* for all the methods.
*/
@PointCut("execution(* com.tutorialspoint.*.*(..))")
private void selectAll(){}
/**
* This is the method which I would like to execute
* before a selected method execution.
*/
@Before("selectAll()")
public void beforeAdvice(){
System.out.println("Going to setup student profile.");
}
}
다음은의 내용입니다 Student.java 파일.
package com.tutorialspoint;
public class Student {
private Integer age;
private String name;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
System.out.println("Age : " + age );
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
System.out.println("Name : " + name );
return name;
}
public void printThrowException(){
System.out.println("Exception raised");
throw new IllegalArgumentException();
}
}
다음은의 내용입니다 MainApp.java 파일.
package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context =
new ClassPathXmlApplicationContext("Beans.xml");
Student student = (Student) context.getBean("student");
student.getName();
student.getAge();
}
}
다음은 구성 파일입니다. Beans.xml.
<?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"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">
<aop:aspectj-autoproxy/>
<!-- Definition for student bean -->
<bean id = "student" class = "com.tutorialspoint.Student">
<property name = "name" value = "Zara" />
<property name = "age" value = "11"/>
</bean>
<!-- Definition for logging aspect -->
<bean id = "logging" class = "com.tutorialspoint.Logging"/>
</beans>
프로젝트 실행
소스 및 구성 파일 생성이 완료되면 애플리케이션을 실행합니다. 애플리케이션에서 MainApp.java를 마우스 오른쪽 버튼으로 클릭하고run as Java Application명령. 응용 프로그램에 문제가 없으면 다음 메시지가 인쇄됩니다.
Going to setup student profile.
Name : Zara
Going to setup student profile.
Age : 11
위에 정의 된 @Pointcut은 표현식을 사용하여 com.tutorialspoint 패키지에 정의 된 모든 메서드를 선택합니다. @Before advice는 위에서 정의한 PointCut을 매개 변수로 사용합니다. 효과적으로 beforeAdvice () 메서드는 위의 PointCut에서 다루는 모든 메서드보다 먼저 호출됩니다.
@Before어드바이스가 메소드 실행 전에 실행되도록하는 어드바이스 유형입니다. 다음은 @Before 조언의 구문입니다.
통사론
@PointCut("execution(* com.tutorialspoint.Student.getName(..))")
private void selectGetName(){}
@Before("selectGetName()")
public void beforeAdvice(){
System.out.println("Going to setup student profile.");
}
어디,
@PointCut − 함수를 PointCut으로 표시
execution( expression ) − 어드바이스가 적용될 표현을 다루는 방법.
@Before − 함수를 PointCut에서 다루는 메소드 이전에 실행할 어드바이스로 표시합니다.
위에서 언급 한 @Before Advice 관련 개념을 이해하기 위해 @Before Advice를 구현하는 예제를 작성해 보겠습니다. 몇 가지 조언으로 예제를 작성하기 위해 작동하는 Eclipse IDE를 준비하고 다음 단계를 사용하여 Spring 애플리케이션을 만듭니다.
단계 | 기술 |
---|---|
1 | Spring AOP-Application 장에서 만든 Student 프로젝트를 업데이트합니다 . |
2 | Bean 구성을 업데이트하고 아래 설명 된대로 애플리케이션을 실행하십시오. |
다음 내용은 Logging.java파일. 이것은 실제로 다양한 지점에서 호출 될 메서드를 정의하는 aspect 모듈의 샘플입니다.
package com.tutorialspoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.PointCut;
import org.aspectj.lang.annotation.Before;
@Aspect
public class Logging {
/** Following is the definition for a PointCut to select
* all the methods available. So advice will be called
* for all the methods.
*/
@PointCut("execution(* com.tutorialspoint.Student.getName(..))")
private void selectGetName(){}
/**
* This is the method which I would like to execute
* before a selected method execution.
*/
@Before("selectGetName()")
public void beforeAdvice(){
System.out.println("Going to setup student profile.");
}
}
다음은의 내용입니다 Student.java 파일.
package com.tutorialspoint;
public class Student {
private Integer age;
private String name;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
System.out.println("Age : " + age );
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
System.out.println("Name : " + name );
return name;
}
public void printThrowException(){
System.out.println("Exception raised");
throw new IllegalArgumentException();
}
}
다음은의 내용입니다 MainApp.java 파일.
package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context =
new ClassPathXmlApplicationContext("Beans.xml");
Student student = (Student) context.getBean("student");
student.getName();
student.getAge();
}
}
다음은 구성 파일입니다. Beans.xml.
<?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"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">
<aop:aspectj-autoproxy/>
<!-- Definition for student bean -->
<bean id = "student" class = "com.tutorialspoint.Student">
<property name = "name" value = "Zara" />
<property name = "age" value = "11"/>
</bean>
<!-- Definition for logging aspect -->
<bean id = "logging" class = "com.tutorialspoint.Logging"/>
</beans>
프로젝트 실행
소스 및 구성 파일 생성이 완료되면 애플리케이션을 실행합니다. 애플리케이션에서 MainApp.java를 마우스 오른쪽 버튼으로 클릭하고run as Java Application명령. 응용 프로그램에 문제가 없으면 다음 메시지가 인쇄됩니다.
Going to setup student profile.
Name : Zara
Age : 11
위에 정의 된 @Pointcut은 com.tutorialspoint 패키지 아래의 클래스에 정의 된 getAge () 메소드를 선택하기 위해 표현식을 사용합니다. @After advice는 위에서 정의한 PointCut을 매개 변수로 사용합니다. 효과적으로 afterAdvice () 메서드는 위의 PointCut에서 다루는 모든 메서드보다 먼저 호출됩니다.
@After메소드 실행 후 어드바이스가 실행되도록하는 어드바이스 유형입니다. 다음은 @After 조언의 구문입니다.
통사론
@PointCut("execution(* com.tutorialspoint.Student.getAge(..))")
private void selectGetName(){}
@After("selectGetAge()")
public void afterAdvice(){
System.out.println("Student profile setup completed.");
}
어디,
@PointCut − 함수를 PointCut으로 표시
execution( expression ) − 어드바이스가 적용될 표현을 다루는 방법.
@After − 함수를 PointCut에서 다루는 메소드 이전에 실행할 어드바이스로 표시합니다.
위에서 언급 한 @After Advice 관련 개념을 이해하기 위해 @After Advice를 구현하는 예제를 작성해 보겠습니다. 몇 가지 조언으로 예제를 작성하기 위해 작동하는 Eclipse IDE를 준비하고 다음 단계를 사용하여 Spring 애플리케이션을 만듭니다.
단계 | 기술 |
---|---|
1 | Spring AOP-Application 장에서 만든 Student 프로젝트를 업데이트합니다 . |
2 | Bean 구성을 업데이트하고 아래 설명 된대로 애플리케이션을 실행하십시오. |
다음 내용은 Logging.java파일. 이것은 실제로 다양한 지점에서 호출 될 메서드를 정의하는 aspect 모듈의 샘플입니다.
package com.tutorialspoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.PointCut;
import org.aspectj.lang.annotation.After;
@Aspect
public class Logging {
/** Following is the definition for a PointCut to select
* all the methods available. So advice will be called
* for all the methods.
*/
@PointCut("execution(* com.tutorialspoint.Student.getAge(..))")
private void selectGetAge(){}
/**
* This is the method which I would like to execute
* after a selected method execution.
*/
@After("selectGetAge()")
public void afterAdvice(){
System.out.println("Student profile setup completed.");
}
}
다음은의 내용입니다 Student.java 파일.
package com.tutorialspoint;
public class Student {
private Integer age;
private String name;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
System.out.println("Age : " + age );
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
System.out.println("Name : " + name );
return name;
}
public void printThrowException(){
System.out.println("Exception raised");
throw new IllegalArgumentException();
}
}
다음은의 내용입니다 MainApp.java 파일.
package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context =
new ClassPathXmlApplicationContext("Beans.xml");
Student student = (Student) context.getBean("student");
student.getName();
student.getAge();
}
}
다음은 구성 파일입니다. Beans.xml.
<?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"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">
<aop:aspectj-autoproxy/>
<!-- Definition for student bean -->
<bean id = "student" class = "com.tutorialspoint.Student">
<property name = "name" value = "Zara" />
<property name = "age" value = "11"/>
</bean>
<!-- Definition for logging aspect -->
<bean id = "logging" class = "com.tutorialspoint.Logging"/>
</beans>
프로젝트 실행
소스 및 구성 파일 생성이 완료되면 애플리케이션을 실행합니다. 애플리케이션에서 MainApp.java를 마우스 오른쪽 버튼으로 클릭하고run as Java Application명령. 응용 프로그램에 문제가 없으면 다음 메시지가 인쇄됩니다.
Name : Zara
Age : 11
Student profile setup completed.
위에 정의 된 @Pointcut은 com.tutorialspoint 패키지 아래의 클래스에 정의 된 getAge () 메소드를 선택하기 위해 표현식을 사용합니다. @After advice는 위에서 정의한 PointCut을 매개 변수로 사용합니다. 효과적으로 afterAdvice () 메서드는 위의 PointCut에서 다루는 모든 메서드보다 먼저 호출됩니다.
@AfterReturning메서드가 성공적으로 실행 된 후 어드바이스가 실행되도록하는 어드바이스 유형입니다. 다음은 @AfterReturning 조언의 구문입니다.
통사론
@AfterReturning(PointCut = "execution(* com.tutorialspoint.Student.*(..))",
returning = "retVal")
public void afterReturningAdvice(JoinPoint jp, Object retVal){
System.out.println("Method Signature: " + jp.getSignature());
System.out.println("Returning:" + retVal.toString() );
}
어디,
@AfterReturning − 메서드가 성공적으로 반환되면 PointCut에서 다루는 메서드보다 먼저 실행할 어드바이스로 함수를 표시합니다.
PointCut − 기능 선택을위한 표현식 제공
execution( expression ) − 어드바이스가 적용될 표현을 다루는 방법.
returning − 반환 할 변수의 이름.
위에서 언급 한 @AfterReturning Advice 관련 개념을 이해하기 위해 @AfterReturning Advice를 구현하는 예제를 작성하겠습니다. 몇 가지 조언으로 예제를 작성하기 위해 작동하는 Eclipse IDE를 준비하고 다음 단계를 사용하여 Spring 애플리케이션을 만듭니다.
단계 | 기술 |
---|---|
1 | Spring AOP-Application 장에서 만든 Student 프로젝트를 업데이트합니다 . |
2 | Bean 구성을 업데이트하고 아래 설명 된대로 애플리케이션을 실행하십시오. |
다음 내용은 Logging.java파일. 이것은 실제로 다양한 지점에서 호출 될 메서드를 정의하는 aspect 모듈의 샘플입니다.
package com.tutorialspoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
@Aspect
public class Logging {
/**
* This is the method which I would like to execute
* after a selected method execution.
*/
@AfterReturning(PointCut = "execution(* com.tutorialspoint.Student.*(..))",
returning = "retVal")
public void afterReturningAdvice(JoinPoint jp, Object retVal){
System.out.println("Method Signature: " + jp.getSignature());
System.out.println("Returning:" + retVal.toString() );
}
}
다음은의 내용입니다 Student.java 파일.
package com.tutorialspoint;
public class Student {
private Integer age;
private String name;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
System.out.println("Age : " + age );
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
System.out.println("Name : " + name );
return name;
}
public void printThrowException(){
System.out.println("Exception raised");
throw new IllegalArgumentException();
}
}
다음은의 내용입니다 MainApp.java 파일.
package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context =
new ClassPathXmlApplicationContext("Beans.xml");
Student student = (Student) context.getBean("student");
student.getAge();
}
}
다음은 구성 파일입니다. Beans.xml.
<?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"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">
<aop:aspectj-autoproxy/>
<!-- Definition for student bean -->
<bean id = "student" class = "com.tutorialspoint.Student">
<property name = "name" value = "Zara" />
<property name = "age" value = "11"/>
</bean>
<!-- Definition for logging aspect -->
<bean id = "logging" class = "com.tutorialspoint.Logging"/>
</beans>
프로젝트 실행
소스 및 구성 파일 생성이 완료되면 애플리케이션을 실행합니다. 애플리케이션에서 MainApp.java를 마우스 오른쪽 버튼으로 클릭하고run as Java Application명령. 응용 프로그램에 문제가 없으면 다음 메시지가 인쇄됩니다.
Age : 11
Method Signature: Integer com.tutorialspoint.Student.getAge()
Returning 11
@AfterThrowing메소드가 예외를 던질 경우 어드바이스가 실행되도록하는 어드바이스 유형입니다. 다음은 @AfterThrowing 조언의 구문입니다.
통사론
@AfterThrowing(PointCut = "execution(* com.tutorialspoint.Student.*(..))",
throwing = "error")
public void afterThrowingAdvice(JoinPoint jp, Throwable error){
System.out.println("Method Signature: " + jp.getSignature());
System.out.println("Exception: "+error);
}
어디,
@AfterThrowing − 메서드에서 예외가 발생하는 경우 PointCut에서 다루는 메서드보다 먼저 실행할 어드바이스로 함수를 표시합니다.
PointCut − 함수를 선택하는 표현식을 제공합니다.
execution( expression ) − 어드바이스가 적용될 표현을 다루는 방법.
throwing − 반환 될 예외의 이름.
위에서 언급 한 @AfterThrowing Advice 관련 개념을 이해하기 위해 @AfterThrowing Advice를 구현하는 예제를 작성해 보겠습니다. 몇 가지 조언으로 예제를 작성하기 위해 작동하는 Eclipse IDE를 준비하고 다음 단계를 사용하여 Spring 애플리케이션을 만듭니다.
단계 | 기술 |
---|---|
1 | Spring AOP-Application 장에서 만든 Student 프로젝트를 업데이트합니다 . |
2 | Bean 구성을 업데이트하고 아래 설명 된대로 애플리케이션을 실행하십시오. |
다음 내용은 Logging.java파일. 이것은 실제로 다양한 지점에서 호출 될 메서드를 정의하는 aspect 모듈의 샘플입니다.
package com.tutorialspoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterThrowing;
@Aspect
public class Logging {
/**
* This is the method which I would like to execute
* after a selected method execution throws exception.
*/
@AfterThrowing(PointCut = "execution(* com.tutorialspoint.Student.*(..))",
throwing = "error")
public void afterThrowingAdvice(JoinPoint jp, Throwable error){
System.out.println("Method Signature: " + jp.getSignature());
System.out.println("Exception: "+error);
}
}
다음은의 내용입니다 Student.java 파일.
package com.tutorialspoint;
public class Student {
private Integer age;
private String name;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
System.out.println("Age : " + age );
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
System.out.println("Name : " + name );
return name;
}
public void printThrowException(){
System.out.println("Exception raised");
throw new IllegalArgumentException();
}
}
다음은의 내용입니다 MainApp.java 파일.
package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context =
new ClassPathXmlApplicationContext("Beans.xml");
Student student = (Student) context.getBean("student");
student.printThrowException();
}
}
다음은 구성 파일입니다. Beans.xml.
<?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"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">
<aop:aspectj-autoproxy/>
<!-- Definition for student bean -->
<bean id = "student" class = "com.tutorialspoint.Student">
<property name = "name" value = "Zara" />
<property name = "age" value = "11"/>
</bean>
<!-- Definition for logging aspect -->
<bean id = "logging" class = "com.tutorialspoint.Logging"/>
</beans>
프로젝트 실행
소스 및 구성 파일 생성이 완료되면 애플리케이션을 실행합니다. 애플리케이션에서 MainApp.java를 마우스 오른쪽 버튼으로 클릭하고run as Java Application명령. 응용 프로그램에 문제가 없으면 다음 메시지가 인쇄됩니다.
Exception raised
Method Signature: void com.tutorialspoint.Student.printThrowException()
Exception: java.lang.IllegalArgumentException
Exception in thread "main" java.lang.IllegalArgumentException
at com.tutorialspoint.Student.printThrowException(Student.java:25)
at com.tutorialspoint.Student$$FastClassBySpringCGLIB$$7dc55815.invoke(<generated>)
at org.springframework.cglib.proxy.MethodProxy.invoke(MethodProxy.java:204)
at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.invokeJoinpoint(CglibAopProxy.java:717) at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:157) at org.springframework.aop.aspectj.AspectJAfterThrowingAdvice.invoke(AspectJAfterThrowingAdvice.java:58) at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179) at org.springframework.aop.interceptor.ExposeInvocationInterceptor.invoke(ExposeInvocationInterceptor.java:92) at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179) at org.springframework.aop.framework.CglibAopProxy$DynamicAdvisedInterceptor.intercept(CglibAopProxy.java:653)
at com.tutorialspoint.Student$$EnhancerBySpringCGLIB$$99b0a988.printThrowException(<generated>)
at com.tutorialspoint.MainApp.main(MainApp.java:13)
@Around어드바이스 유형으로, 어드바이스 실행 전후에 어드바이스를 실행할 수 있습니다. 다음은 @Around 조언의 구문입니다.
통사론
@PointCut("execution(* com.tutorialspoint.Student.getAge(..))")
private void selectGetName(){}
@Around("selectGetAge()")
public void aroundAdvice(ProceedingJoinPoint proceedingJoinPoint){
System.out.println("Around advice");
Object[] args = jp.getArgs();
if(args.length>0){
System.out.print("Arguments passed: " );
for (int i = 0; i < args.length; i++) {
System.out.print("arg "+(i+1)+": "+args[i]);
}
}
Object result = jp.proceed(args);
System.out.println("Returning " + result);
return result.toString();
}
어디,
@PointCut − 함수를 PointCut으로 표시
execution( expression ) − 어드바이스가 적용될 표현을 다루는 방법.
@Around − 함수를 PointCut에서 다루는 메소드 이전에 실행할 어드바이스로 표시합니다.
위에서 언급 한 @Around Advice 관련 개념을 이해하기 위해 @Around Advice를 구현하는 예제를 작성해 보겠습니다. 몇 가지 조언으로 예제를 작성하기 위해 작동하는 Eclipse IDE를 준비하고 다음 단계를 사용하여 Spring 애플리케이션을 만듭니다.
단계 | 기술 |
---|---|
1 | Spring AOP-Application 장에서 만든 Student 프로젝트를 업데이트합니다 . |
2 | Bean 구성을 업데이트하고 아래 설명 된대로 애플리케이션을 실행하십시오. |
다음 내용은 Logging.java파일. 이것은 실제로 다양한 지점에서 호출 될 메서드를 정의하는 aspect 모듈의 샘플입니다.
package com.tutorialspoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.PointCut;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.ProceedingJoinPoint;
@Aspect
public class Logging {
/** Following is the definition for a PointCut to select
* all the methods available. So advice will be called
* for all the methods.
*/
@PointCut("execution(* com.tutorialspoint.Student.getAge(..))")
private void selectGetAge(){}
/**
* This is the method which I would like to execute
* around a selected method execution.
*/
@Around("selectGetAge()")
public void aroundAdvice(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
System.out.println("Around advice");
Object[] args = proceedingJoinPoint.getArgs();
if(args.length>0){
System.out.print("Arguments passed: " );
for (int i = 0; i < args.length; i++) {
System.out.print("arg "+(i+1)+": "+args[i]);
}
}
Object result = proceedingJoinPoint.proceed(args);
System.out.println("Returning " + result);
}
}
다음은의 내용입니다 Student.java 파일.
package com.tutorialspoint;
public class Student {
private Integer age;
private String name;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
System.out.println("Age : " + age );
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
System.out.println("Name : " + name );
return name;
}
public void printThrowException(){
System.out.println("Exception raised");
throw new IllegalArgumentException();
}
}
다음은의 내용입니다 MainApp.java 파일.
package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context =
new ClassPathXmlApplicationContext("Beans.xml");
Student student = (Student) context.getBean("student");
student.getAge();
}
}
다음은 구성 파일입니다. Beans.xml.
<?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"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">
<aop:aspectj-autoproxy/>
<!-- Definition for student bean -->
<bean id = "student" class = "com.tutorialspoint.Student">
<property name = "name" value = "Zara" />
<property name = "age" value = "11"/>
</bean>
<!-- Definition for logging aspect -->
<bean id = "logging" class = "com.tutorialspoint.Logging"/>
</beans>
프로젝트 실행
소스 및 구성 파일 생성이 완료되면 애플리케이션을 실행합니다. 애플리케이션에서 MainApp.java를 마우스 오른쪽 버튼으로 클릭하고run as Java Application명령. 응용 프로그램에 문제가 없으면 다음 메시지가 인쇄됩니다.
Around advice
Age : 11
Returning 11
지금까지 우리는 <aop:config> 또는 < aop:aspectj-autoproxy>. 프록시 개체를 사용하여 프로그래밍 방식으로 측면을 호출 할뿐만 아니라 프로그래밍 방식으로 프록시를 만들 수 있습니다.
통사론
//Create object to be proxied
Student student = new Student();
//Create the Proxy Factory
AspectJProxyFactory proxyFactory = new AspectJProxyFactory(student);
//Add Aspect class to the factory
proxyFactory.addAspect(Logging.class);
//Get the proxy object
Student proxyStudent = proxyFactory.getProxy();
//Invoke the proxied method.
proxyStudent.getAge();
어디,
AspectJProxyFactory − 프록시 객체를 생성하기위한 팩토리 클래스.
Logging.class − 조언을 포함하는 Aspect의 클래스.
Student − 추천 할 비즈니스 클래스.
위에서 언급 한 프록시 관련 개념을 이해하기 위해 프록시를 구현하는 예제를 작성해 보겠습니다. 몇 가지 조언으로 예제를 작성하기 위해 작동하는 Eclipse IDE를 준비하고 다음 단계를 사용하여 Spring 애플리케이션을 만듭니다.
단계 | 기술 |
---|---|
1 | Spring AOP-Application 장에서 만든 Student 프로젝트를 업데이트합니다 . |
2 | Bean 구성을 업데이트하고 아래 설명 된대로 애플리케이션을 실행하십시오. |
다음 내용은 Logging.java파일. 이것은 실제로 다양한 지점에서 호출 될 메서드를 정의하는 aspect 모듈의 샘플입니다.
package com.tutorialspoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.PointCut;
import org.aspectj.lang.annotation.Before;
@Aspect
public class Logging {
/** Following is the definition for a PointCut to select
* all the methods available. So advice will be called
* for all the methods.
*/
@PointCut("execution(* com.tutorialspoint.Student.getAge(..))")
private void selectGetAge(){}
/**
* This is the method which I would like to execute
* before a selected method execution.
*/
@Before("selectGetAge()")
public void beforeAdvice(){
System.out.println("Going to setup student profile.");
}
}
다음은의 내용입니다 Student.java 파일.
package com.tutorialspoint;
public class Student {
private Integer age;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
System.out.println("Age : " + age );
return age;
}
}
다음은의 내용입니다 MainApp.java 파일.
package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.aop.aspectj.annotation.AspectJProxyFactory;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context =
new ClassPathXmlApplicationContext("Beans.xml");
Student student = (Student) context.getBean("student");
//Create the Proxy Factory
AspectJProxyFactory proxyFactory = new AspectJProxyFactory(student);
//Add Aspect class to the factory
proxyFactory.addAspect(Logging.class);
//Get the proxy object
Student proxyStudent = proxyFactory.getProxy();
//Invoke the proxied method.
proxyStudent.getAge();
}
}
다음은 구성 파일입니다. Beans.xml.
<?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"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">
<!-- Definition for student bean -->
<bean id = "student" class = "com.tutorialspoint.Student">
<property name = "age" value = "11"/>
</bean>
<!-- Definition for logging aspect -->
<bean id = "logging" class = "com.tutorialspoint.Logging"/>
</beans>
프로젝트 실행
소스 및 구성 파일 생성이 완료되면 애플리케이션을 실행합니다. 애플리케이션에서 MainApp.java를 마우스 오른쪽 버튼으로 클릭하고run as Java Application명령. 응용 프로그램에 문제가 없으면 다음 메시지가 인쇄됩니다.
Going to setup student profile.
Age : 11
PointCut 표현식에 따라 어드바이스가 의도되지 않은 다른 빈에 적용되는 경우가있을 수 있습니다. 예를 들어 다음 표현식을 고려하십시오.
execution(* com.tutorialspoint.*.getAge(..))
getAge () 메소드로 새로운 spring bean이 추가되고 의도하지 않았더라도 조언이 적용되기 시작합니다. 이를 달성하기 위해 사용자 지정 주석을 만들고 조언이 적용될 메서드에 주석을 달 수 있습니다.
@Before("@annotation(com.tutorialspoint.Loggable)")
위에서 언급 한 @Before Advice 관련 개념을 이해하기 위해 @Before Advice를 구현하는 예제를 작성해 보겠습니다. 몇 가지 조언으로 예제를 작성하기 위해 작동하는 Eclipse IDE를 준비하고 다음 단계를 사용하여 Spring 애플리케이션을 만듭니다.
단계 | 기술 |
---|---|
1 | Spring AOP-Application 장에서 만든 Student 프로젝트를 업데이트합니다 . |
2 | Bean 구성을 업데이트하고 아래 설명 된대로 애플리케이션을 실행하십시오. |
다음 내용은 Logging.java파일. 이것은 실제로 다양한 지점에서 호출 될 메서드를 정의하는 aspect 모듈의 샘플입니다.
package com.tutorialspoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
@Aspect
public class Logging {
/**
* This is the method which I would like to execute
* before a selected method execution.
*/
@Before("@annotation(com.tutorialspoint.Loggable)")
public void beforeAdvice(){
System.out.println("Going to setup student profile.");
}
}
다음은의 내용입니다 Loggable.java 파일-
package com.tutorialspoint;
public @interface Loggable {
}
다음은의 내용입니다 Student.java 파일.
package com.tutorialspoint;
public class Student {
private Integer age;
private String name;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
System.out.println("Age : " + age );
return age;
}
public void setName(String name) {
this.name = name;
}
@Loggable
public String getName() {
System.out.println("Name : " + name );
return name;
}
public void printThrowException(){
System.out.println("Exception raised");
throw new IllegalArgumentException();
}
}
다음은의 내용입니다 MainApp.java 파일.
package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context =
new ClassPathXmlApplicationContext("Beans.xml");
Student student = (Student) context.getBean("student");
student.getName();
student.getAge();
}
}
다음은 구성 파일입니다. Beans.xml.
<?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"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">
<aop:aspectj-autoproxy/>
<!-- Definition for student bean -->
<bean id = "student" class = "com.tutorialspoint.Student">
<property name = "name" value = "Zara" />
<property name = "age" value = "11"/>
</bean>
<!-- Definition for logging aspect -->
<bean id = "logging" class = "com.tutorialspoint.Logging"/>
</beans>
프로젝트 실행
소스 및 구성 파일 생성이 완료되면 애플리케이션을 실행합니다. 애플리케이션에서 MainApp.java를 마우스 오른쪽 버튼으로 클릭하고run as Java Application명령. 응용 프로그램에 문제가 없으면 다음 메시지가 인쇄됩니다.
Going to setup student profile.
Name : Zara
Age : 11