AOP面向切面编程

一、静态代理

1.接口

package com.zhidi.service;

public interface PayService {
    /*
     * 支付方法
     */
    public boolean pay(String userName,double money);
 
}

2.目标对象(实现接口)

package com.zhidi.service.imp;

import com.zhidi.service.PayService;
/*
 * 目标对象
 */
public class QQPayService implements PayService {

    @Override
    public boolean pay(String userName, double money) {
        
        System.out.println(userName+"用QQ支付了"+money+"块钱");
        return true;
    }

}

package com.zhidi.service.imp;

import com.zhidi.service.PayService;
/*
 * 目标对象
 */
public class WxPayService implements PayService {

    @Override
    public boolean pay(String userName, double money) {
        System.out.println(userName+"用微信支付了"+money+"块钱");
        return true;
    }

}

3.代理类(实现接口)

package com.zhidi.service.proxy;

import com.zhidi.service.PayService;
/*
 * 静态代理类
 */
public class PayServiceProxy implements PayService {
    //引用目标对象
    private PayService target;
    
    public PayServiceProxy(PayService target) {
        this.target = target;
    }

    @Override
    public boolean pay(String userName, double money) {
        before(userName, money);
        //调用目标对象的pay方法完成支付
        boolean result=target.pay(userName, money);
        after(userName, money, result);
        return result;
    }

    //增加额外的功能
    public void before(String userName, double money)
    {
        System.out.println(userName+"准备用"+money+"钱");
    }
    
    public void after(String userName, double money,boolean result)
    {
        if(result)
        {
            System.out.println("用钱成功");
        }else
        {
            System.out.println("用钱失败");
        }
    }
}

4.测试

package com.zhidi.service.test;


import com.zhidi.service.imp.QQPayService;
import com.zhidi.service.proxy.PayServiceProxy;

public class TestStaticProxy {
    public static void main(String[] args) {
        //创建代理对象并为其指定代理的目标对象
        PayServiceProxy proxy=new PayServiceProxy(new QQPayService());
        proxy.pay("尼古拉斯·赵四", 20000);
    }

}

二、动态代理

1.接口

package com.zhidi.service;

public interface PayService {
    /*
     * 支付方法
     */
    public boolean pay(String userName,double money);
 
}

2.目标对象

package com.zhidi.service.imp;

import com.zhidi.service.PayService;
/*
 * 目标对象
 */
public class QQPayService implements PayService {

    @Override
    public boolean pay(String userName, double money) {
        
        System.out.println(userName+"用QQ支付了"+money+"块钱");
        return true;
    }

}

package com.zhidi.service.imp;

import com.zhidi.service.PayService;
/*
 * 目标对象
 */
public class WxPayService implements PayService {

    @Override
    public boolean pay(String userName, double money) {
        System.out.println(userName+"用微信支付了"+money+"块钱");
        return true;
    }

}

3.代理类

package com.zhidi.service.proxy;

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

import com.zhidi.service.PayService;

/*
 * 动态代理
 */
public class DynamicServiceProxy implements InvocationHandler {
    //目标对象
    private PayService payService;

    public DynamicServiceProxy(PayService payService) {
        this.payService = payService;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //参数在args数组中
        before((String) args[0], (double) args[1]);
        //调用目标对象的目标方法
        Object result = method.invoke(payService, args);
        after((String) args[0], (double) args[1], (boolean) result);
        return result;
    }

    // 增加额外的功能
    public void before(String userName, double money) {
        System.out.println(userName + "准备用" + money + "钱");
    }

    public void after(String userName, double money, boolean result) {
        if (result) {
            System.out.println("用钱成功");
        } else {
            System.out.println("用钱失败");
        }
    }

}

4.测试

package com.zhidi.service.test;

import java.lang.reflect.Proxy;

import com.zhidi.service.PayService;
import com.zhidi.service.imp.QQPayService;
import com.zhidi.service.proxy.DynamicServiceProxy;

public class TestDynamicProxy {
    public static void main(String[] args) {
        // proxy的newProxyInstance()方法用于为目标对象创建代理对象，目标对象和代理对象实现相同的接口
        // ClassLoader loader:类加载器
        // interfacers:目标对象实现的接口
        // h:代理对象通过该对象实现对目标的增强
        PayService proxy = (PayService) Proxy.newProxyInstance(TestDynamicProxy.class.getClassLoader(),
                new Class[] { PayService.class }, new DynamicServiceProxy(new QQPayService()));

        proxy.pay("刘能", 20000);
    }

}

三、基于xml的Spring AOP

1.接口

package com.zhidi.service;

public interface PayService {
    /*
     * 支付方法
     */
    public boolean pay(String userName,double money);
 
}

2.目标对象

package com.zhidi.service.imp;

import com.zhidi.service.PayService;
/*
 * 目标对象
 */
public class QQPayService implements PayService {

    @Override
    public boolean pay(String userName, double money) {
        
        System.out.println(userName+"用QQ支付了"+money+"块钱");
        return true;
    }

}

package com.zhidi.service.imp;

import com.zhidi.service.PayService;
/*
 * 目标对象
 */
public class WxPayService implements PayService {

    @Override
    public boolean pay(String userName, double money) {
        System.out.println(userName+"用微信支付了"+money+"块钱");
        return true;
    }

}

3.通知类

package com.zhidi.advice;

import org.aspectj.lang.ProceedingJoinPoint;

/*
 * 通知类
 */
public class LogAdvice {
    
    //前置通知
    public void before()
    {
        System.out.println("前置通知");
    }
    //后置通知
    public void after()
    {
        System.out.println("后置通知");
    }
    //带参数的前置通知
    public void beforeLog(String userName, double money)
    {
        System.out.println(userName+"准备用"+money+"钱");
    }
    //带参数的后置返回通知
    public void afterLog(String userName, double money,boolean result)
    {
        if(result)
        {
            System.out.println("用钱成功");
        }else
        {
            System.out.println("用钱失败");
        }
    }
    //异常返回通知，是有参的，
    public void afterThrowing(Exception e)
    {
        System.out.println(e.getMessage());
    }
    //后通知，无论什么情况都会执行的，
    public void afterFinally()
    {
        System.out.println("最终返回通知，无论怎样都会执行");
    }
    //环绕通知,是有返回值的，不需要设置
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable
    {
        //环绕前通知
        System.out.println("环绕前通知");
        Object result=    joinPoint.proceed();
        //环绕后通知
        System.out.println("环绕后通知");
        return result;
    }
    
}

4.测试

package com.zhidi.service.test;

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

import com.zhidi.service.PayService;

public class TestAop {

    public static void main(String[] args) {
       ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml"); 
       //通过id获得指定的目标对象
       PayService payService= context.getBean("wxPayService",PayService.class);
       payService.pay("黄老邪", 30000);
    }
}

5.applicationContext.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: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/context http://www.springframework.org/schema/context/spring-context-4.3.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">
    <!-- 将目标对象交给Spring的IOC容器管理 -->
    <bean id="QQPayService" class="com.zhidi.service.imp.QQPayService" />
    <bean id="wxPayService" class="com.zhidi.service.imp.WxPayService" />
    <!-- 将切面支持类纳入Spring的IoC容器管理 ,该类中定义通知实现方法 -->
    <bean id="logAdvice" class="com.zhidi.advice.LogAdvice" />
    <!-- aop定义开始 -->
    <aop:config>
        <!-- 定义全局切入点，该切入点可以应用于多个切面定义中 expression="execution(public boolean com.zhidi.service.imp.QQPayService.pay(java.lang.String,java.lang.Double)) -->
        <aop:pointcut expression="execution(* com.zhidi.service..*.pay(..))"
            id="pointcut" />
        <!-- 定义切面，同时指定该切面所需的切面支持类（通知所在类） -->
        <aop:aspect ref="logAdvice">
            <!-- 定义前置通知， -->
            <aop:before method="before" pointcut-ref="pointcut" />
            <!-- 后置返回通知 -->
            <aop:after-returning method="after" pointcut-ref="pointcut" />
            <!-- 前置通知，带有参数 -->
            <aop:before method="beforeLog"
                pointcut="execution(* com.zhidi.service..*.pay(..)) and args(userName,money)"
                arg-names="userName,money" />
            <!-- 带参数的后置返回通知 -->
            <aop:after-returning method="afterLog"
                pointcut="execution(* com.zhidi.service..*.pay(..)) and args(userName,money)"
                returning="result" arg-names="userName,money,result" />
            <!-- 异常返回通知 -->
            <aop:after-throwing method="afterThrowing"
                pointcut-ref="pointcut" throwing="e" />
            <!-- 后通知 -->
            <aop:after method="afterFinally" pointcut-ref="pointcut" />
            <!-- 环绕通知 -->
            <aop:around method="around" pointcut-ref="pointcut" />
        </aop:aspect>
    </aop:config>

</beans>

四、基于@AspectJ风格的AOP(接口、目标对象和测试以上一样)

1.通知类

package com.zhidi.advice;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

/*
 * 通知类
 */
//基于@Aspect的AOP
@Component // 将当前的Bean交给Spring的IOC容器管理
@Aspect // 将该Bean定义为切面
public class LogAonnection {

    // 前置通知
    @Before("execution(* com.zhidi.service..*.*(..))")
    public void before() {
        System.out.println("前置通知");
    }

    // 后置通知
    @AfterReturning("execution(* com.zhidi.service..*.*(..))")
    public void after() {
        System.out.println("后置通知");
    }

    // 带参数的前置通知
    @Before(value = "execution(* com.zhidi.service..*.*(..)) and args(userName,money)", argNames = "userName,money")
    public void beforeLog(String userName, double money) {
        System.out.println(userName + "准备用" + money + "钱");
    }

    // 带参数的后置返回通知
    @AfterReturning(value = "execution(* com.zhidi.service..*.*(..)) and args(userName,money)", returning = "result", argNames = "userName,money,result")
    public void afterLog(String userName, double money, boolean result) {
        if (result) {
            System.out.println("用钱成功");
        } else {
            System.out.println("用钱失败");
        }
    }

    // 异常返回通知，是有参的，
    @AfterThrowing(value = "execution(* com.zhidi.service..*.*(..))", throwing = "e")
    public void afterThrowing(Exception e) {
        System.out.println(e.getMessage());
    }

    // 后通知，无论什么情况都会执行的，
    @After(value = "execution(* com.zhidi.service..*.*(..))")
    public void afterFinally() {
        System.out.println("最终返回通知，无论怎样都会执行");
    }

    // 环绕通知,是有返回值的，不需要设置
    @Around(value = "execution(* com.zhidi.service..*.*(..))")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        // 环绕前通知
        System.out.println("环绕前通知");
        Object result = joinPoint.proceed();
        // 环绕后通知
        System.out.println("环绕后通知");
        return result;
    }

}

2.applicationContext.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: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/context http://www.springframework.org/schema/context/spring-context-4.3.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">
    <!-- 开启注解配置 -->
    <context:component-scan base-package="com.zhidi"/>
    <!-- aspectj注解配置  -->
    <aop:aspectj-autoproxy/> 
    <!-- 将目标对象交给Spring的IOC容器管理 -->
    <bean id="QQPayService" class="com.zhidi.service.imp.QQPayService" />
    <bean id="wxPayService" class="com.zhidi.service.imp.WxPayService" />


</beans>