Spring AOP

函数增强，当前有二种处理方式，

a. 基于jdk的接口动态代理增强

b. 基于 cglib 的父类动态代理增强

在Spring框架中，在动态代理增加时，依据是否有接口来自动识别并实现增强

如果有接口，将使用基于 jdk的接口动态代理，否则使用基于cglib的父类动态代理增强；

 

01. 基于 jdk 动态代理增强

　　>> 要求： 必须有接口；否则无法实现动态代理;

　　>> 代码实现

//接口
public interface TargetInterface {
    public void save();
}

//接口实现
public class Target implements TargetInterface {
    @Override
    public void save() {
        System.out.println("目标方法执行 ... ");
    }
}

//增强对象
public class Advice {

    public void preAdvice(){
        System.out.println("前置增强...");
    }

    public void sufAdvice(){
        System.out.println("后置增强...");
    }
}

 

//动态代理增强
    public static void main(String[] args) {
        //目标对象
        Target target = new Target();
        //增强对象
        Advice advice = new Advice();
        //jdk的接口代理增强
        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.preAdvice();
                        Object invoke = method.invoke(target, args);
                        advice.sufAdvice();
                        return invoke;
                    }
                }
        );
        proxyInstance.save();
    }

 

02.基于cglib的动态代理增强

　　>> 无接口要求

　　>> 代码实现 (增强对象与上面一样)

//目标对象  
public class Target  {
    public void save() {
        System.out.println("目标方法执行 ... ");
    }
}

 

//动态代理增强
    public static void main(String[] args) {
        //目标对象
        Target target = new Target();
        //增强对象
        Advice advice = new Advice();
        //cglib增强对象
        Enhancer enhancer = new Enhancer();
        //设置父类
        enhancer.setSuperclass(target.getClass());
        //设置回调
        enhancer.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
               advice.preAdvice();
                Object invoke = method.invoke(target, args);
                advice.sufAdvice();
                return invoke;
            }
        });
        //生成代理对象
        Target o = (Target) enhancer.create();
        o.save();

    }

 

03. 基于Spring 配置实现动态代理增强  (目标对象带接口)

// applicationContext.xml 配置
<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="club.wuyu.proxy.AOP.Target"/>
    <!--目标对象(无接口)-->
    <bean id="targetcglib" class="club.wuyu.proxy.AOP.TargetCglib"/>
    <!--切面对象-->
    <bean id="advice" class="club.wuyu.proxy.AOP.Advice"/>

    <!--织入-->
    <aop:config>
        <aop:aspect ref="advice">
            <aop:before method="preAdvice" pointcut="execution(public void club.wuyu.proxy.AOP.Target.save())"/>
            <aop:after method="sufAdvice" pointcut="execution(public void club.wuyu.proxy.AOP.Target.save())"/>

            <aop:before method="preAdvice" pointcut="execution(public void club.wuyu.proxy.AOP.TargetCglib.save())"/>
            <aop:after method="sufAdvice" pointcut="execution(public void club.wuyu.proxy.AOP.TargetCglib.save())"/>
        </aop:aspect>
    </aop:config>
</beans>

//测试
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class AOPTest {

    @Autowired
    private TargetInterface targetInterface;

    @Autowired
    private TargetCglib targetCglib;

    @Test
    public void test02(){
        targetCglib.save();
    }

    @Test
    public void test01(){
        targetInterface.save();
    }
}

 

04. AOP配置说明

　　

 

　　

 

 　　>> 环绕方法的配置

　　　　　<aop:around method="around" pointcut="execution(* com.itheima.aop.*.*(..))"/>　

　　　　

 　　>> 切点表达式的抽取, 便于多个不同的切点类型引用切点表达式；

　　　　切点表达式的引用：pointcut-ref 

05. 关于注解方式动态代理的实现

　　>> 创建目标接口及目标类 (内部有目标方法); 　 

　　>> 创建切面类 (内部有增强方法) 

　　>> 将目标类和切面类做注解申明，将对象的创建权交由Spring; @Componet 注解;

 　  >> 在切面类中使用注解，配置织入关系   

@Component("advice")    //切面类的创建权，交由Spring
@Aspect                         //标识当前类为一个切面类
public class Advice {

    @Before("execution(* club.wuyu.proxy.anno.*.*(..))") //织入
    public void preAdvice(){
        System.out.println("前置增强...");
    }
    @After("execution(* club.wuyu.proxy.anno.*.*(..))") //织入
    public void sufAdvice(){
        System.out.println("后置增强...");
    }
}

 　　>> 配置文件

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

    <context:component-scan base-package="club.wuyu.proxy.anno"/>

    <aop:aspectj-autoproxy proxy-target-class="true"/>
    <!--<aop:aspectj-autoproxy/>-->

</beans>

 

　　<aop:aspectj-autoproxy />声明自动为spring容器中那些配置@aspect 切面的bean创建代理，织入切面。

　　<aop:aspectj-autoproxy />的proxy-target-class属性，默认为false，表示使用jdk动态代理织入增强。

　　当配为<aop:aspectj-autoproxy  poxy-target-class="true"/>时，表示使用CGLib动态代理技术织入增强。

　　如果proxy-target-class设置为false，但是目标类没有声明接口，则spring将自动使用CGLib动态代理。

　　>> 关于 but was actually of type 'com.sun.proxy.$Proxy20' 错误的原因及处理

　　>> 在 java 中，默认使用的动态代理是JDK基于接口的代理，如果出现上述错误，极有可能是在自动注入的时候，注入到了目标对象的实现类上，而不是目标对象的接口上;

　　　即：配置  <aop:aspectj-autoproxy/>

           或：配置  <aop:aspectj-autoproxy proxy-target-class="false"/>   时

　　    自动注入配置到了实现类上

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext-anno.xml")
public class AnnoTest {

    @Autowired
    private Target target;

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

 

　　正确的注入，应该是接口

    @Autowired
    private TargetInterface target;

 

       或者，直接配置为 CGLib 动态代理，　

　　即：<aop:aspectj-autoproxy proxy-target-class="true"/> 

 

　　>> 注解方式下，切点表达式的抽取