AOP編程
1. AOP概念
AOP (Aspect Oriented Programing) 面向切面編程 = Spring動態代理開發 以切面爲基本單位的程序開發，通過切面間的彼此協同，相互調用，完成程序的構建 切面 = 切入點 + 額外功能
OOP (Object Oriented Programing) 面向對象編程 Java 以對象爲基本單位的程序開發，通過對象間的彼此協同，相互調用，完成程序的構建 POP (Procedure Oriented Programing) 面向過程(方法、函數)編程 C 以過程爲基本單位的程序開發，通過過程間的彼此協同，相互調用，完成程序的構建
aop的本質就是spring的動態代理開發
想要實現動態代理需要滿足三個條件：
- 目標對象
- 接口 代理對象和目標對象的相同接口
- 增強功能
AOP的底層實現原理
1. 核心問題
-
AOP如何創建動態代理類？(動態字節碼技術)
-
Spring工廠如何加工創建代理對象？通過原始對象的id值，獲得的是代理對象。
2. 動態代理類的創建
2.1 JDK的動態代理
TestJDKProxy.java
package proxy.jdk; import proxy.service.UserService; import proxy.service.impl.UserServiceImpl; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy;
public class TestJDKProxy { public static void main(String[] args) { //1.創建原始對象 //注意：由於後面匿名子類的方法中用到了userService，所以應該用final修飾 // 而JDK1.8以後默認加了final，不需要手動加 UserService userService = new UserServiceImpl(); //2.JDK創建代理對象 InvocationHandler handler = new InvocationHandler() {
/**
*proxy:代理對象
*method：額外功能要增加的原始方法
*args：原始方法的參數
*
**/ @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("----------- JDKProxy log -----------");\ //目標方法運行： Object ret = method.invoke(userService, args); return ret; } };
/**
*ClassLoader:類加載對象
*inerface：實現的接口（相同的接口）
*handler：額外增加的功能
*
**/
UserService userServiceProxy = (UserService) Proxy.newProxyInstance(userService.getClass().getClassLoader(), userService.getClass().getInterfaces(),handler);
userServiceProxy.login("海綿寶寶", "1111"); userServiceProxy.register(new User());
}
}
在InvocationHandler中invoke的方法中增加額外功能，程序在執行Proxy.newProxyInstance的過程中就是動態字節碼加載的過程(沒有代理類，這個過程就是通過動態字節碼技術在jvm內存中創建代理類，再通過ClassLoad類加載，繼而創建代理類對象)，借用的類加載器，借誰的都可以
2.2 CGlib動態代理
原理：
1.目標類
StudentService
package proxy.cglib; import proxy.service.User; public class StudentServiceImpl { public boolean login(String name,String password){ System.out.println("StudentService.login"); return true; } public void register(User user) { System.out.println("StudentService.register"); } }
2.測試類 Enhancer java中已經提供了
package com.yuziyan.cglib; import org.springframework.cglib.proxy.Enhancer; import org.springframework.cglib.proxy.MethodInterceptor; import org.springframework.cglib.proxy.MethodProxy; import java.lang.reflect.Method; public class TestCGlibProxy { public static void main(String[] args) { //1.創建原始對象 UserServiceImpl userService = new UserServiceImpl(); //2.通過CGlib創建代理對象 // 2.1 創建Enhancer Enhancer enhancer = new Enhancer(); // 2.2 設置借用類加載器 enhancer.setClassLoader(TestCGlibProxy.class.getClassLoader()); // 2.3 設置父類（目標類） enhancer.setSuperclass(userService.getClass()); // 2.4 設置回調，額外功能寫在裏面 enhancer.setCallback(new MethodInterceptor() { //相當於 InvocationHandler --> invoke() @Override public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable { //額外功能： System.out.println("========= CGlibProxy log ========"); //目標方法執行： Object ret = method.invoke(userService, objects); return ret; } }); // 2.5 通過Enhancer對象創建代理 UserServiceImpl service = (UserServiceImpl) enhancer.create(); //測試： service.register(); service.login(); } }
jdk和cglib的本質不同
1. JDK動態代理 Proxy.newProxyInstance() 通過目標類實現的接口創建代理類
2. Cglib動態代理 Enhancer 通過繼承目標類創建代理類
3. Spring工廠如何返回代理對象
- 思路分析：
![]()
編碼模擬：
public class ProxyBeanPostProcessor implements BeanPostProcessor { @Override public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { return bean; } @Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { InvocationHandler invocation = new InvocationHandler() { @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("----------- 模擬Spring返回代理對象的方式 log -----------"); Object ret = method.invoke(bean, args); return ret; } }; return Proxy.newProxyInstance(ProxyBeanPostProcessor.class.getClassLoader(), bean.getClass().getInterfaces(), invocation); } }
配置文件
<!-- 1.配置原始對象 --> <bean id="userService" class="com.yuziyan.factory.UserServiceImpl"></bean> <!-- 2.配置自己模擬的ProxyBeanPostProcessor --> <bean id="proxyBeanPostProcessor" class="com.yuziyan.factory.ProxyBeanPostProcessor"/>
爲什麼從spring容器中拿原始id的值，獲取的是代理對象
因爲是通過BeanPostProcessor方式拿到的
基於註解的AOP編程
1. 開發步驟：
-
原始對象
-
額外功能
-
切入點
-
組裝切面
/** * 聲明切面類 @Aspect * 定義額外功能 @Around * 定義切入點 @Around("execution(* login(..))") * */ @Aspect public class MyAspect { @Around("execution(* login(..))")//組裝了切入點和額外功能 public Object around(ProceedingJoinPoint joinPoint) throws Throwable { //額外功能： System.out.println("--------- 基於註解的AOP編程 log --------"); //原始方法執行： Object ret = joinPoint.proceed(); return ret; } }
配置文件
<!-- 原始對象 --> <bean id="userService" class="com.yuziyan.aspect.UserServiceImpl"></bean> <!-- 切面 --> <bean id="myAspect" class="com.yuziyan.aspect.MyAspect"/> <!-- 開啓基於註解的AOP編程 --> <aop:aspectj-autoproxy/>
2. 細節分析：
-
切入點複用：
@Aspect public class MyAspect { /** * 切入點複用：定義一個函數，加上@Pointcut註解，通過該註解的value定義切入點表達式，以後可以複用。 */ @Pointcut("execution(* login(..))") public void myPointcut(){} @Around("myPointcut()")//組裝了切入點和額外功能 public Object around(ProceedingJoinPoint joinPoint) throws Throwable { //額外功能： System.out.println("--------- 基於註解的AOP編程 log --------"); //原始方法執行： Object ret = joinPoint.proceed(); return ret; } @Around("myPointcut()") public Object around1(ProceedingJoinPoint joinPoint) throws Throwable { //額外功能： System.out.println("--------- 基於註解的AOP編程 tx --------"); //原始方法執行： Object ret = joinPoint.proceed(); return ret; } }
動態代理的創建方式：
AOP底層實現 2種代理創建方式 1. JDK 通過實現接口，創建代理對象 2. Cglib 通過繼承目標類，創建代理對象 默認情況 AOP編程 底層應用JDK動態代理創建方式 如果要切換Cglib 1. 基於註解AOP開發 <aop:aspectj-autoproxy proxy-target-class="true" /> 2. 傳統的AOP開發 <aop:config proxy-target-class="true"> </aop>
AOP開發中的一個坑
坑：在同一個業務類中，業務方法間相互調用時，只有最外層的方法,加入了額外功能(內部的方法，通過普通的方式調用，運行的都是原始方法)。如果想讓內層的方法也調用代理對象的方法，就要實現AppicationContextAware獲得工廠，進而獲得代理對象。
一個調用的是原始對象，一個是代理對象，spring的aop只會對代理對象有效
public class UserServiceImpl implements UserService, ApplicationContextAware { private ApplicationContext ctx; @Override public void setApplicationContext(ApplicationContext applicationContext) throws BeansException { this.ctx = applicationContext; } @Log @Override public void register(User user) { System.out.println("UserServiceImpl.register 業務運算 + DAO "); //throw new RuntimeException("測試異常"); //調用的是原始對象的login方法 ---> 核心功能 /* 設計目的：代理對象的login方法 ---> 額外功能+核心功能 ApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext2.xml"); UserService userService = (UserService) ctx.getBean("userService"); userService.login(); Spring工廠重量級資源 一個應用中 應該只創建一個工廠 */ UserService userService = (UserService) ctx.getBean("userService"); userService.login("suns", "123456"); } @Override public boolean login(String name, String password) { System.out.println("UserServiceImpl.login"); return true; } }
AOP階段知識總結
