代理模式与aspectJ实现AOP

一、问题

1、代码混乱：越来越多的非业务需求（日志和验证等）加入后，原有的业务方法急剧膨胀。每个方法在处理核心逻辑的同时还必须兼顾其他多个关注点

2、代码分散：以日志需求为例，只是为了满足这个单一需求，就不得不在多个模块方法（方法）里多次重复相同的日志代码。如果日志需求发生变化，必修修改所有的模块。

二、 使用动态代理解决上述问题

代理设计模式的原理：使用一个代理将对象包装起来，然后用该代理对象取代原始对象，任何对原始对象调用都要通过代理，代理对象决定是否以及何时将方法调用转到原始对象上

原对象

public class AtithmeticCalculatorImpl implements AtithmeticCalculator {
@Override
public int add ( int i , int j ) {
return i + j ;
}

@Override
public int sub ( int i , int j ) {
return i - j ;
}

@Override
public int mul ( int i , int j ) {
return i * j ;
}

@Override
public int div ( int i , int j ) {
return i / j ;
}
}

代理对象

public class ArithmeticCalculatorLoggingProxy {
/**
* 需要代理的对象
*/
private AtithmeticCalculator target ;

public ArithmeticCalculatorLoggingProxy ( AtithmeticCalculator target ) {
this . target = target ;
}

public AtithmeticCalculator getLoggerPorxy (){
//指定代理对象由哪个类加载器进行加载
ClassLoader loader = target . getClass () . getClassLoader () ;
//代理对象的类型
Class [] interfaces = new Class []{ AtithmeticCalculator . class } ;
//代理对象需要执行的逻辑，当调用代理对象其中的方法时，执行该代码
InvocationHandler h = new InvocationHandler () {
/**
* 记录日志的方法
* @param proxy 正在返回的那个代理对象，一般情况下，在invoke中不使用该对象
* @param method 正在被调用的方法
* @param args 调用方法时，传入的参数
* @return 一般返回代理对象返回的结果
*/
@Override
public Object invoke ( Object proxy , Method method , Object [] args ) throws Throwable {
//被调用对象的方法名
String methodName = method . getName () ;
//记录开始日志
System . out . println ( "调用" + methodName + "方法，处理" + Arrays . asList ( args )) ;
//执行原对象的方法
Object invoke = method . invoke ( target , args ) ;
//记录结束日志
System . out . println ( "处理结果为：" + invoke ) ;
return invoke ;
}
} ;
return ( AtithmeticCalculator ) Proxy . newProxyInstance ( loader , interfaces , h ) ;
}
}

运行Main方法

public class Main {
public static void main ( String [] args ) {
AtithmeticCalculator target = new AtithmeticCalculatorImpl () ;
AtithmeticCalculator proxy = new ArithmeticCalculatorLoggingProxy ( target ) . getLoggerPorxy () ;
proxy . add ( 1 , 2 ) ;
proxy . mul ( 3 , 5 ) ;
}
}

运行结果

三、使用AOP解决上述问题

1、是什么是AOP

--AOP（Aspect-Oriented-Programming，面向切面编程）：是一种新的方法论，是对传统OOP的补充

--AOP的主要编程对象是切面，而切面模块化横切关注点

--在应用AOP编程时，仍然需要定义公共功能，但可以明确定的定义在个功能在哪里，以书面方式进行应用，并且不必修改收影响的类。这样一来横切关注点就被模块化到特殊的对象（切面）里。

--AOP的好处：

每个视为逻辑位于一个位置，代码不分散，便于维护和升级

业务模块更简洁只包含核心业务代码

2、AOP术语

--切面（Aspect）：横切关注点（跨越应用程序多个模块的功能）被模块化的特殊对象

--通知（Advice）：切面必须要完成的工作

--目标（Target）：被通知的对象

--代理（Proxy）：向目标对象应用通知之后创建的对象

--连接点（Joinpoint）：程序执行的某个特定位置：如类某个方法调用前、调用后、方法抛出异常后等。连接点由两个信息确定：方法表示的程序执行点；相对点表示的方位。如ArithmeticCalculator中的add（）方法指向前的连接点，执行点为add（）；方位为该方法执行前的位置

--切点（pointcut）：每个类都拥有多个连接点：例如ArithmeticCalculator的所有方法实际上都是连接点，即连接点是程序类中客观存在的事务。AOP通过切点定位到特定的连接点。类比：连接点相当于数据库中的记录，相当于查询条件。切点的连接点不是一对一的关系，一个切点匹配多个连接点，切点通过org.springframeword.aop.Pointcut接口进行描述，它使用；类和方法作为连接点的查询条件

3.AspectJ

--AspectJ是java社区里最完整最流行的AOP框架

--在Spring2.0以上版本中，可以使用基于AspectJ注解或基于Xml配置的AOP

4、在Spring中启用AspectJ注解支持

--要在Spring应用中视同AspectJ注解，必须在classpath下包含AspectJ类库：aopalliance.jar、aspectj.weaver.jar和spring-aspects.jar

< dependency >
< groupId >aopalliance </ groupId >
< artifactId >aopalliance </ artifactId >
< version >1.0 </ version >
</ dependency >
< dependency >
< groupId >org.aspectj </ groupId >
< artifactId >aspectjweaver </ artifactId >
< version >1.7.4 </ version >
</ dependency >
< dependency >
< groupId >org.springframework </ groupId >
< artifactId >spring-aspects </ artifactId >
< version >4.3.1.RELEASE </ version >
</ dependency >

--将aopSchema添加到<beans>根元素中。

--要在SpringIOC容器中启用AspectJ注解支持，只要在Bean的配置文件中定义一个空的XML元素<aop:aspectj-autoproxy>

--当SpringIOC容器侦测到Bean配置文件中的<aop:aspectj-autoproxy>元素时，会自动为与AspectJ切面匹配的Bean创建代理

4.使用AspectJ实现切面

（1）配置Spring 文件

<? 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"
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" >


< context :component-scan base-package ="aop" ></ context :component-scan >


< aop :aspectj-autoproxy ></ aop :aspectj-autoproxy >
</ beans >

（2）实现切面类

/**
* 内容摘要：日志切面
*
* 将这个类声明为一个切面
* 1、通过@Component注解把内放入Ioc容器中
* 2、通过@Aspect声明为切面
*/
@Aspect
@Component
public class LoggingAspect {
/**
* 声明该方法是一个前置通知：在目标方法开始之前执行
*/
@Before ( "execution(public int aop.AtithmeticCalculatorImpl.*(int,int))" )
public void beforeMethod ( JoinPoint joinPoint ){
System . out . println ( "调用" + joinPoint . getSignature () . getName () + "方法，处理" + Arrays . asList ( joinPoint . getArgs ())) ;
}
}

（3）编写运行Main方法

public class Main {
public static void main ( String [] args ) {
//创建IOC容器
ApplicationContext ctx = new ClassPathXmlApplicationContext ( "applicationContext.xml" ) ;
//从IOC实例中获取Bean的实例
AtithmeticCalculator atithmeticCalculator = ( AtithmeticCalculator ) ctx . getBean ( "atithmeticCalculatorImpl" ) ;
//使用bean
atithmeticCalculator . add ( 1 , 2 ) ;
}
}

（4）结果

5.用aspectJ注解声明

--要在 Spring 中声明 AspectJ 切面, 只需要在 IOC 容器中将切面声明为 Bean 实例. 当在 Spring IOC 容器中初始化 AspectJ 切面之后, Spring IOC 容器就会为那些与 AspectJ 切面相匹配的 Bean 创建代理.

--在 AspectJ 注解中, 切面只是一个带有 @Aspect 注解的 Java 类.

--通知是标注有某种注解的简单的 Java 方法.

--AspectJ 支持 5 种类型的通知注解:

@Before: 前置通知, 在方法执行之前执行

@After: 后置通知, 在方法执行之后执行

@AfterRunning: 返回通知, 在方法返回结果之后执行

@AfterThrowing: 异常通知, 在方法抛出异常之后

@Around: 环绕通知, 围绕着方法执行

代理模式与aspectJ实现AOP

猜你喜欢