代理模式（Proxy） ： 为其他对象提供一种代理以控制对这个对象的访问。
代理模式说白了就是“真实对象” 的代表， 在访问对象时引入一定程度的间接性， 因为这种间接性可以附加多种用途。

举例说明：操作员查询销售订单功能， 为了提高查询性能， 我们接入缓存功能， 如果缓存中有数据， 那么直接返回缓存中的数据，;如果缓存中没有数据， 那么查询订单数据后， 把数据加入到缓存， 这样在下次查询订单数据时， 就可以从缓存中读取了。 

a.创建订单类、模拟的数据库类、模拟的缓存类；

//模拟的数据库类：提供getOrder方法来通过oid查询订单信息
public class DB {
    private static List<Order> list = new ArrayList<>();
    static{
        list.add(new Order(1,"毛巾3条",45,"2020-2-1"));
        list.add(new Order(2,"小纸巾10包",12,"2020-1-21"));
        list.add(new Order(3,"洗发水1瓶",32,"2020-1-30"));
        list.add(new Order(4,"红牛1箱",36,"2020-2-2"));
        list.add(new Order(5,"哈脾2箱",120,"2020-2-3"));
    }

    public Order getOrder(int oid){
        System.out.println("从数据库中查找数据...");
        for(Order order:list){
            if(order.getOid() == oid){
                return order;
            }
        }
        return null;
    }
}

//模拟的缓存类：提供getCache方法来通过oid查询订单信息; 提供putCache方法将订单信息存放到缓存中;
public class Cache {

    private Map<Integer,Order> map = new HashMap();
    private volatile static Cache cache;

    private Cache(){
    }

    //双检 + 单例模式
    public static Cache getInstance(){
        if (cache == null){
            synchronized (Cache.class){
                if (cache == null){
                    cache = new Cache();
                }
            }
        }
        return cache;
    }

    //把订单添加到缓存中
    public void putCache(int key, Order value){
        System.out.println("把订单数据添加到缓存中...");
        map.put(key,value);
    }

    //从缓存中获取订单
    public Order getCache(int key){
        System.out.println("从缓存中查询订单数据...");
        return map.get(key);
    }
}

b.定义业务类（被代理的对象类）接口，以供业务类和代理类去实现

public interface OrderDao {
    public Order queryOrder(int oid);
}

c.定义业务类、代理类实现业务类（被代理的对象类）接口

public class OrderDaoImpl implements OrderDao {
    @Override
    public Order queryOrder(int oid) {
        DB db = new DB();
        Order order = db.getOrder(oid);
        return order;
    }
}

public class OrderProxy implements OrderDao {
    private OrderDao target;    //目标对象（被代理的对象）

    public OrderProxy (OrderDao target){
        this.target = target;
    }


    @Override
    public Order queryOrder(int oid) {
        Cache cache = Cache.getInstance();
        Order order = cache.getCache(oid);  //从缓存中查订单（代理做了被代理对象额外的业务）
        if (null == order){
            order = target.queryOrder(oid); //从数据库中查订单（被代理对象的业务，方法名相同）
            cache.putCache(order.getOid(),order);   //把订单放入缓存中
        }
        return order;
    }
}

测试对比：

public class Test {
    public static void main(String[] args) {
        OrderDaoImpl odi = new OrderDaoImpl();
        Order order = odi.queryOrder(2);    //实际调用的是db.getOrder(oid)
        System.out.println(order);
        System.out.println("-------------------");
        //查缓存
        OrderProxy orderProxy = new OrderProxy(odi);
        Order order1 = orderProxy.queryOrder(2);
        System.out.println(order1);
        System.out.println("----------第二次查询---------");
        Order order2 = orderProxy.queryOrder(2);
        System.out.println(order2);
    }
}