AOP 프로 그래 밍 입문

Aspect Oriented Programming (AOP) 은 절단면 을 대상 으로 프로 그래 밍 한 것 으로 비교적 뜨 거 운 화제 다.AOP 는 주로 업무 처리 과정 에서 의 절단면 을 추출 하 는 것 을 목적 으로 하 는데 이것 은 처리 과정 에서 의 특정한 절차 나 단계 에 직면 하여 논리 과정 에서 각 부분 간 의 낮은 결합 성의 격 리 효 과 를 얻 는 것 이다.예 를 들 어 우리 가 가장 흔히 볼 수 있 는 것 은 로그 기록 이다. 예 를 들 어 우 리 는 지금 학생 들 의 정 보 를 조회 하 는 서 비 스 를 제공 하고 있 지만 우 리 는 누가 이 조 회 를 했 는 지 기록 하고 싶다.만약 에 전통 적 인 OOP 의 실현 에 따라 우 리 는 학생 정 보 를 조회 하 는 서비스 인터페이스 (Student InfoService) 와 그 실현 류 (Student InfoServiceImpl. 자바) 를 실현 하고 기록 을 하기 위해 우 리 는 실현 류 (Student InfoServiceImpl. 자바) 에 기록 을 실현 하 는 과정 을 추가 해 야 한다.그렇다면 우리 가 실현 하고 자 하 는 서 비 스 는 얼마나 될 까?그러면 모든 실 현 된 클래스 에 이 기록 과정 을 추가 해 야 한다.이렇게 하면 좀 번 거 롭 고 모든 실현 류 는 서비스 로 그 를 기록 하 는 행위 와 결합 하여 대상 을 대상 으로 하 는 규칙 을 위반 할 수 있다.그러면 어떻게 해야만 기록 서비스의 행위 와 업무 처리 과정 에서 분리 할 수 있 습 니까?학생 들 의 서 비 스 를 조회 하 는 것 처럼 보이 지만 배후 로그 기록 은 이러한 행 위 를 기록 하지만 학생 들 의 서 비 스 를 조회 하 는 데 이런 기록 과정 이 존재 하 는 지 모 르 는 것 이 바로 AOP 의 목적 이다.AOP 의 프로 그래 밍 은 우리 가 특정한 기능 을 제기 하여 일부 대상 과 격 리 시 키 는 것 처럼 일부 대상 과 결합 성 을 낮 추고 특정한 기능 에 대해 프로 그래 밍 을 할 수 있다.
코드 부터 시작 합 시다. 이상 의 목 표를 실현 하려 면 동적 프 록 시 클래스 (Proxy) 를 사용 하여 대상 의 행동 을 차단 하고 우리 가 필요 로 하 는 기능 을 추가 하여 완성 할 수 있 습 니 다.자바 의 자바. lang. reflect. Proxy 류 와 자바. lang. reflect. InvocationHandler 인 터 페 이 스 는 동적 에이전트 류 를 실현 하 는 방안 을 제공 하지만 이 방안 이 대상 에 대한 인 터 페 이 스 를 실현 해 야 합 니 다.목적 이 클래스 라면 cglib 는 우리 에 게 또 다른 실현 방안 을 제공 합 니 다.잠시 후 둘 의 차 이 를 설명 하 겠 습 니 다.
1. 인터페이스의 실현 방안:
1) 먼저 업무 인터페이스 (Student InfoService. java) 를 작성 합 니 다.

public interface StudentInfoService{
 void findInfo(String studentName);
}

그 실현 클래스 (Student InfoServiceImpl. 자바):

public class StudentInfoServiceImpl implements StudentInfoService{
 public void findInfo(String name){
  System.out.println("         :"+name);
 }
}

2) 현재 로그 기능 이 필요 합 니 다. findInfo 행 위 를 수행 하고 기록 하기 전에 이 행 위 를 차단 해 야 합 니 다.실제 집행 과정 에서 하나의 대리 류 로 우 리 를 대신 해서 완성 하 다.자바 에서 동적 에이전트 클래스 를 실현 하 는 방안 을 제공 합 니 다.
1 '차단 목적 의 클래스 처리 (MyHandler. java)

import org.apache.log4j.Logger;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.lang.reflect.Method;

public class MyHandler implements InvocationHandler{
 private Object proxyObj;
 private static Logger log=Logger.getLogger(MyHandler.class);
 public Object bind(Object obj){
  this.proxyObj=obj;
  return Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(),this);
 }
 public Object invoke(Object proxy,Method method,Object[] args) throws Throwable{
  Object result=null;
  try{
   //        ，      
   log.info("  log    "+method.getName());
   result=method.invoke(proxyObj,args); //   
   //        ，     
  }catch(Exception e){
   e.printStackTrace();
  }
  return result;
 }
}

2. 우 리 는 이 차단 류 (AOFactory. java) 를 편리 하 게 사용 할 수 있 도록 공장 을 실현 합 니 다.

public class AOPFactory{
 private static Object getClassInstance(String clzName){
  Object obj=null;
  try{
   Class cls=Class.forName(clzName);
   obj=(Object)cls.newInstance();
  }catch(ClassNotFoundException cnfe){
   System.out.println("ClassNotFoundException:"+cnfe.getMessage());
  }catch(Exception e){
   e.printStackTrace();
  }
  return obj;
 }
 public static Object getAOPProxyedObject(String clzName){
  Object proxy=null;
  MyHandler handler=new MyHandler();
  Object obj=getClassInstance(clzName);
  if(obj!=null) {
   proxy=handler.bind(obj);
  }else{
   System.out.println("Can't get the proxyobj");
  //throw
  }
  return proxy;
 }
}

3) 기본 적 인 차단 과 공장 을 우 리 는 모두 실현 했다. 현재 테스트 (Client Test. java):

public class ClientTest{
 public static void main(String[] args){
  StudentInfoService studentInfo=(StudentInfoService)AOPFactory.getAOPProxyedObject("StudentInfoServiceImpl");
  studentInfo.findInfo("  ");
 }
}

출력 결과 (log4j 설정 참조):
[INFO] 로그 로그 호출 방법 findInfo
당신 이 현재 입력 한 이름 은: 아비
이렇게 해서 우리 가 필요 로 하 는 효과 가 나 왔 다. 업무 처 리 는 스스로 진행 되 고 있 지만 우 리 는 로그 기능 을 실 현 했 고 업무 처리 (Student InfoService) 는 이 행위 가 존재 하 는 지 전혀 몰 랐 다.그러나 자바 에서 제공 하 는 동적 프 록 시 클래스 의 실현 은 일부 인 터 페 이 스 를 실현 하 는 클래스 를 대상 으로 하 는 것 입 니 다. 인터페이스 가 실현 되 지 않 으 면 프 록 시 클래스 를 만 들 수 없습니다. 상기 부분 을 보십시오.
return Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(),this);
봤 어?obj. getClass (). getInterfaces () 는 일부 인 터 페 이 스 를 실현 하도록 요구 합 니 다.다음은 인 터 페 이 스 를 실현 하지 못 한 실현 방안 을 제공 합 니 다.
2. 자 류 의 실현 방안.
우선 CGLib 가방 을 인터넷 으로 내 려 주세요.
http://sourceforge.net/project/showfiles.php?group_id=56933 。classpath 경 로 를 설정 합 니 다. CGLib 는 자바 표준 라 이브 러 리 에서 제공 하 는 실현 방안 과 달리 cglib 는 주로 실현 클래스 를 기반 으로 합 니 다.(예 를 들 어 Student InfoServiceImpl. 자바) 하위 클래스 를 확장 하여 구현 합 니 다. Dynamic Proxy 의 Proxy 와 InvocationHandler 에 대응 하여 net. sf. cglib. proxy. Enhancer 와 MethodInterceptor 는 CGLib 에서 대리 대상 생 성과 방법 캡 처 처 처 리 를 담당 합 니 다. 인터페이스 로 차단 하 는 것 이 아니 라 목표 클래스 의 하위 클래스 가 발생 합 니 다. Enhancer 는 주로 동적 인 구 조 를 구성 하 는 데 사 용 됩 니 다.프 록 시 하위 클래스 로 차단 을 실현 합 니 다. MethodInterceptor (Callback 인터페이스 확장) 는 주로 around advice (AOP 의 개념) 를 실현 하 는 데 사 용 됩 니 다.
1) 우리 의 업무 처리 (Student InfoServiceImpl. java):

public class StudentInfoServiceImpl{
 public void findInfo(String name){
  System.out.println("         :"+name);
 }
}

2) 로그 기능 을 처리 하 는 도 구 를 실행 합 니 다 (AOP Instrumenter. java):

import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
import org.apache.log4j.Logger;

public class AOPInstrumenter implements MethodInterceptor{
 private Logger log=Logger.getLogger(AOPInstrumenter.class);
 private Enhancer enhancer=new Enhancer();
 public Object getInstrumentedClass(Class clz){
  enhancer.setSuperclass(clz);
  enhancer.setCallback(this);
  return enhancer.create();
 }
 public Object intercept(Object o,Method method,Object[] args,MethodProxy proxy) throws Throwable{
  log.info("      "+method.getName());
  Object result=proxy.invokeSuper(o,args);
  return result;
 }
}

3) 테스트 해 보 겠 습 니 다 (AOPTest. java):

public class AOPTest{
 public static void main(String[] args){
  AOPInstrumenter instrumenter=new AOPInstrumenter();
  StudentInfoServiceImpl studentInfo=(StudentInfoServiceImpl)instrumenter.getInstrumentedClass(StudentInfoServiceImpl.class);
  studentInfo.findInfo("  ");
 }
}

출력 결 과 는 이상 과 같 습 니 다.
CGLib 에서 상기 목적 을 실현 하기 위해 주로 제공 하 는 클래스
1) Enhancer: setCallback (Callback), setSuperclass (Class), create () 는 동적 하위 클래스 오 브 젝 트 를 되 돌려 줍 니 다.
2) MethodInterceptor 가 구현 해 야 할 인터페이스: intercept (Object, Method, Object [], MethodProxy) 는 원래 방법 으로 호출 된 결 과 를 되 돌려 줍 니 다.프 록 시 원리 와 같다.
3. 이상 의 두 가지 간단 한 AOP 실현 방안 은 모두 당신 을 위해 준비 되 었 습 니 다. 당신 은 스스로 테스트 를 작성 할 수 있 습 니 다. 다음은 AOP 의 기본 개념 을 간단하게 소개 합 니 다.
1) aspect (절단면): cross - cutting 기능 을 실현 하고 절단면 을 위 한 모듈 입 니 다.가장 흔히 볼 수 있 는 것 은 logging 모듈 입 니 다. 그러면 프로그램 은 기능 에 따라 여러 층 으로 나 뉘 는데 전통 적 인 계승 에 따라 비 즈 니스 모델 계승 로그 모듈 은 아무런 의미 가 없습니다. logging 절단면 을 만 들 면 AOP 를 사용 하여 같은 기능 을 실현 할 수 있 습 니 다.
2) jointpoint (연결 점): 연결 점 은 절단면 이 프로그램 에 삽 입 된 곳 입 니 다. 이 점 은 방법 에 의 해 호출 될 수 있 고 의외 의 사고 도 발생 할 수 있 습 니 다.연결 점 은 응용 프로그램 이 절단면 에 삽입 하 는 곳 으로 새로운 방법 을 추가 할 수 있 습 니 다.예 를 들 어 상기 우리 의 접점 은 findInfo (String) 방법 이 라 고 볼 수 있다.
3) advice (처리 논리): advice 는 우리 의 절단면 기능 의 실현 으로 프로그램 에 새로운 행 위 를 알려 줍 니 다.예 를 들 어 logging 에서 logging advice 는 logging 의 실현 코드 를 포함 합 니 다. 예 를 들 어 로 그 를 한 파일 에 쓰 는 것 과 같 습 니 다.advice 는 jointpoint 에서 응용 프로그램 에 삽입 합 니 다.지금까지 MyHandler. java 에서 advice 기능 을 실 현 했 습 니 다.
4) pointcut (접점): pointcut 는 어떤 advice 를 jointpoint 에 적용 하 는 지 제어 할 수 있 습 니 다. 보통 pointcuts 를 사용 하여 정규 표현 식 을 통 해 뚜렷 한 이름과 패턴 을 일치 시 킵 니 다.그 조 인 트 포인트 가 결정 되면 통 지 를 받 을 겁 니 다.
5) introduction: 클래스 에 새로운 방법 과 속성 을 추가 할 수 있 습 니 다.
6) target (목표 클래스): advice 를 사용 할 클래스 를 말 하 며, 일반적으로 독립 된 비 즈 니스 모델 을 말한다.예 를 들 어 이상 의 Student InfoServiceImpl.
7) proxy (프 록 시 클래스): proxy 모드 를 사 용 했 습 니 다.advice 를 적용 한 대상 으로 target 대상 과 비슷 해 보 입 니 다.
8) weaving (삽입): aspects 를 사용 하여 target 대상 에 proxy 대상 을 만 드 는 과정 을 말 합 니 다: copie time, classload time, runtime
AOP 프로 그래 밍 의 단순 입문 은 여기까지 이 며, 이 글 이 독자 여러분 에 게 도움 이 되 기 를 바 랍 니 다.