AOP分类及其实现原理
程序员文章站
2022-03-30 21:12:42
...
- 编译期AOP
在编译阶段就可生成 AOP代理类，在java编译期采用特殊的编译期，将切面织如java类中。 - 类加载期AOP
在类加载期，通过特殊的类加载器，在类字节码加载到JVM时，织入切面。 - 运行期AOP
在运行期，采用gclib工具或者jdk动态代理进行切面织入。
AspectJ采用编译期织入和类加载期织入的方式织入切面，第一种采用特殊编译器，在编译期将采用aspectJ语言编写的切面织入到java类中，第二种方式是采用织入器类包，代理java默认的类加载器，并通过在aop.xml文件中指定切面类和和需要进行切面织入的目标类，最终实现类加载期织入。
aspectj的类加载期织入的实现方式：
AOP中的术语
Join Point(连接点):join point就是一个方法，类中的每一个方法都可以称作为一个连接点。
Pointcut(切入点):满足指定条件的连接点就是切入点，例如在spring配置文件中，通过设置切点表达式指定对相应的方法进行增强。
Advice(增强):在join point上特定的时刻执行的操作。
Aspect(切面):组合了Pointcut与Advice，切点+增强构成切面。
Weaving：将Advice织入join point的这个过程。
Advice的类型：
- Before advice: 在join point之前执行的advice,但是它不能阻止joint point的执行流程，除非抛出了一个异常（exception）。
- After returning advice: 在join point这个方法返回之后执行的advice。
- After throwing advice: 在join point抛出异常之后执行的advice。
- After(finally) advice: 在join point返回之后或者抛出异常之后执行的advice，通常用来释放所使用的资源。
- Around advice: 在join point这个方法执行之前与之后执行的advice。
Spring AOP基于代理实现，默认使用jdk动态代理，这也是为什么spring提倡面向接口编程，因为jdk动态代理，需要目标类实现接口，且只能代理接口中的方法，无法代理类中特有方法，要克服这一局限，需要采用cglib来实现动态代理。如果目标类实现了接口，spring使用jdk动态代理，如果没有实现接口，spring使用cglib，spring会自动在CGLIB和JDK动态代理之间切换 。
注：jdk动态代理和cglib都是在运行时动态扩展java类。
AOP有什么作用呢？
当我们需要为多个对象引入一个公共行为，比如日志，操作记录，事务，性能检测等，就需要在每个对象中引用公共行为，这样程序就产生了大量的重复代码，使用AOP可以完美解决这个问题。
动态代理
静态代理的代理类是我们自己定义的，而动态代理的代理类是在运行期自动生成的。如果我们需要在代理类的所有方法中增加公共的操作，如果方法太多的话，我们需要对每个方法都进行修改，重复代码多，而且耦合性高。但是，采用动态代理就可以解决这些问题。举例如下：
public interface Person {
//定义一个Person接口，里面只有一个方法
void reportWork();
}
这里以汇报工作为例，每个员工需要汇报工作，但不是直接向老板汇报工作，而是通过一个代理部门主管。
public class Employee implements Person{
private String name;
public Employee(String name){
this.name=name;
}
void reportWork(){
System.out.println(name+"汇报:xxxxxxxxx"+);
}
}
public class WorkInvocationHandler<T> implements InvocationHandler{
T target;
public WorkInvocationHandler(T target){
this.target=target;
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
{
System.out.println("代理执行" +method.getName() + "方法");
Object result = method.invoke(target, args);
return result;
}
}
public class ProxyTest {
public static void main(String[] args) {
//创建一个实例对象，这个对象是被代理的对象
Person p = new Worker("劳模1");
//创建一个与代理对象相关联的InvocationHandler
InvocationHandler wokerHandler = new WorkerInvocationHandler<Person>(p);
//创建一个代理对象proxy
Person proxy = (Person) Proxy.newProxyInstance(Person.class.getClassLoader(), new Class<?>[]{Person.class}, workerHandler);
//代理执行方法
proxy.reportWork();
}
}
Proxy类的newProxyInstance方法创建了一个动态代理对象，看一下他的源码：
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
throws IllegalArgumentException
{
Objects.requireNonNull(h);
final Class<?>[] intfs = interfaces.clone();
final SecurityManager sm = System.getSecurityManager();
if (sm != null) {
checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
}
/*
* Look up or generate the designated proxy class.
*/
Class<?> cl = getProxyClass0(loader, intfs);
/*
* Invoke its constructor with the designated invocation handler.
*/
try {
if (sm != null) {
checkNewProxyPermission(Reflection.getCallerClass(), cl);
}
final Constructor<?> cons = cl.getConstructor(constructorParams);
final InvocationHandler ih = h;
if (!Modifier.isPublic(cl.getModifiers())) {
AccessController.doPrivileged(new PrivilegedAction<Void>() {
public Void run() {
cons.setAccessible(true);
return null;
}
});
}
return cons.newInstance(new Object[]{h});
} catch (IllegalAccessException|InstantiationException e) {
throw new InternalError(e.toString(), e);
} catch (InvocationTargetException e) {
Throwable t = e.getCause();
if (t instanceof RuntimeException) {
throw (RuntimeException) t;
} else {
throw new InternalError(t.toString(), t);
}
} catch (NoSuchMethodException e) {
throw new InternalError(e.toString(), e);
}
}
Class<?> cl = getProxyClass0(loader, intfs)这句代码，这里产生了代理类,对这个class文件进行反编译，我们看看jdk为我们生成了什么样的内容：
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
import proxy.Person;
public final class $Proxy0 extends Proxy implements Person
{
private static Method m1;
private static Method m2;
private static Method m3;
private static Method m0;
/**
*注意这里是生成代理类的构造方法，方法参数为InvocationHandler类型，看到这，是不是就有点明白
*为何代理对象调用方法都是执行InvocationHandler中的invoke方法，而InvocationHandler又持有一个
*被代理对象的实例，就可以去调用真正的对象实例。
*/
public $Proxy0(InvocationHandler paramInvocationHandler)
throws
{
super(paramInvocationHandler);
}
//这个静态块本来是在最后的，我把它拿到前面来，方便描述
static
{
try
{
//看看这儿静态块儿里面的住giveTask通过反射得到的名字m3，其他的先不管
m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
m3 = Class.forName("proxy.Person").getMethod("reportWork", new Class[0]);
m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
return;
}
catch (NoSuchMethodException localNoSuchMethodException)
{
throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
}
catch (ClassNotFoundException localClassNotFoundException)
{
throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
}
}
/**
*
*这里调用代理对象的giveMoney方法，直接就调用了InvocationHandler中的invoke方法，并把m3传了进去。
*this.h.invoke(this, m3, null);我们可以对将InvocationHandler看做一个中介类，中介类持有一个被代理对象，在invoke方法中调用了被代理对象的相应方法。通过聚合方式持有被代理对象的引用，把外部对invoke的调用最终都转为对被代理对象的调用。
*/
public final void reportWork()
throws
{
try
{
this.h.invoke(this, m3, null);
return;
}
catch (Error|RuntimeException localError)
{
throw localError;
}
catch (Throwable localThrowable)
{
throw new UndeclaredThrowableException(localThrowable);
}
}
}
AOP创建代理的源码分析
protected Object createProxy(
Class<?> beanClass, String beanName, Object[] specificInterceptors, TargetSource targetSource) {
if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
}
// 1.创建proxyFactory，proxy的生产主要就是在proxyFactory做的
ProxyFactory proxyFactory = new ProxyFactory();
proxyFactory.copyFrom(this);
if (!proxyFactory.isProxyTargetClass()) {
if (shouldProxyTargetClass(beanClass, beanName)) {
proxyFactory.setProxyTargetClass(true);
}
else {
evaluateProxyInterfaces(beanClass, proxyFactory);
}
}
// 2.将当前bean适合的advice，重新封装下，封装为Advisor类，然后添加到ProxyFactory中
Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
for (Advisor advisor : advisors) {
proxyFactory.addAdvisor(advisor);
}
proxyFactory.setTargetSource(targetSource);
customizeProxyFactory(proxyFactory);
proxyFactory.setFrozen(this.freezeProxy);
if (advisorsPreFiltered()) {
proxyFactory.setPreFiltered(true);
}
// 3.调用getProxy获取bean对应的proxy
return proxyFactory.getProxy(getProxyClassLoader());
}
这里的TargetSource有什么用？
TargetSource被用于获取当前MethodInvocation(方法调用)所需要的target(目标对象),这个target通过反射的方式被调用(如:method.invode(target,args))。换句话说,proxy(代理对象)代理的不是target,而是TargetSource,这点非常重要!!!
https://blog.csdn.net/shenchaohao12321/article/details/85538163
//该方法决定采用JDK还是采用CGLIB
public Object getProxy(ClassLoader classLoader) {
return createAopProxy().getProxy(classLoader);
}
// createAopProxy()方法就是决定究竟创建何种类型的proxy
protected final synchronized AopProxy createAopProxy() {
if (!this.active) {
activate();
}
// 关键方法createAopProxy()
return getAopProxyFactory().createAopProxy(this);
}
// createAopProxy()
public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
// 1.config.isOptimize()是否使用优化的代理策略，目前使用与CGLIB
// config.isProxyTargetClass() 是否目标类本身被代理而不是目标类的接口
// hasNoUserSuppliedProxyInterfaces()是否存在代理接口
if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
Class<?> targetClass = config.getTargetClass();
if (targetClass == null) {
throw new AopConfigException("TargetSource cannot determine target class: " +
"Either an interface or a target is required for proxy creation.");
}
// 2.如果目标类是接口类（目标对象实现了接口），则直接使用JDKproxy
if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
return new JdkDynamicAopProxy(config);
}
// 3.其他情况则使用CGLIBproxy
return new ObjenesisCglibAopProxy(config);
}
else {
return new JdkDynamicAopProxy(config);
}
}
final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable
// JdkDynamicAopProxy类结构，由此可知，其实现了InvocationHandler，则必定有invoke方法，来被调用，也就是用户调用bean相关方法时，此invoke()被真正调用
// getProxy()
public Object getProxy(ClassLoader classLoader) {
if (logger.isDebugEnabled()) {
logger.debug("Creating JDK dynamic proxy: target source is " + this.advised.getTargetSource());
}
Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
// JDK proxy 动态代理的标准用法
return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
}
//使用了JDK动态代理模式，真正的方法执行在invoke()方法里，看到这里在想一下上面动态代理的例子，是不是就完全明白Spring源码实现动态代理的原理了。
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
MethodInvocation invocation;
Object oldProxy = null;
boolean setProxyContext = false;
TargetSource targetSource = this.advised.targetSource;
Class<?> targetClass = null;
Object target = null;
try {
// 1.以下的几个判断，主要是为了判断method是否为equals、hashCode等Object的方法
if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
// The target does not implement the equals(Object) method itself.
return equals(args[0]);
}
else if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
// The target does not implement the hashCode() method itself.
return hashCode();
}
else if (method.getDeclaringClass() == DecoratingProxy.class) {
// There is only getDecoratedClass() declared -> dispatch to proxy config.
return AopProxyUtils.ultimateTargetClass(this.advised);
}
else if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
method.getDeclaringClass().isAssignableFrom(Advised.class)) {
// Service invocations on ProxyConfig with the proxy config...
return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
}
Object retVal;
if (this.advised.exposeProxy) {
// Make invocation available if necessary.
oldProxy = AopContext.setCurrentProxy(proxy);
setProxyContext = true;
}
// May be null. Get as late as possible to minimize the time we "own" the target,
// in case it comes from a pool.
target = targetSource.getTarget();
if (target != null) {
targetClass = target.getClass();
}
// 2.获取当前bean被拦截方法链表
List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
// 3.如果为空，则直接调用target的method
if (chain.isEmpty()) {
Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
}
// 4.不为空，则逐一调用chain中的每一个拦截方法的proceed，这里的一系列执行的原因以及proceed执行的内容，我 在这里就不详细讲了，大家感兴趣可以自己去研读哈
else {
// We need to create a method invocation...
invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
// Proceed to the joinpoint through the interceptor chain.
retVal = invocation.proceed();
}
...
return retVal;
}
}
}
上一篇： 【Android开发】高级组件-进度条
下一篇： Flutter中使用进度条seekbar