aop 两种代理方式初探

cglib源码,需要的请自行前往——https://github.com/cglib/cglib/wiki

两种代理的区别:

java动态代理是利用反射机制生成一个实现代理接口的匿名类,在调用具体方法前调用InvokeHandler来处理。

而cglib动态代理是利用asm开源包,对代理对象类的class文件加载进来,通过修改其字节码生成子类来处理。

1、如果目标对象实现了接口,默认情况下会采用JDK的动态代理实现AOP  2、如果目标对象实现了接口,可以强制使用CGLIB实现AOP  3、如果目标对象没有实现了接口,必须采用CGLIB库,spring会自动在JDK动态代理和CGLIB之间转换

如何强制使用CGLIB实现AOP?  (1)添加CGLIB库,SPRING_HOME/cglib/*.jar  (2)在spring配置文件中加入<aop:aspectj-autoproxy proxy-target-class="true"/>

JDK动态代理和CGLIB字节码生成的区别?  (1)JDK动态代理只能对实现了接口的类生成代理,而不能针对类  (2)CGLIB是针对类实现代理,主要是对指定的类生成一个子类,覆盖其中的方法    因为是继承,所以该类或方法最好不要声明成final 

talk is cheap , show me the code.  

a simple e.g——

我用的spring boot,quik start —— http://start.spring.io

加入 aspects 的起步依赖即可,会快速生成一个demo工程,打开工程,会看到对应的pom.xml结构如下:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>

	<groupId>com.example</groupId>
	<artifactId>demo</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>

	<name>demo</name>
	<description>Demo project for Spring Boot</description>

	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.5.9.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
		<java.version>1.8</java.version>
		<spring-cloud.version>Edgware.SR1</spring-cloud.version>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-aop</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter</artifactId>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>

		<!--<dependency>-->
			<!--<groupId>org.aspectj</groupId>-->
			<!--<artifactId>aspectjrt</artifactId>-->
		<!--</dependency>-->

		<!-- 用于反射 的开源项目 -->
		<!--<dependency>-->
			<!--<groupId>org.javassist</groupId>-->
			<!--<artifactId>javassist</artifactId>-->
		<!--</dependency>-->
	</dependencies>

	<dependencyManagement>
		<dependencies>
			<dependency>
				<groupId>org.springframework.cloud</groupId>
				<artifactId>spring-cloud-dependencies</artifactId>
				<version>${spring-cloud.version}</version>
				<type>pom</type>
				<scope>import</scope>
			</dependency>
		</dependencies>
	</dependencyManagement>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>


</project>

其中,有个自己添加的依赖,是一个有关反射的开源项目,想学习的,传送门——

https://github.com/jboss-javassist/javassist

Animal接口:

package com.example.aop;

public interface Animal {

    void eat();

    void drink();
}

实现,impl:

package com.example.aop;

public class AnimalImpl implements Animal{

    @Override
    public void eat() {
        System.out.println("call the method eat().");
    }

    @Override
    public void drink() {
        System.out.println("call the method drink().");
    }
}

jdk代理类:

package com.example.aop;

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

/**
 * jdk 动态代理
 */
public class JDKproxy implements InvocationHandler {


    private Object targetObject = null;

    /**
     * 将目标对象传入进行代理
     * @param targetObject
     * @return
     */
    public Object newTargetObject(Object targetObject) {
        this.targetObject = targetObject;
        return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(), targetObject.getClass().getInterfaces(), this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        checkPerm();
        Object result = null;
        System.out.println("pre the method called.");
        result = method.invoke(targetObject,args);
        System.out.println("after the method called.");
        return result;
    }

    private void checkPerm(){
        System.out.println("this method is to check userperm .");
    }
}

cglib代理:

package com.example.aop;

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class CglibProxy implements MethodInterceptor {

    private Object targetProxy;

    public Object newProxy(Object targetProxy) {
        this.targetProxy = targetProxy;
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(targetProxy.getClass());
        enhancer.setCallback(this);
        return enhancer.create();
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        Object result = null;
        if ("eat".equals(method.getName())) {
            checkperm();
        }
        result = method.invoke(targetProxy, objects);
        return result;
    }


    private void checkperm() {
        System.out.println("call the method to check user perm.");
    }
}

测试类:

package com.example.aop;

import java.io.FileInputStream;
import java.io.InputStream;

/**
 * 测试类
 */
public class Client {

    public static void main(String[] args) {

        System.out.println("------JDK proxy------ .");
        JDKproxy jdKproxy = new JDKproxy();
        Animal animal = (Animal) jdKproxy.newTargetObject(new AnimalImpl());
        animal.drink();
        animal.eat();

        System.out.println("==========cglib proxy ============");
        CglibProxy cglibProxy = new CglibProxy();
        Animal animal1 = (Animal) cglibProxy.newProxy(new AnimalImpl());

        animal1.drink();
        animal1.eat();
    }
}

本来是要利用aop实现方法入参出参记录在日志之中,以方便统计和监控方法的调用情况,改天再更新相关代码实现。

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏haifeiWu与他朋友们的专栏

造个轮子之基于 Netty 实现自己的 RPC 框架

服务端开发都会或多或少的涉及到 RPC 的使用,当然如果止步于会用,对自己的成长很是不利,所以楼主今天本着知其然,且知其所以然的精神来探讨一下 RPC 这个东西...

1153
来自专栏Jimoer

Java设计模式学习记录-迭代器模式

这次要介绍的是迭代器模式,也是一种行为模式。我现在觉得写博客有点应付了,前阵子一天一篇,感觉这样其实有点没理解透彻就写下来了,而且写完后自己也没有多看几遍,上次...

793
来自专栏林德熙的博客

WPF 插拔触摸设备触摸失效

最近使用 WPF 程序,在不停插拔触摸设备会让 WPF 程序触摸失效。通过分析 WPF 源代码可以找到 WPF 触摸失效的原因。

991
来自专栏后端之路

dubbo源码系列之filter的前生

dubbo的filter类似于spring的aop,提供了环绕增强功能。 参考dubbo缓存代码分析 缓存是filter的一个很典型的实现。 那么filter是...

3406
来自专栏大内老A

我的WCF之旅 (11): 再谈WCF的双向通讯-基于Http的双向通讯 V.S. 基于TCP的双向通讯

在一个基于面向服务的分布式环境中,借助一个标准的、平台无关的Communication Infrastructure,各个Service通过SOAP Messa...

1717
来自专栏coolblog.xyz技术专栏

Spring AOP 源码分析 - 创建代理对象

在上一篇文章中,我分析了 Spring 是如何为目标 bean 筛选合适的通知器的。现在通知器选好了,接下来就要通过代理的方式将通知器(Advisor)所持有的...

1647
来自专栏Spark生态圈

[spark] BlockManager 解析

BlockManager是spark自己的存储系统,RDD-Cache、 Shuffle-output、broadcast 等的实现都是基于BlockManag...

1213
来自专栏码洞

基于Netty实现Redis协议的编码解码器

上面是Netty的服务器端基本消息处理结构,为了便于初学者理解,它和真实的结构有稍许出入。Netty是基于NIO的消息处理框架,用来高效处理网络IO。处理网络消...

871
来自专栏Android 研究

OKHttp源码解析(七)--中阶之缓存机制

Entry内部类是实际用于存储的缓存数据的实体类,每一个url对应一个Entry实体

895
来自专栏阿杜的世界

Java Web技术经验总结(九)

这个配置的含义有二:(1)对于所有符合"/"模式的请求(除"/admin/"之外)要应用ThemeChangeInterceptor拦截器;(2)对于所有符合"...

823

扫码关注云+社区