Java基础学习记录-代理模式

目录

1 代理模式

1.1 静态代理

1.2 动态代理

2 学习demo

---

 

1 代理模式

代理模式为其他对象提供一种代理，以控制对这个对象的访问。代理对象在客户端和目标对象之间起到中介的作用。

代理模式的作用：

• 在某些情况下，一个客户类不想或者不能直接引用一个委托对象，而代理类对象可以在客户类和委托对象之间起到中介的作用，其特征是代理类和委托类实现相同的接口。

• 代理类除了是客户类和委托类的中介之外，我们还可以通过给代理类增加额外的功能来扩展委托类的功能，这样做我们只需要修改代理类而不需要再修改委托类，符合代码设计的开闭原则。

1.1 静态代理

静态代理在使用时，需要定义接口或者父类，被代理对象与代理对象一起实现相同的接口或者是继承相同父类。

静态代理优缺点：

• 优点：不修改目标对象的功能前提下，对目标功能进行扩展。

• 缺点：因为代理对象需要与目标对象实现一样的接口，所以会有很多代理类被创建。同时，一旦接口增加方法，目标对象和代理对象都要维护，增加维护成本。

1.2 动态代理

代理类在程序运行时创建的代理方法被称为动态代理。这种情况下，代理类并不是在Java代码中定义的，而是在运行时根据我们在Java代码中的“指示”动态生成的。

动态代理&静态代理：

• 静态代理类和委托类实现了相同的接口，代理类通过委托类实现了相同的方法。这样就出现了大量的代码重复。

• 静态代理对象只服务于一种类型的对象，如果要服务多类型的对象。势必要为每一种对象都进行代理，静态代理在程序规模稍大时就无法胜任了。

2 学习demo

目录结构：

工厂类：

package com.education.proxy.factory;

/**
 * @program: interview
 * @description: 订单工厂
 * @author: onion
 * @create: 2020-06-10 09:31
 **/
public interface OrderFactory {
    void create();
}

实现类：

package com.education.proxy.service;

import com.education.proxy.factory.OrderFactory;
import com.sun.jmx.remote.util.OrderClassLoaders;

/**
 * @program: interview
 * @description: 订单实现类
 * @author: onion
 * @create: 2020-06-10 09:35
 **/
public class OrderService implements OrderFactory {
    /**
     * 生成订单
     */
    @Override
    public void create() {
        System.out.println("-------订单生成-----------");
    }
}

代理类：

package com.education.proxy.proxy;

import com.education.proxy.factory.OrderFactory;

/**
 * @program: interview
 * @description: 静态代理
 * @company：Interview Questions
 * @author: onion
 * @create: 2020-06-10 09:22
 **/
public class OrderProxy implements OrderFactory {

    OrderFactory orderFactory;

    public OrderProxy(OrderFactory orderFactory){
        this.orderFactory = orderFactory;
    }

    @Override
    public void create() {
        doBefore();
        orderFactory.create();
        doAfter();
    }

    public void doBefore(){
        System.out.println("-------订单生成前-----------");
    }

    public void doAfter(){
        System.out.println("-------订单生成后-----------");
    }
}

package com.education.proxy.proxy;

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

/**
 * @program: interview
 * @description: 动态代理
 * @author: onion
 * @create: 2020-06-10 09:50
 **/
public class OrderProxy2 implements InvocationHandler {
    /**
     * 被代理的对象
     */
    private Object target;

    public Object getTarget() {
        return target;
    }

    public void setTarget(Object target) {
        this.target = target;
    }

    public Object getProxy(){
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        doBefore();
        Object invoke = method.invoke(target, args);
        doAfter();
        return null;
    }

    public void doBefore(){
        System.out.println("-------订单生成前-----------");
    }

    public void doAfter(){
        System.out.println("-------订单生成后-----------");
    }
}

测试类：

package com.education.proxy.test;

import com.education.proxy.factory.OrderFactory;
import com.education.proxy.proxy.OrderProxy;
import com.education.proxy.service.OrderService;

/**
 * @program: interview
 * @description: 静态代理测试类
 * @author: onion
 * @create: 2020-06-10 09:40
 **/
public class TestDemo {
    public static void main(String[] args) {
        OrderFactory orderFactory = new OrderService();
        OrderProxy orderProxy = new OrderProxy(orderFactory);
        orderProxy.create();
    }
}

package com.education.proxy.test;

import com.education.proxy.factory.OrderFactory;
import com.education.proxy.proxy.OrderProxy2;
import com.education.proxy.service.OrderService;

/**
 * @program: interview
 * @description: 动态代理测试类
 * @author: onion
 * @create: 2020-06-10 09:40
 **/
public class TestDemo2 {
    public static void main(String[] args) {
        OrderFactory orderService = new OrderService();
        OrderProxy2 orderProxy = new OrderProxy2();
        orderProxy.setTarget(orderService);
        OrderFactory orderFactory = (OrderFactory) orderProxy.getProxy();
        orderFactory.create();
    }
}