AOP配置文件型和纯注解型

AOP配置文件型：

方法一（切面）：

新创建一个接口：

public interface professioner {
    public void talent();
}

在创建一个类来实现接口：

public class engineer implements professioner{
    public void talent(){
        System.out.println("构造相关项目");
    }
}

创建一个切面类：用途就是等同于动态代理中想要加入的一些方法

public class Log {
    public void before(){
        System.out.println("准备好一切预备工作");
    }
    public void after(){
        System.out.println("取得报酬");
    }
}

动态代理中是创建一个 调用程序 来创建代理类，现在交个容器来创建：
配置文件：

导入相关的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: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/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd">

    <bean id="eng" class="engineer"></bean>
    <bean id="log" class="Log"></bean>
    <aop:config>
        <!--将自定义的切面注册-->
        <aop:aspect ref="log">
            <!--被切面加入的目标-->
            <aop:pointcut id="poin" expression="execution(* engineer.*(..))"/>
            <!--将切面中的方法切入到被切面加入的目标中-->
            <aop:before method="before" pointcut-ref="poin"></aop:before>
            <aop:after method="after" pointcut-ref="poin"></aop:after>
        </aop:aspect>
    </aop:config>
</beans>

测试类：

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
    public static void main(String[] args) {
        ApplicationContext context=new ClassPathXmlApplicationContext("Bean.xml");
        professioner professioner=(professioner) context.getBean("eng");
        professioner.talent();
    }
}

方法二:

先创建一个抽象方法：

 interface Musica {
    public void talent();
}

创建一个类来实现它，就是后面所说的目标类：

class Compose implements Musica{
    public void talent(){
        System.out.println("创作曲目");
    }
}

写一个前通知的类，并且实现MethodBeforeAdvice,并且创建一个通知方法：

import org.springframework.aop.MethodBeforeAdvice;

import java.lang.reflect.Method;

 class BeforeAd implements MethodBeforeAdvice {
    public void before(Method method, Object[] args, Object target) throws Throwable{
        System.out.println(target.getClass().getName()+"中的"+method.getName()+"方法被执行了");
    }
 }

写一个后置通知类，且实现AfterReturningAdvice，并且创建一个通知方法：

import org.springframework.aop.AfterReturningAdvice;

import java.lang.reflect.Method;

public class AfterAd implements AfterReturningAdvice {

    @Override
    public void afterReturning(Object o, Method method, Object[] objects, Object o1) throws Throwable {
        System.out.println(method+"方法"+"被执行了，结果是："+o);
    }
}

然后创建配置文件，加入相关约束：

<?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
        http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd ">
        <bean id="after" class="AfterAd"></bean>
        <bean id="compose" class="Compose"></bean>
        <bean id="before" class="BeforeAd"></bean>
        <aop:config>
        <!--目标类-->
                <aop:pointcut id="pointcut" expression="execution(* Compose.*(..))"/>
                <!--将id为before的类切入id为pointcut的目标类中-->
                <aop:advisor advice-ref="before" pointcut-ref="pointcut"></aop:advisor>
                <!--将id为after的类切入id为pointcut的目标类中-->
                <aop:advisor advice-ref="after" pointcut-ref="pointcut"></aop:advisor>
        </aop:config>
</beans>

测试类：

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
    public static void main(String[] args) {
        ApplicationContext context=new ClassPathXmlApplicationContext("Bean.xml");
        Musica musica=(Musica) context.getBean("compose");
        musica.talent();
    }
}

方法一和方法二不同点在于：
第一个方法：通知放在前面还是后面，是由配置文件中的aop:before属性决定
第二个方法：通知前后放置，是由创建的前后通知类所实现的方法（MethodBeforeAdvice和AfterReturningAdvice）来决定的

AOP纯注解型

创建一个接口，再创建一个实现类，里面只有一个简单的方法，内容是输出一段话。创建一个配置类代替配置文件，想办法扫描到上面这个类。然后再创建一个通知类，里面加入前置语句等（自己随便写个方法），通过 @Pointcut等，将最开始那个实现类和前置语句绑在一起

pom.xml文件：spring-aop,spring-context,aspectjweaver：

其中context里面包含aop，可以不用再单独导入aop

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.7.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.4</version>
        </dependency>
    </dependencies>

实现类的接口：

package com.itjh.pojo;

public interface Dao {
    public void save();
}

上面接口的实现类：

package com.itjh.pojo;

import org.springframework.stereotype.Repository;

@Repository
public class DaoImple implements Dao{
    public void save(){
        System.out.println("save方法");
    }
}

通知类，包含通知方法：

• 通过@Pointcut（"execution(void com.itjh.pojo.Dao.save())"）：其中Dao为接口，换成他的实现类也可以，但是接口的范围大点。注解表示这个包中的这个接口的这个方法在被调用时愿意进行一些前置后置环绕等操作，当然，这只是他愿意，能不能真正的执行还得看下面的@Before等注解中，是否写入了上面这些有想法的方法
• 别忘了@Aspect注解

package com.itjh.aop;

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

@Component
@Aspect
public class Myadvice {
    @Pointcut("execution(void com.itjh.pojo.Dao.save())")
    private void pt(){
    }
    @Before("pt()")
    public void method(){
        System.out.println("3D前置，天天静听。。。");
    }
}

配置类：添加@EnableAspectJAutoProxy(proxyTargetClass=true)和上面的@Aspect呼应，这样才能扫描到通知类

package com.itjh.springaopconfig;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@ComponentScan("com.itjh")
@EnableAspectJAutoProxy(proxyTargetClass=true)
public class AopConfig {
}

测试类：直接调用Dao中的方法，这里getBean()中加入实现类也可以

import com.itjh.pojo.Dao;
import com.itjh.springaopconfig.AopConfig;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class TestAop01 {
    public static void main(String[] args) {
        ApplicationContext applicationContext =new AnnotationConfigApplicationContext(AopConfig.class);
        Dao aop =applicationContext.getBean(Dao.class);
        aop.save();
    }
}

结果

3D前置，天天静听。。。
save方法

Process finished with exit code 0

总结： 调用一个实现类，然后加入将通知类和实现类中的这个方法绑在一起，这样调用这个实现类方法产生结果时，就会自动将绑在一起的也输出