Spring系列第15篇：代理详解（java动态代理&CGLIB代理)

2401_84008965

于 2024-04-18 16:13:06 发布

阅读量812

点赞数 10

分类专栏：程序员文章标签： java spring 后端

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文链接：https://blog.csdn.net/2401_84008965/article/details/137925842

版权

程序员专栏收录该内容

274 篇文章 0 订阅

订阅专栏

cglib代理常见的各种玩法详解

代理spring中用到的挺多的，比如上篇文章中的lookup-method和replaced-method，以及后面我们要学的aop、spring中的事务、spring中解析@configuration注解等等，这些都是依靠代理来实现的，所以我们先把代理拿出来讲讲，有利于我们理解其他内容。

为什么要用代理

我们先来看一个案例。

有一个接口IService，如下：

package com.javacode2018.lesson001.demo15;

public interface IService {

void m1();

void m2();

void m3();

}

接口有2个实现类ServiceA和ServiceB，如下：

package com.javacode2018.lesson001.demo15;

public class ServiceA implements IService {

@Override

public void m1() {

System.out.println(“我是ServiceA中的m1方法!”);

}

@Override

public void m2() {

System.out.println(“我是ServiceA中的m2方法!”);

}

@Override

public void m3() {

System.out.println(“我是ServiceA中的m3方法!”);

}

}

package com.javacode2018.lesson001.demo15;

public class ServiceB implements IService {

@Override

public void m1() {

System.out.println(“我是ServiceB中的m1方法!”);

}

@Override

public void m2() {

System.out.println(“我是ServiceB中的m2方法!”);

}

@Override

public void m3() {

System.out.println(“我是ServiceB中的m3方法!”);

}

}

来个测试用例来调用上面类的方法，如下：

package com.javacode2018.lesson001.demo15;

import org.junit.Test;

public class ProxyTest {

@Test

public void m1() {

IService serviceA = new ServiceA();

IService serviceB = new ServiceB();

serviceA.m1();

serviceA.m2();

serviceA.m3();

serviceB.m1();

serviceB.m2();

serviceB.m3();

}

}

上面的代码很简单，就不解释了，我们运行一下m1()方法，输出：

我是ServiceA中的m1方法!

我是ServiceA中的m2方法!

我是ServiceA中的m3方法!

我是ServiceA中的m1方法!

我是ServiceA中的m2方法!

我是ServiceA中的m3方法!

上面是我们原本的程序，突然领导有个需求：调用IService接口中的任何方法的时候，需要记录方法的耗时。

此时你会怎么做呢？

IService接口有2个实现类ServiceA和ServiceB，我们可以在这两个类的所有方法中加上统计耗时的代码，如果IService接口有几十个实现，是不是要修改很多代码，所有被修改的方法需重新测试？是不是非常痛苦，不过上面这种修改代码的方式倒是可以解决问题，只是增加了很多工作量（编码 & 测试）。

突然有一天，领导又说，要将这些耗时统计发送到监控系统用来做监控报警使用。

此时是不是又要去一个修改上面的代码？又要去测试？此时的系统是难以维护。

还有假如上面这些类都是第三方以jar包的方式提供给我们的，此时这些类都是class文件，此时我们无法去修改源码。

比较好的方式：可以为IService接口创建一个代理类，通过这个代理类来间接访问IService接口的实现类，在这个代理类中去做耗时及发送至监控的代码，代码如下：

package com.javacode2018.lesson001.demo15;

// IService的代理类

public class ServiceProxy implements IService {

//目标对象，被代理的对象

private IService target;

public ServiceProxy(IService target) {

this.target = target;

}

@Override

public void m1() {

long starTime = System.nanoTime();

this.target.m1();

long endTime = System.nanoTime();

System.out.println(this.target.getClass() + “.m1()方法耗时(纳秒):” + (endTime - starTime));

}

@Override

public void m2() {

long starTime = System.nanoTime();

this.target.m1();

long endTime = System.nanoTime();

System.out.println(this.target.getClass() + “.m1()方法耗时(纳秒):” + (endTime - starTime));

}

@Override

public void m3() {

long starTime = System.nanoTime();

this.target.m1();

long endTime = System.nanoTime();

System.out.println(this.target.getClass() + “.m1()方法耗时(纳秒):” + (endTime - starTime));

}

}

ServiceProxy是IService接口的代理类，target为被代理的对象，即实际需要访问的对象，也实现了IService接口，上面的3个方法中加了统计耗时的代码，当我们需要访问IService的其他实现类的时候，可以通过ServiceProxy来间接的进行访问，用法如下：

@Test

public void serviceProxy() {

IService serviceA = new ServiceProxy(new ServiceA());//@1

IService serviceB = new ServiceProxy(new ServiceB()); //@2

serviceA.m1();

serviceA.m2();

serviceA.m3();

serviceB.m1();

serviceB.m2();

serviceB.m3();

}

上面代码重点在于@1和@2，创建的是代理对象ServiceProxy，ServiceProxy构造方法中传入了被代理访问的对象，现在我们访问ServiceA或者ServiceB，都需要经过ServiceProxy，运行输出：

我是ServiceA中的m1方法!

class com.javacode2018.lesson001.demo15.ServiceA.m1()方法耗时(纳秒):90100

我是ServiceA中的m1方法!

class com.javacode2018.lesson001.demo15.ServiceA.m1()方法耗时(纳秒):31600

我是ServiceA中的m1方法!

class com.javacode2018.lesson001.demo15.ServiceA.m1()方法耗时(纳秒):25800

我是ServiceB中的m1方法!

class com.javacode2018.lesson001.demo15.ServiceB.m1()方法耗时(纳秒):142100

我是ServiceB中的m1方法!

class com.javacode2018.lesson001.demo15.ServiceB.m1()方法耗时(纳秒):35000

我是ServiceB中的m1方法!

class com.javacode2018.lesson001.demo15.ServiceB.m1()方法耗时(纳秒):32900

上面实现中我们没有去修改ServiceA和ServiceB中的方法，只是给IService接口创建了一个代理类，通过代理类去访问目标对象，需要添加的一些共有的功能都放在代理中，当领导有其他需求的时候，我们只需修改ServiceProxy的代码，方便系统的扩展和测试。

假如现在我们需要给系统中所有接口都加上统计耗时的功能，若按照上面的方式，我们需要给每个接口创建一个代理类，此时代码量和测试的工作量也是巨大的，那么我们能不能写一个通用的代理类，来满足上面的功能呢？

通用代理的2种实现：

jdk动态代理
cglib代理

jdk动态代理详解

jdk中为实现代理提供了支持，主要用到2个类：

java.lang.reflect.Proxy

java.lang.reflect.InvocationHandler

jdk自带的代理使用上面有个限制，只能为接口创建代理类，如果需要给具体的类创建代理类，需要用后面要说的cglib

java.lang.reflect.Proxy

这是jdk动态代理中主要的一个类，里面有一些静态方法会经常用到，我们来熟悉一下：

getProxyClass方法

为指定的接口创建代理类，返回代理类的Class对象

public static Class<?> getProxyClass(ClassLoader loader,

Class<?>… interfaces)

参数说明：

loader：定义代理类的类加载器

interfaces：指定需要实现的接口列表，创建的代理默认会按顺序实现interfaces指定的接口

newProxyInstance方法

创建代理类的实例对象

public static Object newProxyInstance(ClassLoader loader,

Class<?>[] interfaces,

InvocationHandler h)

这个方法先为指定的接口创建代理类，然后会生成代理类的一个实例，最后一个参数比较特殊，是InvocationHandler类型的，这个是个借口如下：

public Object invoke(Object proxy, Method method, Object[] args)

throws Throwable;

上面方法会返回一个代理对象，当调用代理对象的任何方法的时候，会就被InvocationHandler接口的invoke方法处理，所以主要代码需要卸载invoke方法中，稍后会有案例细说。

isProxy方法

判断指定的类是否是一个代理类

public static boolean isProxyClass(Class<?> cl)

getInvocationHandler方法

获取代理对象的InvocationHandler对象

public static InvocationHandler getInvocationHandler(Object proxy)

throws IllegalArgumentException

上面几个方法大家熟悉一下，下面我们来看创建代理具体的2种方式。

创建代理：方式一

步骤

1.调用Proxy.getProxyClass方法获取代理类的Class对象

2.使用InvocationHandler接口创建代理类的处理器

3.通过代理类和InvocationHandler创建代理对象

4.上面已经创建好代理对象了，接着我们就可以使用代理对象了

案例

先来个接口IService

package com.javacode2018.lesson001.demo16;

public interface IService {

void m1();

void m2();

void m3();

}

创建IService接口的代理对象

@Test

public void m1() throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {

// 1. 获取接口对应的代理类

Class proxyClass = (Class) Proxy.getProxyClass(IService.class.getClassLoader(), IService.class);

// 2. 创建代理类的处理器

InvocationHandler invocationHandler = new InvocationHandler() {

@Override

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

System.out.println(“我是InvocationHandler，被调用的方法是：” + method.getName());

return null;

}

};

// 3. 创建代理实例

IService proxyService = proxyClass.getConstructor(InvocationHandler.class).newInstance(invocationHandler);

// 4. 调用代理的方法

proxyService.m1();

proxyService.m2();

proxyService.m3();

}

运行输出

我是InvocationHandler，被调用的方法是：m1

我是InvocationHandler，被调用的方法是：m2

我是InvocationHandler，被调用的方法是：m3

创建代理：方式二

创建代理对象有更简单的方式。

步骤

1.使用InvocationHandler接口创建代理类的处理器

2.使用Proxy类的静态方法newProxyInstance直接创建代理对象

3.使用代理对象

案例

@Test

public void m2() throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {

// 1. 创建代理类的处理器

InvocationHandler invocationHandler = new InvocationHandler() {

@Override

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

System.out.println(“我是InvocationHandler，被调用的方法是：” + method.getName());

return null;

}

};

// 2. 创建代理实例

IService proxyService = (IService) Proxy.newProxyInstance(IService.class.getClassLoader(), new Class[]{IService.class}, invocationHandler);

// 3. 调用代理的方法

proxyService.m1();

proxyService.m2();

proxyService.m3();

}

运行输出：

我是InvocationHandler，被调用的方法是：m1

我是InvocationHandler，被调用的方法是：m2

我是InvocationHandler，被调用的方法是：m3

案例：任意接口中的方法耗时统计

下面我们通过jdk动态代理实现一个通用的代理，解决统计所有接口方法耗时的问题。

主要的代码在代理处理器InvocationHandler实现上面，如下：

package com.javacode2018.lesson001.demo16;

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

import java.lang.reflect.Proxy;

public class CostTimeInvocationHandler implements InvocationHandler {

private Object target;

public CostTimeInvocationHandler(Object target) {

this.target = target;

}

@Override

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

long starTime = System.nanoTime();

Object result = method.invoke(this.target, args);//@1

long endTime = System.nanoTime();

System.out.println(this.target.getClass() + “.m1()方法耗时(纳秒):” + (endTime - starTime));

return result;

}

/**

* 用来创建targetInterface接口的代理对象

* @param target 需要被代理的对象

* @param targetInterface 被代理的接口

* @param

* @return

*/

public static T createProxy(Object target, Class targetInterface) {

if (!targetInterface.isInterface()) {

throw new IllegalStateException(“targetInterface必须是接口类型!”);

} else if (!targetInterface.isAssignableFrom(target.getClass())) {

throw new IllegalStateException(“target必须是targetInterface接口的实现类!”);

}

return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new CostTimeInvocationHandler(target));

}

}

上面主要是createProxy方法用来创建代理对象，2个参数：

target：目标对象，需要实现targetInterface接口

targetInterface：需要创建代理的接口

invoke方法中通过method.invoke(this.target, args)调用目标方法，然后统计方法的耗时。

测试用例

@Test

public void costTimeProxy() {

IService serviceA = CostTimeInvocationHandler.createProxy(new ServiceA(), IService.class);

IService serviceB = CostTimeInvocationHandler.createProxy(new ServiceB(), IService.class);

serviceA.m1();

serviceA.m2();

serviceA.m3();

serviceB.m1();

serviceB.m2();

serviceB.m3();

}

运行输出

我是ServiceA中的m1方法!

class com.javacode2018.lesson001.demo16.ServiceA.m1()方法耗时(纳秒):61300

我是ServiceA中的m2方法!

class com.javacode2018.lesson001.demo16.ServiceA.m1()方法耗时(纳秒):22300

我是ServiceA中的m3方法!

class com.javacode2018.lesson001.demo16.ServiceA.m1()方法耗时(纳秒):18700

我是ServiceB中的m1方法!

class com.javacode2018.lesson001.demo16.ServiceB.m1()方法耗时(纳秒):54700

我是ServiceB中的m2方法!

class com.javacode2018.lesson001.demo16.ServiceB.m1()方法耗时(纳秒):27200

我是ServiceB中的m3方法!

class com.javacode2018.lesson001.demo16.ServiceB.m1()方法耗时(纳秒):19800

我们再来的接口，也需要统计耗时的功能，此时我们无需去创建新的代理类即可实现同样的功能，如下：

IUserService接口

package com.javacode2018.lesson001.demo16;

public interface IUserService {

/**

* 插入用户信息

* @param name

*/

void insert(String name);

}

IUserService接口实现类：

package com.javacode2018.lesson001.demo16;

public class UserService implements IUserService {

@Override

public void insert(String name) {

System.out.println(String.format(“用户[name:%s]插入成功!”, name));

}

}

测试用例

@Test

public void userService() {

IUserService userService = CostTimeInvocationHandler.createProxy(new UserService(), IUserService.class);

userService.insert(“路人甲Java”);

}

运行输出：

用户[name:路人甲Java]插入成功!

class com.javacode2018.lesson001.demo16.UserService.m1()方法耗时(纳秒):193000

上面当我们创建一个新的接口的时候，不需要再去新建一个代理类了，只需要使用CostTimeInvocationHandler.createProxy创建一个新的代理对象就可以了，方便了很多。

Proxy使用注意

jdk中的Proxy只能为接口生成代理类，如果你想给某个类创建代理类，那么Proxy是无能为力的，此时需要我们用到下面要说的cglib了。
Proxy类中提供的几个常用的静态方法大家需要掌握
通过Proxy创建代理对象，当调用代理对象任意方法时候，会被InvocationHandler接口中的invoke方法进行处理，这个接口内容是关键

cglib代理详解

什么是cglib

jdk动态代理只能为接口创建代理，使用上有局限性。实际的场景中我们的类不一定有接口，此时如果我们想为普通的类也实现代理功能，我们就需要用到cglib来实现了。

cglib是一个强大、高性能的字节码生成库，它用于在运行时扩展Java类和实现接口；本质上它是通过动态的生成一个子类去覆盖所要代理的类（非final修饰的类和方法）。Enhancer可能是CGLIB中最常用的一个类，和jdk中的Proxy不同的是，Enhancer既能够代理普通的class，也能够代理接口。Enhancer创建一个被代理对象的子类并且拦截所有的方法调用（包括从Object中继承的toString和hashCode方法）。Enhancer不能够拦截final方法，例如Object.getClass()方法，这是由于Java final方法语义决定的。基于同样的道理，Enhancer也不能对final类进行代理操作。

CGLIB作为一个开源项目，其代码托管在github，地址为：

https://github.com/cglib/cglib

cglib组成结构

CGLIB底层使用了ASM（一个短小精悍的字节码操作框架）来操作字节码生成新的类。除了CGLIB库外，脚本语言（如Groovy和BeanShell）也使用ASM生成字节码。ASM使用类似SAX的解析器来实现高性能。我们不鼓励直接使用ASM，因为它需要对Java字节码的格式足够的了解。

spring已将第三方cglib jar包中所有的类集成到spring自己的jar包中，本系列内容都是和spring相关的，为了方便，我们直接使用spring内部已集成的来讲解

5个案例来演示cglib常见的用法

案例1：拦截所有方法（MethodInterceptor）

创建一个具体的类，如下：

package com.javacode2018.lesson001.demo17;

public class Service1 {

public void m1() {

System.out.println(“我是m1方法”);

}

public void m2() {

System.out.println(“我是m2方法”);

}

}

下面我们为这个类创建一个代理，代理中实现打印每个方法的调用日志。

package com.javacode2018.lesson001.demo17;

import org.junit.Test;

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 CglibTest {

@Test

public void test1() {

//使用Enhancer来给某个类创建代理类，步骤

//1.创建Enhancer对象

Enhancer enhancer = new Enhancer();

//2.通过setSuperclass来设置父类型，即需要给哪个类创建代理类

enhancer.setSuperclass(Service1.class);

/*3.设置回调，需实现org.springframework.cglib.proxy.Callback接口，

此处我们使用的是org.springframework.cglib.proxy.MethodInterceptor，也是一个接口，实现了Callback接口，

当调用代理对象的任何方法的时候，都会被MethodInterceptor接口的invoke方法处理*/

enhancer.setCallback(new MethodInterceptor() {

/**

* 代理对象方法拦截器

* @param o 代理对象

* @param method 被代理的类的方法，即Service1中的方法

* @param objects 调用方法传递的参数

* @param methodProxy 方法代理对象

* @return

* @throws Throwable

*/

@Override

public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {

System.out.println(“调用方法:” + method);

//可以调用MethodProxy的invokeSuper调用被代理类的方法

Object result = methodProxy.invokeSuper(o, objects);

return result;

}

});

//4.获取代理对象,调用enhancer.create方法获取代理对象，这个方法返回的是Object类型的，所以需要强转一下

Service1 proxy = (Service1) enhancer.create();

//5.调用代理对象的方法

proxy.m1();

proxy.m2();

}

}

上面代码中的注释很详细，列出了给指定的类创建代理的具体步骤，整个过程中主要用到了Enhancer类和MethodInterceptor接口。

enhancer.setSuperclass用来设置代理类的父类，即需要给哪个类创建代理类，此处是Service1

enhancer.setCallback传递的是MethodInterceptor接口类型的参数，MethodInterceptor接口有个intercept方法，这个方法会拦截代理对象所有的方法调用。

还有一个重点是Object result = methodProxy.invokeSuper(o, objects);可以调用被代理类，也就是Service1类中的具体的方法，从方法名称的意思可以看出是调用父类，实际对某个类创建代理，cglib底层通过修改字节码的方式为Service1类创建了一个子类。

运行输出：

调用方法:public void com.javacode2018.lesson001.demo17.Service1.m1()

我是m1方法

调用方法:public void com.javacode2018.lesson001.demo17.Service1.m2()

我是m2方法

从输出中可以看出Service1中的2个方法都被MethodInterceptor中的invoke拦截处理了。

案例2：拦截所有方法（MethodInterceptor）

在创建一个类，如下：

package com.javacode2018.lesson001.demo17;

public class Service2 {

public void m1() {

System.out.println(“我是m1方法”);

this.m2(); //@1

}

public void m2() {

System.out.println(“我是m2方法”);

}

}

这个类和上面的Service1类似，有点不同是@1，在m1方法中调用了m2方法。

下面来采用案例1中同样的方式来给Service2创建代理，如下：

@Test

public void test2() {

Enhancer enhancer = new Enhancer();

enhancer.setSuperclass(Service2.class);

enhancer.setCallback(new MethodInterceptor() {

@Override

public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {

System.out.println(“调用方法:” + method);

Object result = methodProxy.invokeSuper(o, objects);

return result;

}

});

Service2 proxy = (Service2) enhancer.create();

proxy.m1(); //@1

}

注意上面@1的代码，只调用了m1方法，看一下输出效果：

调用方法:public void com.javacode2018.lesson001.demo17.Service2.m1()

我是m1方法

调用方法:public void com.javacode2018.lesson001.demo17.Service2.m2()

我是m2方法

从输出中可以看出m1和m2方法都被拦截器处理了，而m2方法是在Service1的m1方法中调用的，也被拦截处理了。

spring中的@configuration注解就是采用这种方式实现的，给大家上个@configuration案例眼熟一下：

package com.javacode2018.lesson001.demo17;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

@Configuration

public class Config {

@Bean

public C1 c1(){

return new C1();

}

@Bean

public C2 c2(){

C1 c1 = this.c1(); //@1

return new C2(c1);

}

@Bean

public C3 c3(){

C1 c1 = this.c1(); //@2

return new C3(c1);

}

public static class C1{}

public static class C2{

private C1 c1;

public C2(C1 c1) {

this.c1 = c1;

}

}

public static class C3{

private C1 c1;

public C3(C1 c1) {

this.c1 = c1;

}

}

}

上面代码中C2和C3依赖于C1，都是通过构造器注入C1，注意代码中的@1和@2都是调用c1方法获取容器中的C1，如何确保多次获取的C1都是一个的？这个地方就是使用cglib代理拦截@Bean注解的方法来实现的。

案例3：拦截所有方法并返回固定值（FixedValue）

当调用某个类的任何方法的时候，都希望返回一个固定的值，此时可以使用FixedValue接口，如下：

enhancer.setCallback(new FixedValue() {

@Override

public Object loadObject() throws Exception {

return “路人甲”;

}

});

上面创建的代理对象，调用其任意方法返回的都是"路人甲"。

案例代码如下：

创建一个类Service3，如下：

package com.javacode2018.lesson001.demo17;

public class Service3 {

public String m1() {

System.out.println(“我是m1方法”);

return “hello:m1”;

}

public String m2() {

System.out.println(“我是m2方法”);

return “hello:m2”;

}

}

对用的测试用例：

@Test

public void test3() {

Enhancer enhancer = new Enhancer();

enhancer.setSuperclass(Service3.class);

enhancer.setCallback(new FixedValue() {

@Override

public Object loadObject() throws Exception {

return “路人甲”;

}

});

Service3 proxy = (Service3) enhancer.create();

System.out.println(proxy.m1());//@1

System.out.println(proxy.m2()); //@2

System.out.println(proxy.toString());//@3

}

@1、@2、@3调用了代理对象的3个方法，运行输出：

运行输出：

路人甲

路人甲
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

最后

由于细节内容实在太多了，为了不影响文章的观赏性，只截出了一部分知识点大致的介绍一下，每个小节点里面都有更细化的内容！

小编准备了一份Java进阶学习路线图（Xmind）以及来年金三银四必备的一份《Java面试必备指南》

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！

return “hello:m1”;

}

public String m2() {

System.out.println(“我是m2方法”);

return “hello:m2”;

}

}

对用的测试用例：

@Test

public void test3() {

Enhancer enhancer = new Enhancer();

enhancer.setSuperclass(Service3.class);

enhancer.setCallback(new FixedValue() {

@Override

public Object loadObject() throws Exception {

return “路人甲”;

}

});

Service3 proxy = (Service3) enhancer.create();

System.out.println(proxy.m1());//@1

System.out.println(proxy.m2()); //@2

System.out.println(proxy.toString());//@3

}

@1、@2、@3调用了代理对象的3个方法，运行输出：

运行输出：

路人甲

路人甲
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。[外链图片转存中…(img-YCE5t70D-1713427973682)]

[外链图片转存中…(img-9gTQESt9-1713427973683)]

[外链图片转存中…(img-AVEjbvAJ-1713427973683)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

最后

由于细节内容实在太多了，为了不影响文章的观赏性，只截出了一部分知识点大致的介绍一下，每个小节点里面都有更细化的内容！

[外链图片转存中…(img-eCKZAIAq-1713427973683)]

小编准备了一份Java进阶学习路线图（Xmind）以及来年金三银四必备的一份《Java面试必备指南》

[外链图片转存中…(img-Eizvac4O-1713427973684)]

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！

关注

10
点赞
踩
11

收藏

觉得还不错? 一键收藏
0
评论
Spring系列第15篇：代理详解（java动态代理&CGLIB代理)

jdk动态代理只能为接口创建代理，使用上有局限性。实际的场景中我们的类不一定有接口，此时如果我们想为普通的类也实现代理功能，我们就需要用到cglib来实现了。cglib是一个强大、高性能的字节码生成库，它用于在运行时扩展Java类和实现接口；本质上它是通过动态的生成一个子类去覆盖所要代理的类（非final修饰的类和方法）。Enhancer可能是CGLIB中最常用的一个类，和jdk中的Proxy不同的是，Enhancer既能够代理普通的class，也能够代理接口。
复制链接

扫一扫

专栏目录

评论

被折叠的条评论为什么被折叠?

到【灌水乐园】发言

查看更多评论

添加红包

成就一亿技术人!

hope_wisdom

发出的红包

实付元

使用余额支付

点击重新获取

扫码支付

钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。