实战JDK 1.8的Java代理与反射：高级编程技巧

星空下的梦 2020-06-12 ⋅ 13 阅读

简介

在Java开发中，代理和反射是非常强大的编程技术。代理模式可以用于实现运行时的代码拦截和增强，而反射则允许我们在运行时动态地获取类的信息并调用类的方法。本文将介绍JDK 1.8中的Java代理和反射的一些高级编程技巧，帮助读者在开发过程中更好地利用这些功能。

代理模式

代理模式在Java中有着广泛的应用，可以用于实现运行时的方法拦截、增强和实现AOP（面向切面编程）。JDK 1.8引入了java.lang.reflect.Proxy类，使得代理模式的实现更加简单。

动态代理

动态代理是指在运行时动态地生成代理对象。JDK的动态代理是基于接口的，只能代理实现了接口的类。要实现动态代理，首先需要定义一个代理处理器，实现InvocationHandler接口，然后通过Proxy.newProxyInstance()方法动态生成代理对象。代理处理器可以在代理对象的方法调用前后添加自定义的逻辑，实现方法的拦截和增强。

以下是一个简单的示例代码，演示了如何使用动态代理来计算方法的执行时间：

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

interface Calculator {
    int add(int a, int b);
}

class CalculatorImpl implements Calculator {
    @Override
    public int add(int a, int b) {
        return a + b;
    }
}

class TimingInvocationHandler implements InvocationHandler {
    private Object target;

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

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        long startTime = System.currentTimeMillis();
        Object result = method.invoke(target, args);
        long endTime = System.currentTimeMillis();
        System.out.println("Method " + method.getName() + " took " + (endTime - startTime) + " ms");
        return result;
    }
}

public class DynamicProxyExample {
    public static void main(String[] args) {
        Calculator calculator = new CalculatorImpl();
        Calculator proxy = (Calculator) Proxy.newProxyInstance(
                Calculator.class.getClassLoader(),
                new Class<?>[] { Calculator.class },
                new TimingInvocationHandler(calculator)
        );

        int sum = proxy.add(1, 2);
        System.out.println("Sum: " + sum);
    }
}

运行以上代码将输出：

Method add took 1 ms
Sum: 3

CGLIB代理

JDK的动态代理只能代理接口，如果要代理没有实现接口的类，则可以使用CGLIB代理。CGLIB（Code Generation Library）是一个强大的代码生成库，可以在运行时生成代理类。

要使用CGLIB代理，首先需要引入CGLIB的依赖，在Maven项目中可以使用以下依赖配置：

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.3.0</version>
</dependency>

使用CGLIB代理的步骤如下：

  1. 定义一个方法拦截器来实现代理逻辑；
  2. 使用Enhancer类创建代理类；
  3. 设置代理类的父类和方法拦截器。

以下是一个示例代码，演示了如何使用CGLIB代理来增强方法调用：

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
}

class LoggingInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("Called method: " + method.getName());
        Object result = proxy.invokeSuper(obj, args);
        System.out.println("Method returned: " + result);
        return result;
    }
}

public class CglibProxyExample {
    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(Calculator.class);
        enhancer.setCallback(new LoggingInterceptor());

        Calculator calculator = (Calculator) enhancer.create();
        int sum = calculator.add(1, 2);
        System.out.println("Sum: " + sum);
    }
}

运行以上代码将输出：

Called method: add
Method returned: 3
Sum: 3

反射

反射是指在运行时动态地获取和操作类的信息。JDK的反射API使得我们可以在运行时动态地加载类、获取类的结构（如成员变量、方法等）以及调用类的方法。

获取类的信息

Java的反射API提供了许多方法来获取类的信息，如获取类的构造方法、成员变量、方法等。以下是一些常用的反射API方法：

  • Class.forName(String className)：根据类的全限定名获取Class对象；
  • getClass()：获取对象的Class对象；
  • getConstructors()：获取类的所有公共构造方法；
  • getDeclaredFields()：获取类的所有成员变量；
  • getMethods()：获取类的所有公共方法。

以下是一个示例代码，演示了如何使用反射API来获取类的信息：

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

class Person {
    private String name;
    public int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void sayHello() {
        System.out.println("Hello, my name is " + name);
    }
}

public class ReflectionExample {
    public static void main(String[] args) throws Exception {
        Class<?> personClass = Class.forName("Person");

        Constructor<?>[] constructors = personClass.getConstructors();
        System.out.println("Constructors:");
        for (Constructor<?> constructor : constructors) {
            System.out.println(constructor);
        }

        Field[] fields = personClass.getDeclaredFields();
        System.out.println("Fields:");
        for (Field field : fields) {
            System.out.println(field);
        }

        Method[] methods = personClass.getMethods();
        System.out.println("Methods:");
        for (Method method : methods) {
            System.out.println(method);
        }
    }
}

运行以上代码将输出：

Constructors:
public Person(java.lang.String,int)
Fields:
private java.lang.String Person.name
public int Person.age
Methods:
public java.lang.String Person.toString()
public void Person.sayHello()
public int Person.getAge()
public java.lang.String Person.getName()
public void Person.setName(java.lang.String)
public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
...

调用方法

除了获取类的信息，反射还可以通过Method类的invoke()方法来调用类的方法。invoke()方法接收两个参数，第一个参数为要调用方法的对象，第二个参数为方法的参数（如果有的话），并返回方法的返回值。

以下是一个示例代码，演示了如何使用反射来调用类的方法：

import java.lang.reflect.Method;

class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
}

public class MethodInvokeExample {
    public static void main(String[] args) throws Exception {
        Calculator calculator = new Calculator();
        Class<?> calculatorClass = calculator.getClass();
        Method addMethod = calculatorClass.getMethod("add", int.class, int.class);

        int sum = (int) addMethod.invoke(calculator, 1, 2);
        System.out.println("Sum: " + sum);
    }
}

运行以上代码将输出：

Sum: 3

总结

代理和反射是Java编程中非常强大的工具。代理模式可以用于实现代码拦截、增强和AOP等功能，而反射允许我们在运行时动态地获取和操作类的信息。JDK 1.8中的Java代理和反射提供了简洁而强大的API，帮助我们实现高级编程技巧。通过掌握这些技术，开发者可以在项目中更好地利用代理和反射，提高代码的灵活性和可重用性。


本文来自极简博客，作者：星空下的梦，转载请注明原文链接：实战JDK 1.8的Java代理与反射：高级编程技巧

#JDK
阅读全部

全部评论: 0 条

    我有话说: