Spring 学习笔记 （三）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>

• 创建计算器car接口，定义四个方法

package com.lalila.utils;

public interface Car {
    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);
}

• 创建接口的实现类Callmpl

package com.lalila.utils.impl;

import com.lalila.utils.Car;

public class Callmpl implements Car {

    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.lalila.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));
        Object result = method.invoke(this.object,args);
        System.out.println(method.getName()+"结果为"+result);
        return result;    } }

以上通过动态代理实现AOP过程，Spring框架对AOP进行了封装。
不需要创建InvocationHandler，只需要创建一个切面对象，所有的非业务代码在切面对象中完成即可。Spring框架底层会自动根据切面类及目标类生成一个代理对象。

package com.lalila.utils.aop;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

import java.util.Arrays;
//变成切面对象
@Aspect
//负责管理
@Component
public class LoggerAspect {
    @Before(value = "execution(public int com.lalila.utils.impl.Callmpl.*(..))")
    public void before(JoinPoint joinPoint){
//        获取方法名
        String name= joinPoint.getSignature().getName();
//        获取参数
        String args= Arrays.toString(joinPoint.getArgs());
        System.out.print(name+"的参数为"+args);
    }
}

两个注解

• @Aspect:表示该类是切面类
• @Component:表示该类的对象注入IoC容器中

具体方法添加的注解

• @Before：表示方法执行的位置和时机

Callmpl也需要添加@Component注解

package com.lalila.utils.impl;

import com.lalila.utils.Car;
import org.springframework.stereotype.Component;

@Component
public class Callmpl implements Car {

    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.lalila.utils"> </context:component-scan>
<!-- 让Aspect注解生效，为目标类自动生成代理对象-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

</beans>