静态代理和动态代理

静态代理
接口类：TargetClass

package main.java.com.xzq.staticproxy;

/**
 * 目标接口
 */
public interface TargetClass {

    public void sayHi();
}

接口实现类TargetClassImpl

package main.java.com.xzq.staticproxy;

public class TargetClassImpl implements TargetClass {
    @Override
    public void sayHi() {
        System.out.println("Hi,static proxy.sayHi");
    }
}

代理类ProxyClass

package main.java.com.xzq.staticproxy;

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

/**
 * 代理类
 */
public class ProxyClass implements TargetClass {


    //持有目标接口的引用
    private TargetClass targetClass;


    //构造方法对目标接口的引用进行初始化
    public ProxyClass(TargetClass targetClass) {
        this.targetClass = targetClass;
    }

    /**
     * 覆盖目标接口的方法
     */
    @Override
    public void sayHi() {
        System.out.println("前置增强~");
        targetClass.sayHi();
        System.out.println("后置增强~");
    }
}

不使用静态代理测试

使用静态代理测试

===================================================
动态代理

接口类：TargetClass

package main.java.com.xzq.dynamicproxy;

/**
 * 目标接口
 */
public interface TargetClass {
    public void sayHi();
    public void work();
}

接口实现类：TargetClassImpl

package main.java.com.xzq.dynamicproxy;

public class TargetClassImpl implements TargetClass {
    @Override
    public void sayHi() {
        System.out.println("Hi,dynamic proxy.sayHi");
    }

    @Override
    public void work() {
        System.out.println("Hi,dynamic proxy.work");
    }
}

动态代理类 ProxyClass，需要继承InvocationHandler

package main.java.com.xzq.dynamicproxy;

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

/**
 * 实现jdk提供的InvocationHandler接口
 * 实现该接口是为了实现jdk的动态代理
 *
 * 此类不是真正的代理类
 */
public class ProxyClass implements InvocationHandler {

    //持有目标接口的引用，动态代理为了适配各种目标类型，把引用使用object
    private Object target;

    /**
     * 使用构造方法对目标接口的引用实现初始化
     * @param target
     */
    public ProxyClass(Object target){
        this.target = target;
    }



    /**
     * 覆盖InvocationHandler接口的方法
     * 该方法会对目标接口的方法进行拦截
     * @param proxy
     * @param method
     * @param args
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {


        System.out.println("前置增强~");

        //中间是调用目标接口的方法
        Object result = method.invoke(target,args);

        System.out.println("后置增强~");

        return result;
    }
}

测试类Client02

package main.java.com.xzq.dynamicproxy;

import java.lang.reflect.Proxy;

public class Client02 {

    //使用动态代理
    public static void main(String[] args) {

        /**
         * 使用JDK中的 Proxy.newProxyInstance 获取代理类
         *
         * 传入三个参数 (ClassLoader loader,Class<?>[] interfaces, InvocationHandler h)
         *  ClassLoader loader : 加载类的ClassLoader，可以传接口类的ClassLoader
         *  Class<?>[] interfaces ：接口数组，new Class<?>[]{TargetClass.class} class类型
         *  InvocationHandler h ：实现InvocationHandler的接口的类，new ProxyClass(传入目标类)
         */
        TargetClass targetClass = (TargetClass) Proxy.newProxyInstance(TargetClass.class.getClassLoader(),
                new Class<?>[]{TargetClass.class},
                new ProxyClass(new TargetClassImpl()));
        
        targetClass.sayHi();
        targetClass.work();

    }

}

未使用动态代理，未增强