静态代理和动态代理

java中的代理是什么:

代理就是通过代理对象去访问实际的目标对象,比如买火车票,我们可以去火车站买票,也可以从代售点买票,通过代售点的方式就是代理。在java中,代售点就是就是代理类,不仅可以实现目标对象,还可以增加一些额外的功能。据我所知java中的代理方式有两种,一种是静态代理,一种是动态代理。

什么是静态代理:

静态代理就是代码运行之前,这个代理类就已经存在了,还是以买火车票为例子,在代码中先创建一个通用的买票接口

/**
 * 卖票接口
 *
 * @Dte:2022/9/3
 */
public interface SellTickets {
    /**
     * 卖票方法
     */
    void sell();
}

然后需要一个真实的类

/**
 * 火车站 具有卖票功能,所以需要实现SellTickets接口
 *
 * @Dte:2022/9/3
 */
public class TrainStation implements SellTickets {

    @Override
    public void sell() {
        System.out.println("火车站卖票......");
    }
}

最后需要一个代理类

/**
 * 代售点
 *
 * @Dte:2022/9/3
 */
public class ProxyPoint implements SellTickets {

    private TrainStation station = new TrainStation();

    @Override
    public void sell() {
        System.out.println("代售点收取一些费用......");
        station.sell();
    }
}

代理类可以在不更改被代理对象的情况下去增加功能

/**
 * @Dte:2022/9/3
 */
public class Client {
    public static void main(String[] args) {
        //创建代售点对象
        ProxyPoint proxyPoint = new ProxyPoint();   
        //调用方法进行买票
        proxyPoint.sell();
    }
}

/**
代售点收取一些费用......
火车站卖票......
**/

静态代理的缺点

因为静态代理在代码运行之前就已经存在代理类了,所以每一个代理对象都需要去建一个代理类去代理,当需要代理的对象有很多时,就需要创建很多的代理类,降低了程序可维护性。所以有了动态代理。

什么是动态代理

动态代理指代理类不写在代码中,而是在运行过程中产生,java提供了两种动态代理,分别是jdk的动态代理和基于Cglib的动态代理。

JDK动态代理

要想用jdk动态代理,可以先写一个ProxyHandler类,这个类实现了InvocationHandler接口,并重写里面的invoke方法,invoke方法里有被代理对象的需要被增强的方法,到这里只是定义了被代理类的通用增强方法,要想真正使用的话,需要通过Proxy.newProxyInstance,它的目的是在运行期间生成代理类,它的参数是类加载器,目标类实现的接口,InvocationHandler对象,要注意的是Proxy.newProxyInstance的返回值需要用被代理类所实现的接口来接,接住的就是代理对象,如果代理对象中的方法被调用,就会调用InvocationHandler实现类中的invoke方法,这里面有需要增强的内容。

通用接口

/**
 * 卖票接口
 *
 */
public interface SellTickets {
    /**
     * 卖票方法
     */
    void sell();
}

具体类

/**
 * 火车站 具有卖票功能,所以需要实现SellTickets接口
 *
 */
public class TrainStation implements SellTickets {

    @Override
    public String sell() {
        System.out.println("火车站卖票......");
        return "我正在被打印";
    }
}

ProxyHandler类

public class ProxyHandler implements InvocationHandler {
    Object object;

    public ProxyHandler(Object object) {
        this.object = object;
    }

    /**
     * @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 invoke = method.invoke(object, args);
        return invoke;
    }
}
public class ProxyTest {
    public static void main(String[] args) {
        TrainStation trainStation = new TrainStation();
        InvocationHandler proxyHandler = new ProxyHandler(trainStation);
        SellTickets sellTickets = (SellTickets) Proxy.newProxyInstance(trainStation.getClass().getClassLoader()
                , trainStation.getClass().getInterfaces()
                , proxyHandler);
        String sell = sellTickets.sell();
        System.out.println(sell);
    }
}

/**
注册账号......
火车站卖票......
**/

动态代理的优势

静态代理的话需要对每一个被代理对象都创建一个代理对象,因为静态代理是在项目运行前就写好的。但是动态代理不是,动态代理是在运行期间才创建代理类,所以只需要创建一个动态代理类就可以。比如我在写一个被代理的对象招聘员工。

首先先写一个通用接口

/**
 * 招聘接口
 *
 */
public interface Recruit {
    /**
     * 招聘方法
     */
    void find();
}

再写一个被代理对象的类

public class TrainStationCenter implements Recruit {

    @Override
    public void find() {
        System.out.println("火车站总部在招人......");
    }
}

不写代理类源代码,直接用动态代理生成

public class ProxyTest {
    public static void main(String[] args) {
        TrainStationCenter trainStationCenter = new TrainStationCenter();
        InvocationHandler proxyHandler1 = new ProxyHandler(trainStationCenter);
        Recruit proxyInstance = (Recruit) Proxy.newProxyInstance(trainStationCenter.getClass().getClassLoader()
                , trainStationCenter.getClass().getInterfaces()
                , proxyHandler1);
        proxyInstance.find();
    }
}

/**
注册账号......
火车站总部在招人......
**/

通过动态代理,就可以使用一个动态代理类,去代理多个对象。

动态代理只能代理接口,要想代理类,可以使用cglib的动态代理类

首先写一个真实的类,比如火车站类,里面有卖票的方法

public class TrainStation {
    /**
     * 卖票方法
     */
    public void sell() {
        System.out.println("火车站卖票......");
    }
}

然后写一个ProxyHandler,它实现了MethodInterceptor接口,重写了intercept方法,类似于jdk中的invoke方法

public class ProxyHandler implements MethodInterceptor {

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("注册......");
        Object o1 = methodProxy.invokeSuper(o, objects);
        return o1;
    }
}

不写代理类源代码,直接用cglib动态生成字节码

public class ProxyTest {
    public static void main(String[] args) {
        //创建Enhancer对象,类似于JDK动态代理中的Proxy类,下一步就是设置几个参数
        Enhancer enhancer = new Enhancer();
        //设置目标类的字节码文件
        enhancer.setSuperclass(TrainStation.class);
        //设置回调函数
        enhancer.setCallback(new ProxyHandler());
        //创建代理对象
        TrainStation trainStation = (TrainStation) enhancer.create();
        trainStation.sell();
    }
}
/**
注册账号......
火车站卖票......
**/

哪些地方用到了动态代理

spring中的AOP思想就是使用了动态代理,AOP通过动态代理对目标方法进行了增强,比如拦截器。

评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值