十.mian向切面编程---方法一

代理模式：动态代理和静态代理要先学会，aop就是根据动态代理实现的

1.概念

面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，

也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，

从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

 

 

 2.aop在spring中

在不改变原有代码的情况下，为我们的业务代码增加新的功能

 

 

 

 3.一边使用，一边去了解它

先导入aop织入的jar包

<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.5</version>
</dependency>

使用方式一：继承spring的aop接口

 

先写2个测试日志类：一个是在执行之前切入，一个是在执行之后切入；再写一个service类，来模拟crud

package com.why.aop;
import org.springframework.aop.AfterReturningAdvice;
import org.springframework.stereotype.Component;
import java.lang.reflect.Method;
/**
 * @program: AOP
 * @description:
 * @author: @why
 * @create: 2020-08-31 20:25
 **/
@Component
public class AfterLog implements AfterReturningAdvice {
    /**
     *
     * @param returnValue:方法的返回值
     * @param method：执行的方法
     * @param args：方法参数
     * @param target：那个对象执行的这个方法
     * @throws Throwable
     */
    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
       System.out.println(method.getName()+"执行了，执行者"+target.getClass().getName());
    }
}

package com.why.aop;
import org.springframework.aop.MethodBeforeAdvice;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

/**
 * @program: AOP
 * @description:
 * @author: @why
 * @create: 2020-08-31 20:28
 **/
@Component
public class BeforeLog implements MethodBeforeAdvice {
    /**
     *
     * @param method:需要执行的方法
     * @param args：方法参数
     * @param target：那个对象执行的这个方法
     * @throws Throwable
     */
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println("before!!!!!(破喉咙！！！)");
    }
}

package com.why.serivce;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.stereotype.Component;
/**
 * @program: AOP
 * @description:
 * @author: @why
 * @create: 2020-08-31 20:23
 **/
@Component
public class ServiceIml implements  Service {
    @Override
    public void add() {
        System.out.println("我是add");
    }
    @Override
    public void delete() {
        System.out.println("我是delete");
    }
    @Override
    public void update() {
        System.out.println("我是update");
    }
    @Override
    public void select() {
        System.out.println("我是select");

    }
}

配置spring-config.xml文件

  <aop:config proxy-target-class="true">  要设置为动态代理模式！！！

<?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 
https://www.springframework.org/schema/context/spring-context.xsd
 http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">

    <context:component-scan base-package="com.why"/>


    <!--            配置aop 注意这里：给类使用注解，要使用动态代理                     -->
    <aop:config proxy-target-class="true">
        <!--        切入点，就是当原生的业务代码执行的时候，我们从哪个地方切入           -->
        <!--        第一个*是指返回参数的类型任意；com.why.serivce.ServiceIml就是你想要切入的类；-->
        <!--         切入的类：com.why.serivce.ServiceIml                             -->
        <!--         .*(..)这部分指的是你要切入的方法，.*是指所有方法,(..)是指方法中的参数-->
        <aop:pointcut id="cut" expression="execution(* com.why.serivce.ServiceIml.*(..))"/>

        <!--        环绕增加，就是开始切入了-->
        <aop:advisor advice-ref="afterLog" pointcut-ref="cut"/>
        <aop:advisor advice-ref="beforeLog" pointcut-ref="cut"/>
    </aop:config>
</beans>

 

执行代码：