JDK动态代理在Spring AOP中的实现

JDK动态代理在Spring AOP中的实现

动态代理机制

  • 通过实现 InvocationHandler 接口创建自己的调用处理器

  • 通过为 Proxy 类指定 ClassLoader 对象和一组 interface 来创建动态代理类

  • 通过反射机制获得动态代理类的构造函数,其唯一参数类型是调用处理器接口类型

  • 通过构造函数创建动态代理类实例,构造时调用处理器对象作为参数被传入

AOP思想

  • OOP中引入封装、继承和多态性等概念来建立一种对象层次结构,用以模拟公共行为的一个集合。

  • AOP技术利用一种称为“横切”的技术,解剖封装的对象内部,并将那些影响了多个类的公共行为封装到一个可重用模块,这样就能减少系统的重复代码,降低模块间的耦合度,并有利于未来的可操作性和可维护性。

  • AOP把软件系统分为两个部分:核心关注点和横切关注点,业务处理的主要流程是核心关注点,与之关系不大的部分是横切关注点。

动态代理源码实现 AopProxyFactory

public class DefaultAopProxyFactory implements AopProxyFactory, Serializable {

    @Override
    public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
        if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
            Class targetClass = config.getTargetClass();
            if (targetClass == null) {
                throw new AopConfigException("TargetSource cannot determine target class: " +
                        "Either an interface or a target is required for proxy creation.");
            }
            if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
                // 表示在有接口实现的时候采用JDK动态代理
                return new JdkDynamicAopProxy(config);
            }
            // 在没有接口实现的时候采用Cglib动态代理
            return new ObjenesisCglibAopProxy(config);
        }
        else {
            return new JdkDynamicAopProxy(config);
        }
    }

Spring中AOP的实现

程序自上而下执行,与主业务逻辑的关系不大的横切性问题,aop面向切面编程,就是将主业务与横切代码分离,做到解耦。

常见实现有:

  • 统一日志处理
  • 统一异常处理
  • Spring事务管理

代码实现

定义接口

/**
 * @ClassName: BuyService
 * @Description: 购买基础接口
 * @Author: 尚先生
 * @CreateDate: 2019/6/17 14:52
 * @Version: 1.0
 */
public interface BuyService {

    String buyPhone(BuyService buyService);

    String buyComputer(BuyService buyService);

}

定义实现类

/**
 * @ClassName: BusiServiceImpl
 * @Description: 购买实现类
 * @Author: 尚先生
 * @CreateDate: 2019/6/17 14:53
 * @Version: 1.0
 */
@Service
public class BuyServiceImpl implements BuyService {

    @Intercept("buyPhone")
    @Override
    public String buyPhone(BuyService buyService) {
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("==========当前类描述 " + buyService.getClass().getName() + "=============" + " buyPhone");
        this.buyComputer(this);
        return "buy phone";
    }

    @Intercept("buyComputer")
    @Override
    public String buyComputer(BuyService buyService) {
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("==========当前类描述 " + buyService.getClass().getName() + "=============" + " buyComputer");
        return "buy computer";
    }
}

自定义拦截注解

/**
 * @ClassName: Intercept
 * @Description: 自定义拦截器注解
 * @Author: 尚先生
 * @CreateDate: 2019/6/17 16:28
 * @Version: 1.0
 */
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Intercept {

    String value() default "";
}

自定义拦截器实现

/**
 * @ClassName: Interceptor
 * @Description: 拦截器实现类
 * @Author: 尚先生
 * @CreateDate: 2019/6/17 15:12
 * @Version: 1.0
 */
@Component
@Aspect
public class Interceptor {
    @Pointcut(value = "@annotation(com.learn.demo.java.proxy.Intercept)")
    public void buySomething() {
        System.out.println("===========自定义切入点===============");
    }
    @Around("buySomething()")
    public Object around(ProceedingJoinPoint point) throws Throwable {
        try {
            //通过获取 Intercept 注解
            Method proxyMethod = ((MethodSignature) point.getSignature()).getMethod();
            Method targetMethod = point.getTarget().getClass().getMethod(proxyMethod.getName(), proxyMethod.getParameterTypes());
            Intercept intercept = targetMethod.getAnnotation(Intercept.class);
            String methodName = targetMethod.getName();
            //处理注解逻辑
            String value = intercept.value();
            System.err.println("=========== " + methodName + " 获取前置拦截信息 ===========" + value);
            return point.proceed();
        } catch (Throwable e) {
            System.out.println("执行异常"+ e.getMessage());
        }finally {
            System.err.println("=========== " + " 后置处理结果返回 ===========");
        }
        return "执行异常,请查看详细日志信息";
    }
}

自定义拦截器配置类

/**
 * @ClassName: AspectJConfig
 * @Description: 开启Spring对AspectJ的支持
 * @Author: 尚先生
 * @CreateDate: 2019/6/17 18:39
 * @Version: 1.0
 */
@Configuration
@ComponentScan("com.learn.demo.java.proxy")
@EnableAspectJAutoProxy
public class AspectJConfiguration {
}

启动引导类

/**
 * @ClassName: Bootstrap
 * @Description: 启动测试类
 * @Author: 尚先生
 * @CreateDate: 2019/6/17 14:58
 * @Version: 1.0
 */
public class Bootstrap {
    public static void main(String[] args) {
        // spring 采用的 jdk 动态代理
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();

        context.scan("com.learn.demo.java.proxy");

        context.register(Interceptor.class);

        context.refresh();

        BuyService bean = context.getBean("buyServiceImpl", BuyService.class);

        String phone = bean.buyPhone(bean);

        System.err.println("=========Bootstrap.class============== " + phone);

        // 输出代理对象 class 文件
        createProxyClassFile();
    }

    /**
     * 生成代理文件
     */
    private static void createProxyClassFile() {
        String name = "ProxyBuyService";
        byte[] data = ProxyGenerator.generateProxyClass(name,
                new Class[] {BuyService.class});
        FileOutputStream out = null;
        try {
            out = new FileOutputStream("D://" + name + ".class");
            out.write(data);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (null != out)
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
        }
    }
}

执行结果

=========== buyPhone 获取前置拦截信息 ===========buyPhone
==========当前类描述 com.sun.proxy.$Proxy22============= buyPhone
===========  后置处理结果返回 ===========
=========Bootstrap.class============== buy phone
==========当前类描述 com.learn.demo.java.proxy.BuyServiceImpl============= buyComputer

流程分析

  • 从执行结果中可以明确看到在buyPhone()中执行的对象com.sun.proxy.$Proxy22,而后执行this.buyComputer(this);执行的对象变为com.learn.demo.java.proxy.BuyServiceImpl,所以在面向切面编程时只会拦截buyPhone()方法。

  • 主要是生成的代理对象跟被代理对象不是同一个,所以后者调用类方法就像是直接调用,不会走切面。

  • 代码已经在GitHub中更新,更多详情可关注dwyanewede。更多JDK动态代理,可参见上篇文章:JDK动态代理实现原理

更多优秀文章

java界的小学生
https://blog.csdn.net/shang_xs

公众号推荐

在这里插入图片描述

你可能感兴趣的:(JDK动态代理在Spring AOP中的实现)