Java----代理

最新推荐文章于 2024-11-11 21:19:25 发布

沙糖桔45

最新推荐文章于 2024-11-11 21:19:25 发布

阅读量468

点赞数 3

文章标签： java 代理模式开发语言 involk 反射动态代理 proxy

本文链接：https://blog.csdn.net/weixin_65237252/article/details/140808634

版权

什么是代理？

在Java中，代理是一种用于创建一个或多个服务的中间层，它可以拦截并处理程序对实际服务对象的请求。代理模式是一种设计模式，属于结构型模式，它允许程序员在不修改实际对象代码的情况下，增强或控制对它的访问。

Java中的代理可以分为以下几种类型：

1.静态代理：

静态代理在编译时就已经确定代理类和原始类的关系。代理类通常与原始类实现相同的接口，然后在代理类中维护一个原始对象的引用，从而可以在调用原始对象方法前后添加额外的处理逻辑（例如日志记录、权限校验等）。


interface IService {
    void doSomething();
}


class Service implements IService {
    public void doSomething() {
        System.out.println("执行业务逻辑");
    }
}


class ServiceProxy implements IService {
    private IService service;

    public ServiceProxy(IService service) {
        this.service = service;
    }

    public void doSomething() {
        System.out.println("前置处理");
        service.doSomething();
        System.out.println("后置处理");
    }
}

2.动态代理：

动态代理是在运行时动态创建的代理方式，不需要在编译时确定代理类。Java提供了java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口来支持动态代理。动态代理可以代理任何实现了接口的类。

我们需要准备我们对象：

package com.wxy.proxy;

//将需要代理操作的方法声明在接口中，并继承该接口
public class BigStar implements Star{

    public BigStar() {
    }

    public BigStar(String name) {
        this.name = name;
    }

    @Override
    public String sing(String name) {
        System.out.println(name + "正在唱歌");
        return "表演唱歌完毕";
    }

    @Override
    public String dance(String name) {
        System.out.println(name + "正在跳舞");
        return "表演跳舞完毕";
    }

    private String name;

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    public String toString() {
        return "BigStar{name = " + name + "}";
    }
}

将我们需要拓展功能的方法声明在接口中，并让原来的类继承它：

package com.wxy.proxy;

//声明对应的代理方法
public interface Star {
    String sing(String name);
    String dance(String name);
}

然后我们就可以开始编写代理类了，需要注意是该内部类的involk方法是在测试类中使用代理（接口star对象）调用其方法时，会自动调用其involk方法，该involk有三个参数，在源码是这样描述的：

proxy -方法上调用方法的代理实例-对应于代理实例上调用的接口方法的方法实例。

Method对象的声明类将是在其中声明方法的接口，该接口可能是代理类继承该方法所通过的代理接口的超接口。

Args -一个对象数组，其中包含在代理实例的方法调用中传递的参数值，如果接口方法不接受参数，则为空。基本类型的参数被包装在适当的基本包装类的实例中，例如java.lang.Integer或java.lang.Boolean。

package com.wxy.proxy;

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

//代理工具类
public class ProxyUtil {

    //使用静态修饰方便调用，可直接使用类名进行调用
    public static Star createProxy(BigStar bigStar){
        //对我们需要进行代理的方法构建代理对象
        Star star = (Star) Proxy.newProxyInstance(
                //参数一：用于指定使用哪个类去加载生成加载的代理类，指定加载器，这里我们直接使用当前类的加载器
                ProxyUtil.class.getClassLoader(),
                //参数二：需要代理的字节码对象数组，指定接口这些接口指定生成的代张什么样，也就是说有哪些方法需要代理
                new Class[]{Star.class},
                //参数三：用来指定生成的代理对象要干什么事情，可用Lambda表达式进行简化
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        if(method.getName().equals("sing")){
                            System.out.println("现在是唱歌业务");

                        }else if(method.getName().equals("dance")){
                            System.out.println("现在是跳舞业务");
                        }
                        System.out.println("做好前置工作");
                        //这里才是我们正在要改造的方法，我们在这里通过反射的方法运行我们原先的代码
                        String result = (String) method.invoke(bigStar, args);
                        System.out.println("做好后置工作");
                        //将原先的返回值进行返回
                        return result;
                    }
                }
        );

        return star;
    }
}

编写测试类查看结果：

package com.wxy.proxy;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class TestForProxy {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        //通过反射的方法来创建我们的对象
        Class<?> classz = Class.forName("com.wxy.proxy.BigStar");
        //指定使用我要使用参数是String类型的构造方法
        Constructor<?> constructor = classz.getDeclaredConstructor(String.class);
        //通过该构造方法我们来创建我们的对象
        BigStar xiaoming = (BigStar) constructor.newInstance("小明");
        //将我们的对象传递给我们的代理，然后拿到代理对象，使用代理对象来调用我们的方法，而不是使用以前的对象调用原先的方法！！！
        Star proxy = ProxyUtil.createProxy(xiaoming);
        System.out.println(proxy.sing(xiaoming.getName()));
        System.out.println(proxy.dance(xiaoming.getName()));
    }
}

输出结果如下：