Spring Aop实现简单代码实现

/*
* spring的AOP面向切面编程
* 理解：在不改变原来方法的基础上，实现方法增强处理
* 实现方式：
* 1.jdk的Proxy：动态代理，执行的时候处理，要求必须有接口、实现类，代理创建的是实现类的子类。
* 2.cglib:第三方实现的动态代理，要求必须有父类，代理创建的是父类的子类，比jdk实现的要灵活。
* AOP中如果有接口则用jkd动态代理，没有则用cglib
*

* */

jdk实现代码：
代码结构：
1.目标类：Target
2.目标接口类：TargetInterface
3.增强方法类：Advice
4.用Proxy.newProxyInstance实现对目标类的方法增强

public class Target implements TargetInterface {
    @Override
    public void save() {
        System.out.println("save run ...");
    }
}

public interface TargetInterface {
    void save();
}

public class Advice {
    public void before(){
        System.out.println("增强前方法。。。。");
    }

    public void after(){
        System.out.println("增强后方法");
    }
}

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class ProxyText {
    public static void main(String[] args) {
        Target target=new Target();

        Advice advice=new Advice();


        TargetInterface proxyInstance = (TargetInterface)Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                advice.after();
                Object invoke = method.invoke(target, args);
                advice.after();
                return invoke;
            }
        });

        proxyInstance.save();
    }
}

cglib实现：
目标类和增强方法一样

import org.springframework.cglib.proxy.*;
import java.lang.reflect.Method;

/*
* spring的AOP面向切面编程
* 理解：在不改变原来方法的基础上，实现方法增强处理
* 实现方式：
* 1.jdk的Proxy：动态代理，执行的时候处理，要求必须有接口、实现类，代理创建的是实现类的子类。
* 2.cglib:第三方实现的动态代理，要求必须有父类，代理创建的是父类的子类，比jdk实现的要灵活。
* AOP中如果有接口则用jkd动态代理，没有则用cglib
*
* cglib步骤：
* 1.导入包org.aspectj
* 2.代码实现，如下。实现代码和Proxy.newProxyInstance差不多
* */
public class ProxyTest {
    public static void main(String[] args) {
        //目标对象
        Target target=new Target();

        //增强对象
        Advice advice=new Advice();

        //1.创建增强器
        Enhancer enhancer=new Enhancer();
        //2.设置父目标
        enhancer.setSuperclass(Target.class);
        //3.设置回调
        enhancer.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                advice.before();
                Object invoke = method.invoke(target, objects);
                advice.after();

                return invoke;
            }
        });
        //4.创建代理对象
        Target proxy = (Target) enhancer.create();
        proxy.save();
    }
}

 spring配置方式实现;

包配置：

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.4</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.0.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>

xml方式实现：

1.target类

public class Target implements TargetInterface {

    @Override
    public void save() {
        System.out.println("save run ...");
    }
}

2.接口

public interface TargetInterface {
    void save();
}

3.切面类

import org.aspectj.lang.ProceedingJoinPoint;

/*
* aop的重点概念：
        Pointcut（切入点）：被增强的方法
        Advice（通知/ 增强）：封装增强业务逻辑的方法
        Aspect（切面）：切点+通知
        Weaving（织入）：将切点与通知结合的过程

*
*
*
* 前置通知        <aop:before>            用于配置前置通知。指定增强的方法在切入点方法之前执行
  后置通知        <aop:after-returning>    用于配置后置通知。指定增强的方法在切入点方法之后执行
  环绕通知        <aop:around>            用于配置环绕通知。指定增强的方法在切入点方法之前和之后都执行
  异常抛出通知    <aop:throwing>            用于配置异常抛出通知。指定增强的方法在出现异常时执行
  最终通知        <aop:after>                用于配置最终通知。无论增强方式执行是否有异常都会执行
* */
public class MyAspect {
    public void before(){
        System.out.println("before增强方法");
    }


    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("around增强前");
        Object proceed = pjp.proceed();
        System.out.println("around增强后");
        return proceed;
    }
}

4.配置

<?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="target" class="cn.web.aop.Target"></bean>

    <!--切面对象-->
    <bean id="myAspect" class="cn.web.aop.MyAspect"></bean>

    <!--配置织入：告诉spring哪些方法需要那总增强-->
    <aop:config>
        <!--声明切面-->
        <aop:aspect ref="myAspect">
            <!--切点表达式-->
            <aop:pointcut id="pointcut" expression="execution( * cn.web.aop.Target.*())"></aop:pointcut>
            <!--切面：切点+通知-->
            <!--<aop:before method="before" pointcut="execution(public void cn.web.aop.Target.save())"></aop:before>-->
            <!--返回值、包、类、方法都可以用通配符取代，表示里面的所有类、方法等-->
            <aop:before method="before" pointcut="execution( * cn.web.aop.Target.*())"></aop:before>

            <aop:around method="around" pointcut-ref="pointcut"></aop:around>
        </aop:aspect>
    </aop:config>
</beans>

5.测试

import cn.web.aop.TargetInterface;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class AopTest {

    @Autowired
    private TargetInterface target;

    @Test
    public void test(){
        target.save();
    }
}

注解方式实现；

就列些不同的

1.切面类

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

/*
* aop的重点概念：
        Pointcut（切入点）：被增强的方法
        Advice（通知/ 增强）：封装增强业务逻辑的方法
        Aspect（切面）：切点+通知
        Weaving（织入）：将切点与通知结合的过程

*
*
*
* 前置通知        <aop:before>            用于配置前置通知。指定增强的方法在切入点方法之前执行
  后置通知        <aop:after-returning>    用于配置后置通知。指定增强的方法在切入点方法之后执行
  环绕通知        <aop:around>            用于配置环绕通知。指定增强的方法在切入点方法之前和之后都执行
  异常抛出通知    <aop:throwing>            用于配置异常抛出通知。指定增强的方法在出现异常时执行
  最终通知        <aop:after>                用于配置最终通知。无论增强方式执行是否有异常都会执行
* */
@Component
@Aspect
public class MyAspect {

    @Before("execution(* cn.web.aop.Target.*(..))")
    public void before(){
        System.out.println("before增强方法");
    }


    @Around("pointcut()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("around增强前");
        Object proceed = pjp.proceed();
        System.out.println("around增强后");
        return proceed;
    }

    @AfterReturning("pointcut()")
    public void afterReturning(){
        System.out.println("afterReturning返回后");
    }


    //设置切点表达式：可以共用
    @Pointcut("execution(* cn.web.aop.Target.*(..))")
    public void pointcut(){

    }
}

2.配置

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

    <!--组件扫描-->
    <context:component-scan base-package="com.itheima.anno"/>

    <!--aop自动代理-->
    <aop:aspectj-autoproxy/>

</beans>

3.测试

import cn.web.anno.TargetInterface;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext_anno.xml")
public class AnnoTest {

    @Autowired
    private TargetInterface target;

    @Test
    public void test(){
        target.save();
    }
}