java设计模式 GOF23 06 代理模式

一.代理模式简介

　　使用代理模式可以控制访问摸个对象的方法，在调用某个方法之前做前置工作，调用方法之后

做后只处理。java设计中的代理模式就如同生活中的中介，由中介（代理）做很多准备工作，客户只需要

调用关键方法，不需要关心其他固定的，基本不变的流程。AOP（面向切面编程）的核心机制就是代理模式。

这里是AOP简介

 

二.代理模式模块分析

　　核心角色：

　　　　1）.抽象角色：定义代理角色和真是角色的公共方法

　　　　2）.真是角色：定义真是角色的业务逻辑，供代理角色调用，这里只关心核心的业务逻辑

　　　　3) .代理角色： 实现了抽象角色，是真是角色的代理，调用真是角色的核心方法，并将统一的流程

　　　　　　控制放在其中。

三.应用场景

　　1）.安全代理：屏蔽对真是角色的直接访问

　　2）.运程代理: 处理远程方法调用

　　3）.延时加载:先加载轻量的代理对象，真正需要再加载真是对象

四.分类

　　1). 静态代理模式

　　下面是简单代码实现

　　

package com.lz.agency;

/*
 * 抽象角色，规定代理与真实对象的方法
 */
public interface AbstractRole {
    void before();
    void run();
    void last();
}

package com.lz.agency;


/*
 * 真实对象
 */
public class RealRole implements AbstractRole{

    @Override
    public void before() {
        System.out.println("RealRole>>>before");
    }

    @Override
    public void run() {
        System.out.println("RealRole>>>run");
    }

    @Override
    public void last() {
        System.out.println("RealRole>>>last");
    }

}

package com.lz.agency;


/*
 * 代理对象
 * 真实角色的主要方法由代理对象调用
 */
public class Agent implements AbstractRole{
    
    RealRole realRole;
    public Agent(RealRole realRole) {
        super();
        this.realRole = realRole;
    }

    @Override
    public void before() {
        System.out.println("Agent>>>before");
    }

    /*
     * 代理调用正是对象的run方法
     * @see com.lz.agency.AbstractRole#run()
     */
    @Override
    public void run() {
        realRole.run();
    }

    @Override
    public void last() {
        System.out.println("Agent>>>last");
    }

}

package com.lz.agency;


public class Client {
    public static void main(String[] args) {
        RealRole realRole = new RealRole();
        Agent agnet = new Agent(realRole);
        agnet.before();
        agnet.run();
        agnet.last();
    }
}

　　2）.动态代理模式

　　java中可以使用 java.lang.reflect.InvocationHandler类重载 invoke 方法，在这个方法内进行流程控制

　　客户可以使用AbstractRole的newProxyInstance方法动态实现代理类

 

package com.lz.dynamicProxy;

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

public class RoleHandler implements InvocationHandler{

    AbstractRole role;
    public RoleHandler(AbstractRole role) {
        super();
        this.role = role;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        Object obj = null;
        System.out.println("代理先前工作");
        if (method.getName().equals("run")) {
            method.invoke(role, args);
        }
        System.out.println("代理事后工作");
        return obj;
    }

}

package com.lz.dynamicProxy;

import java.lang.reflect.Proxy;

public class Client {
    public static void main(String[] args) {
        RoleHandler handler = new RoleHandler(new RealRole());
        AbstractRole proxy = (AbstractRole)Proxy.newProxyInstance(ClassLoader
                .getSystemClassLoader(), new Class[]{AbstractRole.class}, handler);
        proxy.run();
    }
}