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 条评论
登录 后参与评论

相关文章

来自专栏游戏杂谈

Objective-C 内存管理

1) 手动引用计数 MRC (Mannul Reference Counting);

1241
来自专栏编程

Python入门白皮书#P01 Lists

文档: 我们以Google Python Exercises作为练习素材。 参考对应的文档 https://developers.google.com/edu/...

2026
来自专栏Golang语言社区

编写地道的Go代码

最地道的Go代码就是Go的标准库的代码,有空的时候可以多看看Google的工程师是如何实现的。 1. 注释 可以通过/* ... */或者//增加注释, //之...

3076
来自专栏python学习指南

Java面试题问与答——编译时与运行时

在开发和设计的时候,我们需要考虑编译时,运行时以及构建时这三个概念。理解这几个概念可以更好地帮助你去了解一些基本的原理。下面是初学者晋级中级水平需要知道的一些问...

2159
来自专栏GreenLeaves

C# checked和unchecked详解

1、对基元类型执行的许多算术运算都可能造成溢出,有如下代码: Byte b=100; b=(Byte)(b+200); 简单的解读上面的代码: 第一步,将所有的...

2058
来自专栏Java帮帮-微信公众号-技术文章全总结

24(02)多线程锁,线程通讯,线程组,线程池,多线程三种方式,匿名内部类,定时器,设计模式,单例模式,Runtime

(6)多线程实现的第三种方案 package cn.itcast_09;(1) import java.util.concurrent.Callable; //...

4774
来自专栏Java帮帮-微信公众号-技术文章全总结

【选择题】Java基础测试八(16道)

【选择题】Java基础测试八(16道) 101.下面哪个流类属于面向字符的输入流( D ) A)BufferedWriter ...

5316
来自专栏java一日一条

一个Java对象到底占用多大内存

大家可以用这个代码边看边验证,注意的是,运行这个程序需要通过javaagent注入Instrumentation,具体可以看原博客。我今天主要是总结下手动计算J...

831
来自专栏柠檬先生

Less 常用基础知识

LESS 中的注释   也可以额使用css 中的注释(/**/) 这种方式是可以被编译出来的。   也可以使用// 注释 不会被编译的 变量 ...

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

Dubbo 源码分析 - SPI 机制

SPI 全称为 Service Provider Interface,是 Java 提供的一种服务发现机制。SPI 的本质是将接口实现类的全限定名配置在文件中,...

831

扫码关注云+社区

领取腾讯云代金券