Proxy实现AOP切面编程案例

2023-07-18 12:26:04 59

通过JDK的Proxy代理实现对业务类做简单的AOP实现

接口：UserService包含的方法为切入点，会被代理拦截

类：UserServiceImpl实现UserService接口

类：UserServiceFactory工厂模式生成动态代理

类：MyAspect切面类，实现对切入点的操作

UserService

publicinterfaceUserService{
//切面:需要被拦截的方法
publicvoidaddUser();
publicvoidupdateUser();
publicintdeleteUser(intid);
}

UserServiceImpl

publicclassUserServiceImplimplementsUserService{
publicvoidadd(){
System.out.println("UserServiceImpl.add()");
}

publicvoidadd(Useruser){
System.out.println("UserServiceImpl.add("+user+")");
}

//下面继承自UserService接口的方法会被拦截
@Override
publicvoidaddUser(){
System.out.println("UserServiceImpl.addUser()");
}

@Override
publicvoidupdateUser(){
System.out.println("UserServiceImpl.updateUser()");
}

@Override
publicintdeleteUser(intid){
System.out.println("UserServiceImpl.deleteUser("+id+")");
return1;
}
}

UserServiceFactory

publicclassUserServiceFactory{
publicstaticUserServicecreateUserService(){
//1、创建目标对象target
finalUserServiceuserService=newUserServiceImpl();
//2、声明切面类对象
finalMyAspectmyAspect=newMyAspect();
//3、将切面类before()与after()方法应用到目标类
//3.1、创建JDK代理(返回一个接口)
/*
newProxyInstance(
ClassLoaderloader,//类加载器，写当前类
Class[]interfaces,//接口，接口中包含的方法执行时会被拦截
InvocationHandlerh)//处理调用切面类中的处理如：deforre()、after()
*/
UserServiceserviceProxy=(UserService)Proxy.newProxyInstance(
UserServiceFactory.class.getClassLoader(),
userService.getClass().getInterfaces(),
newInvocationHandler(){
@Override
publicObjectinvoke(Objectproxy,Methodmethod,Object[]args)throwsThrowable{
//开启事务
myAspect.before();

//返回值是调用的业务方法的返回值
Objectobj=method.invoke(userService,args);

//提交事务
myAspect.after();

returnobj;
}
});
returnserviceProxy;
}
}

MyAspect:(就是一些具体操作，如记录日志等)

publicclassMyAspect{
publicvoidbefore(){
System.out.println("MyAspect.before()开启事务...");
}

publicvoidafter(){
System.out.println("MyAspect.after()提交事务...");
}
}

单元测试：

@Test
publicvoidaop_test(){
UserServiceuserService=UserServiceFactory.createUserService();
userService.addUser();
userService.deleteUser(10);
userService.updateUser();
}

输出：

MyAspect.before()开启事务...

UserServiceImpl.addUser()

MyAspect.after()提交事务...

MyAspect.before()开启事务...

UserServiceImpl.deleteUser(10)

MyAspect.after()提交事务...

MyAspect.before()开启事务...

UserServiceImpl.updateUser()

MyAspect.after()提交事务...

补充知识：结合动态代理技术学习SpringAop实现切面编程

结合一个例子利用动态代理技术和SpringAop实现需求

需求：为我的UserService类中的每一个方法加上一个计时器

最初的实现是为每一个类添加一段代码，这样看起来代码的冗余度特别大

静态代理实现

在使用JDK提供动态代理之前我们先利用静态代理技术实现这个需求

静态代理需要我们自己创建代理类具体代码如下:

创建UserService接口以及他的实现类及目标类UserServiceTarget

publicinterfaceUserService{

publicvoidinsert();
publicvoidupdate();
publicvoiddelete();
}

//目标类
publicclassUserServiceTargetimplementsUserService{

@Time
publicvoidinsert(){
System.out.println("插入用户");
}

publicvoidupdate(){
System.out.println("修改用户");
}

publicvoiddelete(){
System.out.println("删除用户");
}
}

创建TimeHandler类，将重复的计时器代码逻辑写入TimeHandler类中

publicclassTimeHandler{
privateUserServiceTargetuserService=newUserServiceTarget();
//需要加计时器的方法对应的对象--method
publicvoidinvoke(Methodmethod){
longstart=System.nanoTime();
//反射调用：方法.invoke(对象,参数);
try{
method.invoke(userService);
}catch(Exceptione){
e.printStackTrace();
}
longend=System.nanoTime();
Timetime=method.getAnnotation(Time.class);
if(time!=null){
System.out.println("花费了："+(end-start));
}
}
}

最后一步就是自己实现代理类UserServiceProxy，自己实现代理类被称作静态代理

publicclassUserServiceProxyimplementsUserService{

publicvoidinsert(){
try{
TimeHandlertimeHandler=newTimeHandler();
Methoda=UserServiceTarget.class.getMethod("insert");
timeHandler.invoke(a);
}catch(NoSuchMethodExceptione){
e.printStackTrace();
}
}

publicvoidupdate(){
try{
TimeHandlertimeHandler=newTimeHandler();
Methodb=UserServiceTarget.class.getMethod("update");
timeHandler.invoke(b);
}catch(NoSuchMethodExceptione){
e.printStackTrace();
}
}

publicvoiddelete(){
try{
TimeHandlertimeHandler=newTimeHandler();
Methodc=UserServiceTarget.class.getMethod("delete");
timeHandler.invoke(c);
}catch(NoSuchMethodExceptione){
e.printStackTrace();
}
}
}

这样在无需改变UserService类和其实现类的情况下增加了代码的扩展性，降低了代码间的耦合度。

动态代理实现

动态代理就是不需要我们自己创建代理类和代理对象,JDK会在程序运行中为我们自动生成代理对象

动态代理的三个步骤

1、生成代理类的字节码

2、执行类加载将字节码加载进入JVM

3、创建代理类的实例对象

方式一

自己写代码生成需要代理类的字节码

1、获取代理类的字节码

byte[]bytes=ProxyGenerator.generateProxyClass("UserServiceProxy",newClass[]{UserService.class});

//这里第一个参数是自己为代理类起的类名，第二个参数是需要创建代理类的字节码数组

2、执行类加载

ClassLoadercl=newClassLoader(){
@Override
protectedClassfindClass(Stringname)throwsClassNotFoundException{
returndefineClass(name,bytes,0,bytes.length);
}
};
Classc=cl.loadClass("UserServiceProxy");//进行类加载,获得了UserServiceProxy类对象

3、创建代理类实例对象--通过反射

//获取代理类的构造方法
Constructorconstructor=c.getConstructor(InvocationHandler.class);

UserServiceTargettarget=newUserServiceTarget();
//创建实例对象,强制转换为它的接口类型
UserServiceproxy=(UserService)constructor.newInstance(newInvocationHandler(){
@Override
publicObjectinvoke(Objectproxy,Methodmethod,Object[]args)throwsThrowable{
longstart=System.nanoTime();
method.invoke(target,args);
longend=System.nanoTime();
System.out.println("花费了:"+(end-start));
returnnull;
}
});

这里的InvocationHandler接口匿名实现类似于我们之前的TimeHandler类，只需要将重复代码逻辑写入其中在通过方法对象反射调用该方法即可实现动态代理。

//使用代理对象

proxy.insert();

方式二

利用Proxy类的newProxyInstance()方法实现动态代理，具体代码如下

publicstaticvoidmain(String[]args){
//直接创建代理类的实例
//1.获取类加载器
ClassLoadercl=UserService.class.getClassLoader();
//2.规定代理类要实现的接口
Class[]interfaces=newClass[]{UserService.class};
//3.给一个InvocationHandler对象,包含要执行的重复逻辑
UserServiceTargettarget=newUserServiceTarget();
InvocationHandlerh=newInvocationHandler(){
@Override
publicObjectinvoke(Objectproxy,Methodmethod,Object[]args)throwsThrowable{
longstart=System.nanoTime();

//方法.invoke(目标,参数);
method.invoke(target,args);

longend=System.nanoTime();
System.out.println("花费了:"+(end-start));
returnnull;
}
};
UserServiceproxy=(UserService)Proxy.newProxyInstance(cl,interfaces,h);
//4.使用代理对象
proxy.update();
}
}

使用Spring框架AOP（面向切面编程）完成需求

Spring框架最最主要的两大特性就是IOC（控制反转）和AOP（面向切面编程）

IOC总结见我的博客SpringIOC总结

AOP(aspectorientedprogramming)即面向切面编程

切面aspect=通知adivce+切点pointcut

通知：是一个方法，其中包含了重复的逻辑（例如我们今天需要实现的计时器需求，以及Spring事务管理的底层实现）

切点：是一种匹配条件,与条件相符合的目标方法，才会应用通知方法，需要配合切点表达式

再来类比一下之前的图

图中的UserService就是SpringAOP技术中的代理，TimeHandler就是切面，UserServiceTarget在SpringAOP技术中被称作目标。

SpringAOP实现

首先需要添加maven依赖



org.springframework
spring-context
4.3.22.RELEASE



org.aspectj
aspectjrt
1.8.13


org.aspectj
aspectjweaver
1.8.13

第二步，编写切面类

@Component
//将切面交给spring容器管理
@Aspect
//@Aspect注解表示该类是一个切面类
//切面=通知+切点
publicclassUserAspect{
//配置切点@Around注解和切点表达式
@Around("within(service.impl.*)")

//配置通知方法
//ProceedingJoinPoint参数用来调用目标方法
publicObjecttime(ProceedingJoinPointproceedingJoinPoint)throwsThrowable{
longstart=System.nanoTime();
Objectproceed=proceedingJoinPoint.proceed();//调用目标方法返回结果
longend=System.nanoTime();
System.out.println("springaop方法耗时"+(end-start)+"纳秒");
returnproceed;
}
}

UserService和UserServiceImpl代码如下

publicinterfaceUserService{
voidinsert();
voidupdate();
voiddelete();
}

@Service
publicclassUserServiceImplimplementsUserService{
@Override
publicvoidinsert(){
System.out.println("UserServiceImpl增加用户信息");
}

@Override
publicvoidupdate(){
System.out.println("UserServiceImpl修改用户信息");
}

@Override
publicvoiddelete(){
System.out.println("UserServiceImpl删除用户信息");
}
}

最后一步，配置Spring配置文件

编写测试类

publicclassTestSpringAopProgramming{
publicstaticvoidmain(String[]args){
ClassPathXmlApplicationContextcontext=
newClassPathXmlApplicationContext("spring.xml");
UserServiceuserService=context.getBean(UserService.class);
userService.insert();
userService.update();
userService.delete();
}
}

彩蛋

这个时候上面的需求又发生了变法，不是给UserService中所有的方法加计时器，而是给指定方法加计时器，又该如何实现？

如果我们给需要加计时器的方法加上一个注解，当反射调用该方法的时候判断如果有该注解在通过动态代理的方式为其加计时器不就可以解决问题了。

自定义注解

自定义注解需要添加两个注解@Target@Retention

@Target表示能够加在哪些位置

ElementType.TYPE表示能够加在类上

ElementType.METHOD表示能够加在方法上

ElementType.FIELD表示能够加在属性上

@Retention表示注解的作用范围

Source表示注解仅在*.java源码中有效

Class表示注解在*.java源码和*.class字节码中有效

Runtime表示注解在*.java源码和*.class字节码和运行期间都中有效

自定义注解类Time

@Target({ElementType.METHOD})//该只需要加载方法上
@Retention(RetentionPolicy.RUNTIME)//需要在源码，字节码，以及运行中都有效
public@interfaceTime{
}

这个时候只需要在指定的方法上加@Time注解，然后在代理对象进行判断即可，示例代码如下：

publicvoidinsert(){
try{
TimeHandlertimeHandler=newTimeHandler();
Methoda=UserServiceTarget.class.getMethod("insert");
//通过getAnnotation()方法判断是否存在@Time注解
if(method.getAnnotation(Time.class)!=null){
timeHandler.invoke(a);
}
}catch(NoSuchMethodExceptione){
e.printStackTrace();
}
}

以上这篇Proxy实现AOP切面编程案例就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持毛票票。

声明：本文内容来源于网络，版权归原作者所有，内容由互联网用户自发贡献自行上传，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任。如果您发现有涉嫌版权的内容，欢迎发送邮件至：czq8825#qq.com（发邮件时，请将#更换为@）进行举报，并提供相关证据，一经查实，本站将立刻删除涉嫌侵权内容。

Proxy实现AOP切面编程案例

热门推荐

随机推荐