Spring 프레임 워 크 학습 의 AOP 상세 설명
1.절단면 프로 그래 밍(방면)을 대상 으로 AOP 를 이용 하여 업무 논리의 각 부분 을 격 리 시 켜 업무 논리의 각 부분 간 의 결합 도 를 낮 추고 프로그램의 중용 성 을 높 일 수 있 으 며 개발 의 효율 을 높 일 수 있다.
2.일반적인 설명:원본 코드 를 수정 하지 않 고 메 인 기능 에 새로운 기능 을 추가 합 니 다.
2.바 텀 원리:동적 대리
두 가지 상황 이 있 습 니 다.동적 대리.
2.1 인터페이스,JDK 동적 에이전트
1.대리 대상
public class UserDaoImpl implements UserDao {
@Override
public int add(int a, int b) {
System.out.println("add ");
return a + b;
}
@Override
public String update(String id) {
System.out.println("update ");
return id;
}
}
package cn.zj.proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;
import cn.zj.dao.UserDao;
import cn.zj.dao.impl.UserDaoImpl;
public class JDKProxy {
public static void main(String[] args) {
//
Class[] interfaces = { UserDao.class };
UserDaoImpl userDao = new UserDaoImpl();
UserDao dao = (UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces,
new UserDaoProxy(userDao));
int result = dao.add(1, 2);
System. out .println( "result:"+result);
}
}
//
class UserDaoProxy implements InvocationHandler {
private Object target;//
public UserDaoProxy(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//
System.out.println(" .." + method.getName() + "; :" + Arrays.toString(args));
//
Object res = method.invoke(target, args);
//
System.out.println(" .." + target);
return res;
}
}
..add; :[1, 2]
add
..cn.zj.dao.impl.UserDaoImpl@6c629d6e
result:31.대리 대상
public class Cat {
public void eat() {
System.out.println(" ");
}
}
public class CglibProxy {
public static void main(String[] args) {
Cat c = new CglibProxy().createProxyObject(Cat.class);
c.eat();
}
// JDK ，cglib
public Cat createProxyObject(Class clazz) {
// 1. Enhance
//
Enhancer enhancer = new Enhancer();
// 2. ， ， ――――
enhancer.setSuperclass(clazz);
// 3.
//
//
Callback callback = new MethodInterceptor() {
// proxy:
// method:
// args:
// methodProxy:
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy)
throws Throwable {
//
System.out.println(" ");
// Object obj=method.invoke(proxy, args);// , ,
//
// Object obj = methodProxy.invokeSuper(proxy, args);//
// Object obj=method.invoke(proxy, args);
Object res = methodProxy.invokeSuper(proxy, args);
System.out.println(" ");
return res;
}
};
enhancer.setCallback(callback);
// 4.
Object proxyObj = enhancer.create();
return (Cat) proxyObj;
}
}
1.연결 점(Joinpoint)
클래스 의 임 의 방법 이 실 행 될 때 클래스 의 방법,즉 강화 할 수 있 는 방법 으로 간단하게 이해 할 수 있다 는 것 을 나타 낸다.
2.삽입점(Pointcut)
공통성 기능 을 가 진 방법의 운행 은 공통성 기능 을 가 진 방법,즉 실제 강 화 된 방법 으로 간단하게 이해 할 수 있 음 을 나타 낸다.
메모:접점 에 대응 하 는 것 은 공통성 기능 을 파 낸 후의 방법 이 실 행 될 때 단언(형식)과 일치 합 니 다.
3.알림/강화(조언)
공통성 기능 모듈 화 는 공통성 기능 을 추출 하여 독립 적 인 방법 으로 만 들 고 실제 강 화 된 논리 부분 으로 간단하게 이해 할 수 있다.
유형:전치,전치,이상,최종,서 라운드
4.절단면(가로)
접점 과 통지 의 대응 관 계 는 추출 된 공통성 기능 과 공통성 기능 이 추출 된 위치 에 대응 하 는 방법 간 의 관 계 를 간단하게 이해 하고 통 지 를 접점 에 응용 하 는 과정 으로 이해 할 수 있다.
5.대상(대상)
착안점 의 운행 대상 을 포함 하고 개발 단 계 는 목표 대상 에 대응 하 는 클래스 를 제작한다
6.AOP 에이전트(AOP 프 록 시)
AOP 의 프 록 시 메커니즘 을 사용 하여 대상 이 실 행 될 때 프 록 시 대상 을 만 들 고 원본 기능 을 수행 합 니 다.
주의:원시 목표 대상 은 이미 공통 기능 을 파 헤 쳤 습 니 다.이때 목표 대상 을 사용 하여 임 무 를 수행 하면 원시 임 무 를 완성 할 수 없습니다.AOP 대리 체 제 를 사용 하여 원시 목표 대상 의 기능 을 수행 하기 위해 대리 대상 을 만 듭 니 다.
7.뜨개질(Weaving)
알림 기능 을 원본 바이트 코드 에 추가 하 는 동적 과정 으로 목표 클래스 에 대한 구체 적 인 연결 점 을 추가 하 는 과정 입 니 다.
Spring 은 실행 시 짜 임 메커니즘 을 사용 합 니 다.
8.도입(소개)
하나의 바이트 코드 의 동적 인 변수 나 방법 을 추가 할 수 있 는 특수 한 메커니즘
조작
4.1 Spring 프레임 워 크 는 보통 AspectJ 를 바탕 으로 AOP 를 실현 합 니 다.
AspectJ 는 Spring 구성 부분 이 아니 라 AOP 프레임 워 크 를 독립 적 으로 사용 합 니 다.보통 AspectJ 와 Spirng 프레임 워 크 를 함께 사용 합 니 다.
사용,AOP 조작 진행
4.2 실천
1.jar 패키지 도입
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>5.3.6</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>5.3.6</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.3.6</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-expression -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-expression</artifactId>
<version>5.3.6</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-aop -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>5.3.6</version>
</dependency>
<!-- https://mvnrepository.com/artifact/commons-logging/commons-logging -->
<dependency>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
<version>1.2</version>
</dependency>
<!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.2.6</version>
</dependency>
<!-- @Resource -->
<dependency>
<groupId>javax.annotation</groupId>
<artifactId>javax.annotation-api</artifactId>
<version>1.3.1</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-aspects -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
<version>5.3.6</version>
</dependency>
<!-- https://mvnrepository.com/artifact/net.sourceforge.cglib/com.springsource.net.sf.cglib -->
<dependency>
<groupId>net.sourceforge.cglib</groupId>
<artifactId>com.springsource.net.sf.cglib</artifactId>
<version>2.2.0</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.aopalliance/com.springsource.org.aopalliance -->
<dependency>
<groupId>org.aopalliance</groupId>
<artifactId>com.springsource.org.aopalliance</artifactId>
<version>1.0.0</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.aspectj/com.springsource.org.aspectj.weaver -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>com.springsource.org.aspectj.weaver</artifactId>
<version>1.6.8.RELEASE</version>
</dependency>
</dependencies>
역할:어떤 종류의 어떤 방법 을 강화 하 는 지 알 고 있다.
문법 구조:execution([권한 수정자][반환 유형][클래스 전체 경로]방법 이름)
예 1:com.zj.dao.bookdao 류 의 add 를 강화 합 니 다.
execution(* com.zj.dao.BookDao.add(…))
예 2:com.zj.dao.bookdao 류 의 모든 방법 을 강화 합 니 다.
execution(* com.zj.dao.BookDao.* (…))
예 3:com.zj.dao 가방 안의 모든 종류,클래스 안의 모든 방법 을 강화 합 니 다.
execution(* com.zj.dao.. (…))
3.xml 방식
1.클래스 생 성
package cn.zj.aop.xml;
public class Book {
public void buy() {
System.out.println("buy.............");
}
}
package cn.zj.aop.xml;
public class BookProxy {
public void before() {
System.out.println("before.........");
}
}
<?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:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
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.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
<!-- -->
<bean id="book" class="cn.zj.aop.xml.Book"></bean>
<bean id="bookProxy" class="cn.zj.aop.xml.BookProxy"></bean>
<!-- aop -->
<aop:config>
<!-- -->
<aop:pointcut id="p" expression="execution(* cn.zj.aop.xml.Book.buy(..))"/>
<!-- -->
<aop:aspect ref="bookProxy">
<!-- -->
<aop:before method="before" pointcut-ref="p"/>
</aop:aspect>
</aop:config>
</beans>
1.클래스 생 성
public class User {
public void add() {
System.out.println("add.......");
}
}
package cn.zj.aop.an;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
//
@Component
@Aspect //
public class UserProxy {
//
@Before(value = "execution(* cn.zj.aop.an.User.add(..))")
public void before() {
System.out.println("before.........");
}
// （ ）
@AfterReturning(value = "execution(* cn.zj.aop.an.User.add(..))")
public void afterReturning() {
System.out.println("afterReturning.........");
}
//
@After(value = "execution(* cn.zj.aop.an.User.add(..))")
public void after() {
System.out.println("after.........");
}
//
@AfterThrowing(value = "execution(* cn.zj.aop.an.User.add(..))")
public void afterThrowing() {
System.out.println("afterThrowing.........");
}
//
@Around(value = "execution(* cn.zj.aop.an.User.add(..))")
public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
System.out.println(" .........");
//
proceedingJoinPoint.proceed();
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:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
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.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
<!-- -->
<context:component-scan base-package="cn.zj.aop.an"></context:component-scan>
<!-- Aspect -->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>
ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
User user = context.getBean("user", User.class);
user.add();
//
@Pointcut(value = "execution(* cn.zj.aop.an.User.add(..))")
public void pointdemo() {
}
//
//@Before
@Before(value = "pointdemo()")
public void before() {
System.out.println("before.........");
}
증강 클래스 에 주석@Order(디지털 형식 값)를 추가 하면 디지털 형식 값 이 작 을 수록 우선 순위 가 높 습 니 다.
@Component
@Aspect
@Order(1)
public class PersonProxy {
// （ ）
@Before(value = "execution(* cn.zj.aop.an.User.add(..))")
public void afterReturning() {
System.out.println("Person Before.........");
}
}
//
@Component
@Aspect //
@Order(2)
public class UserProxy {
이 내용에 흥미가 있습니까?
현재 기사가 여러분의 문제를 해결하지 못하는 경우 AI 엔진은 머신러닝 분석(스마트 모델이 방금 만들어져 부정확한 경우가 있을 수 있음)을 통해 가장 유사한 기사를 추천합니다:
[MeU] Hashtag 기능 개발➡️ 기존 Tag 테이블에 존재하지 않는 해시태그라면 Tag , tagPostMapping 테이블에 모두 추가 ➡️ 기존에 존재하는 해시태그라면, tagPostMapping 테이블에만 추가 이후에 개발할 태그 기반 ...
텍스트를 자유롭게 공유하거나 복사할 수 있습니다.하지만 이 문서의 URL은 참조 URL로 남겨 두십시오.
CC BY-SA 2.5, CC BY-SA 3.0 및 CC BY-SA 4.0에 따라 라이센스가 부여됩니다.
좋은 웹페이지 즐겨찾기
