业务场景：首先你有了一个非常好的前辈无时无刻的在“教育”你。有这么一天，它叫你将它写好的一个方法进行改进测试，这时出现了功能迭代的情况。然后前辈好好“教育”你的说，不行改我的代码！改就腿打折！悲催的你有两条路可走，拿出你10年跆拳道的功夫去火拼一波然后拍拍屁股潇洒走人，要么就是悲催的开始百度。。。这时你会发现，我擦怎么把AOP代理这种事给忘了？【其实在我们工作中很少去手写它，但是它又是很常见的在使用（控制台日志）】
怎么办？打赢送手镯，打输睡大觉？
兄弟，信我的！
写吧。。。
AOP是一种设计思想，是软件设计领域中的面向切面编程，它是面向对象编程的一种补充和完善，它以通过预编译方式和运行期动态代理方式实现在不修改源代码的情况下给程序动态统一添加额外功能的一种技术。
利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率
简单说就是在不影响原有功能代码的情况下进行扩展，浸入少。
废话不多说，开搞！
1、JDK实现
MyAop
package com.example.quasar.aop;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
//继承InvocationHandler接口实现
public class MyAop implements InvocationHandler {
private Object object;
public MyAop(Object object) {
this.object = object;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//前置
System.out.println("前置运行");
Object invoke = method.invoke(this.object, args);
//后置
System.out.println("后置运行");
return invoke;
}
}
IndexService
package com.example.quasar.service;
public interface IndexService {
public void run();
public void run1();
}
IndexServiceImpl
package com.example.quasar.service.impl;
import com.example.quasar.service.IndexService;
public class IndexServiceImpl implements IndexService {
@Override
public void run() {
System.out.println("运行了");
}
@Override
public void run1() {
System.out.println("运行了1");
}
}
QuasarApplication
package com.example.quasar;
import com.example.quasar.aop.MyAop;
import com.example.quasar.service.IndexService;
import com.example.quasar.service.impl.IndexServiceImpl;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import java.lang.reflect.Proxy;
@SpringBootApplication
public class QuasarApplication {
public static void main(String[] args) {
//实现类实例化
IndexService indexService = new IndexServiceImpl();
//将实例传入aop
MyAop myAop = new MyAop(indexService);
//通过Proxy.newProxyInstance实现代理
IndexService o = (IndexService) Proxy.newProxyInstance(IndexServiceImpl.class.getClassLoader(), new Class[]{IndexService.class}, myAop);
//执行实现方法
o.run();
o.run1();
}
}
执行结果
2、CGLIB实现
如果项目中，已经使用了Spring，可以忽略导入上述两个包。因为在spring-core中已经集成了。否则需要引入该包，百度去找。
MyAop
package com.example.quasar.aop;
public class MyAop {
public void befor() {
System.out.println("befor...");
}
public void after() {
System.out.println("after...");
}
}
IndexService
package com.example.quasar.service;
public interface IndexService {
public void run();
public void run1();
}
IndexServiceImpl
package com.example.quasar.service.impl;
import com.example.quasar.service.IndexService;
public class IndexServiceImpl implements IndexService {
@Override
public void run() {
System.out.println("运行了");
}
@Override
public void run1() {
System.out.println("运行了1");
}
}
QuasarApplication
package com.example.quasar;
import com.example.quasar.aop.MyAop;
import com.example.quasar.service.IndexService;
import com.example.quasar.service.impl.IndexServiceImpl;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
@SpringBootApplication
public class QuasarApplication {
public static void main(String[] args) {
//实现类实例化
IndexService indexService = new IndexServiceImpl();
// 代理类 ，采用cglib，底层创建目标类的子类
MyAop myAop = new MyAop();
// 核心类
Enhancer enhancer = new Enhancer();
//确定父类
enhancer.setSuperclass(indexService.getClass());
enhancer.setCallback(new MethodInterceptor() {
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
//前置
myAop.after();
// 执行目标类的方法
Object obj = method.invoke(indexService, args);
//后置
myAop.befor();
return obj;
}
});
// 3.4 创建代理
IndexService proxService = (IndexService) enhancer.create();
proxService.run();
proxService.run1();
}
}
执行结果
3、boot注解实现【注意只对bean有效】
MyAop
package com.v1.aop;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;
@Aspect
@Component
public class MyAop {
//*号作用：com.v1.service.impl下的所有类和所有方法
@Before(value = "within(com.v1.service.impl.*)")
public void before(JoinPoint joinPoint) {
System.out.println("before开始执行查询.......");
System.out.println("正在执行的目标类是: " + joinPoint.getTarget());
System.out.println("正在执行的目标方法是: " + joinPoint.getSignature().getName());
}
//*号作用：com.v1.controller下的所有类和所有方法
@Around(value = "execution(* com.v1.controller.*.*(..))")
public Object aroud(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
System.out.println("aroud环绕通知开始.......");
System.out.println("执行的目标类 = " + proceedingJoinPoint.getTarget());
System.out.println("执行的目标方法 = " + proceedingJoinPoint.getSignature().getName());
// 必须方法目标方法
Object proceed = proceedingJoinPoint.proceed();
System.out.println("aroud环绕通知结束.......");
// 将目标方法的返回值进行返回，否则调用目标方法的方法无法获取到返回值
return proceed;
}
}
非常简单，直接就根据注解进行代理了！
注解参数可以具体在咱们csdn平台去查一下，有很多文章讲的很细的！
执行结果
发个请求跑一下
以上就是Java实现AOP代理的三种方式详解的详细内容，更多关于Java AOP代理的资料请关注编程网其它相关文章！
