什么是AOP?
AOP(Aspect Oriented Programming)又叫面向切面编程。它是一种编程思想,它会对业务逻辑的各个部分进行隔离,实现业务逻辑各个部分的松耦合,提高了程序的可重用性,已经开发效率。
为什么需要AOP?
-
我们知道如今OOP正在主宰着软件行业,OOP它将需求抽象出来,封装成一个个独立的类,每个类中拥有自己的字段和行为(方法),让类与类之间来相互依赖,相互协作。
- 但这其实是有点问题的,这样做会出现一种情况,那就是很多不同业务的类中,存在大量的功能相同或相似的行为。这其实是一个代码的坏味道——重复代码(Duplicated Code)。
- 还可能面临的一个问题就是大量行为在细微程度上的变化。
如果只是相同的行为我们只需要将它独立并提取出来即可,但对于相似的行为和易变化的行为处理起来就很困难。虽然GoF给我们提供了装饰模式这个解决方案,但对于细粒的模块大面积的采用装饰模式,势必会提升系统的复杂性,不利于维护。
-
这时候AOP的作用就发挥出来了。它是将业务逻辑的各个部分(方法)进行了隔离,在执行业务逻辑的时候,只需要将这各个部分进行组装即可。
- 这样做就能减少重复代码,使得一旦代码需要进行修改,只需要更改一处的代码。
- 对于易变化的行为,只需要在配置中更改它的切面即可。
这就提高了代码的维护性、可重用性以及灵活性。
AOP是如何做的?
AOP是根据反射和动态代理来运转的。以AOP来编写的代码,在调用方法的时候,不会直接调用真实对象的具体方法。它会根据真实对象的信息,动态生成一个它的接口的代理对象。在调用的时候,它去调这个代理对象中的方法,从而根据多态间接的调用到真实对象的方法。
这就让代码变的灵活了起来。因为我们可以在外部,通过配置等方式来控制这个代理对象的生成,从而可以为它在真实调用的这个切入点周围进行切面(方法)织入,来对这个切入点进行增强。一旦需求发生变化,只需要调整配置文件,修改织入的切面即可。
并且通过这种方式,就可以将不同业务逻辑中相似的代码全都独立出来,分割成更为细小的单元。再利用切面织入的方式就能组装成满足业务需求部分。
参考代码如下:
动态代理实现方式
public interface ITest {
void Fun();
void Fun1();
}
public class Test implements ITest{
public void Fun(){
System.out.println("Test类的Fun方法被执行!");
}
@Override
public void Fun1() {
System.out.println("Test类的Fun1方法被执行!");
}
}
public class ProxyInvocationHandler implements InvocationHandler {
//被代理的接口
private Object target;
//动态生成并得到代理类
public Object getProxy(){
return Proxy.newProxyInstance(
this.getClass().getClassLoader(),
target.getClass().getInterfaces(),
this);
}
public void setTarget(Object target) {
this.target = target;
}
//处理代理类的方法
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("========方法开始执行========");
Object result = method.invoke(target, args);
System.out.println("========方法执行结束========");
return result;
}
}
public class Program {
public static void main(String[] args) {
ProxyInvocationHandler proxyInvocationHandler =
new ProxyInvocationHandler();
Test test = new Test();
proxyInvocationHandler.setTarget(test);
//代理的是接口,而不是类
ITest proxy = (ITest) proxyInvocationHandler.getProxy();
proxy.Fun();
System.out.println();
proxy.Fun1();
/* 运行结果:
* ========方法开始执行========
* Test类的Fun方法被执行!
* ========方法执行结束========
*
* ========方法开始执行========
* Test类的Fun1方法被执行!
* ========方法执行结束========
*/
}
}
Spring使用AOP
<!-- pom.xml AOP的依赖包 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.2.1.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-core -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>5.2.1.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.2</version>
</dependency>
<?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:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
https://www.springframework.org/schema/aop/spring-aop.xsd">
<bean id="Test" class="com.XiaoJie.Test"/>
<bean id="AdvisorBefore" class="com.XiaoJie.AdvisorBefore"/>
<bean id="AdvisorAfter" class="com.XiaoJie.AdvisorAfter"/>
<bean id="Program" class="com.XiaoJie.Program"/>
<aop:config>
<aop:pointcut id="TestCut" expression="execution(* com.XiaoJie.Test.*(..))"/>
<aop:advisor advice-ref="AdvisorBefore" pointcut-ref="TestCut"/>
<aop:advisor advice-ref="AdvisorAfter" pointcut-ref="TestCut"/>
</aop:config>
</beans>
public class AdvisorAfter implements AfterReturningAdvice {
@Override
public void afterReturning(Object o, Method method, Object[] objects, Object o1) throws Throwable {
System.out.println("========方法执行结束========");
}
}
public class AdvisorBefore implements MethodBeforeAdvice {
@Override
public void before(Method method, Object[] objects, Object o) throws Throwable {
System.out.println("========方法开始执行========");
}
}
public interface ITest {
void Fun();
void Fun1();
}
public class Test implements ITest{
@Override
public void Fun(){
System.out.println("Test类的Fun方法被执行!");
}
@Override
public void Fun1() {
System.out.println("Test类的Fun1方法被执行!");
}
}
public class Program {
public static void main(String[] args) {
ApplicationContext context =
new ClassPathXmlApplicationContext("Beans.xml");
//AOP代理的是接口,所以这里的类型不能是类
ITest test = context.getBean("Test",ITest.class);
test.Fun();
System.out.println();
test.Fun1();
/* 运行结果:
* ========方法开始执行========
* Test类的Fun方法被执行!
* ========方法执行结束========
*
* ========方法开始执行========
* Test类的Fun1方法被执行!
* ========方法执行结束========
*/
}
}