本文详细介绍了Spring AOP的概念、应用场合、作用及术语，解析了AOP的实现原理，包括静态代理和动态代理（JDK与CGLIB）。此外，还探讨了Spring中的通知类型以及基于ProxyFactoryBean的AOP实现。最后提到了AspectJ的声明式AOP应用。
- AOP
一、简介
1.1概念
AOP：将程序中交叉业务逻辑（一条插入语句还要有）（事务、日志）代码提取出来，封装成切面，由AOP容器在适当时机（位置）将封装的切面动态的植入到具体业务逻辑中
1.2应用场合
适用于具有横切逻辑的场合，如事务管理、日志记录、性能检测、异常通知、访问控制
1.3作用
不改变原来代码的基础上动态添加新的功能
模块化（每一层都要做相同的事务，封装在一起形成一个模块）
1.4术语
连接点：程序执行的某个特定位置，如方法调用前，方法调用后，方法抛出异常时
切入点：定位查找到需要的连接点，即切点
增强Advice:通知 在切入点执行的一段程序代码，用来实现某些功能
目标对象：将执行增强处理的目标类
织入：将增强添加到目标类具体切入点上的过程
代理： 一个类被织入增强后，会产生一个代理类
切面：切点和增强的组合
引介：引入
二、实现原理
2.1代理模式
概念：为其他对象提供一种代理，以控制对这个对象的访问，起到中介的作用，通过代理对象访问目标对象，可以增强额外的操作，扩展目标对象功能。
分类：
1、静态代理：
代理类是程序员创建或工具生成。
所谓静态代理就是在程序运行之前就已经存在代理类的字节码文件
代理的三要素：
1、目标类的接口
Public class UserServiceProxy implements UserService
UserServiceImpl里实现的方法，UserServiceProxy里都有这些方法并且进行了增强
2、目标类的实例
Private UserService userService=new UserServiceImpl();
要想实现它的功能，得先new一个实例出来
3、交叉业务逻辑，要执行的操作
缺点：代理对象需要和目标对象相同的接口，如果接口增加方法，目标对象和代理对象都要维护。
2、动态代理
代理类是程序在运行期间有JVM根据反射等机制动态生成的，自动生成代理类和代理对象。
所谓动态就是在程序运行前不存在代理类的字节码文件
动态代理的两种技术
- JDK动态代理
Proxy.newProxyInstance{
classLoader,//目标类的类加载器
interface,//目标类的接口列表
InvocationHandler//交叉业务逻辑
}
缺点：目标对象必须实现一个或多个接口，如果没有实现任何接口，则无法使用jdk的动态代理，此时可以用cglib
（1）创建接口UserDao,并在该接口中编写添加和删除的方法
package com.itheima.jdk;
public interface UserDao {
public void addUser();
public void deleteUser();
}
（2）创建接口的实现类UserDaoImpl,分别实现接口中的方法，并在每个方法中添加一条输出语句
package com.itheima.jdk;
import org.springframework.stereotype.Repository;
public class UserDaoImpl implements UserDao {
public void addUser() {
System.out.println("添加用户");
}
public void deleteUser() {
System.out.println("删除用户");
}
}
（3）创建aspect包，创建切面类MyAspect,在该类中定义一个模拟权限检查的方法和一个模拟记录日志的方法，这两个方法就表示切面中的通知。
package com.itheima.aspect;
//切面类：可以存在多个通知（即增强的方法）
public class MyAspect {
public void check_Permissions(){
System.out.println("模拟检查");
}
public void log(){
System.out.println("模拟记录日志");
}
}
（4）创建代理类JdkProxy,该类需要实现InvocationHandler接口，并编写代理方法。在代理方法中，需要通过Proxy类实现动态代理
ackage com.itheima.jdk;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import com.itheima.aspect.MyAspect;
public class JdkProxy implements InvocationHandler {
//声明目标类接口
private UserDao userDao;
//创建代理方法
public Object createProxy(UserDao userDao){
this.userDao=userDao;
//1.类加载器
ClassLoader classLoader=JdkProxy.class.getClassLoader();
//2.被代理对象实现的所有接口
Class<?>[]clazz = userDao.getClass().getInterfaces();
//使用代理类，进行增强，返回的是代理后的对象
return Proxy.newProxyInstance(classLoader, clazz, this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// TODO Auto-generated method stub
//声明切面
MyAspect myAspect = new MyAspect();
//前切面
myAspect.check_Permissions();
//在目标类上调用方法，并传入参数
Object obj=method.invoke(userDao, args);
//后增强
myAspect.log();
return obj;
}
}
在创建的代理方法createProxy()中，使用了Proxy类的newProxyInstance()方法来创建代理对象。该方法包含3个参数，其中第一个是当前类的类加载器，第二个参数表示的是被代理对象实现的所有接口，第三个参数this代表的就是代理类JdkProxy本身。
（5）创建测试类JdkTest
package com.itheima.jdk;
public class JdkTest {
public static void main(String[] args) {
//创建代理对象
JdkProxy jdkProxy=new JdkProxy();
//创建目标对象
UserDao userDao=new UserDaoImpl();
//从代理对象中获取增强后的目标对象
UserDao userDao1 =(UserDao)jdkProxy.createProxy(userDao);
userDao1.addUser();
userDao1.deleteUser();
}
}
这种实现了接口的代理方式，就是Spring中的动态代理
2、CGLB动态代理
包装没有实现接口的类，采用非常底层的字节码技术，对指定的目标类生成一个子类，并对子类进行增强。
实现过程：
（1）创建目标类UserDao
package com.itheima.cglib;
public class UserDao {
public void addUser(){
System.out.println("添加用户");
}
public void deleteUser(){
System.out.println("删除用户");
}
}
(2)创建代理类CglibProxy，该代理类需要实现MethodInterceptor接口，并实现接口中的intercept()方法
package com.itheima.cglib;
import java.lang.reflect.Method;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import com.itheima.aspect.MyAspect;
public class CglibProxy implements MethodInterceptor {
//代理方法
public Object createProxy(Object target){
//创建一个动态类对象
Enhancer enhancer = new Enhancer();
//确定需要增强的类，实现其父类
enhancer.setSuperclass(target.getClass());
//添加回调函数
enhancer.setCallback(this);
//返回创建的代理类
return enhancer.create();
}
@Override
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
// TODO Auto-generated method stub
//创建切面类对象
MyAspect myAspect=new MyAspect();
//前增强
myAspect.check_Permissions();
//目标方法执行
Object obj=methodProxy.invokeSuper(proxy, args);
//后增强
myAspect.log();
return obj;
}
首先创建了一个动态类对象Enhancer,它是CGLIB的核心类，然后调用的Enhancer类的setSuperclass()方法来确定目标对象；接下来调用了setCallback()方法添加回调函数，其中this代表的就是代理类CglibProxy本身；最后通过return语句将创建的代理类返回，intercept()方法会在程序执行目标方法时被调用，方法运行时将会执行切面类中的增强方法。
（3）创建测试类CglibTest
package com.itheima.cglib;
public class CglibTest {
public static void main(String[] args) {
//创建代理对象
CglibProxy cglibProxy = new CglibProxy();
//创建目标对象
UserDao userDao=new UserDao();
//获取增强后的目标对象
UserDao userDao1=(UserDao) cglibProxy.createProxy(userDao);
//执行方法
userDao1.addUser();
userDao1.deleteUser();
}
}
(4)运行结果
这种没有实现接口的代理方式，就是CGLIB代理
三、基于代理类的AOP实现
默认使用JDK动态代理
1、Spring的通知类型
Spring的通知按照在目标类方法的连接点位置，可以分为以下5种类型
- org.aopalliance.intercept.MethodInterceptor(环绕通知)----目标方法执行前后执行，日志、事务管理
- org.aopalliance.intercept.MethodBeforeAdvice(前置通知)----目标方法执行前，权限管理
- org.aopalliance.intercept.AfterReturningAdvice(后置通知)----目标方法执行后，关闭流、上传文件、删除临时文件
- org.aopalliance.intercept.ThrowsAdvice(异常通知)----在方法抛出异常后实施增强，处理异常记录日志
- org.aopalliance.intercept.IntroductionInterceptor(引介通知)----在目标类中添加一些新的方法和属性
2、ProxyFactoryBean
ProxyFactoryBean是FactoryBean接口的实现类，FactoryBean负责实例化一个Bean,而 ProxyFactoryBean负责为其它Bean创建代理实例
| 属性名称 | 描述 |
| target | 代理的目标对象 |
| proxyInterfaces | 代理要实现的接口，可以是多个接口 |
| proxyTargetClass | 是否对类代理而不是接口，设置为true时，使用CGLIB代理 |
| interceptorNames | 需要织入目标的Advice |
| singleton | 返回的代理是否为单实例，默认为true |
| optimize | 当设置为true时，强制使用CGLIB |
实现过程：
（1）创建切面类MyAspect,实现环绕通知，所以要实现org.aopalliance.intercept.MethodInterceptor接口，并实现接口中的invoke()方法
package com.itheima.factorybean;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
//切面类
public class MyAspect implements MethodInterceptor {
@Override
public Object invoke(MethodInvocation mi) throws Throwable {
check_Permissions();
//执行目标方法
Object obj=mi.proceed();
log();
return obj;
}
public void check_Permissions() {
System.out.println("模拟检查权限...");
}
public void log() {
System.out.println("模拟日志记录...");
}
}
（2）创建配置文件，指定代理对象
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.3.xsd">
<!-- 1、目标类 -->
<bean id="userDao" class="com.itheima.jdk.UserDaoImpl"/>
<!-- 2、切面类 -->
<bean id="myAspect" class="com.itheima.factorybean.MyAspect"/>
<!-- 3 使用Spring代理工厂定义一个名称为userDaoProxy的代理对象 -->
<bean id="userDaoProxy"
class="org.springframework.aop.framework.ProxyFactoryBean">
<!-- 3.1指定实现代理类的接口 -->
<property name="proxyInterfaces" value="com.itheima.jdk.UserDao"/>
<!-- 3.2指定目标对象 -->
<property name="target" ref="userDao"/>
<!-- 3.3指定切面，植入环绕通知 -->
<property name="interceptorNames" value="myAspect"/>
<!-- 3.4指定代理方式，true:使用cglib,false（默认）：使用jdk动态代理 -->
<property name="proxyTargetClass" value="true"/>
</bean>
</beans>
（3）测试类
package com.itheima.factorybean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.itheima.jdk.UserDao;
public class ProxyFactoryBeanTest {
public static void main(String[] args) {
String xmlPath="com/itheima/factorybean/applicationContext.xml";
ApplicationContext applicationContext=new ClassPathXmlApplicationContext(xmlPath);
UserDao userDao=(UserDao) applicationContext.getBean("userDaoProxy");
userDao.addUser();
userDao.deleteUser();
}
（4）输出结果
四、AspectJ开发
使用AspectJ实现AOP有两种方式：一种是基于XML的声明式AspectJ,另一种是基于注解声明式AspectJ
1、基于XML的声明式AspectJ
扫一扫
614
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
