代理模式

静态代理：静态代理确实实现了解耦，但是由于代码都写死了，完全不具备任何的灵活性。就拿日志功能来说，将来其他地方也需要附加日志，那还得再声明更多个静态代理类，那就产生了大量重复的代码，日志功能还是分散的，没有统一管理。

动态代理：解决静态代理的写死性，减少重复代码的出现。

动态代理的例子

CalcultorImpl实现类

public class CalculatorImpl implements Calcultor{

    @Override
    public int add(int num1, int num2) {
        return num1 + num2;
    }

    @Override
    public int minus(int num1, int num2) {
        return num1 - num2;
    }
}

生产代理对象的工厂类ProxyFactory

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.util.Arrays;

//代理工厂
//在使用Calculator类的方法时打印对应的信息
//实现动态代理
public class ProxyFactory {
    //目标类
    private Object target;

    //构造方法
    public ProxyFactory(Object target) {
        this.target = target;
    }

    //获取对应代理类的方法
    public Object getProxy() {
        /**
         * ClassLoader loader:类加载器，就是target的类加载器
         * Class<?>[] interfaces：target的使用实现的接口，loader和interfaces用与代理类的生成，可以把代理类理解成target的子类
         * InvocationHandler h：将具体的处理步骤写在这类中，完成解藕合
         */
        ClassLoader classLoader = target.getClass().getClassLoader();
        Class<?>[] interfaces = target.getClass().getInterfaces();
        InvocationHandler invocationHandler = (proxy, method, args) -> {
            /**
             * proxy:代理对象
             * method当前调用的方法
             * 当前调用方法的参数
             */
            //方法执行前的打印
            System.out.println("调用函数的名字" + method.getName() + ", 参数:" + Arrays.toString(args));
            Object result = method.invoke(target, args);
            System.out.println("结果为:" + result);
            System.out.println("执行完毕");
            return result;
        };
        System.out.println(invocationHandler);
        //通过Proxy获取对应的代理类
        return Proxy.newProxyInstance(classLoader, interfaces, invocationHandler);
    }
}

测试类

public static void main(String[] args) {
        ProxyFactory proxyFactory = new ProxyFactory(new CalculatorImpl());
        System.out.println(proxyFactory.getProxy());
        //动态代理需要基于接口，所以强转类型只能为接口，如果使用实现类会报错
        //所以存在实体类要基于接口实现
        Calcultor proxy = (Calcultor) proxyFactory.getProxy();
        System.out.println(proxy.add(1, 3));
    }

动态代理需要基于接口，所以强转类型只能为接口，如果使用实现类会报错,所以存在实体类要基于接口实现。

AOP

AOP（Aspect Oriented Programming）是一种设计思想，是软件设计领域中的面向切面编程，它是面向对象编程的一种补充和完善，它以通过预编译方式和运行期动态代理方式实现，在不修改源代码的情况下，给程序动态统一添加额外功能的一种技术。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

增强(通知)

增强，通俗说，就是你想要增强的功能，比如安全，事务，日志等。

每一个横切关注点上要做的事情都需要写一个方法来实现，这样的方法就叫通知方法。

前置通知：在被代理的目标方法前执行
返回通知：在被代理的目标方法成功结束后执行（寿终正寝）
异常通知：在被代理的目标方法异常结束后执行（死于非命）
后置通知：在被代理的目标方法最终结束后执行（盖棺定论）
环绕通知：使用try...catch...finally结构围绕整个被代理的目标方法，包括上面四种通知对应的所有位置，可以完成前面四种通知。

增强通知例子

引入aspect的依赖

 <!--spring aop依赖-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aop</artifactId>
        <version>5.3.20</version>
    </dependency>
    <!--spring aspects依赖-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aspects</artifactId>
        <version>5.3.20</version>
    </dependency>

创建bean.xml配置文件，并配置注解扫描和切面的自动代理

<?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">
    <!--
        基于注解的AOP的实现：
        1、将目标对象和切面交给IOC容器管理（注解+扫描）
        2、开启AspectJ的自动代理，为目标对象自动生成代理
        3、将切面类通过注解@Aspect标识
    -->
    <context:component-scan base-package="com.huang"></context:component-scan>

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

创建接口并创建实现类

import org.springframework.stereotype.Component;

@Component
public class CalculatorImpl implements Calculator{
    @Override
    public int add(int num1, int num2) {
        return num1 + num2;
    }

    @Override
    public int div(int num1, int num2) {
        return num1 / num2;
    }
}

创建切面配置类

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

import java.util.Arrays;

@Component
@Aspect
//切面类
public class LogAspect {

    //前置通知
    //会在对应的方法执行之前完成对应的切面操作
    @Before(value = "execution(* com.huang.CalculatorImpl.*(..))")
    public void BeforeMethod(JoinPoint joinPoint) {
        System.out.println("执行Before通知:" + joinPoint.getSignature().getName());
    }

    //后置通知
    //会在对应的方法执行之后完成对应的切面操作,是在返回之后
    @After(value = "execution(* com.huang.CalculatorImpl.*(..))")
    public void AfterMethod(JoinPoint joinPoint) {
        System.out.println("执行after通知:" + joinPoint.getSignature().getName());
    }

    //返回通知
    //会在对应的方法返回数据时进行
    //returning 中的返回值的名字是自定义的
    @AfterReturning(value = "execution(* com.huang.CalculatorImpl.*(..))", returning = "result")
    public void ReturnMethod(JoinPoint joinPoint, Object result) {
        System.out.println("执行return通知" + joinPoint.getSignature().
                getName() + ": 对应的返回值为:" + result);
    }

    //异常通知
    //会在发生异常时进行通知
    @AfterThrowing(value = "execution(* com.huang.CalculatorImpl.*(..))", throwing = "ex")
    public void ThrowMethod(JoinPoint joinPoint, Throwable ex) {
        System.out.println("在发生异常时执行:" + joinPoint.getSignature().
                getName() + ";对应的异常为:" + ex);
    }

    //环绕同时
    //环绕可以完成上述四种操作
    //ProceedingJoinPoint,可以实现目标类的方法
    @Around(value = "execution(* com.huang.CalculatorImpl.*(..))")
    public Object AroundMethod(ProceedingJoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        String args = Arrays.toString(joinPoint.getArgs());
        Object result = null;
        //就是模拟上述的四个位置
        try {
            System.out.println("环绕通知-->目标对象方法执行之前");
            //目标对象（连接点）方法的执行
            result = joinPoint.proceed();
            System.out.println("环绕通知-->目标对象方法返回值之后");
        } catch (Throwable throwable) {
            throwable.printStackTrace();
            System.out.println("环绕通知-->目标对象方法出现异常时");
        } finally {
            System.out.println("环绕通知-->目标对象方法执行完毕");
        }
        return result;
    }
}

编写测试类最终完成测试，结果为下

在方法调用时对应切面位置的通知都执行了。

重用切入点表达式

通过创建可以方法在此方法上添加切入点的信息，最终只要通过使用该方法就可以完成重用切入点表达式操作。

  /**
     *     //后置通知
     *     //会在对应的方法执行之后完成对应的切面操作,是在返回之后
     *     @After(value = "pointCut()")
     *     public void AfterMethod(JoinPoint joinPoint) {
     *         System.out.println("执行after通知:" + joinPoint.getSignature().getName());
     *     }
     * 
     */
    

    //在使用时调用方法即可
    @Pointcut(value = "execution(* com.huang.CalculatorImpl.*(..))")
    public void pointCut() {

    }

优先级

通过@order注解来调整优先级，越小越大。（1 > 2）

通过xml文件实现AOP配置

aopbean.xml文件配置

<?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="com.huang"></context:component-scan>

   <aop:config>
<!--       配置切面-->
       <aop:pointcut id="pointcut" expression="execution(* com.huang.CalculatorImpl.*(..))"/>
<!--       设置切面配置类-->
       <aop:aspect ref="logAspect">
<!--           前置通知-->
           <aop:before method="BeforeMethod" pointcut-ref="pointcut"></aop:before>
<!--           后置通知-->
           <aop:after method="AfterMethod" pointcut-ref="pointcut"></aop:after>
<!--           返回通知-->
           <aop:after-returning method="ReturnMethod" pointcut-ref="pointcut" returning="result"></aop:after-returning>
<!--           异常通知-->
           <aop:after-throwing method="ThrowMethod" pointcut-ref="pointcut" throwing="ex"></aop:after-throwing>
<!--           环绕通知-->
           <aop:around method="AroundMethod" pointcut-ref="pointcut"></aop:around>
       </aop:aspect>
   </aop:config>


<!--    <aop:aspectj-autoproxy /> 自动代理使用此方法-->
</beans>

完成配置进行测试结果和自动配置效果一样。