Java代理之jdk动态代理+应用场景实战

本文将先介绍jdk动态代理的基本用法,并对其原理和注意事项予以说明。之后将以两个最常见的应用场景为例,进行代码实操。这两个应用场景分别是拦截器声明性接口,它们在许多开发框架中广泛使用。比如在spring和mybatis中均使用了拦截器模式,在mybatis中还利用动态代理来实现声明性接口的功能。因此,掌握动态代理的原理和代码书写方式,对阅读理解这些开源框架非常有益。

文中的示例代码基于jdk8编写,且都经过验证,但在将代码迁移到博客的过程中,难免存在遗漏。如果您将代码复制到自己的IDE后无法运行,或存在语法错误,请在评论中留言指正 😉

小示例

先来看一个jdk代理的最小demo

点击查看代码
package demo.proxy;

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

public class JdkProxyBasicDemo {

    // ⑴ 定义业务接口
    interface BusinessInterface {
        void greeting(String str);
    }

    // ⑵ 编写代理逻辑处理类
    static class ProxyLogicHandler implements InvocationHandler {
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.printf("运行的代理类为: %s\n", proxy.getClass().getName());
            System.out.printf("调用的代理方法为: %s\n", method.getName);
            System.out.printf("调用方法的参数为: %s\n", args[0]);
            System.out.println("请在这里插入代码逻辑代码...");  // ⑵.1
            return null;                                   // ⑵.2
        }
    }

    // ⑶ 生成代理实例,并使用
    public static void main(String[] args) {
        ProxyLogicHandler proxyLogicHandler = new ProxyLogicHandler(original);
        Class[] interfaces = new Class[]{BusinessInterface.class},
        BusinessInterface businessProxy = (BusinessInterface) Proxy.newProxyInstance(BusinessInterface.class.getClassLoader(), proxyLogicHandler);
        businessProxy.greeting("Hello, Jdk Proxy");
    }
}

上述代码执行后的输出结果如下:

运行的代理类为: class com.sun.proxy.$Proxy0
调用的代理方法为: greeting
调用方法的参数为: Hello, Jdk Proxy
请在这里插入代理的逻辑代码...

其中倒数第二行的businessProxy变量,就是一个代理对象,它是BusinessInterface接口的一个实例,但我们并没有编写这个接口的实现类,而是通过Proxy.newProxyInstance方法生成出了该接口的实例。那么这个动态代理实例对应的Class长什么样子呢?上面的结果输出中已经打印出来了,这个代理类名称为com.sun.proxy.$Proxy0。实际上,如果我们再为另外一个接口生成代理对象的话,它的Class名称为com.sun.proxy.$Proxy1,依次类推。

还有一个值得关注的问题:最重要的逻辑代码应该写在哪里?答案是写在InvocationHandler这个接口的invoke()方法中,也就是上面示例代码的第⑵处。由此可以看出:代理对象实际要执行的代码,就是invoke()方法中的代码,换言之,代理对象所代理的所有接口方法,最终要执行的代码都在invoke方法里,因此,这里是一切魔法的入口。

编写一个jdk代理实例的基本步骤如下:

  1. 编写业务接口
    因为jdk代理是基于接口的,因此,只能将业务方法定义成接口,但它可以一次生成多个接口的代理对象

  2. 编写调用处理器
    即编写一个java.lang.reflect.InvocationHandler接口的实现类,代理对象的业务逻辑就写成该接口的invoke方法中

  3. 生成代理对象
    有了业务接口和调用处理器后,将二者作为参数,通过Proxy.newProxyInstance方法便可以生成这个(或这些)接口的代理对象。比如上述示例代码中的businessProxy对象,它拥有greeting()这个方法,调用该方法时,实际执行的就是invoke方法。

代理对象生成原理

代理的目的,是为接口动态生成一个实例对象,该对象有接口定义的所有方法。调用对象的这些方法时,都将执行生成该对象时,指定的“调用处理器”中的方法(即invoke方法)。

生成代理对象的方法签名如下:

Proxy.newProxyInstance (ClassLoader loader,  Class<?>[] interfaces, InvocationHandler handler)

classloader一般选择当前类的类加载器,interfaces是一个接口数组,newProxyInstance方法将为这组接口生成实例对象,handler中的代码则是生成的实例对象实际要执行的内容,这些代码就位于invoke方法中。在生成代理对象前,会先生成一个Class,这个Class实现了interfaces中的所有接口,且这些方法的内容为直接调用handler#invoke,如下图所示:

下面将以小示例中的BusinessInterface接口和ProxyLogicHandler为基础,用普通Java代码的方式,模拟一下Proxy.newProxyInstance的代码逻辑,如下:

点击查看代码
public static Object newProxyInstance(ClassLoader loader,  Class<?>[] interfaces, InvocationHandler handler) {
    return new Proxy0(handler);
}

static class Proxy0 implements BusinessInterface{
    private InvocationHandler handler;

    BusinessInterface(InvocationHandler handler) {
        this.handler = handler;
    }

    @Override
    public void greeting(String str) {
        handler.invoke(this, 'greeting', new Object[]{str});
    }
}

上面的代码是示意性的,并不正确,比如它没有使用到loader和interfaces参数,调用hanlder.invoke方法时,对于method参数只是简单的用'greeting'字符串替代,类型都不正确。但这段示意代码很简单明了地呈现了真实的Proxy.newProxyInstance方法内部的宏观流程。

下面再提供一个与真实的newProxyInstance方法稍微接近一点的模拟实现(需要您对jdk里JavaCompiler类的使用有一定了解)

点击查看代码
package guzb.diy.proxy;

import javax.tools.*;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.net.URI;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;

public class ImitateJdkProxy {

    public static void main(String[] args) throws Throwable{
        InvocationHandler handler = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("执行invocationHandler#invoke()方法");
                System.out.println("调用的代理方法名为:" + method.getName());
                System.out.println("调用时传递的参数为:" + args[0]);
                return null;
            }
        };
        Foo foo = (Foo) newProxyInstance(ImitateJdkProxy.class.getClassLoader(), Foo.class, handler);
        foo.sayHi("East Knight");
    }

    /** 
     * 模拟java.lang.reflect.Proxy#newProxyInstance方法
     * 这里简化了代理类的类名,固定为:guzb.diy.$Proxy0
     */
    public static final Object newProxyInstance(ClassLoader loader, Class<?> interfaces, InvocationHandler handler) throws Exception {
        // 1. 构建代理类源码对象
        JavaFileObject sourceCode = generateProxySourceCode();

        // 2. 编译代理源代码
        JavaBytesFileObject byteCodeFile = new JavaBytesFileObject("guzb.diy.$Proxy0");
        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
        StandardJavaFileManager stdFileManager = compiler.getStandardFileManager(null, Locale.CHINA, Charset.forName("utf8"));
        JavaFileManager fileManager = new ForwardingJavaFileManager(stdFileManager) {
            @Override
            public JavaFileObject getJavaFileForOutput(Location location, String className, JavaFileObject.Kind kind, FileObject sibling) throws IOException {
                return byteCodeFile;
            }
        };
        List<JavaFileObject> compilationUnits = new ArrayList<>();
        compilationUnits.add(sourceCode);
        JavaCompiler.CompilationTask compilationTask = compiler.getTask(null, fileManager, null, null, null, compilationUnits);
        if (!compilationTask.call()) {
            return null;
        }

        // 3. 加载编译后的代理类字节码
        loader = new ClassLoader() {
            @Override
            public Class<?> findClass(String name) throws ClassNotFoundException {
                byte[] bytes = byteCodeFile.getBytes();
                return defineClass(name, bytes, 0, bytes.length);
            }
        };
        Class clazz = loader.loadClass("guzb.diy.$Proxy0");

        // 4. 创建代理类实例并返回
        Constructor constructor = clazz.getConstructor(new Class[]{InvocationHandler.class});
        return constructor.newInstance(handler);
    }

    /**
     * 生成代理Class的源代码,该代码将在运行期间动态编译和加载。
     * 为了便于直观查看代理类的原理,故意采用了这个使用源码编译的方式,实际上,
     * JDK真实的newProxyInstance方法,内部是采用纯反射+直接生成字节码数组的方式实现的,比较晦涩。
     * 这里也简化了代理代码,比如:
     *   1. 写死了代理类的类名:guzb.diy.$Proxy0
     *   2. 写死了要实现的接口和方法
     *      不写死的话,需要通过反射遍历所有接口的所有方法,并基于Method对象的方法名、返回类型、参数列表和异常列表,
     *      创建实现类的方法签名文本,这样的话,代码就太冗长了,干扰了对代理主线逻辑的理解,也不是本文的重点
     *   3. 没有使用调用者传递的ClassLoader来加载编译后的字节码文件,原因同上,涉及加载器的隔离问题,代码过于冗长
     */
    private static JavaFileObject generateProxySourceCode() throws NoSuchMethodException {
        String[] codeLines = new String[]{
                "package guzb.diy;",

                "import java.lang.reflect.*;",
                "import guzb.diy.proxy.ImitateJdkProxy.Foo;",

                "public class $Proxy0 implements Foo {                    ",
                "    private InvocationHandler handler;                   ",
                "                                                         ",
                "    public $Proxy0 (InvocationHandler handler) {         ",
                "        this.handler = handler;                          ",
                "    }                                                    ",
                "                                                         ",
                "    @Override                                            ",
                "    public void sayHi(String name) throws Throwable {    ",
                "        Method method = Foo.class.getMethod(\"sayHi\", new Class[]{String.class}); ",
                "        this.handler.invoke(this, method, new Object[]{name}); ",
                "    }",
                "}"
        };

        String code = "";
        for (String codeLine : codeLines) {
            code += codeLine + "\n";
        }
        return new JavaStringFileObject("guzb.diy.$Proxy0", code);
    }

    /** 一个简单的业务接口 */
    public interface Foo {
        void sayHi(String name) throws Throwable;
    }

    /** 基于字符串的Java源代码对象 */
    public static class JavaStringFileObject extends SimpleJavaFileObject {
        // 源代码文本
        final String code;

        /**
         *  @param name Java源代码文件名,要包含完整的包名,比如guzb.diy.Proxy
         *  @param code Java源代码文本
         */
        JavaStringFileObject(String name, String code) {
            super(URI.create("string:///" + name.replace('.','/') + Kind.SOURCE.extension), Kind.SOURCE);
            this.code = code;
        }

        @Override
        public CharSequence getCharContent(boolean ignoreEncodingErrors) {
            return code;
        }
    }

    /** 编译后的字节码文件 */
    public static class JavaBytesFileObject extends SimpleJavaFileObject {
        // 接收编译后的字节码
        private ByteArrayOutputStream byteCodesReceiver;

        /** @param name Java源代码文件名,要包含完整的包名,比如guzb.diy.Proxy */
        protected JavaBytesFileObject(String name) {
            super(URI.create("bytes:///" + name + name.replace(".", "/")), Kind.CLASS);
            byteCodesReceiver = new ByteArrayOutputStream();
        }

        @Override
        public OutputStream openOutputStream() throws IOException {
            return byteCodesReceiver;
        }

        public byte[] getBytes() {
            return byteCodesReceiver.toByteArray();
        }
    }
}

代码运行结果为:

执行invocationHandler#invoke()方法
调用的代理方法名为:sayHi
调用时传递的参数为:East Knight

应用场景

上面提到:代理是在运行期,为接口动态生成了一个实现类,和这个实现类的实例。那这个功能有什么用呢?我们直接写一个实现类不也是一样的么?代理类与我们手动写代码的主要差异在于它的动态性,它允许我们在程序的运行期间动态创建Class,这对于框架类程序,为其预设的业务组件增加公共特性提供了技术支持。因为这种额外特性的加持,对业务代码没有直接的侵入性,因此效果非常好。动态代理的两个最常用见应用场景为拦截器和声明性接口,下面分别介绍。

拦截器功能

搭载器就是将目标组件劫持,在执行目标组件代码的前后,塞入一些其它代码。比如在正式执行业务方法前,先进行权限校验,如果校验不通过,则拒绝继续执行。对于此类操作,业界已经抽象出一组通用的编程模型:面向切面编程AOP

接下来,将以演员和导演为业务背景,实现一个简易的拦截器,各个组件介绍如下:

  • Performer <Interface>
    演员接口,有play和introduction方法

  • DefaultActor <Class>
    代码男性演员,它实现了Performer接口,也是拦截器将要拦截的对象

  • Director <Interface>
    导演接口,只有一个getCreations方法, 该方法返回一个字符串列表,它代表导演的作品集

  • DefaultDirector <Class>
    Director接口的实现类,同时也是拦截器将要拦截的对象

  • ProxyForInterceptor <Class>
    拦截器核心类,实现了InvocationHandler接口,拦截器代码位于接口的invoke方法中。

    拦截器将持有Performer和Direcotor的真实实现实例,并在调用Performer的play和introduction方法前,先执行一段代码。这里实现为打印一段文本,接着再调用play或introduction,执行完后,再执行一段代码,也是打印一段文本。Director实例方法的拦截处理逻辑与此相同。这便是最简单的拦截器效果了。

  • IntercepterTestMain <Class>
    拦截器测试类,在main方法中,验证上述组件的拦截器功能效果。这个例子中,特意写了两个接口和两个实现类,就是为了演示,JDK的动态代理是支持多接口的。

下面是各个组件的源代码

Performer
package guzb.diy.proxy;

/**
 * 演员接口
 * 在这个示例中,将为该接口生成代理实例
 */
public interface Performer {
    /**
     * 根据主题即兴表演一段
     * @param subject 表演的主题
     */
    void play(String subject);

    /** 自我介绍 */
    String introduction();
}
DefaultActor
package guzb.diy.proxy;

/**
 * 这是演员接口的默认实现类
 * 在本示例中,它将作为原始的接口实现者,被代理(拦截)
 */
public class DefaultActor implements Performer {
    @Override
    public void play(String subject) {
        System.out.println("[DefaultActor]: 默认男演员正在即兴表演《"+ subject +"》");
    }

    @Override
    public String introduction() {
        return "李白·上李邕: 大鹏一日同风起,扶摇直上九万里。假令风歇时下来,犹能颠却沧溟水。世人见我恒殊调,闻余大言皆冷笑。宣父尚能畏后生,丈夫未可轻年少。";
    }
}
Director
package guzb.diy.proxy;

import java.util.List;

/**
 * 导演接口
 * 在这个示例中,将为该接口生成代理实例
 */
public interface Director {
    /**
     * 获取曾导演过的作品集
     * @return 作品名称列表
     */
    List<String> getCreations();
}

DefaultDirector
package guzb.study.javacore.proxy.jdk;

import java.util.ArrayList;
import java.util.List;

/**
 * 这是导演接口的默认实现类
 * 在本示例中,它将作为原始的接口实现者,被代理(拦截)
 */
public class DefaultDirector implements Director{
    @Override
    public List<String> getCreations() {
        return new ArrayList(){
            {
                add("活着");
                add("盲井");
                add("走出夹边沟");
                add("少年派的奇幻漂流");
            }
        };
    }
}
ProxyForInterceptor
package guzb.diy.proxy;

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

/**
 * 代理应用场景一:拦截器
 * 即在原来的业务逻辑上追加额外的代码,这是代理功能最常见的应用场景。
 *
 * 在本示例中,导演与演员实例代表原始业务,
 * 由于代理的目的是在执行真实的接口实现类方法的前后,执行一段其它代码。
 * 因此,本类需要持有原始的导演和演员实例。
 */
public class ProxyForInterceptor implements InvocationHandler {

    // 原始的演员对象
    private Performer performer;

    // 原始的导演对象
    private Director director;

    public ProxyForInterceptor(Director director, Performer performer) {
        this.director = director;
        this.performer = performer;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        String methodName = method.getName();
        System.out.printf("[DirectorActorProxyHandler]: 调用的代理方法为:%s\n", methodName);

        System.out.printf("[DirectorActorProxyHandler]: >>> 调用 %s 之前的逻辑\n", methodName);

        Object result = null;
        // 因为本代理处理器,只针对Director和Actor接口,因此,如果方法名为play,则一定调用的是Actor的play方法
        // 根据Actor#play方法的参数定义,它只有一个String参数,所以直接取args[0]即可
        if(methodName.equals("play")) {
            performer.play((String)args[0]);
        } else if (methodName.equals("introduction")) {
            result = performer.introduction();
        } else if (methodName.equals("getCreations")) {
            result = director.getCreations();
        }

        System.out.printf("[DirectorActorProxyHandler]: <<< 调用 %s 之后的逻辑\n", methodName);
        return result;
    }
}
IntercepterTestMain
package guzb.diy.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.util.List;

public class IntercepterTestMain {
    public static void main(String[] args) {
        Performer actor = new DefaultActor();
        Director director = new DefaultDirector();
        InvocationHandler interceptor = new ProxyForInterceptor(director, actor);

        // 要代理的接口,这里称之为委托接口,即委托给代理实例,去实现相应的功能
        Class[] principalInterfaces = new Class[]{Director.class, Performer.class};

        // 创建一个代理实例,该实例实现了委托接口所定义的方法,因此,这个实例可以强转为Performer和Director
        Object directorPerformerProxy = Proxy.newProxyInstance(IntercepterTestMain .class.getClassLoader(), principalInterfaces, interceptor);

        Performer performerProxy = (Performer) directorPerformerProxy;
        Director directorProxy = (Director) directorPerformerProxy;

        // ① 调用代理实例中,Performer接口相关的方法
        performerProxy.play("长板坡");
        String introduction = performerProxy.introduction();
        System.out.printf("[IntercepterTestMain ]: 代理对象返回的个人简介内容为: %s\n", introduction);

        // 调用代理实例中,Director接口相关的方法
        List<String> creations = directorProxy.getCreations();
        System.out.println("[IntercepterTestMain ]: 代理对象返回的导演作品列表:");
        for (String creation : creations) {
            System.out.printf("    · %s\n", creation);
        }
    }
}

以上代码的执行结果如下:

[DirectorActorProxyHandler]: 调用的代理方法为:play
[DirectorActorProxyHandler]: >>> 调用 play 之前的逻辑
[DefaultActor]: 默认男演员正在即兴表演《长板坡》
[DirectorActorProxyHandler]: <<< 调用 play 之后的逻辑
[DirectorActorProxyHandler]: 调用的代理方法为:introduction
[DirectorActorProxyHandler]: >>> 调用 introduction 之前的逻辑
[DirectorActorProxyHandler]: <<< 调用 introduction 之后的逻辑
[IntercepterTestMain ]: 代理对象返回的个人简介内容为: 李白·上李邕: 大鹏一日同风起,扶摇直上九万里。假令风歇时下来,犹能颠却沧溟水。世人见我恒殊调,闻余大言皆冷笑。宣父尚能畏后生,丈夫未可轻年少。
[DirectorActorProxyHandler]: 调用的代理方法为:getCreations
[DirectorActorProxyHandler]: >>> 调用 getCreations 之前的逻辑
[DirectorActorProxyHandler]: <<< 调用 getCreations 之后的逻辑
[IntercepterTestMain ]: 代理对象返回的导演作品列表:
    · 活着
    · 盲井
    · 走出夹边沟
    · 少年派的奇幻漂流

可以看到,在main方法中,调用代理类的play方法后(位于代码的①处),在执行真实的DefaultActor#play方法前后,均有额外的文本输出,这些都不是DefaultActor#play方法的逻辑。这便实现了拦截器效果,且对于使用者而言(即编写DefaultActor类的开发者),是无侵入无感知的。

声明性接口

声明性接口的特点是:开发者只需要提供接口,并在接口方法中声明该方法要完成的功能(通常是以多个注解的方式声明),但不用编写具体的功能实现代码,而是通过框架的工厂方法来获取该接口的实例。当然,该实例会完成接口方法中所声明的那些功能。比较典型的产品是MyBatis的Mapper接口。实现手段也是采用jdk动态代理,在InvocationHandler的invoke方法中,完成该接口方法所声明的那些特性功能。

接下来,本文将模拟MyBatis的Mapper功能,组件说明如下:

  • SqlMapper <Annotaton>
    与MyBatis的Mapper注解等效,用于标识一个接口为Sql映射接口,但在本示例中,这个接口并未使用到。因为这个标识接口的真实用途,是在SpringBoot环境中,用于自动扫描和加载Mapper接口的。本示例仅模拟Mapper本身的声明性功能,因此用不上它。保留这个接口,只是为了显得更完整。

  • Select <Annotation>
    与MyBatis的Select注解等效,它有一个sql属性,用于指定要执行的SQL语句,且支持#{}形式的插值

  • ParamName <Annotation>
    与MyBatis的Param注解等效,用于标识Mapper接口的方法参数名称,以便用于Select注解中sql语句的插值替换

  • PerformerMapper <Interface>
    演员实体的数据库访问接口,与开发者使用MyBatis时,日常编写的各类Mapper接口一样。在里边定义各种数据库查询接口方法,并利用Select和ParamName注解,声明数据操作的具体功能。

  • ProxyForDeclaration <Classs>
    整个Mapper功能的核心类,实现了InvocationHandler接口,在invoke方法中,完成Mapper的所有功能

  • DeclarationTestMain <Classs>
    声明性接口的功能测试类,在main方法中,通过jdk代理获得一个PerformerMapper实例,并调用其中的getQuantityByNameAndAage、getRandomPoetryOf和listAllOfAge方法,分别传入不的SQL和参数,用以验证3种不同的情况。

下面是各个组件的源代码:

SqlMapper
package guzb.diy.proxy;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 标识一个接口是一个SQL映射类,用于模拟MyBatis的mapper功能
 */
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
public @interface SqlMapper {
}
Select
package guzb.diy.proxy;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 为一个mapper方法指定查询类sql语句
 * 本类用于模拟MyBatis的mapper功能
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Select {
    /**
     * 查询sql语句,支持#{}这样的插值占位符
     */
    String sql();
}

ParamName
package guzb.diy.proxy;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 为一个mapper方法的参数,指定一个名称,以便在sql语句中进行插值替换
 * 本类用于模拟MyBatis的mapper功能
 */
@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
public @interface ParamName {
    /** 参数的名称 */
    String value();
}
PerformerMapper
package guzb.diy.proxy;

/**
 * 演员实体查询接口。
 * 本类用于模拟MyBatis的mapper功能
 */
@SqlMapper
public interface PerformerMapper {

    @Select(sql = "select count(*) from performer where name=#{name} and age = #{ age }")
    Long getQuantityByNameAndAage(@ParamName("name") String name, @ParamName("age") Integer age);

    @Select(sql = "select poetry_item from poetry where performer_name = #{ name }")
    String getRandomPoetryOf(@ParamName("name") String name);

    // ② SQL中故障引入了一个pageSize的变量,由于方法签名中没有声明这个参数,因此会导致SQL在插值替换阶段发生异常
    @Select(sql = "select * from performer where age >= #{age} limit #{ pageSize }")
    Object listAllOfAge(@ParamName("age") int age);

}
ProxyForDeclaration
package guzb.diy.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 〔声明性接口〕功能的核心实现类
 */
public class ProxyForDeclaration implements InvocationHandler {
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.printf("[ProxyForDeclaration]: 调用的方法名为:%s\n", method.getName());

        // 1. 先提取出原始的SQL
        String rawSql = extractSql(method);
        if (rawSql == null || rawSql.trim().length() == 0) {
            System.out.printf("[ProxyForDeclaration]: 方法%s()未指定SQL语句,无法执行。请通过@Select注解指定Sql\n", method.getName());
            return null;
        }
        System.out.printf("[ProxyForDeclaration]: 原始sql为:%s\n", rawSql);

        // 2. 对原始SQL做插值替换,String类型的参数追加''号,其它类型原样替换
        String finalSql = interpolateSql(rawSql, method, args);
        System.out.printf("[ProxyForDeclaration]: 插值替换后的sql为:%s\n", finalSql);

        // 3. 模拟执行SQL语句
        return imitateJdbcExecution(finalSql, method.getReturnType());
    }

    private String extractSql(Method method) {
        Select selectAnnotation = method.getAnnotation(Select.class);
        return selectAnnotation == null ? null : selectAnnotation.sql();
    }

    private String interpolateSql(String rawSql, Method method, Object[] args) {
        // 使用正则表达式来完成插值表达式#{}的内容替换
        Pattern interpolationTokenPattern = Pattern.compile("(#\\{\\s*([a-zA-Z0-9]+)\\s*\\})");
        Matcher matcher = interpolationTokenPattern.matcher(rawSql);

        // 提取出方法参数名称与参数对象的对应关系,key为参数名(通过@ParamName注解指定),value为参数对象
        Map<String, Object> paramMap = extractParameterMap(method, args);

        // 插值替换
        String finalSql = rawSql;
        while (matcher.find()) {
            String interpolationToken = matcher.group(1);
            String parameterName = matcher.group(2);
            if (!paramMap.containsKey(parameterName)) {
                throw new SqlMapperExecuteException("未知参数:" + parameterName);
            }

            Object value = paramMap.get(parameterName);
            String valueStr = value instanceof String ? "'" + value.toString() + "'" : value.toString();
            finalSql = finalSql.replace(interpolationToken, valueStr);
        }
        return finalSql;
    }

    private Map<String, Object> extractParameterMap(Method method, Object[] args) {
        Parameter[] parameters = method.getParameters();
        if (parameters.length == 0) {
            return Collections.EMPTY_MAP;
        }

        Map<String, Object> sqlParamMap = new HashMap<>();
        for (int i = 0; i < parameters.length; i++) {
            Parameter parameter = parameters[i];
            ParamName paramName = parameter.getAnnotation(ParamName.class);
            // 这里不用检查数组越界问题,因为args参数本身就是调用接口方法时的传递的参数,只要是正常调用(不是通过反射)就不会越界
            sqlParamMap.put(paramName.value(), args[i]);
        }
        return sqlParamMap;
    }

    /** 模拟执行jdbc sql, 这里仅对数字和字符串进行了模拟,其它返回null */
    private Object imitateJdbcExecution(String finalSql, Class<?> returnType) {
        if(Number.class.isAssignableFrom(returnType)){
            return (long)(Math.random() * 1000 + 1);
        }

        if (returnType == String.class) {
            String[] poetry = new String[]{
                    "黄四娘家花满蹊,千朵万朵压枝低。",
                    "留连戏蝶时时舞,自在妖莺恰恰啼。",
                    "荷尽已无擎雨盖,菊残犹有傲霜枝。",
                    "一年好景君须记,最是橙黄橘绿时。"
            };
            int index = (int)(Math.random() * 4);
            return poetry[index];
        }

        return null;
    }

    static class SqlMapperExecuteException extends RuntimeException {
        public SqlMapperExecuteException(String message) {
            super(message);
        }
    }
}

DeclarationTestMain
package guzb.diy.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.util.List;

/**
 * 〔声明性接口〕功能测试入口类
 */
public class DeclarationTestMain {

    public static void main(String[] args) {
        Class[] principalInterfaces = new Class[]{PerformerMapper.class};
        ProxyForDeclaration declarationHandler = new ProxyForDeclaration();
        PerformerMapper performerMapper = (PerformerMapper) Proxy.newProxyInstance(JdkProxyStudyMain.class.getClassLoader(), principalInterfaces, declarationHandler);

        Long count = performerMapper.getQuantityByNameAndAage("Jane Lotus", 47);
        System.out.printf("[DeclarationTestMain]: 代理实例方法方法的返回值为:%s\n\n", count);

        String poetryItem = performerMapper.getRandomPoetryOf("杜甫");
        System.out.printf("[DeclarationTestMain]: 代理实例方法的返回值为:%s\n\n", poetryItem);

        // ③ 本方法调用后将发生异常,因为PerformerMapper中的②处,声明的SQL有未知的插值变量,这里特意测试验证
        performerMapper.listAllOfAge(100);
    }

}

以上代码的执行结果为:

[ProxyForDeclaration]: 调用的方法名为:getQuantityByNameAndAage
[ProxyForDeclaration]: 原始sql为:select count(*) from performer where name=#{name} and age = #{ age }
[ProxyForDeclaration]: 插值替换后的sql为:select count(*) from performer where name='Jane Lotus' and age = 47
[DeclarationTestMain]: 代理实例方法方法的返回值为:40

[ProxyForDeclaration]: 调用的方法名为:getRandomPoetryOf
[ProxyForDeclaration]: 原始sql为:select poetry_item from poetry where performer_name = #{ name }
[ProxyForDeclaration]: 插值替换后的sql为:select poetry_item from poetry where performer_name = '杜甫'
[DeclarationTestMain]: 代理实例方法的返回值为:黄四娘家花满蹊,千朵万朵压枝低。

[ProxyForDeclaration]: 调用的方法名为:listAllOfAge
[ProxyForDeclaration]: 原始sql为:select * from performer where age >= #{age} limit #{ pageSize }
Exception in thread "main" guzb.diy.proxy.ProxyForDeclaration$SqlMapperExecuteException: 未知参数:pageSize
	at guzb.diy.proxy.ProxyForDeclaration.interpolateSql(ProxyForDeclaration.java:55)
	at guzb.diy.proxy.ProxyForDeclaration.invoke(ProxyForDeclaration.java:29)
	at com.sun.proxy.$Proxy1.listAllOfAge(Unknown Source)
	at guzb.diy.proxy.DeclarationTestMain.main(JdkProxyStudyMain.java:24)

以上代码共模拟了3个调用Mapper的场景:

  1. 调用getQuantityByNameAndAage()方法根据姓名的年龄查询演员数量。但并未真正执行JDBC查询,只是将SQL进行了插值替换和输出,然后随机返回了一个数字。这足以演示声明性接口这一特性了,真实地执行jdbc查询,那将一个代码量巨大的工作,它的缺失并不影响本示例的主旨。

  2. 调用getRandomPoetryOf()方法查询指定诗人的一段诗句。同样没有真正执行jdbc查询,而是随机返回了一句诗文。

  3. 调用listAllOfAge()方法查询指定年龄的所有演员。该方法有意设计为引发一个异常,因为接口方法上声明的SQL中,pageSize这个插值变量并未在方面签名中声明。

热门相关:仙城纪   霸皇纪   我不喜欢年轻的男人2   苏醒的秘密   豪门闪婚:帝少的神秘冷妻