设计模式：06-享元模式 / 代理模式(静态代理·动态代理·cglib代理)

最新推荐文章于 2023-07-12 16:50:36 发布
最新推荐文章于 2023-07-12 16:50:36 发布
阅读量509 收藏 3
点赞数 1
分类专栏： 设计模式 文章标签： 设计模式 享元模式 动态代理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jinglongsource/article/details/103791964
版权

文章目录

本篇博客主要是学习 韩顺平_Java设计模式 做一个学习笔记使用

12. 享元模式(蝇量模式,池化模式)

12.1 需求的引入

小型的外包项目，给客户 A 做一个产品展示网站，客户 A 的朋友感觉效果不错，也希望做这样的产品展示网 站，但是要求都有些不同： 1) 有客户要求以新闻的形式发布 2) 有客户人要求以博客的形式发布 3) 有客户希望以微信公众号的形式发布

解决方案:

  1. 需要的网站结构相似度很高，而且都不是高访问量网站，如果分成多个虚拟空间来处理，相当于一个相同网站 的实例对象很多，造成服务器的资源浪费
  2. 解决思路：整合到一个网站中，共享其相关的代码和数据，对于硬盘、内存、CPU、数据库空间等服务器资源 都可以达成共享，减少服务器资源
  3. 对于代码来说，由于是一份实例，维护和扩展都更加容易

12.2 基本介绍

  1. 享元模式（Flyweight Pattern） 也叫 蝇量模式: 运用共享技术有效地支持大量细粒度的对象
  2. 常用于系统底层开发，解决系统的性能问题。像数据库连接池，里面都是创建好的连接对象，在这些连接对象 中有我们需要的则直接拿来用，避免重新创建，如果没有我们需要的，则创建一个
  3. 享元模式能够解决重复对象的内存浪费的问题，当系统中有大量相似对象，需要缓冲池时。不需总是创建新对 象，可以从缓冲池里拿。这样可以降低系统内存，同时提高效率
  4. 享元模式经典的应用场景就是池技术了，String 常量池、数据库连接池、缓冲池等等都是享元模式的应用，享 元模式是池技术的重要实现方式

  • 享元模式的原理类图
    在这里插入图片描述

  • 对原理图的说明-即(模式的角色及职责)

  1. FlyWeight 是抽象的享元角色, 他是产品的抽象类, 同时定义出对象的外部状态和内部状态的接口或实现
  2. ConcreteFlyWeight 是具体的享元角色，是具体的产品类，实现抽象角色定义相关业务
  3. UnSharedConcreteFlyWeight 是不可共享的角色，一般不会出现在享元工厂。
  4. FlyWeightFactory 享元工厂类，用于构建一个池容器(集合)， 同时提供从池中获取对象方法
  • 内部状态和外部状态
    比如围棋、五子棋、跳棋，它们都有大量的棋子对象，围棋和五子棋只有黑白两色，跳棋颜色多一点，所以棋子颜 色就是棋子的内部状态；而各个棋子之间的差别就是位置的不同，当我们落子后，落子颜色是定的，但位置是变化 的，所以棋子坐标就是棋子的外部状态
  1. 享元模式提出了两个要求：细粒度和共享对象。这里就涉及到内部状态和外部状态了，即将对象的信息分为两 个部分：内部状态和外部状态
  2. 内部状态指对象共享出来的信息，存储在享元对象内部且不会随环境的改变而改变
  3. 外部状态指对象得以依赖的一个标记，是随环境改变而改变的、不可共享的状态。
  4. 举个例子：围棋理论上有 361 个空位可以放棋子，每盘棋都有可能有两三百个棋子对象产生，因为内存空间有 限，一台服务器很难支持更多的玩家玩围棋游戏，如果用享元模式来处理棋子，那么棋子对象就可以减少到只 有两个实例，这样就很好的解决了对象的开销问题

12.3 应用实例


import java.util.HashMap;
import java.util.Map;

/**
 *
 * 享元模式 (池化技术)
 *
 * @author houyu
 * @createTime 2020/1/1 12:13
 */
public abstract class Demo1 {

    public static void main(String[] args) {

        WebSiteFactory factory = new WebSiteFactory();
        WebSite site1 = factory.get("新闻");
        site1.use();
        WebSite site2 = factory.get("博客");
        site2.use();
        WebSite site3 = factory.get("微信公众号");
        site3.use();
    }
}

/**
 * 抽象的享元角色
 */
abstract class WebSite {
    public abstract void use();
}

/**
 * 具体的享元角色
 */
class ConcreteWebSite extends WebSite {

    private String type;

    public ConcreteWebSite(String type) {
        this.type = type;
    }

    @Override
    public void use() {
        System.out.println("网站的发布形式为:" + type + " 在使用中...");
    }
}

/**
 *  享元工厂类
 */
class WebSiteFactory {

    private Map<String, WebSite> pool = new HashMap<>(8);

    public WebSite get(String type) {
        if(!pool.containsKey(type)) {
            pool.put(type, new ConcreteWebSite(type));
        }
        return pool.get(type);
    }
}

12.4 享元模式在 JDK-Interger 的应用源码分析

  • Integer.valueOf()
public static Integer valueOf(int i) {
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}
  • Integer.IntegerCache
private static class IntegerCache {
    static final int low = -128;
    static final int high;
    static final Integer cache[];

    static {
        // high value may be configured by property
        int h = 127;
        String integerCacheHighPropValue =
            sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
        if (integerCacheHighPropValue != null) {
            try {
                int i = parseInt(integerCacheHighPropValue);
                i = Math.max(i, 127);
                // Maximum array size is Integer.MAX_VALUE
                h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
            } catch( NumberFormatException nfe) {
                // If the property cannot be parsed into an int, ignore it.
            }
        }
        high = h;

        cache = new Integer[(high - low) + 1];
        int j = low;
        for(int k = 0; k < cache.length; k++)
            cache[k] = new Integer(j++);

        // range [-128, 127] must be interned (JLS7 5.1.7)
        assert IntegerCache.high >= 127;
    }

    private IntegerCache() {}
}
  • 缓存 -128 至 127的 Integer 对象

12.5 享元模式的注意事项和细节

  1. 在享元模式这样理解，“享”就表示共享，“元”表示对象
  2. 系统中有大量对象，这些对象消耗大量内存，并且对象的状态大部分可以外部化时，我们就可以考虑选用享元 模式
  3. 用唯一标识码判断，如果在内存中有，则返回这个唯一标识码所标识的对象，用 HashMap/HashTable 存储
  4. 享元模式大大减少了对象的创建，降低了程序内存的占用，提高效率
  5. 享元模式提高了系统的复杂度。需要分离出内部状态和外部状态，而外部状态具有固化特性，不应该随着内部 状态的改变而改变，这是我们使用享元模式需要注意的地方.
  6. 使用享元模式时，注意划分内部状态和外部状态，并且需要有一个工厂类加以控制。
  7. 享元模式经典的应用场景是需要缓冲池的场景，比如 String 常量池、数据库连接池

13. 代理模式(Proxy)

13.1 代理模式的基本介绍

  1. 代理模式：为一个对象提供一个替身，以控制对这个对象的访问。即通过代理对象访问目标对象.这样做的好处 是:可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能。
  2. 被代理的对象可以是远程对象、创建开销大的对象或需要安全控制的对象
  3. 代理模式有不同的形式, 主要有三种 静态代理、动态代理 (JDK 代理、接口代理)和 Cglib 代理 (可以在内存 动态的创建对象，而不需要实现接口， 他是属于动态代理的范畴) 。
  4. 代理模式示意图

在这里插入图片描述

13.2 静态代理

13.2.1 静态代码模式的基本介绍

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

13.2.2 应用实例

/**
 *
 * 静态代理
 *
 * @author houyu
 * @createTime 2020/1/1 13:18
 */
public class StaticProxyDemo {

    public static void main(String[] args) {

        // 1. 创建目标对象(被代理对象)
        Teacher teacher = new Teacher();
        // 2. 创建代理对象,同时将被代理对象传递给代理对象
        TeacherProxy teacherProxy = new TeacherProxy(teacher);
        // 3. 通过代理对象，调用到被代理对象的方法
        //      即：执行的是代理对象的方法，代理对象再去调用目标对象的方法
        teacherProxy.teach();

        /*
         * 前置执行
         * 老师正在上课...
         * 后置执行
         */
    }

}

/**
 * 抽象接口
 */
interface ITeacher {
    /**
     * 抽象方法
     */
    void teach();
}

/**
 * 具体实现层
 */
class Teacher implements ITeacher {

    @Override
    public void teach() {
        System.out.println("老师正在上课...");
    }
}

/**
 * 代理
 */
class TeacherProxy implements ITeacher {

    private ITeacher teacher;

    public TeacherProxy(ITeacher teacher) {
        this.teacher = teacher;
    }

    @Override
    public void teach() {
        System.out.println("前置执行");
        teacher.teach();
        System.out.println("后置执行");
    }
}

13.2.3 静态代理优缺点

优点：

  1. 在不修改目标对象的功能前提下,能通过代理对象对目标功能扩展

缺点：

  1. 因为代理对象需要与目标对象实现一样的接口,所以会有很多代理类
  2. 一旦接口增加方法,目标对象与代理对象都要维护

13.3 动态代理

13.3.1 动态代码模式的基本介绍

  1. 代理对象,不需要实现接口，但是目标对象要实现接口，否则不能用动态代理
  2. 代理对象的生成，是利用JDK的API，动态的在内存中构建代理对象
  3. 动态代理也叫做：JDK代理、接口代理

13.3.2 应用实例

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

/**
 *
 * 动态代理
 *
 * @author houyu
 * @createTime 2020/1/1 13:18
 */
public class DynamicProxyDemo {

    public static void main(String[] args) {
        // 1. 创建目标对象(被代理对象)
        Teacher teacher = new Teacher();
        // 2. 创建代理对象,同时将被代理对象传递给代理对象
        ProxyFactory factory = new ProxyFactory(teacher, new PreHandler() {
            @Override
            public void invoke(Object proxy, Method method, Object[] args) {
                System.out.println("前置通知");
            }
        }, new PostHandler() {
            @Override
            public void invoke(Object proxy, Method method, Object result, Object[] args) {
                System.out.println("后置通知");
            }
        });
        // 返回的是一个接口实现层, 并非目标对象哦~~~
        ITeacher proxyInstance = (ITeacher) factory.newProxyInstance();
        proxyInstance.teach();
        /*
         * 前置通知
         * 老师正在上课...
         * 后置通知
         */
    }

    /**
     * 抽象接口
     */
    static interface ITeacher {

        /**
         * 抽象方法
         */
        void teach();
    }

    /**
     * 具体实现层
     */
    static class Teacher implements ITeacher {

        @Override
        public void teach() {
            System.out.println("老师正在上课...");
        }
    }

    /**
     * 代理工厂
     */
    static class ProxyFactory {

        private Object target;
        private PreHandler preHandler;
        private PostHandler postHandler;

        public ProxyFactory(Object target, PreHandler preHandler, PostHandler postHandler) {
            this.target = target;
            this.preHandler = preHandler;
            this.postHandler = postHandler;
        }

        public Object newProxyInstance() {
            // ClassLoader loader,Class<?>[] interfaces,InvocationHandler h
            return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new InvocationHandler(){
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    preHandler.invoke(proxy, method, args);
                    Object result = null;
                    try {
                        // 执行实际的方法, 一定是使用目标对象执行(被代理对象), 也就是说代理对象调用被代理对象的方法
                        result = method.invoke(target, args);
                        return result;
                    } finally {
                        postHandler.invoke(proxy, method, result, args);
                    }
                }
            });
        }
    }

    /**
     * 前置通知
     */
    static interface PreHandler {
        void invoke(Object proxy, Method method, Object[] args);
    }

    /**
     * 后置通知
     */
    static interface PostHandler {
        void invoke(Object proxy, Method method, Object result, Object[] args);
    }

}

13.3.3 动态代理优缺点

优点：

  1. 动态创建代理实例

缺点：

  1. 需要目标类需要实现接口(interface)

13.4 Cglib代理(子类代理)

13.4.1 Cglib代理模式的基本介绍

  1. 静态代理和JDK代理模式都要求目标对象是实现一个接口,但是有时候目标对象只是一个单独的对象,并没有实现任何的接口,这个时候可使用目标对象子类来实现代理-这就是Cglib代理
    2 )Cglib代理也叫作子类代理,它是在内存中构建一个子类对象从而实现对目标对象功能扩展,有些书也将Cglib代理归属到动态代理。
  2. Cglib是一个强大的高性能的代码生成包,它可以在运行期扩展java类与实现java接口.它广泛的被许多AOP的框架使用,例如SpringAOP，实现方法拦截
  3. 在AOP编程中如何选择代理模式：1. 目标对象需要实现接口，用JDK代理 2. 目标对象不需要实现接口，用Cglib代理
  4. Cglib包的底层是通过使用字节码处理框架ASM来转换字节码并生成新的类

13.4.2 应用实例

import java.lang.reflect.Method;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

/**
 *
 * Cglib代理
 * compile 'cglib:cglib:3.1'
 *
 * @author houyu
 * @createTime 2020/1/1 13:18
 */
public class CglibProxyDemo {

    public static void main(String[] args) {
        // 1. 创建目标对象(被代理对象)
        Teacher teacher = new Teacher();
        // 2. 创建代理对象,同时将被代理对象传递给代理对象
        ProxyFactory factory = new ProxyFactory(teacher, new PreHandler() {
            @Override
            public void invoke(Object proxy, Method method, Object[] args) {
                System.out.println("前置通知(cglib)");
            }
        }, new PostHandler() {
            @Override
            public void invoke(Object proxy, Method method, Object result, Object[] args) {
                System.out.println("后置通知(cglib)");
            }
        });
        // 返回的是一个接口实现层, 并非目标对象哦~~~
        Teacher proxyInstance = (Teacher) factory.newProxyInstance();
        proxyInstance.teach();
        /*
         * 前置通知
         * 老师正在上课...
         * 后置通知
         */
    }

    /**
     * 具体实现层
     */
    static class Teacher {

        public void teach() {
            System.out.println("老师正在上课...");
        }
    }

    /**
     * 代理工厂
     */
    static class ProxyFactory implements MethodInterceptor {

        private Object target;
        private PreHandler preHandler;
        private PostHandler postHandler;

        public ProxyFactory(Object target, PreHandler preHandler, PostHandler postHandler) {
            this.target = target;
            this.preHandler = preHandler;
            this.postHandler = postHandler;
        }

        public Object newProxyInstance() {
            // 1.创建一个工具类
            Enhancer enhancer = new Enhancer();
            // 2.设置父类
            enhancer.setSuperclass(target.getClass());
            // 3.设置回调函数
            enhancer.setCallback(this);
            // 4.创建子类对象，即代理对象
            return enhancer.create();
        }

        /**
         * @param object 被代理的对象
         * @param method 代理的方法
         * @param args 方法的参数
         * @param methodProxy CGLIB方法代理对象
         * @return  cglib生成用来代替Method对象的一个对象，使用MethodProxy比调用JDK自身的Method直接执行方法效率会有提升
         * @throws Throwable
         */
        @Override
        public Object intercept(Object object, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
            preHandler.invoke(object, method, args);
            Object result = null;
            try {
                result = methodProxy.invokeSuper(object, args);
                /* Object result = method.invoke(target, args); */
                return result;
            } finally {
                postHandler.invoke(object, method, result, args);
            }
        }
    }

    /**
     * 前置通知
     */
    static interface PreHandler {
        void invoke(Object proxy, Method method, Object[] args);
    }

    /**
     * 后置通知
     */
    static interface PostHandler {
        void invoke(Object proxy, Method method, Object result, Object[] args);
    }

}

13.4.3 Cglib代理优缺点

优点：

  1. 高效 ( Cglib包的底层是通过使用字节码处理框架ASM来转换字节码并生成新的类 )
  2. 不需要实现接口, 可以直接对普通类进行代理

缺点：

  1. 在内存中动态构建子类，注意代理的类不能为final，否则报错 java.lang.IllegalArgumentException:
  2. 目标对象的方法如果为final/static,那么就不会被拦截,即不会执行目标对象额外的业务方法

13.4 几种常见的代理模式介绍—几种变体

  1. 防火墙代理
    内网通过代理穿透防火墙，实现对公网的访问。
  2. 缓存代理
    比如：当请求图片文件等资源时，先到缓存代理取，如果取到资源则ok,如果取不到资源，再到公网或者数据库取，然后缓存。
  3. 远程代理
    远程对象的本地代表，通过它可以把远程对象当本地对象来调用。远程代理通过网络和真正的远程对象沟通信息。
  4. 同步代理
    主要使用在多线程编程中，完成多线程间同步工作
IT加载中
关注
专栏目录
代理模式：静态代理与动态代理（JDK、CGLIB、javassist动态代理）
头好重好重的博客
08-24 895
介绍代理模式中的静态代理与动态代理（JDK、CGLIB、javassist动态代理）
设计模式之代理模式Java实现和类设计图
04-20
设计模式之代理模式Java实现和类设计图，包括静态代理和动态代理
代理模式
qq_35306443的博客
08-22 239
代理模式的基本介绍 1) 代理模式：为一个对象提供一个替身，以控制对这个对象的访问。即通过代理 对象访问目标对象.这样做的好处是:可以在目标对象实现的基础上,增强额外的 功能操作,即扩展目标对象的功能。 2) 被代理的对象可以是远程对象、创建开销大的对象或需要安全控制的对象 3) 代理模式有不同的形式, 主要有三种 静态代理、动态代理 (JDK代理、接口代 理)和 Cglib代理 (可以在内存...
设计模式之代理模式
ssllnn1314的博客
03-27 154
** 原理图 ** ** 创建步骤 ** 步骤 1 创建一个接口。 Image.java public interface Image { void display(); } 步骤 2 创建实现接口的实体类。 RealImage.java public class RealImage implements Image { private String fileName; ...
代理模式-静态动态代理-jdk动态代理-cglib动态代理
最新发布
11-12
在Java中，代理模式有多种实现方式，包括静态代理、JDK动态代理和CGLIB动态代理。 **静态代理** 静态代理是最早也是最基础的代理实现方式。在静态代理中，我们需要创建一个代理类，这个代理类与原始类（被代理类）...
Java设计模式：静态代理、装饰者、动态代理详解
12-21
【静态代理设计模式】 静态代理是一种提前编码的代理方式，代理类和被代理类需要有相同的接口或继承自相同的父类。实现步骤如下： 1. 定义接口或父类，确保代理类和被代理类有共同的行为。 2. 创建代理类，实现与...
cglib代理模式要使用的相关jar包
08-02
代理模式通常分为静态代理和动态代理。本文将重点介绍使用CGLIB库实现的动态代理。 CGLIB（Code Generation Library）是一个强大的高性能的代码生成库，它在许多AOP（面向切面编程）框架中被广泛应用，如Spring AOP...
设计模式-代理模式（讲解及其实现代码）
08-07
设计模式-代理模式（讲解及其实现代码）
设计模式(结构型)之代理模式(Proxy Pattern)
工匠若水
05-04 9814
代理模式是常用的结构型设计模式之一，当无法直接访问某个对象或访问某个对象存在困难时可以通过一个代理对象来间接访问，为了保证客户端使用的透明性，所访问的真实对象与代理对象需要实现相同的接口。根据代理模式的使用目的不同，代理模式又可以分为多种类型，例如保护代理、远程代理、虚拟代理、缓冲代理等，它们应用于不同的场合，满足用户的不同需求。
Java设计模式之结构型-代理模式（UML类图+案例分析）
黄团团的个人博客
07-12 2122
代理模式是一种结构型设计模式，它用一个代理对象来封装一个目标对象，通常是为了对目标对象的访问进行增强或控制。主要作用是扩展目标对象的功能，比如延迟加载、访问控制、远程访问和日志记录等。
设计模式图例之代理模式
dingweipeng1228的博客
06-02 96
转载于:https://www.cnblogs.com/lijiale/p/6932487.html
代理模式（结构型）
小憩一下
04-07 461
一：相关定义 代理模式：为另一个对象提供一个替身或占位符以控制对这个对象的访问。 二：相关类图和示例 代理模式类图： 看类图和装饰者模式很像，但两者的目的不同，代理强调的是控制对象的访问。代理有很多的应用场景和分类，这里我们主要来看一下java中的动态代理如何工作，因为它比较常用嘛，下面看类图。 因为java已经为你创建了Proxy类，所以你需要有办法来告诉Proxy类你要做...
spring代理的类图
songyang19871115的博客
06-02 698
希望达到目的： spring两种代理的区别（间接说明spring代理的选择），两种代理的核心依赖 从图中看出JdkDynamicAopProxy和CglibAopProxy区别在于CglibAopProxy是使用Enhancer(spring asm技术生成代理对象)而JdkDynamicAopProxy是InvocationHandler接口的实现（是基于JDK 动态代理实现的）这也是Defa
设计模式_代理设计模式
qq_43852319的博客
07-16 152
代理设计模式一种结构型设计模式。为其他对象提供一种代理，以控制对这个对象的访问。代理对象在客户端和目标对象之间起到中介的作用。可以提高目标类的纯洁性。 1.静态代理模式。 1.1 静态代理模式类图 分为目标类和代理类，目标类和代理类实现一个共同的接口，目标类和代理类之间的关系是一对一的关系。 1.2 角色分类 1.抽象角色 通过接口或抽象类声明真实角色实现的业务方法。 2.代理角色 实现抽象角色，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，并可以附加自己的操作 3.目标角色 实现抽象角.
图解设计模式------Proxy（代理）模式
weixin_44096353的博客
07-07 455
一、Proxy模式     Proxy是“代理人”的意思，它指的是代替别人进行工作的人。当不一定需要本人亲自进行工作时，就可以寻找代理人去完成工作。但代理人毕竟只是代理人，能代替本人做的事情终究是有限的。因此，当代理人遇到无法自己解决的事情时就会去找本人解决该问题。     在面向对象编程中，“本人”和“代理人”都是对象。如果“本人”对象太忙了，有些工作无法自己亲自完成，就将其交给“代理人”对象负责。 二 、示例程序 &nbsp
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值