初学Spring之AOP（二）

最新推荐文章于 2024-07-22 14:15:06 发布

Tcml_

最新推荐文章于 2024-07-22 14:15:06 发布

阅读量123

点赞数

分类专栏： Spring 文章标签： aop java spring

本文链接：https://blog.csdn.net/Fireblackbo/article/details/105344627

版权

Spring 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

AOP

AOP：Aspect Oriented Programming ⾯向切⾯编程。
AOP 的优点：

降低模块之间的耦合度。
使系统更容易扩展。
更好的代码复⽤。
⾮业务代码更加集中，不分散，便于统⼀管理。
业务代码更加简洁存粹，不参杂其他代码的影响。

AOP 是对⾯向对象编程的⼀个补充，在运⾏时，动态地将代码切⼊到类的指定⽅法、指定位置上的编程思想就是⾯向切⾯编程。将不同⽅法的同⼀个位置抽象成⼀个切⾯对象，对该切⾯对象进⾏编程就是 AOP。

如何使⽤？

创建 Maven ⼯程，pom.xml 添加


<dependencies>
 <dependency>
	 <groupId>org.springframework</groupId>
	 <artifactId>spring-context</artifactId>
	 <version>5.0.11.RELEASE</version>
 </dependency>
 
 <dependency>
	 <groupId>org.springframework</groupId>
	 <artifactId>spring-aop</artifactId>
	 <version>5.0.11.RELEASE</version>
 </dependency>

 <dependency>
	 <groupId>org.springframework</groupId>
	 <artifactId>spring-aspects</artifactId>
	 <version>5.0.11.RELEASE</version>
 </dependency>
</dependencies>

创建⼀个计算器接⼝ Cal，定义4个⽅法。


public interface Cal {
	 public int add(int num1,int num2);
	 public int sub(int num1,int num2);
	 public int mul(int num1,int num2);
	 public int div(int num1,int num2);
}

创建接⼝的实现类 CalImpl。

package com.southwind.utils.impl;
import com.southwind.utils.Cal;
public class CalImpl implements Cal {
	 public int add(int num1, int num2) {
	 System.out.println("add⽅法的参数是["+num1+","+num2+"]");
	 int result = num1+num2;
	 System.out.println("add⽅法的结果是"+result);
	 return result;
 }
	 public int sub(int num1, int num2) {
	 System.out.println("sub⽅法的参数是["+num1+","+num2+"]");
	 int result = num1-num2;
	 System.out.println("sub⽅法的结果是"+result);
	 return result;
 }


	 public int mul(int num1, int num2) {
		 System.out.println("mul⽅法的参数是["+num1+","+num2+"]");
		 int result = num1*num2;
		 System.out.println("mul⽅法的结果是"+result);
		 return result;
	 }
	 public int div(int num1, int num2) {
		 System.out.println("div⽅法的参数是["+num1+","+num2+"]");
		 int result = num1/num2;
		 System.out.println("div⽅法的结果是"+result);
	 return result;
 }
}

上述代码中，⽇志信息和业务逻辑的耦合性很⾼，不利于系统的维护，使⽤ AOP 可以进⾏优化，如何来实现 AOP？使⽤动态代理的⽅式来实现。给业务代码找⼀个代理，打印⽇志信息的⼯作交个代理来做，这样的话业务代码就只需要关注⾃身的业务即可。

package com.southwind.utils;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;

public class MyInvocationHandler implements InvocationHandler {
	 //接收委托对象
	 private Object object = null;
	 //返回代理对象
	 public Object bind(Object object){
		 this.object = object;
		 return Proxy.newProxyInstance(object.getClass().getClassLoader(),object.getClass().
		getInterfaces(),this);
	 }
	 public Object invoke(Object proxy, Method method, Object[] args) throws
	Throwable {
		 //要抽象的代理方法（打印信息）
        System.out.println(method.getName() + "方法参数是：" + Arrays.toString(args));
        //这里最难理解
        //这里即为this.object方法调用method方法，传args参数，返回结果
        //如，object = CalImpl调用method = add方法，返回结果
        Object result = method.invoke(this.object, args);
        System.out.println(method.getName() + "的结果是：" + result);
        return result;
		 
	 }
}

测试

package com.trygzb.utils.test;

import com.trygzb.utils.Cal;
import com.trygzb.utils.Impl.CalImpl;
import com.trygzb.utils.MyInvocationHandler;

public class Test1 {
    public static void main(String[] args) {
        Cal cal = new CalImpl();
        MyInvocationHandler myInvocationHandler = new MyInvocationHandler();
        Cal proxy = (Cal) myInvocationHandler.bind(cal);
        proxy.add(1, 2);
        proxy.sub(1, 2);
        proxy.mul(1, 2);
        proxy.div(1, 2);
    }
}

输出结果：

add方法参数是：[1, 2]
add的结果是：3
sub方法参数是：[1, 2]
sub的结果是：-1
mul方法参数是：[1, 2]
mul的结果是：2
div方法参数是：[1, 2]
div的结果是：0

以上是通过动态代理实现 AOP 的过程，⽐较复杂，不好理解，Spring 框架对 AOP 进⾏了封装，使⽤Spring 框架可以⽤⾯向对象的思想来实现 AOP。

Spring 框架中不需要创建 InvocationHandler，只需要创建⼀个切⾯对象，将所有的⾮业务代码在切⾯对象中完成即可，Spring 框架底层会⾃动根据切⾯类以及⽬标类⽣成⼀个代理对象。

LoggerAspect

package com.southwind.aop;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
import java.util.Arrays;
@Aspect
@Component
public class LoggerAspect {
	 @Before(value = "execution(public int com.southwind.utils.impl.CalImpl.*(..))")
	 public void before(JoinPoint joinPoint){
		 //获取⽅法名
		 String name = joinPoint.getSignature().getName();
		 //获取参数
		 String args = Arrays.toString(joinPoint.getArgs());
		 System.out.println(name+"⽅法的参数是："+ args);
	 }
	 @After(value = "execution(public int com.southwind.utils.impl.CalImpl.*(..))")
	 public void after(JoinPoint joinPoint){
	 //获取⽅法名
		 String name = joinPoint.getSignature().getName();
		 System.out.println(name+"⽅法执⾏完毕");
	 }
	 @AfterReturning(value = "execution(public int com.southwind.utils.impl.CalImpl.*(..))",returning = "result")
	 public void afterReturning(JoinPoint joinPoint,Object result){
	 //获取⽅法名
		 String name = joinPoint.getSignature().getName();
		 System.out.println(name+"⽅法的结果是"+result);
	 }
	 @AfterThrowing(value = "execution(public int com.southwind.utils.impl.CalImpl.*(..))",throwing = "exception")
	 public void afterThrowing(JoinPoint joinPoint,Exception exception){
	 //获取⽅法名
		 String name = joinPoint.getSignature().getName();
		 System.out.println(name+"⽅法抛出异常："+exception);
	 }
}

测试

package com.trygzb.utils.test;
import com.trygzb.utils.Cal;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test2 {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
        Cal proxy = (Cal) applicationContext.getBean("calImpl");
        proxy.add(1, 2);
    }
}

结果：

add⽅法的参数是：[1, 2]
add⽅法执行完毕

LoggerAspect 类定义处添加的两个注解：

@Aspect ：表示该类是切⾯类。
@Component ：将该类的对象注⼊到 IoC 容器。具体⽅法处添加的注解：
@Before：表示⽅法执⾏的具体位置和时机。CalImpl 也需要添加 @Component ，交给 IoC 容器来管理。

package com.southwind.utils.impl;
import com.southwind.utils.Cal;
import org.springframework.stereotype.Component;
@Component
public class CalImpl implements Cal {
	 public int add(int num1, int num2) {
		 int result = num1+num2;
		 return result;
	 }
	 public int sub(int num1, int num2) {
		 int result = num1-num2;
		 return result;
	 }
	 public int mul(int num1, int num2) {
		 int result = num1*num2;
		 return result;
	 }
	 public int div(int num1, int num2) {
		 int result = num1/num2;
		 return result;
	 }
}

spring.xml 中配置 AOP。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns:context="http://www.springframework.org/schema/context"
 xmlns:aop="http://www.springframework.org/schema/aop"
 xmlns:p="http://www.springframework.org/schema/p"
 xsi:schemaLocation="http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
 http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
 http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.3.xsd
">

 <!-- ⾃动扫描 -->
 <context:component-scan base-package="com.southwind"></context:component-scan>
 
 <!-- 是Aspect注解⽣效，为⽬标类⾃动⽣成代理对象 -->
 <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

</beans>

context:component-scan 将 com.southwind 包中的所有类进⾏扫描，如果该类同时添加了@Component ，则将该类扫描到 IoC 容器中，即 IoC 管理它的对象。

aop:aspectj-autoproxy 让 Spring 框架结合切⾯类和⽬标类⾃动⽣成动态代理对象。

切⾯：横切关注点被模块化的抽象对象。
通知：切⾯对象完成的⼯作。
⽬标：被通知的对象，即被横切的对象。
代理：切⾯、通知、⽬标混合之后的对象。
连接点：通知要插⼊业务代码的具体位置。
切点：AOP 通过切点定位到连接点

示意图

Tcml_

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
初学Spring之AOP（二）

AOPAOP：Aspect Oriented Programming ⾯向切⾯编程。AOP 的优点：降低模块之间的耦合度。使系统更容易扩展。更好的代码复⽤。⾮业务代码更加集中，不分散，便于统⼀管理。业务代码更加简洁存粹，不参杂其他代码的影响。AOP 是对⾯向对象编程的⼀个补充，在运⾏时，动态地将代码切⼊到类的指定⽅法、指定位置上的编程思想就是⾯向切⾯编程。将不同⽅法的同⼀个位...
复制链接

扫一扫

专栏目录