java设计模式----代理模式

目录

　　  1.代理模式

　　2.静态代理

　　3.动态代理

一、代理模式

　　核心作用：

　　　　通过代理，控制对对象的访问，

　　　　代理可以详细控制对某个或某类对象的方法，在调用这个方法之前或之后做事

　　　　ps：代理模式是AOP（面向切面编程）的核心实现机制

　　

　　应用场景：

　　　　--安全代理：屏蔽对真实角色的直接访问

　　　　--远程代理：通过代理类处理远程方法调用

　　　　--延迟代理：先加载轻量级的代理对象，真正需要再加载真实对象

　　

　　分类：

　　　　--静态代理：自己定义代理类

　　　　--动态代理：程序动态生成代理类

　　　　　　1.JDK自带的动态代理

　　　　　　2.javaassist字节码操作库

　　　　　　3.CGLIB

　　　　　　4.ASM（底层使用命令，可维护行差）

二、静态代理

　　模型：

实现：

　　接口：

package com.demo.proxy.staticproxy;

/**
 * 明星接口
 * @author HYSong
 *
 */
public interface Star {
    /**
     * 面谈
     */
    void confer();
    /**
     * 签合同
     */
    void signContract();
    /**
     * 订票
     */
    void bookTicket();
    /**
     * 唱歌
     */
    void sing();
    /**
     * 收尾款
     */
    void collectMoney();
}

　　真实类：

package com.demo.proxy.staticproxy;

/**
 * 真实类（明星能做的都能做）
 * @author HYSong
 *
 */
public class RealStar implements Star{

    @Override
    public void confer() {
        System.out.println("RealStar.confer()");
    }

    @Override
    public void signContract() {
        System.out.println("RealStar.signContract()");
    }

    @Override
    public void bookTicket() {
        System.out.println("RealStar.bookTicket()");
    }

    @Override
    public void sing() {
        System.out.println("RealStar.sing()");
    }

    @Override
    public void collectMoney() {
        System.out.println("RealStar.collectMoney()");
    }
    
}

　　代理类：

package com.demo.proxy.staticproxy;

/**
 * 代理类（唯独不会唱歌）
 * @author HYSong
 *
 */
public class ProxyStar implements Star{

    private Star star;
    public ProxyStar(Star star) {
        this.star = star;
    }
    @Override
    public void confer() {
        System.out.println("ProxyStar.confer()");
    }

    @Override
    public void signContract() {
        System.out.println("ProxyStar.signContract()");
    }

    @Override
    public void bookTicket() {
        System.out.println("ProxyStar.bookTicket()");
    }

    @Override
    public void sing() {
        star.sing();
    }

    @Override
    public void collectMoney() {
        System.out.println("ProxyStar.collectMoney()");
    }
    
}

　　客户调用：

package com.demo.proxy.staticproxy;

/**
 * 客户只与经济人相关
 * @author HYSong
 *
 */
public class Client {
    public static void main(String[] args) {
//          真实对象
         Star real = new RealStar();
//          代理对象
         Star proxy = new ProxyStar(real);
         proxy.confer();
         proxy.signContract();
         proxy.bookTicket();
         proxy.sing();
         proxy.collectMoney();
    }
}

三、动态代理

　　这里的动态代理我们是用jdk自带的一种动态代理

　　--java.lang.reflect.Proxy

　　　　动态生成代理类和对象

　　--java.lang.reflect.InvocationHandler(处理器接口)

　　　　可以通过invoke方法实现对真实角色的代理访问

　　　　每次通过proxy生成代理类对象，对象都要指定对应的处理器对象

实现：

　　

package com.demo.proxy.dynamicproxy;

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

public class StarHandler implements InvocationHandler{

    private Star realStar ; 
    public StarHandler(Star realStar) {
        this.realStar = realStar;
    }
    /**
     * 只要调用代理类的方法，所有方法全都会在这个方法中来执行
     * 所有流程控制都在这个方法里面
     * @param proxy 代理类
     * @param method 正在调用的方法
     * @param args 方法的参数
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("我是代理");
        System.out.println("面谈、签合同、预付款、订机票");
        //        激活方法（反射）
        if(method.getName().equals("sing")) {            
            method.invoke(realStar, args);
        }
        System.out.println("收尾款");
        return null;
    }

}

package com.demo.proxy.dynamicproxy;

import java.lang.reflect.Proxy;

public class Client {

    public static void main(String[] args) {
//        需要被代理的对象
        Star realStar = new RealStar();
//        创建一个处理对象
        StarHandler starHandler = new StarHandler(realStar);
//        创建一个代理类对象
        Star proxyStar= (Star)Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(),
                new Class[] {Star.class}, starHandler);
        proxyStar.sing();
    }

}