Java 学习笔记

👉 所有文章
基础 Java 安装 Java : 第一个程序 Hello World Java : 建议使用 UTF-8 编写 Java 代码 Java : package 包命名规范 使用 Intellij IDEA 创建 Java 项目 Java 布尔类型 Java 处理日期和时间 Java 正则表达式 Java finalize 方法 Java : 空值 null Java 如何触发垃圾回收 Java ThreadLocal Java InheritableThreadLocal Java Integer之间的比较 Java 动态代理 Java 匿名类 Java 枚举 Java: 加速maven、gradle依赖下载 Java 如何静态导入 import static println Java 引用级别:强引用、软引用、弱引用、幽灵引用 Java try finally return 解惑 Java WeakHashMap Java ReferenceQueue 怎么写 Java 示例代码? Java 匿名类双大括号初始化 什么是 Java Bean Java 多行字符串 Java 快速生成 List Java 快速生成 Map Java 将异常堆栈转换为 String JDK SPI 的使用和源码分析 Java Map 中的 key 和 value 能否为 null Java List 和 数组的互相转换 Java 获取环境变量 Java 获取和设置系统属性 Java: 如何获取当前进程的 PID ? Java 字符串左侧/右侧补充空格或者其他字符 Java 线程 Java: 如何获取文本文件内容 Java: 读取资源文件内容 Java: 获取 jar 中文件的内容 Java: 使用 JavaFx 构建 GUI Java: Class 类 Java : 使用 instanceof 判断对象类型 一个自定义的 Java 工具类 Java : 获取当前函数所属类的类名 Java : 获取当前执行的函数名 Java : 使用 String 的 split 函数拆分字符串 Java : 获取字符的 Unicode 编号(代码点) Java : 获取当前工作目录 Java : 使用 Class 对象的 isArray 方法判断对象是否为数组 使用 Java 生成 CSV 文件
工具 Java : jps 命令的使用 Java : jcmd 命令的使用 Java : VisualVM 工具的使用 Java : 使用 javap 解析 class 文件 Java : jar 命令
项目构建 ( 基于 Gradle ) Java: 使用 Gradle 将源码打包为 jar Java: Gradle 下载项目依赖 Java : 清理 Gradle 生成的 build、out 目录 Java : 将 maven 项目转换为 gradle 项目
测试 Java Mockito 测试框架快速入门 JMockit 入门 JUnit 入门 JUnit 单测隔离
三方库 Java JOOR 反射库 Java alibaba transmittable-thread-local 库:让 ThreadLocal 跨线程传播 Java 日志组件 slf4j 的使用和源码分析 Java Lombok 库:为你减少样板代码 Java: 使用 cglib 实现动态代理 Java Hibernate validator 校验框架 Java 使用 Hessian2 序列化和反序列化 H2 数据库快速入门 Java : 使用 Gson 库处理json数据
IDE Intellij IDEA 使用技巧汇总 Intellij IDEA 如何修改/添加代码颜色主题 解决 Intellij IDEA 右下角不显示 git 分支的问题 Intellij IDEA 指定/修改 JDK 版本 Intellij IDEA 文件初始化模板
其他 Java: 加速maven、gradle依赖下载 Java: 如何创建多模块项目 Java 集成 groovy 构建规则引擎 Java 13: 安装 Java 13 新特性:文本块(多行字符串) 卸载 MacOS 上安装的 Java Java: 执行 sql 文件 Java JDK 有哪些发行版 ? java拾遗:String和数组 java拾遗:由反转数组想到System.out的实现机制 java拾遗:如何读取properties文件内容 Java并发概念汇总 java拾遗:System.out.println()是什么? java拾遗:通过示例理解位运算 使用“庖丁解牛”进行中文分词 DBUtils简明教程 试用velocity模板引擎
TODO Java: 如何使用 java、javac 、jar 命令 使用 Nexus Repository Manager 搭建 maven 私有仓库

Java 动态代理


有一个设计模式是代理模式,常见的实现都是为一个类特地编写一个代理类,这种代理叫做静态代理。

而动态代理中,代理对象是在运行时候生成的,可以针对多种不同的类生成代理。

动态代理入门

示例代码包结构:

demo01
├── CustomInvocationHandler.java
├── HelloImpl.java
├── IHello.java
└── Main.java

定义接口 IHello:

package proxy01;

public interface IHello {

    void hello();
    void hi();

}

增加接口 IHello 的实现类:

package proxy01;

public class HelloImpl implements IHello {
    @Override
    public void hello() {
        System.out.println("hello");
    }

    @Override
    public void hi() {
        System.out.println("hi");
    }
}

自定义 InvocationHandler:

package proxy01;


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

public class CustomInvocationHandler implements InvocationHandler {

    private Object target;

    public CustomInvocationHandler(Object target) {
        this.target=target;
    }

    /**
     * 被代理的类,在执行方法时,会经过这里
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println(String.format("proxy类名: %s", proxy.getClass().getCanonicalName()));
        System.out.println(String.format("调用类: %s, 调用方法: %s", target.getClass().getCanonicalName(), method.getName()));
        return method.invoke(target,args);
    }
}

生成代理对象,并测试效果:

package proxy01;

import org.junit.Test;

import java.lang.reflect.Proxy;

public class Main {

    public static void main(String[] args) {
        HelloImpl helloImpl = new HelloImpl();  // 要被代理的对象
        ClassLoader classLoader = HelloImpl.class.getClassLoader();  // 类加载
        Class<?>[] interfaces = new Class[] { IHello.class };        // 接口

        // 用自定义 InvocationHandler 包装 helloImpl
        CustomInvocationHandler handler = new CustomInvocationHandler(helloImpl);  

        // 生成代理对象
        IHello hello = (IHello) Proxy.newProxyInstance(classLoader, interfaces, handler); 
        hello.hello();
    }

}

运行结果:

proxy类名: com.sun.proxy.$Proxy0
调用类: demo01.HelloImpl, 调用方法: hello
hello

关于类名com.sun.proxy.$Proxy0: 因为代理类是动态生成的,所以特地用了一个独有的包com.sun.proxy,类名用$开头,后缀是数字。如果有多个动态代理类产生,会发现数字是不同的。

Java 动态代理是基于接口的

Java 动态代理是基于接口的 ,所以对Proxy.newProxyInstance生成的对象,只能用接口进行类型装换,也就是:

IHello hello = (IHello) Proxy.newProxyInstance(classLoader, interfaces, handler); 

下面这种方式是错误的:

// 错误的用法,运行时会报错
HelloImpl hello = (HelloImpl) Proxy.newProxyInstance(classLoader, interfaces, handler);

动态代理长什么样子?

要看长什么样子,需要两步。

第一步,将动态生成的代理类字节码写入文件:

import sun.misc.ProxyGenerator;

import java.io.FileOutputStream;
import java.io.IOException;
import java.lang.reflect.Proxy;

public class Main {

    public static void main(String[] args) {
        HelloImpl helloImpl = new HelloImpl();
        ClassLoader classLoader = HelloImpl.class.getClassLoader();
        Class<?>[] interfaces = new Class[] { IHello.class };
        CustomInvocationHandler handler = new CustomInvocationHandler(helloImpl);

        Object proxy = Proxy.newProxyInstance(classLoader, interfaces, handler);
        addClassToDisk(proxy.getClass().getName(), HelloImpl.class,"/Users/letian/Proxy.class");
    }


    /**
     * 这个代码来自:https://www.jianshu.com/p/e2917b0b9614 ,作用是将类的字节码写入指定path对应的文件
     */
    private static void addClassToDisk(String className, Class<?> cl, String path) {
        //用于生产代理对象的字节码
        byte[] classFile = ProxyGenerator.generateProxyClass(className, cl.getInterfaces());
        FileOutputStream out = null;
        try {
            out = new FileOutputStream(path);
            //将代理对象的class字节码写到硬盘上
            out.write(classFile);
            out.flush();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (out!=null) {
                    out.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}

我用的macOS,家目录是/Users/letian,所以写到了这个目录下。

第2步,反编译生成的Proxy.class文件。使用 Intellij IDEA 打开该文件即可,反编译的结果如下:

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package com.sun.proxy;

import demo02.IHello;
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 IHello {
    private static Method m1;
    private static Method m4;
    private static Method m3;
    private static Method m2;
    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});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final void hi() throws  {
        try {
            super.h.invoke(this, m4, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final void hello() 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 int hashCode() throws  {
        try {
            return (Integer)super.h.invoke(this, m0, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m4 = Class.forName("demo02.IHello").getMethod("hi");
            m3 = Class.forName("demo02.IHello").getMethod("hello");
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

本质上,和我们常见的静态代理相同。

动态代理的好处:编写一次,到处使用

我们把 CustomInvocationHandler 改造的更通用些:

public class CustomInvocationHandler implements InvocationHandler {

    private Object target;
    public CustomInvocationHandler(Object target) {
        this.target=target;
    }

    // 增加了生成代理的通用函数
    public static Object getProxy(Object target) {
        ClassLoader classLoader = target.getClass().getClassLoader(); // 获取被代理类的类加载器
        Class<?>[] interfaces = target.getClass().getInterfaces();    // 获取被代理类的接口
        CustomInvocationHandler handler = new CustomInvocationHandler(target);  // 生成 InvocationHandler
        return Proxy.newProxyInstance(classLoader, interfaces, handler);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println(String.format("proxy类名: %s", proxy.getClass().getCanonicalName()));
        System.out.println(String.format("调用类: %s, 调用方法: %s", target.getClass().getCanonicalName(), method.getName()));
        return method.invoke(target,args);
    }
}

使用方法如下:

public class Main {

    public static void main(String[] args) {
        HelloImpl helloImpl = new HelloImpl();
        IHello hello = (IHello) CustomInvocationHandler.getProxy(helloImpl);
        hello.hello();
    }

}

执行 Main 类,会输出:

proxy类名: com.sun.proxy.$Proxy0
调用类: demo03.HelloImpl, 调用方法: hello
hello

为什么说可以到处使用? 只要类是基于接口实现,便可以使用基于上面的基于 CustomInvocationHandler 的动态代理。

被代理对象的自调用

动态代理的代理粒度是类,所以执行被代理对象的某个方法A时,若方法内部调用了另一个方法B,方法B的执行是不经过代理的。

看下示例(demo04):

稍微修改被代理对象:

public class HelloImpl implements IHello {
    @Override
    public void hello() {
        System.out.println("hello");
        hi();  // 这里调用了另一个 hi 函数
    }

    @Override
    public void hi() {
        System.out.println("hi");
    }
}

测试效果:

public class Main {
    public static void main(String[] args) {
        HelloImpl helloImpl = new HelloImpl();
        IHello hello = (IHello) CustomInvocationHandler.getProxy(helloImpl);
        hello.hello();
        hello.hi();
    }
}

执行后,输出:

proxy类名: com.sun.proxy.$Proxy0
调用类: demo04.HelloImpl, 调用方法: hello
hello
hi
proxy类名: com.sun.proxy.$Proxy0
调用类: demo04.HelloImpl, 调用方法: hi
hi

其中执行 hi 方法的结果是:

proxy类名: com.sun.proxy.$Proxy0
调用类: demo04.HelloImpl, 调用方法: hi
hi

执行 hello 方法的结果是:

proxy类名: com.sun.proxy.$Proxy0
调用类: demo04.HelloImpl, 调用方法: hello
hello
hi

可以看到,执行 hello 方法时,内部执行了 hi方法,hi方法未经过代理。

如果被代理对象有多个接口

$ tree demo05
demo05
├── CustomInvocationHandler.java
├── HelloAndHelloWorldImpl.java
├── IHello.java
├── IHelloWorld.java
└── Main.java

除了 IHello 接口:

package demo05;

public interface IHello {

    void hello();
    void hi();

}

我们增加了一个 IHelloWorld 接口:

package demo05;

public interface IHelloWorld {
    void helloWorld();
}

HelloAndHelloWorldImpl 实现了这两个接口:

package demo05;

public class HelloAndHelloWorldImpl implements IHello, IHelloWorld {
    @Override
    public void hello() {
        System.out.println("hello");
    }

    @Override
    public void hi() {
        System.out.println("hi");
    }

    @Override
    public void helloWorld() {
        System.out.println("hello world");
    }
}

在动态代理中,调用一个接口的方法前,对代理对象类型转换即可:

package demo05;

public class Main {
    public static void main(String[] args) {
        HelloAndHelloWorldImpl helloImpl = new HelloAndHelloWorldImpl();
        Object proxy = CustomInvocationHandler.getProxy(helloImpl);

        // 调用 IHello 接口的方法
        IHello hello = (IHello) proxy;
        hello.hello();

        // 调用 IHelloWorld 接口的方法
        IHelloWorld helloWorld = (IHelloWorld) proxy;
        helloWorld.helloWorld();
    }
}

运行结果如下:

proxy类名: com.sun.proxy.$Proxy0
调用类: demo05.HelloAndHelloWorldImpl, 调用方法: hello
hello
proxy类名: com.sun.proxy.$Proxy0
调用类: demo05.HelloAndHelloWorldImpl, 调用方法: helloWorld
hello world

( 本文完 )

文章目录