再也不怕aop的原理了

1 aop是什么

  java的核心思想是面向对象,aop是面向切面编程.是对面向对象的一个补充,简单通俗的理解下aop,假设我们上楼梯,我的目标是三楼,我直接朝我的三楼直接过去,但是我可以在二楼的时候去朋友那里玩下,坐下其他的,然后再去三楼

这也不会影响我们的目标去三楼,那么去朋友那里玩,相当于增加的生活的乐趣去那里玩.相当于增强了我们的活动.

  那么aop可以做啥呢,可以进行日志记录,可以进行事务管理,可以进行安全控制,可以进行异常处理,可以进行性能统计

2 理解几个关键字

切面

关注点形成的类,就叫切面(类)!

面向切面编程,就是指对很多功能都有的重复的代码抽取,再在运行的时候网业务方法上动态植入“切面类代码”

切点

执行目标对象方法,动态植入切面代码。

可以通过切入点表达式,指定拦截哪些类的哪些方法; 给指定的类在运行的时候植入切面类代码。

通知

在对象上面执行的内容

3 aop的实现原理:

aop的底层实现是代理模式加反射.

反射就不用多讲了,代理模式分为多种,静态代理和动态代理,动态代理面又分为jdk动态代理和cglib动态代理

代理模式的好处:可以防止对方得到我们真实的方法;

静态代理的实现方式:

package com.cxy.cyclicBarrier;

/**
* Created by Administrator on 2017/4/24.
*/
public interface IUserDao {
void save();
}
package com.cxy.cyclicBarrier;

/**
* Created by Administrator on 2019/4/24.
*/
public class UserDao implements IUserDao {
@Override
public void save() {
System.out.println("已经保存数据");
}
}

代理类:

package com.cxy.cyclicBarrier;

/**
* Created by Administrator on 2019/4/24.
*/ public class UserDaoProxy implements IUserDao{
private IUserDao target; public UserDaoProxy(IUserDao iuserDao) {
this.target = iuserDao;
} public void save() {
System.out.println("开启事物...");
target.save();
System.out.println("关闭事物...");
} public static void main(String[] args) {
UserDao userDao=new UserDao();
UserDaoProxy userDaoProxy=new UserDaoProxy(userDao );
userDaoProxy.save();
} }

在最后可以看到执行结果:

再也不怕aop的原理了

结果分析:

静态代理:

由程序员创建或工具生成代理类的源码,再编译代理类。所谓静态也就是在程序运行前就已经存在代理类的字节码文件,代理类和委托类的关系在运行前就确定了。

然后再看jdk动态代理:

package com.cxy.cyclicBarrier;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy; // 每次生成动态代理类对象时,实现了InvocationHandler接口的调用处理器对象
public class InvocationHandlerImpl implements InvocationHandler {
private Object target;// 这其实业务实现类对象,用来调用具体的业务方法
// 通过构造函数传入目标对象
public InvocationHandlerImpl(Object target) {
this.target = target;
} public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object result = null;
System.out.println("调用开始处理");
result = method.invoke(target, args);
System.out.println("调用结束处理");
return result;
} public static void main(String[] args) throws NoSuchMethodException, SecurityException, InstantiationException,
IllegalAccessException, IllegalArgumentException, InvocationTargetException {
// 被代理对象
IUserDao userDao = new UserDao();
InvocationHandlerImpl invocationHandlerImpl = new InvocationHandlerImpl(userDao);
ClassLoader loader = userDao.getClass().getClassLoader();
Class<?>[] interfaces = userDao.getClass().getInterfaces();
// 主要装载器、一组接口及调用处理动态代理实例
IUserDao newProxyInstance = (IUserDao) Proxy.newProxyInstance(loader, interfaces, invocationHandlerImpl);
newProxyInstance.save();
} }

再也不怕aop的原理了

结果分析:

jdk动态代理:

1. 通过实现InvocationHandler接口创建自己的调用处理器 IvocationHandler handler = new InvocationHandlerImpl(…);

2. 通过为Proxy类指定ClassLoader对象和一组interface创建动态代理类Class clazz = Proxy.getProxyClass(classLoader,new Class[]{…});

3. 通过反射机制获取动态代理类的构造函数,其参数类型是调用处理器接口类型Constructor constructor = clazz.getConstructor(new Class[]{InvocationHandler.class});

4. 通过构造函数创建代理类实例,此时需将调用处理器对象作为参数被传入Interface Proxy = (Interface)constructor.newInstance(new Object[] (handler));

cglib代理:

package com.cxy.cyclicBarrier;

import java.lang.reflect.Method;

public class CglibProxy implements MethodInterceptor {
private Object targetObject;
// 这里的目标类型为Object,则可以接受任意一种参数作为被代理类,实现了动态代理
public Object getInstance(Object target) {
// 设置需要创建子类的类
this.targetObject = target;
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(target.getClass());
enhancer.setCallback(this);
return enhancer.create();
} public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
System.out.println("开启事物");
Object result = proxy.invoke(targetObject, args);
System.out.println("关闭事物");
// 返回代理对象
return result;
} public static void main(String[] args) {
CglibProxy cglibProxy = new CglibProxy();
UserDao userDao = (UserDao) cglibProxy.getInstance(new UserDao());
userDao.save();
}
}

执行结果:

再也不怕aop的原理了

在执行上面代码前需要引入asm包

原理:利用asm开源包,对代理对象类的class文件加载进来,通过修改其字节码生成子类来处理。

4 区别比较:
CGLIB动态代理与JDK动态区别

java动态代理是利用反射机制生成一个实现代理接口的匿名类,在调用具体方法前调用InvokeHandler来处理。

而cglib动态代理是利用asm开源包,对代理对象类的class文件加载进来,通过修改其字节码生成子类来处理。

Spring中。

1)、如果目标对象实现了接口,默认情况下会采用JDK的动态代理实现AOP

2)、如果目标对象实现了接口,可以强制使用CGLIB实现AOP

3)、如果目标对象没有实现了接口,必须采用CGLIB库,spring会自动在JDK动态代理和CGLIB之间转换

JDK动态代理只能对实现了接口的类生成代理,而不能针对类 。
CGLIB是针对类实现代理,主要是对指定的类生成一个子类,覆盖其中的方法 。
因为是继承,所以该类或方法最好不要声明成final ,final可以阻止继承和多态。

5 aop的使用方式:

1) 注解方式:

<aop:aspectj-autoproxy></aop:aspectj-autoproxy>  开启事物注解权限
@Aspect 指定一个类为切面类
@Pointcut("execution(* com.xhz.service.UserService.add(..))") 指定切入点表达式
@Before("pointCut_()") 前置通知: 目标方法之前执行
@After("pointCut_()") 后置通知:目标方法之后执行(始终执行)
@AfterReturning("pointCut_()") 返回后通知: 执行方法结束前执行(异常不执行)
@AfterThrowing("pointCut_()") 异常通知: 出现异常时候执行
@Around("pointCut_()") 环绕通知: 环绕目标方法执行 @Component
@Aspect
public class AopLog { // 前置通知
@Before("execution(* com.cxy.service.UserService.add(..))")
public void begin() {
System.out.println("前置通知");
} //
// 后置通知
@After("execution(* com.cxy.service.UserService.add(..))")
public void commit() {
System.out.println("后置通知");
} // 运行通知
@AfterReturning("execution(* com.cxy.service.UserService.add(..))")
public void returning() {
System.out.println("运行通知");
} // 异常通知
@AfterThrowing("execution(* com.cxy.service.UserService.add(..))")
public void afterThrowing() {
System.out.println("异常通知");
} // 环绕通知
@Around("execution(* com.cxy.service.UserService.add(..))")
public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
System.out.println("环绕通知开始");
proceedingJoinPoint.proceed();
System.out.println("环绕通知结束");
}
}

2)xml方式:

<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
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"> <!-- dao 实例 --> <bean id="userService" class="com.cxy.service.UserService"></bean>
<!-- 切面类 -->
<bean id="aop" class="com.cxy.aop2.AopLog2"></bean>
<!-- Aop配置 -->
<aop:config>
<!-- 定义一个切入点表达式: 拦截哪些方法 -->
<aop:pointcut expression="execution(* com.cxy.service.UserService.*(..))"
id="pt" />
<!-- 切面 -->
<aop:aspect ref="aop">
<!-- 环绕通知 -->
<aop:around method="around" pointcut-ref="pt" />
<!-- 前置通知: 在目标方法调用前执行 -->
<aop:before method="begin" pointcut-ref="pt" />
<!-- 后置通知: -->
<aop:after method="after" pointcut-ref="pt" />
<!-- 返回后通知 -->
<aop:after-returning method="afterReturning"
pointcut-ref="pt" />
<!-- 异常通知 -->
<aop:after-throwing method="afterThrowing"
pointcut-ref="pt" />
</aop:aspect>
</aop:config> </beans>
public class AopLog2 {

    // 前置通知
public void begin() {
System.out.println("前置通知");
} //
// 后置通知
public void commit() {
System.out.println("后置通知");
} // 运行通知
public void returning() {
System.out.println("运行通知");
} // 异常通知
public void afterThrowing() {
System.out.println("异常通知");
} // 环绕通知
public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
System.out.println("环绕通知开始");
proceedingJoinPoint.proceed();
System.out.println("环绕通知结束");
}
}
上一篇:12C对ASM rebalance操作的优化


下一篇:Java中子类能继承父类的私有属性吗?