JAVA语言中的代理模式

代理可以进一步划分为静态代理和动态代理,代理模式在实际的生活中场景很多,例如中介、律师、代购等行业,都是简单的代理逻辑,在这个模式下存在两个关键角色:

目标对象角色:即代理对象所代表的对象。

代理对象角色:内部含有目标对象的引用,可以操作目标对象

一、静态代理

目标对象角色

public class Target {
    public void execute(){
        System.out.println("Target execute...");
    }
}

代理对象角色

public class ProxyObj {
    private Target target;
    public  ProxyObj(Target target){
        this.target=target;
    }
    public void invoke(){
        before();
        target.execute();
        after();
    }
    public void before(){
        System.out.println("before...");
    }
    public void after(){
        System.out.println("after...");
    }
}
public class Proxy {
    public static void main(String[] args) {
        Target target = new Target();
        ProxyObj proxy = new ProxyObj(target);
        proxy.invoke();
    }
}

代理模式的本质是在目标对象的方法前后置入增强操作

二、动态代理

首先看两个核心类,这里简述下概念,看完基本过程再细聊:

  • Proxy-创建代理对象,核心参数:

    • ClassLoader:(目标类)加载器;
    • Interfaces:(目标类)接口数组;
    • InvocationHandler:代理调用机制;
  • InvocationHandler-代理类调用机制:

    • invoke:这个上篇说的反射原理;
    • method:反射类库中的核心API;

目标对象和接口

interface IUser {
    Integer update (String name) ;
}
class UserService implements IUser {
    @Override
    public Integer update(String name) {
        Integer userId = 99 ;
        System.out.println("UserId="+userId+";updateName="+name);
        return userId ;
    }
}

代理对象执行机制

class UserHandler implements InvocationHandler {
    private Object target ;
    public UserHandler (Object target){
        this.target = target ;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("before()...");
        Object result = method.invoke(target, args);
        System.out.println("after()...");
        return result;
    }
}

具体使用:

public class Proxy02 {
    public static void main(String[] args) {
        /*
         * 生成$Proxy0的class文件
         */
        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
        /*
         * 目标对象信息
         */
        IUser userService = new UserService();
        ClassLoader classLoader = userService.getClass().getClassLoader();
        Class[] interfaces = UserService.class.getInterfaces() ;
        /*
         * 创建代理对象
         */
        InvocationHandler userHandler = new UserHandler(userService);
        /*
         * 代理类对象名
         * proxyClassName=com.java.proxy.$Proxy0
         */
        String proxyClassName = Proxy.newProxyInstance(classLoader,interfaces,userHandler).getClass().getName();
        System.out.println("proxyClassName="+proxyClassName);
        /*
         * 具体业务实现模拟
         */
        IUser proxyUser1 = (IUser) Proxy.newProxyInstance(classLoader,interfaces,userHandler);
        IUser proxyUser2 = (IUser) Proxy.newProxyInstance(classLoader,interfaces,userHandler);
        proxyUser1.update("cicada") ;
        proxyUser2.update("smile") ;
    }
}

 

JDK源码

IUser proxyUser = (IUser) Proxy.newProxyInstance(classLoader,interfaces,userHandler);

Proxy提供的静态方法newProxyInstance(),通过各个参数的传入,构建一个新的代理Class对象,即$Proxy0类的结构信息,这里再回首看下三个核心参数:

  • ClassLoader:基于JVM运行过程,所以需要获取目标类UserService的类加载器;

  • Interfaces:目标类UserService实现的接口,从面向对象来考虑,接口与实现分离,代理类通过实现IUser接口,模拟目标类的需求;

  • InvocationHandler:代理类提供的功能封装即UserHandler,可以在目标方法调用前后做增强处理

你可能感兴趣的:(java常用类用法,代理模式)