最全从没有人将代理模式分析得如此透彻(1)，让人抓狂的Nginx性能调优

线程、数据库、算法、JVM、分布式、微服务、框架、Spring相关知识

一线互联网P7面试集锦+各种大厂面试集锦

学习笔记以及面试真题解析

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取

运行以上代码，可以在E盘找到一个 P r o x y 0. c l a s s 文 件 。 使 用 J a d 反 编 译 ， 得 到 Proxy0.class文件。使用Jad反编译，得到 Proxy0.class文件。使用Jad反编译，得到Proxy0.jad文件，打开文件看到如下内容。

import com.tom.pattern.proxy.dynamicproxy.jdkproxy.IPerson;

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

import java.lang.reflect.Proxy;

import java.lang.reflect.UndeclaredThrowableException;

public final class $Proxy0 extends Proxy implements IPerson {

private static Method m1;

private static Method m3;

private static Method m2;

private static Method m4;

private static Method m0;

public $Proxy0(InvocationHandler var1) throws {

super(var1);

}

public final boolean equals(Object var1) throws {

try {

return ((Boolean)super.h.invoke(this, m1, new Object[]{var1})).booleanValue();

} catch (RuntimeException | Error var3) {

throw var3;

} catch (Throwable var4) {

throw new UndeclaredThrowableException(var4);

}

}

public final void findLove() throws {

try {

super.h.invoke(this, m3, (Object[])null);

} catch (RuntimeException | Error var2) {

throw var2;

} catch (Throwable var3) {

throw new UndeclaredThrowableException(var3);

}

}

public final String toString() throws {

try {

return (String)super.h.invoke(this, m2, (Object[])null);

} catch (RuntimeException | Error var2) {

throw var2;

} catch (Throwable var3) {

throw new UndeclaredThrowableException(var3);

}

}

public final void buyInsure() throws {

try {

super.h.invoke(this, m4, (Object[])null);

} catch (RuntimeException | Error var2) {

throw var2;

} catch (Throwable var3) {

throw new UndeclaredThrowableException(var3);

}

}

public final int hashCode() throws {

try {

return ((Integer)super.h.invoke(this, m0, (Object[])null)).intValue();

} catch (RuntimeException | Error var2) {

throw var2;

} catch (Throwable var3) {

throw new UndeclaredThrowableException(var3);

}

}

static {

try {

m1 = Class.forName(“java.lang.Object”).getMethod(“equals”,

new Class[]{Class.forName(“java.lang.Object”)});

m3 = Class.forName(“com.tom.pattern.proxy.dynamicproxy.jdkproxy.IPerson”)

.getMethod(“findLove”, new Class[0]);

m2 = Class.forName(“java.lang.Object”).getMethod(“toString”, new Class[0]);

m4 = Class.forName(“com.tom.pattern.proxy.dynamicproxy.jdkproxy.IPerson”)

.getMethod(“buyInsure”, new Class[0]);

m0 = Class.forName(“java.lang.Object”).getMethod(“hashCode”, new Class[0]);

} catch (NoSuchMethodException var2) {

throw new NoSuchMethodError(var2.getMessage());

} catch (ClassNotFoundException var3) {

throw new NoClassDefFoundError(var3.getMessage());

}

}

}

我们发现，$Proxy0继承了Proxy类，同时实现了Person接口，而且重写了findLove()等方法。在静态代码块中用反射查找到了目标对象的所有方法，而且保存了所有方法的引用，重写的方法用反射调用目标对象的方法。小伙伴们此时一定会好奇：这些代码是从哪里来的？其实是JDK自动生成的。现在我们不依赖JDK，自己来动态生成源码、动态完成编译，然后替代目标对象并执行。

创建GPInvocationHandler接口。

public interface GPInvocationHandler {

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

throws Throwable;

}

创建GPProxy类。

/**

• 用来生成源码的工具类

• Created by Tom.

*/

public class GPProxy {

public static final String ln = “\r\n”;

public static Object newProxyInstance(GPClassLoader classLoader, Class<?> [] interfaces,

GPInvocationHandler h){

try {

//1.动态生成源码.java文件

String src = generateSrc(interfaces);

//2.Java文件输出磁盘

String filePath = GPProxy.class.getResource(“”).getPath();

File f = new File(filePath + “$Proxy0.java”);

FileWriter fw = new FileWriter(f);

fw.write(src);

fw.flush();

fw.close();

//3.把生成的.java文件编译成.class文件

JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();

StandardJavaFileManager manage = compiler.getStandardFileManager(null,null,null);

Iterable iterable = manage.getJavaFileObjects(f);

JavaCompiler.CompilationTask task = compiler.getTask(null,manage,null,null,null,iterable);

task.call();

manage.close();

//4.编译生成的.class文件加载到JVM中

Class proxyClass = classLoader.findClass(“$Proxy0”);

Constructor c = proxyClass.getConstructor(GPInvocationHandler.class);

f.delete();

//5.返回字节码重组以后的新的代理对象

return c.newInstance(h);

}catch (Exception e){

e.printStackTrace();

}

return null;

}

private static String generateSrc(Class<?>[] interfaces){

StringBuffer sb = new StringBuffer();

sb.append(GPProxy.class.getPackage() + “;” + ln);

sb.append("import " + interfaces[0].getName() + “;” + ln);

sb.append(“import java.lang.reflect.*;” + ln);

sb.append("public class $Proxy0 implements " + interfaces[0].getName() + “{” + ln);

sb.append(“GPInvocationHandler h;” + ln);

sb.append("public $Proxy0(GPInvocationHandler h) { " + ln);

sb.append(“this.h = h;”);

sb.append(“}” + ln);

for (Method m : interfaces[0].getMethods()){

Class<?>[] params = m.getParameterTypes();

StringBuffer paramNames = new StringBuffer();

StringBuffer paramValues = new StringBuffer();

StringBuffer paramClasses = new StringBuffer();

for (int i = 0; i < params.length; i++) {

Class clazz = params[i];

String type = clazz.getName();

String paramName = toLowerFirstCase(clazz.getSimpleName());

paramNames.append(type + " " + paramName);

paramValues.append(paramName);

paramClasses.append(clazz.getName() + “.class”);

if(i > 0 && i < params.length-1){

paramNames.append(“,”);

paramClasses.append(“,”);

paramValues.append(“,”);

}

}

sb.append("public " + m.getReturnType().getName() + " " + m.getName() + “(” + paramNames.toString() + “) {” + ln);

sb.append(“try{” + ln);

sb.append(“Method m = " + interfaces[0].getName() + “.class. getMethod(”” + m.getName() + “”,new Class[]{" + paramClasses.toString() + “});” + ln);

sb.append((hasReturnValue(m.getReturnType()) ? "return " : “”) + getCaseCode(“this.h.invoke(this,m,new Object[]{” + paramValues + “})”,m.getReturnType()) + “;” + ln);

sb.append(“}catch(Error _ex) { }”);

sb.append(“catch(Throwable e){” + ln);

sb.append(“throw new UndeclaredThrowableException(e);” + ln);

sb.append(“}”);

sb.append(getReturnEmptyCode(m.getReturnType()));

sb.append(“}”);

}

sb.append(“}” + ln);

return sb.toString();

}

private static Map<Class,Class> mappings = new HashMap<Class, Class>();

static {

mappings.put(int.class,Integer.class);

}

private static String getReturnEmptyCode(Class<?> returnClass){

if(mappings.containsKey(returnClass)){

return “return 0;”;

}else if(returnClass == void.class){

return “”;

}else {

return “return null;”;

}

}

private static String getCaseCode(String code,Class<?> returnClass){

if(mappings.containsKey(returnClass)){

return “((” + mappings.get(returnClass).getName() + “)” + code + “).” + returnClass.getSimpleName() + “Value()”;

}

return code;

}

private static boolean hasReturnValue(Class<?> clazz){

return clazz != void.class;

}

private static String toLowerFirstCase(String src){

char [] chars = src.toCharArray();

chars[0] += 32;

return String.valueOf(chars);

}

}

创建GPClassLoader类。

public class GPClassLoader extends ClassLoader {

private File classPathFile;

public GPClassLoader(){

String classPath = GPClassLoader.class.getResource(“”).getPath();

this.classPathFile = new File(classPath);

}

@Override

protected Class<?> findClass(String name) throws ClassNotFoundException {

String className = GPClassLoader.class.getPackage().getName() + “.” + name;

if(classPathFile != null){

File classFile = new File(classPathFile,name.replaceAll(“\.”,“/”) + “.class”);

if(classFile.exists()){

FileInputStream in = null;

ByteArrayOutputStream out = null;

try{

in = new FileInputStream(classFile);

out = new ByteArrayOutputStream();

byte [] buff = new byte[1024];

int len;

while ((len = in.read(buff)) != -1){

out.write(buff,0,len);

}

return defineClass(className,out.toByteArray(),0,out.size());

}catch (Exception e){

e.printStackTrace();

}

}

}

return null;

}

}

创建GPMeipo类。

public class GpMeipo implements GPInvocationHandler {

private IPerson target;

public IPerson getInstance(IPerson target){

this.target = target;

Class<?> clazz = target.getClass();

return (IPerson) GPProxy.newProxyInstance(new GPClassLoader(),clazz.getInterfaces(),this);

}

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

before();

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

after();

return result;

}

private void after() {

System.out.println(“双方同意，开始交往”);

}

private void before() {

System.out.println(“我是媒婆，已经收集到你的需求，开始物色”);

}

}

客户端测试代码如下。

public static void main(String[] args) {

GpMeipo gpMeipo = new GpMeipo();

IPerson zhangsan = gpMeipo.getInstance(new Zhangsan());

zhangsan.findLove();

}

至此，手写JDK动态代理就完成了。小伙伴们是不是又多了一个面试用的“撒手锏”呢？

5 CGLib动态代理API原理分析

---

简单看一下CGLib动态代理的使用，还是以媒婆为例，创建CglibMeipo类。

public class CGlibMeipo implements MethodInterceptor {

public Object getInstance(Class<?> clazz) throws Exception{

//相当于JDK中的Proxy类，是完成代理的工具类

Enhancer enhancer = new Enhancer();

enhancer.setSuperclass(clazz);

enhancer.setCallback(this);

return enhancer.create();

}

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

before();

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

after();

return obj;

}

private void before(){

System.out.println(“我是媒婆，我要给你找对象，现在已经确认你的需求”);

System.out.println(“开始物色”);

}

private void after(){

System.out.println(“双方同意，准备办婚事”);

}

}

创建单身客户类Customer。

public class Customer {

public void findLove(){

System.out.println(“符合要求”);

}

}

这里有一个小细节，CGLib动态代理的目标对象不需要实现任何接口，它是通过动态继承目标对象实现动态代理的，客户端测试代码如下。

public static void main(String[] args) {

try {

//JDK采用读取接口的信息

//CGLib覆盖父类方法

//目的都是生成一个新的类，去实现增强代码逻辑的功能

//JDK Proxy对于用户而言，必须要有一个接口实现，目标类相对来说复杂

//CGLib可以代理任意一个普通的类，没有任何要求

//CGLib生成代理的逻辑更复杂，调用效率更高，生成一个包含了所有逻辑的FastClass，不再需 要反射调用

//JDK Proxy生成代理的逻辑简单，执行效率相对要低，每次都要反射动态调用

//CGLib有一个缺点，CGLib不能代理final的方法

Customer obj = (Customer) new CGlibMeipo().getInstance(Customer.class);

System.out.println(obj);

obj.findLove();

} catch (Exception e) {

e.printStackTrace();

}

}

CGLib动态代理的实现原理又是怎样的呢？我们可以在客户端测试代码中加上一句代码，将CGLib动态代理后的.class文件写入磁盘，然后反编译来一探究竟，代码如下。

public static void main(String[] args) {

try {

//使用CGLib的代理类可以将内存中的.class文件写入本地磁盘

System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, “E://cglib_proxy_class/”);

Customer obj = (Customer)new CglibMeipo().getInstance(Customer.class);

obj.findLove();

} catch (Exception e) {

e.printStackTrace();

}

}

重新执行代码，我们会发现在E://cglib_proxy_class目录下多了三个.class文件，如下图所示。

通过调试跟踪发现，Customer E n h a n c e r B y C G L I B EnhancerByCGLIB EnhancerByCGLIB3feeb52a.class就是CGLib动态代理生成的代理类，继承了Customer类。

package com.tom.pattern.proxy.dynamicproxy.cglibproxy;

import java.lang.reflect.Method;

import net.sf.cglib.core.ReflectUtils;

import net.sf.cglib.core.Signature;

import net.sf.cglib.proxy.*;

public class Customer$$EnhancerByCGLIB$$3feeb52a extends Customer

implements Factory

{

…

final void CGLIB$findLove$0()

{

super.findLove();

}

public final void findLove()

{

CGLIB$CALLBACK_0;

if(CGLIB$CALLBACK_0 != null) goto _L2; else goto _L1

_L1:

JVM INSTR pop ;

CGLIB$BIND_CALLBACKS(this);

CGLIB$CALLBACK_0;

_L2:

JVM INSTR dup ;

JVM INSTR ifnull 37;

goto _L3 _L4

_L3:

break MISSING_BLOCK_LABEL_21;

_L4:

break MISSING_BLOCK_LABEL_37;

this;

CGLIB$findLove$0$Method;

CGLIB$emptyArgs;

CGLIB$findLove$0$Proxy;

intercept();

return;

super.findLove();

return;

}

…

}

我们重写了Customer类的所有方法，通过代理类的源码可以看到，代理类会获得所有从父类继承来的方法，并且会有MethodProxy与之对应，比如Method CGLIB$findLove000Method、MethodProxyCGLIB$findLove 0 0 0Proxy等方法在代理类的findLove()方法中都有调用。

//代理方法（methodProxy.invokeSuper()方法会调用）

final void CGLIB$findLove$0()

{

super.findLove();

}

//被代理方法（methodProxy.invoke()方法会调用

//这就是为什么在拦截器中调用methodProxy.invoke会发生死循环，一直在调用拦截器）

public final void findLove()

{

…

//调用拦截器

intercept();

return;

super.findLove();

return;

}

调用过程为：代理对象调用this.findLove()方法→调用拦截器→methodProxy.invokeSuper()→ CGLIB$findLove$0→被代理对象findLove()方法。

此时，我们发现MethodInterceptor拦截器就是由MethodProxy的invokeSuper()方法调用代理方法的，因此，MethodProxy类中的代码非常关键，我们分析它具体做了什么。

package net.sf.cglib.proxy;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import net.sf.cglib.core.AbstractClassGenerator;

import net.sf.cglib.core.CodeGenerationException;

import net.sf.cglib.core.GeneratorStrategy;

import net.sf.cglib.core.NamingPolicy;

import net.sf.cglib.core.Signature;

import net.sf.cglib.reflect.FastClass;

import net.sf.cglib.reflect.FastClass.Generator;

public class MethodProxy {

private Signature sig1;

private Signature sig2;

private MethodProxy.CreateInfo createInfo;

private final Object initLock = new Object();

private volatile MethodProxy.FastClassInfo fastClassInfo;

public static MethodProxy create(Class c1, Class c2, String desc, String name1, String name2) {

MethodProxy proxy = new MethodProxy();

proxy.sig1 = new Signature(name1, desc);

proxy.sig2 = new Signature(name2, desc);

proxy.createInfo = new MethodProxy.CreateInfo(c1, c2);

return proxy;

}

…

private static class CreateInfo {

Class c1;

Class c2;

NamingPolicy namingPolicy;

GeneratorStrategy strategy;

boolean attemptLoad;

public CreateInfo(Class c1, Class c2) {

this.c1 = c1;

this.c2 = c2;

AbstractClassGenerator fromEnhancer = AbstractClassGenerator.getCurrent();

if(fromEnhancer != null) {

this.namingPolicy = fromEnhancer.getNamingPolicy();

this.strategy = fromEnhancer.getStrategy();

this.attemptLoad = fromEnhancer.getAttemptLoad();

}

}

}

…

}

继续看invokeSuper()方法。

public Object invokeSuper(Object obj, Object[] args) throws Throwable {

try {

this.init();

MethodProxy.FastClassInfo fci = this.fastClassInfo;

return fci.f2.invoke(fci.i2, obj, args);

} catch (InvocationTargetException var4) {

throw var4.getTargetException();

}

}

…

private static class FastClassInfo {

FastClass f1;

FastClass f2;

int i1;

int i2;

private FastClassInfo() {

}

}

上面代码调用获取代理类对应的FastClass，并执行代理方法。还记得之前生成的三个.class文件吗？Customer E n h a n c e r B y C G L I B EnhancerByCGLIB EnhancerByCGLIB3feeb52a F a s t C l a s s B y C G L I B FastClassByCGLIB FastClassByCGLIB6aad62f1.class就是代理类的FastClass，Customer F a s t C l a s s B y C G L I B FastClassByCGLIB FastClassByCGLIB2669574a.class就是被代理类的FastClass。

CGLib动态代理执行代理方法的效率之所以比JDK高，是因为CGlib采用了FastClass机制，它的原理简单来说就是：为代理类和被代理类各生成一个类，这个类会为代理类或被代理类的方法分配一个index（int类型）；这个index被当作一个入参，FastClass可以直接定位要调用的方法并直接进行调用，省去了反射调用，因此调用效率比JDK代理通过反射调用高。下面我们来反编译一个FastClass。

public int getIndex(Signature signature)

{

String s = signature.toString();

s;

s.hashCode();

JVM INSTR lookupswitch 11: default 223

…

JVM INSTR pop ;

return -1;

}

//部分代码省略

//根据index直接定位执行方法

public Object invoke(int i, Object obj, Object aobj[])

throws InvocationTargetException

{

(Customer)obj;

i;

JVM INSTR tableswitch 0 10: default 161

goto _L1 _L2 _L3 _L4 _L5 _L6 _L7 _L8 _L9 _L10 _L11 _L12

_L2:

eat();

return null;

_L3:

findLove();

return null;

…

throw new IllegalArgumentException(“Cannot find matching method/constructor”);

}

FastClass并不是跟代理类一起生成的，而是在第一次执行MethodProxy的invoke()或invokeSuper()方法时生成的，并被放在了缓存中。

//MethodProxy的invoke()或invokeSuper()方法都调用了init()方法

private void init() {

if(this.fastClassInfo == null) {

Object var1 = this.initLock;

synchronized(this.initLock) {

if(this.fastClassInfo == null) {

MethodProxy.CreateInfo ci = this.createInfo;

MethodProxy.FastClassInfo fci = new MethodProxy.FastClassInfo();

//如果在缓存中，则取出；如果没在缓存中，则生成新的FastClass

fci.f1 = helper(ci, ci.c1);

fci.f2 = helper(ci, ci.c2);

fci.i1 = fci.f1.getIndex(this.sig1);//获取方法的index

fci.i2 = fci.f2.getIndex(this.sig2);

this.fastClassInfo = fci;

}

}

}

}

至此，我们基本清楚了CGLib动态代理的原理，对代码细节感兴趣的小伙伴们可以自行深入研究。

6 CGLib和JDK Proxy对比分析

---

（1）JDK动态代理实现了被代理对象的接口，CGLib动态代理继承了被代理对象。

（2）JDK动态代理和CGLib动态代理都在运行期生成字节码，JDK动态代理直接写Class字节码，CGLib动态代理使用ASM框架写Class字节码。CGLib动态代理实现更复杂，生成代理类比JDK动态代理效率低。

（3）JDK动态代理调用代理方法是通过反射机制调用的，CGLib动态代理是通过FastClass机制直接调用方法的，CGLib动态代理的执行效率更高。

最后，附一张自己面试前准备的脑图：

面试前一定少不了刷题，为了方便大家复习，我分享一波个人整理的面试大全宝典

• Java核心知识整理

• Spring全家桶（实战系列）

Step3：刷题

既然是要面试，那么就少不了刷题，实际上春节回家后，哪儿也去不了，我自己是刷了不少面试题的，所以在面试过程中才能够做到心中有数，基本上会清楚面试过程中会问到哪些知识点，高频题又有哪些，所以刷题是面试前期准备过程中非常重要的一点。

以下是我私藏的面试题库：

很多人感叹“学习无用”，实际上之所以产生无用论，是因为自己想要的与自己所学的匹配不上，这也就意味着自己学得远远不够。无论是学习还是工作，都应该有主动性，所以如果拥有大厂梦，那么就要自己努力去实现它。

最后祝愿各位身体健康，顺利拿到心仪的offer！

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取

fci.f2 = helper(ci, ci.c2);

fci.i1 = fci.f1.getIndex(this.sig1);//获取方法的index

fci.i2 = fci.f2.getIndex(this.sig2);

this.fastClassInfo = fci;

}

}

}

}

至此，我们基本清楚了CGLib动态代理的原理，对代码细节感兴趣的小伙伴们可以自行深入研究。

6 CGLib和JDK Proxy对比分析

---

（1）JDK动态代理实现了被代理对象的接口，CGLib动态代理继承了被代理对象。

（2）JDK动态代理和CGLib动态代理都在运行期生成字节码，JDK动态代理直接写Class字节码，CGLib动态代理使用ASM框架写Class字节码。CGLib动态代理实现更复杂，生成代理类比JDK动态代理效率低。

（3）JDK动态代理调用代理方法是通过反射机制调用的，CGLib动态代理是通过FastClass机制直接调用方法的，CGLib动态代理的执行效率更高。

最后，附一张自己面试前准备的脑图：

[外链图片转存中…(img-tEyd5KKz-1715593510235)]

面试前一定少不了刷题，为了方便大家复习，我分享一波个人整理的面试大全宝典

• Java核心知识整理

[外链图片转存中…(img-6RXLvsGI-1715593510235)]

• Spring全家桶（实战系列）

[外链图片转存中…(img-sXmj3pyn-1715593510236)]

Step3：刷题

既然是要面试，那么就少不了刷题，实际上春节回家后，哪儿也去不了，我自己是刷了不少面试题的，所以在面试过程中才能够做到心中有数，基本上会清楚面试过程中会问到哪些知识点，高频题又有哪些，所以刷题是面试前期准备过程中非常重要的一点。

以下是我私藏的面试题库：

[外链图片转存中…(img-Zzcp8hIy-1715593510236)]

很多人感叹“学习无用”，实际上之所以产生无用论，是因为自己想要的与自己所学的匹配不上，这也就意味着自己学得远远不够。无论是学习还是工作，都应该有主动性，所以如果拥有大厂梦，那么就要自己努力去实现它。

最后祝愿各位身体健康，顺利拿到心仪的offer！

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取