设计模式之代理模式--慕课网笔记

最新推荐文章于 2024-03-06 19:30:00 发布
最新推荐文章于 2024-03-06 19:30:00 发布
阅读量399 收藏
点赞数
分类专栏： 慕课网笔记 文章标签： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hellopurple/article/details/77337535
版权
第1章 代理模式概念介绍
1-1 代理模式概念及分类
  • 面向对象的设计思维
  • 了解多态的概念

  • 了解反射机制

  • 代理模式基本概念及分类

  • 了解代理模式开发中应用场景
  • 掌握代理模式实现方法
  • 理解JDK动态代理实现

代理模式定义：为其他对象提供一种代理以控制这个对象的访问。
代理对象起到中介作用，可去掉功能服务或增加额外的服务。

  • 远程代理
    为不同地理的对象，提供局域网代表对象
  • 虚拟代理
    根据需要将资源消耗很大的对象进行延时，真正需要的时候进行创建
  • 保护代理
    控制对一个对象的访问的权限
  • 智能代理
    提供对目标对象额外服务
第2章 常用代理模式原理
2-1 静态代理概念及实现

智能引用代理

  • 静态代理
  • 动态代理

静态代理：代理和被代理对象在代理之前是确定的。他们都实现相同的接口或者继承相同的抽象类。

public interface Moveable {
    void move();
}
public class Car implements Moveable {

    @Override
    public void move() {
        //实现开车
        try {
            Thread.sleep(new Random().nextInt(1000));
            System.out.println("汽车行驶中....");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}
public class Car2 extends Car {

    @Override
    public void move() {
        long starttime = System.currentTimeMillis();
        System.out.println("汽车开始行驶....");
        super.move();
        long endtime = System.currentTimeMillis();
        System.out.println("汽车结束行驶....  汽车行驶时间：" 
                + (endtime - starttime) + "毫秒！");
    }


}
public class Car3 implements Moveable {

    public Car3(Car car) {
        super();
        this.car = car;
    }

    private Car car;

    @Override
    public void move() {
        long starttime = System.currentTimeMillis();
        System.out.println("汽车开始行驶....");
        car.move();
        long endtime = System.currentTimeMillis();
        System.out.println("汽车结束行驶....  汽车行驶时间：" 
                + (endtime - starttime) + "毫秒！");
    }

}
public class Client {

    /**
     * 测试类
     */
    public static void main(String[] args) {
//      Car car = new Car();
//      car.move();
        //使用集成方式
//      Moveable m = new Car2();
//      m.move();
        //使用聚合方式实现
        Car car = new Car();
        Moveable m = new Car3(car);
        m.move();
    }

}

通过继承和聚合两种方式都能实现代理，但究竟哪种更好呢？

2-2 聚合比继承更适合代理模式

实现功能叠加

  • 方法move()
  • 增加方法运行时间处理
  • 增加权限管理
  • 增加日志处理
public interface Moveable {
    void move();
}

public class Car implements Moveable {

    @Override
    public void move() {
        //实现开车
        try {
            Thread.sleep(new Random().nextInt(1000));
            System.out.println("汽车行驶中....");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}
public class CarLogProxy implements Moveable {

    public CarLogProxy(Moveable m) {
        super();
        this.m = m;
    }

    private Moveable m;

    @Override
    public void move() {
        System.out.println("日志开始....");
        m.move();
        System.out.println("日志结束....");
    }

}
public class CarTimeProxy implements Moveable {

    public CarTimeProxy(Moveable m) {
        super();
        this.m = m;
    }

    private Moveable m;

    @Override
    public void move() {
        long starttime = System.currentTimeMillis();
        System.out.println("汽车开始行驶....");
        m.move();
        long endtime = System.currentTimeMillis();
        System.out.println("汽车结束行驶....  汽车行驶时间：" 
                + (endtime - starttime) + "毫秒！");
    }

}

public class Client {

    /**
     * 测试类
     */
    public static void main(String[] args) {
        Car car = new Car();
        CarLogProxy clp = new CarLogProxy(car);
        CarTimeProxy ctp = new CarTimeProxy(clp);
        ctp.move();
    }

}
2-3 了解 JDK 动态代理

动态产生代理，实现对不同类，不同方法的代理

ProxySubject->Proxy–>ProxyHandler–>RealSubject

Java动态代理类位于java.lang.reflect包下，一般主要涉及到以下两个类

  • Interface InvocationHandler：该接口中仅定义了一个方法public object invoke(
    Object obj,Method method,Object[] args)在实际使用时，第一个参数obj一般是指
    代理类，method是被代理的方法，args为该方法的参数数组。这个抽象方法在代理中
    动态实现。
  • Proxy：该类即为动态代理类static Object newProxyInstance(ClassLoader loader,
    Class[] interfaces,InvocationHandler h):返回代理类的一个实例，返回后的代理类
    可以当作被代理类使用（可使用被代理类的在接口中声明过的方法）
public interface Moveable {
    void move();
}
public class Car implements Moveable {

    @Override
    public void move() {
        //实现开车
        try {
            Thread.sleep(new Random().nextInt(1000));
            System.out.println("汽车行驶中....");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}
public class TimeHandler implements InvocationHandler {

    public TimeHandler(Object target) {
        super();
        this.target = target;
    }

    private Object target;

    /*
     * 参数：
     * proxy  被代理对象
     * method  被代理对象的方法
     * args 方法的参数
     * 
     * 返回值：
     * Object  方法的返回值
     * */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        long starttime = System.currentTimeMillis();
        System.out.println("汽车开始行驶....");
        method.invoke(target);
        long endtime = System.currentTimeMillis();
        System.out.println("汽车结束行驶....  汽车行驶时间：" 
                + (endtime - starttime) + "毫秒！");
        return null;
    }

}
public class Test {

    /**
     * JDK动态代理测试类
     */
    public static void main(String[] args) {
        Car car = new Car();
        InvocationHandler h = new TimeHandler(car);
        Class<?> cls = car.getClass();
        /**
         * loader  类加载器
         * interfaces  实现接口
         * h InvocationHandler
         */
        Moveable m = (Moveable)Proxy.newProxyInstance(cls.getClassLoader(),
                                                cls.getInterfaces(), h);
        m.move();
    }

}

所谓Dynamic Proxy是这样一种class：
它是在运行时生成的class
该class需要实现一组interface
使用动态代理时，必须实现InvocationHandler接口

动态代理实现步骤

  • 创建一个实现接口InvocationHandler的类，它必须实现invoke方法
  • 创建被代理的类以及接口
  • 调用Proxy的静态方法，创建一个代理类
    newProxyInstance(ClassLoader loader,Class[] interfaces,InvocationHandler h)
  • 通过代理调用方法
2-4 使用 cglib 动态产生代理
  • JDK动态代理
    • 只能代理实现了接口的类
    • 没有实现接口的类不能实现JDK的动态代理
  • CGLIB动态代理
    • 针对类来实现代理的
    • 对指定目标类产生一个子类，通过方法拦截技术拦截所有父类方法的调用
public class Train {

    public void move(){
        System.out.println("火车行驶中...");
    }
}
public class CglibProxy implements MethodInterceptor {

    private Enhancer enhancer = new Enhancer();

    public Object getProxy(Class clazz){
        //设置创建子类的类
        enhancer.setSuperclass(clazz);
        enhancer.setCallback(this);

        return enhancer.create();
    }

    /**
     * 拦截所有目标类方法的调用
     * obj  目标类的实例
     * m   目标方法的反射对象
     * args  方法的参数
     * proxy代理类的实例
     */
    @Override
    public Object intercept(Object obj, Method m, Object[] args,
            MethodProxy proxy) throws Throwable {
        System.out.println("日志开始...");
        //代理类调用父类的方法
        proxy.invokeSuper(obj, args);
        System.out.println("日志结束...");
        return null;
    }

}
public class Client {

    /**
     * @param args
     */
    public static void main(String[] args) {

        CglibProxy proxy = new CglibProxy();
        Train t = (Train)proxy.getProxy(Train.class);
        t.move();
    }

}
第3章 自定义类模拟 JDK 动态代理的实现
3-1 模拟 JDK 动态代理实现思路分析及简单实现

动态代理实现思路
实现功能：通过Proxy的newProxyInstance返回代理对象

  1. 声明一段源码（动态产生代理）
  2. 编译源码（JDK Compiler API），产生新的类（代理类）
  3. 将这个类load到内存当中，产生一个新的对象（代理对象）
  4. return 代理对象
3-2 完善动态代理实现
public interface Moveable {
    void move();
}
public class Proxy {

    public static Object newProxyInstance(Class infce) throws Exception{
        String rt = "\r\n";
        String methodStr = "";
        for(Method m : infce.getMethods()){
            methodStr += "  @Override" + rt +
            "   public void " + m.getName() + "() {" + rt +
            "       long starttime = System.currentTimeMillis();" + rt +
            "       System.out.println(\"汽车开始行驶....\");" + rt +
            "       m." + m.getName() + "();" + rt +
            "       long endtime = System.currentTimeMillis();" + rt +
            "       System.out.println(\"汽车结束行驶....  汽车行驶时间：\" " + rt +
            "               + (endtime - starttime) + \"毫秒！\");" + rt +
            "   }" ;
        }

        String str =
        "package com.imooc.proxy;" + rt +
        "public class $Proxy0 implements " + infce.getName() + " {" + rt +
        "   public $Proxy0(" + infce.getName() + " m) {" + rt +
        "       super();" + rt +
        "       this.m = m;" + rt +
        "   }" + rt +
        "   private " + infce.getName() + " m;" + rt +
        methodStr + rt +
        "}" ;
        //产生代理类的java文件
        String filename = System.getProperty("user.dir") +"/bin/com/imooc/proxy/$Proxy0.java";
        File file = new File(filename);
        FileUtils.writeStringToFile(file, str);

        //编译
        //拿到编译器
        JavaCompiler complier = ToolProvider.getSystemJavaCompiler();
        //文件管理者
        StandardJavaFileManager fileMgr = 
                complier.getStandardFileManager(null, null, null);
        //获取文件
        Iterable units = fileMgr.getJavaFileObjects(filename);
        //编译任务
        CompilationTask t = complier.getTask(null, fileMgr, null, null, null, units);
        //进行编译
        t.call();
        fileMgr.close();

        //load 到内存
        ClassLoader cl = ClassLoader.getSystemClassLoader();
        Class c = cl.loadClass("com.imooc.proxy.$Proxy0");

        Constructor ctr = c.getConstructor(infce);
        return ctr.newInstance(new Car());
    }




}
public class Client {

    /**
     * 测试类
     * @throws Exception 
     */
    public static void main(String[] args) throws Exception {
        Moveable m = (Moveable)Proxy.newProxyInstance(Moveable.class);
        m.move();
    }

}
3-3 动态代理实现添加 InvocationHandler
public interface Moveable {
    void move();
}
public class Car implements Moveable {

    @Override
    public void move() {
        //实现开车
        try {
            Thread.sleep(new Random().nextInt(1000));
            System.out.println("汽车行驶中....");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}
public interface InvocationHandler {

    public void invoke(Object o,Method m);
}
public class TimeHandler implements InvocationHandler {

    private Object target;

    public TimeHandler(Object target) {
        super();
        this.target = target;
    }

    @Override
    public void invoke(Object o, Method m) {

        try {
            long starttime = System.currentTimeMillis();
            System.out.println("汽车开始行驶....");
            m.invoke(target);
            long endtime = System.currentTimeMillis();
            System.out.println("汽车结束行驶....  汽车行驶时间："
                            + (endtime - starttime) + "毫秒！");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}
public class Proxy {

    @SuppressWarnings("unchecked")
    public static Object newProxyInstance(Class infce,InvocationHandler h) throws Exception{
        String rt = "\r\n";
        String methodStr = "";
        for(Method m : infce.getMethods()){
            methodStr += "  @Override" + rt +
            "   public void " + m.getName() + "() {" + rt +
            "  try{" + rt +
            "  Method md = " + infce.getName() + ".class.getMethod(\"" 
                                        + m.getName() + "\");" + rt +
            "  h.invoke(this,md);" +rt+ 
            "  }catch(Exception e){ e.printStackTrace();}" + rt +
            "   }" ;
        }

        String str =
        "package com.imooc.proxy;" + rt +
        "import java.lang.reflect.Method;" + rt +
        "import com.imooc.proxy.InvocationHandler;" +  rt+
        "public class $Proxy0 implements " + infce.getName() + " {" + rt +
        "   public $Proxy0(InvocationHandler h) {" + rt +
        "       this.h = h;" + rt +
        "   }" + rt +
        "  private InvocationHandler h;" + rt+ 
        methodStr + rt +
        "}" ;
        //产生代理类的java文件
        String filename = System.getProperty("user.dir") +"/bin/com/imooc/proxy/$Proxy0.java";
        File file = new File(filename);
        FileUtils.writeStringToFile(file, str);

        //编译
        //拿到编译器
        JavaCompiler complier = ToolProvider.getSystemJavaCompiler();
        //文件管理者
        StandardJavaFileManager fileMgr = 
                complier.getStandardFileManager(null, null, null);
        //获取文件
        Iterable units = fileMgr.getJavaFileObjects(filename);
        //编译任务
        CompilationTask t = complier.getTask(null, fileMgr, null, null, null, units);
        //进行编译
        t.call();
        fileMgr.close();

        //load 到内存
        ClassLoader cl = ClassLoader.getSystemClassLoader();
        Class c = cl.loadClass("com.imooc.proxy.$Proxy0");

        Constructor ctr = c.getConstructor(InvocationHandler.class);
        return ctr.newInstance(h);
    }




}
public class Client {

    /**
     * 测试类
     * @throws Exception 
     */
    public static void main(String[] args) throws Exception {
        Car car = new Car();
        InvocationHandler h = new TimeHandler(car);
        Moveable m = (Moveable)Proxy.newProxyInstance(Moveable.class,h);
        m.move();
    }

}
第4章 代理模式总结
4-1 课程总结
  • 代理概念、分类及应用场景
  • 静态代理（继承、聚合）
  • JDK动态代理实现日志处理功能
    • 产生动态代理不仅可以使用jdk动态代理，也可以使用其他的方式，如cglib.
  • 模拟JDK动态代理实现

常见代理模

  • 远程代理
  • 智能引用代理
  • 虚拟代理
  • 保护代理

智能引用代理

  • 日志处理
  • 权限管理
  • 事务处理

也叫AOP面向切面编程

《模式的秘密—代理模式》视频地址

lmjun3
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
WebRTC + JsSIP + freeSWITCH一对一视频聊天
安晓辉生涯——聚焦程序员的职业规划与成长
07-04 3万+
这是使用JsSIP 、 freeSWITCH 和 WebRTC 开发视频聊天应用最关键的一篇。
jssip中文开发文档（完整版）
weixin_30569153的博客
01-19 1654
jsSip开发文档 （官网地址：http://www.jssip.net/） 完整案例demo下载地址:http://download.csdn.net/download/qq_39421580/10214712 概观： 1.JsSIP是一个简单易用的JavaScript库，它利用SIP和WebRTC的最新发展，在任何网站上提供全功能的SIP端点。 2.通过JsSIP，只要...
【JsSIP】JsSIP.RTCSession-实例详情
最新发布
Ljy_up的博客
03-06 1070
类JsSIP.RTCSession表示WebRTC媒体（音频/视频）会话。它可以由本地用户发起，也可以由远程对等方发起。在内部，它持有一个RTCPeerConnection实例，可通过connection属性进行访问。
freeswitch 使用sipjs 、jssip webrtc网页音视频通话
热门推荐
Java_lilin的专栏
03-12 1万+
关于linphone手机端开发参考https://blog.csdn.net/Java_lilin/article/details/80539116 配置帮助群:261074724 sipjs 官网http://sipjs.com/ 参考官网说明 写法如下: <body> <div id="id_msg"></div> <input id...
JsSIP API 中文文档（3.1.x）
学习笔记
05-14 7920
Module JsSIP JsSIP主要模块 Module Getters name 返回字符串“JsSIP”。 version 返回字符串形式的JsSIP版本号。 console.log(JsSIP.version); =&gt; "X.Y.Z" JsSIP.debug Node.js和浏览器调试。 从版本0.6.0开始，JsSIP包含Node 调试模块...
设计模式之策略模式--慕课网笔记
学习笔记
08-12 410
第1章 引子：什么是策略模式1-1 策略模式简介 什么是策略模式 策略模式如何实现 策略模式总结篇 实际案例分享 日常生活中的例子： 文本编辑软件–》布局 –》布局算法 算法实现1 算法实现2 算法实现3 购物–》支付–》支付算法 招商银行 建设银行 XXX银行 共同点： 抽象出不变部分 定义算法族分别封装起来 客户端不会受算法改变的影响 对新增需求弹性的支持 策略模式将可变的部分从程序中抽象
设计模式--JDK动态代理--新手笔记
Coder_Maker的博客
12-06 149
本文 是 按照慕课网 动态代理章节 总结的！ 感谢慕课网 jdk的 动态代理   前面是动态代理的一些解释，最后有代码实例，可以复制运行的，最好自己敲一遍；再次感谢慕课网 在 代理 类和 被代理类 之间 加入了实现 InvocationHandler的类；我们也叫（InvocationHandler）事务处理器，像我们的日志处理，时间处理 都是在我们的处理器中完成的； Java动态代...
Spring入门篇--慕课网笔记
学习笔记
09-18 1307
第1章 概述1-1 Spring入门课程简介 什么是框架 Spring简介 IOC（配置、注解） Bean（配置、注解） AOP（配置、注解、AspectJ、API） SpringFramework Spring Expression Language(SpEl) Spring Integration Spring Web Flow Spring Security Spring Data
中级软件设计师备考笔记 -设计模式
12-26
中级软件设计师备考笔记 -设计模式
设计模式学习笔记-命令模式
06-17
命令模式是一种行为设计模式，它的主要目的是将请求封装为对象，以便于参数化不同请求、队列请求、记录请求日志以及支持撤销和重做操作。在软件开发中，它帮助解耦了请求发起者（调用者）和请求执行者（接收者），...
Java设计模式笔记-尚硅谷
10-05
Java设计模式笔记-尚硅谷
《C++20设计模式》学习笔记-第12章代理模式-配套代码
02-22
《C++20设计模式》学习笔记-第12章代理模式-配套代码
设计模式-读书笔记（水印）1
08-04
设计模式是一种在特定情境下解决问题的可复用的软件设计蓝图，它们反映了软件设计中的最佳实践和经验。本文主要探讨了两种创建型设计模式：工厂...因此，深入理解并熟练运用设计模式是每个IT专业人员必备的技能之一。
C++，java算法与数据结构（一）--慕课网笔记
学习笔记
09-02 2610
第1章 当我们谈论算法的时候，我们在谈论什么？1-1 我们究竟为什么要学习算法 为什么要学习算法？ 大公司面试？ 因为算法无处不在 IDE 搜索引擎 搜索算法+排序算法 Siri 语音算法 推荐算法 电影后期 迷宫生成 扫雷 电脑AI 计算机视觉 AR PS 魔棒工具 压缩软件 数据库 算法库 我们每天都在接触算法学好算法，才能创造出更有意义的东西算法之美1-2 课程介绍学习要求 语言：C+
JSP--慕课网笔记
学习笔记
09-08 1779
第1章 JAVA WEB简介1-1 什么是WEB应用程序JavaWeb简介 什么是Web应用程序 静态页面与动态页面 搭建Java Web开发环境 手工编写第一个Web应用程序 MyEclipse配置 使用MyEclipse编写第一个Web应用程序 修改Tomcat默认端口 什么是Web应用程序 Web应用程序是一种可以通过Web访问的应用程序。Web应用程序的一个最大好处是用户 很容易访问应用
Java Socket应用---慕课网笔记
学习笔记
08-04 1252
第一章 网络基础知识1-1 网络基础简介Java最初是作为网络编程语言出现的，其对网络提供了高度的支持 而在网络编程中使用最多的就是Socket，像QQ，MSN都使用了Socket 相关的技术Java提供了强大的类，方便网络编程的开发Socket编程 1. 网络基础知识 2. InetAddress类 3. URL 4. TCP编程 5. UDP编程两台计算机通过网络进行通信的必备条件
深入浅出Java多线程--慕课网笔记
学习笔记
08-02 912
深入浅出Java多线程–慕课网视频笔记1-2java多线程基础概念介绍 进程：程序（任务）的执行过程持有资源（共享内存，共享文件）和线程 线程：qq聊天、收发文件*线程是系统中最小的执行单元 同一进程中有多个线程 线程共享进程的资源**线程的交互 互斥 同步* java中线程的常用方法介绍：java对线程的支持 线程的创建和启动 线程常用方法 如何停止线程 java.lang*class T
Servlet--慕课网笔记
学习笔记
09-05 806
第1章 Servlet基础1-1 Servlet概述Servlet基础 什么是Servlet Tomcat容器等级 手工编写第一个Servlet 使用MyEclipse编写Servlet Servlet声明周期 Servlet获取九大内置对象 Servlet与表单 Servlet路径跳转 阶段项目 什么是Servlet 先有JSP还是先有Servlet？ 我可以负责任的告诉大家先有Servlet
深入理解设计模式与架构模式笔记
"这是一份综合整理的设计模式和架构模式的学习笔记，涵盖了多种设计原则、模式分类以及具体的经典设计模式的解析。笔记虽然只包含了部分资料，但内容丰富，包括了不良设计的特点、面向对象思想、设计原则和技术思维...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值