三.1.2.3.4-阿里云开发者社区

(三)、结构性模式(7种)

结构型模式描述如何将类或对象按某种布局组成更大的结构。它分为类结构性模式和对象结构型模式，前者采用继承机制来组织接口和类，后者采用组合或聚合来组合对象。

由于组合关系或聚合关系比继承关系的耦合度低，满足合成复用原则，所以对象结构型模式比类结构型模式具有更大的灵活性。

1.代理模式

(1).概述

由于某些原因需要给某个对象(结婚对象)提供一个代理(婚介)以控制对该对象的访问(结婚仪式)。这时，访问对象不适合或者不能直接引用目标对象，代理对象作为访问对象和目标对象之间的中介。

eg: 结婚: 找婚介。

Java中的代理按照代理类生成时机不同分为静态代理和动态代理。静态代理类在编译期就生成，而动态代理类则是在Java运行时动态生成。动态代理又有JDK和GCLib代理两种。

(2).结构

代理模式分为三种角色:

抽象主题类: 通过接口或抽象类声明真实主题和代理对象实现的业务方法(结婚)。
真实主题类:实现了抽象主题的具体业务,是代理对象所代表的真实对象,是最终要引入的对象(新人)。
代理类: 提供了与真实主题相同的接口,其内部含有对真实主题的引用，他可以访问、控制或扩展真实主题的功能(婚介所)。

(3).静态代理

我们通过案列来感觉一下静态代理。

eg: 火车站买票

如果要买火车票的话,我们需要去火车站买票，排队等一系列的操作,显然比较麻烦。而火车站多个地方都有代售点,我们去代售点买火车票就方便很多了。这个列子其实就是典型的代理模式，火车站是目标对象，代售点是代理对象。

抽象主题类

package com.jsxs.structure.proxy.static_proxy;
/**
 * @Author Jsxs
 * @Date 2023/4/19 13:40
 * @PackageName:com.jsxs.structure.proxy.static_proxy
 * @ClassName: SellTickets
 * @Description: TODO   卖火车票的接口
 * @Version 1.0
 */
public interface SellTickets {
    void sell();
}
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14

真实主题类

package com.jsxs.structure.proxy.static_proxy;
/**
 * @Author Jsxs
 * @Date 2023/4/19 13:41
 * @PackageName:com.jsxs.structure.proxy.static_proxy
 * @ClassName: TrainStation
 * @Description: TODO   火车站类
 * @Version 1.0
 */
public class TrainStation implements SellTickets{
    @Override
    public void sell() {
        System.out.println("在火车站进行卖票业务");
    }
}
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17

代理类

package com.jsxs.structure.proxy.static_proxy;
/**
 * @Author Jsxs
 * @Date 2023/4/19 13:42
 * @PackageName:com.jsxs.structure.proxy.static_proxy
 * @ClassName: ProxyPoint
 * @Description: TODO  代售点
 * @Version 1.0
 */
public class ProxyPoint implements SellTickets{
    private TrainStation trainStation=new TrainStation();
    @Override
    public void sell() {
        System.out.println("代售点收取服务费帮火车站卖票，票的来源是火车站");
        trainStation.sell();
    }
}
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21

从上面的代码中我们可以看出测试类直接访问的是ProxyPoint类对象,也就是说ProxyPoint作为访问对象和目标对象的中介。同时也对sell方法进行了增强(代理点收取一些服务费用)

(4).JDK动态代理

我们使用上面的案例进行动态代理,先说说JDK提供的动态代理。Java中提供了一个动态代理类Proxy,Proxy并不是我们上述所说的代理对象的类,而是提供了一个创建代理对象的静态方法来获取对象。

抽象主题类

package com.jsxs.structure.proxy.jdk_proxy;
/**
 * @Author Jsxs
 * @Date 2023/4/19 13:40
 * @PackageName:com.jsxs.structure.proxy.static_proxy
 * @ClassName: SellTickets
 * @Description: TODO   卖火车票的接口
 * @Version 1.0
 */
public interface SellTickets {
    void sell();
}
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14

真实主题类

package com.jsxs.structure.proxy.jdk_proxy;
/**
 * @Author Jsxs
 * @Date 2023/4/19 13:41
 * @PackageName:com.jsxs.structure.proxy.static_proxy
 * @ClassName: TrainStation
 * @Description: TODO   火车站类
 * @Version 1.0
 */
public class TrainStation implements SellTickets {
    @Override
    public void sell() {
        System.out.println("在火车站进行卖票业务");
    }
}
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17

JDK动态代理类

package com.jsxs.structure.proxy.jdk_proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
 * @Author Jsxs
 * @Date 2023/4/19 14:04
 * @PackageName:com.jsxs.structure.proxy.jdk_proxy
 * @ClassName: ProxyFactory
 * @Description: TODO   获取代理对象的工厂类
 * @Version 1.0
 */
public class ProxyFactory {
    // 1.声明目标对象
    private TrainStation trainStation=new TrainStation();
    // 2.获取代理对象的方法
    public SellTickets getProxyObject(){
        // 返回代理对象即可
        /**
         *  1.类加载器: 用于加载代理类。可以通过目标对象获取类加载器
         *  2.代理类实现的接口的字节码对象
         *  3. 代理对象的调用处理程序:
         */
        SellTickets proxyObject = (SellTickets)Proxy.newProxyInstance(trainStation.getClass().getClassLoader(), trainStation.getClass().getInterfaces(), new InvocationHandler() {
            /**
             *
             * @param proxy 代理对象: 和proxyObject对象是同一个对象,在invoke方法中基本不用
             * @param method 对接口中的方法进行封装的method对象
             * @param args 调用方法的参数
             * @return 方法的返回值
             * @throws Throwable
             */
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("代售点收取一定的服务费用(JDK动态代理)...");
                Object invoke = method.invoke(trainStation, args);
                return invoke;
            }
        });
        return proxyObject;
    }
}
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47

客户端

package com.jsxs.structure.proxy.jdk_proxy;
/**
 * @Author Jsxs
 * @Date 2023/4/19 14:18
 * @PackageName:com.jsxs.structure.proxy.jdk_proxy
 * @ClassName: Client
 * @Description: TODO
 * @Version 1.0
 */
public class Client {
    public static void main(String[] args) {
        // 1.创建代理类工厂
        ProxyFactory proxyFactory = new ProxyFactory();
        // 2.获取代理对象
        SellTickets proxyObject = proxyFactory.getProxyObject();
        // 3.调用售卖的方法
        proxyObject.sell();
    }
}
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21

使用动态代理,我们思考下面问题

Proxy是代理类嘛?
ProxyFactory不是代理模式中所说的代理类，而代理类是程序在运行过程中动态的在内存中生成的类。通过阿里巴巴开源的Java诊断工具(Arthas)查看代理类的结构。

(5).GCLIB动态代理

同样是上面的案列,我们再次使用GCLIB代理实现。

如果没有定义SellTickets接口，只定义了TrainStation(火车站)。很显然JDK代理是无法使用了,因为JDK动态代理要求必须定义接口，对接口进行代理。

GCLIB是一个功能强大，高i性能的代码生成包。它没有实现接口的类提供代理类，为JDK的动态代理做了很好的补充。

GCLIB是第三方提供的包,所以需要引入jar包的坐标。

<!-- https://mvnrepository.com/artifact/cglib/cglib -->
<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>2.2.2</version>
</dependency>
• 1
• 2
• 3
• 4
• 5
• 6
• 7

火车站售票业务

package com.jsxs.structure.proxy.cglib_proxy;
/**
 * @Author Jsxs
 * @Date 2023/4/19 13:41
 * @PackageName:com.jsxs.structure.proxy.static_proxy
 * @ClassName: TrainStation
 * @Description: TODO   火车站类
 * @Version 1.0
 */
public class TrainStation {
    public void sell() {
        System.out.println("在火车站进行卖票业务");
    }
}
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17

代理工厂

package com.jsxs.structure.proxy.cglib_proxy;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
/**
 * @Author Jsxs
 * @Date 2023/4/19 15:08
 * @PackageName:com.jsxs.structure.proxy.cglib_proxy
 * @ClassName: ProxyFactory
 * @Description: TODO
 * @Version 1.0
 */
public class ProxyFactory implements MethodInterceptor {
    // 1.声明目标对象
    private TrainStation trainStation= new TrainStation();
    // 2.获取代理类
    public TrainStation getTrainStation(){
        // 创建Enhancer对象,雷士与JDK中的Proxy类
        Enhancer enhancer = new Enhancer();
        // 设置父类的字节码对象
        enhancer.setSuperclass(trainStation.getClass());
        // 设置回调函数
        enhancer.setCallback(this);  //MethodInterceptor父类的子类也就是 ProxyFactory;
        // 创建代理对象
        TrainStation proxyObject =(TrainStation) enhancer.create();
        return proxyObject;
    }
    /**
     *
     * @param o
     * @param method   方法
     * @param objects  参数
     * @param methodProxy
     * @return
     * @throws Throwable
     */
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("代售点收取费用");
        Object invoke = method.invoke(trainStation, objects);
        return invoke;
    }
}
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52

客户端

package com.jsxs.structure.proxy.cglib_proxy;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
 * @Author Jsxs
 * @Date 2023/4/19 15:15
 * @PackageName:com.jsxs.structure.proxy.cglib_proxy
 * @ClassName: Client
 * @Description: TODO
 * @Version 1.0
 */
public class Client {
    public static void main(String[] args) {
        // 创建代理工厂
        ProxyFactory proxyFactory = new ProxyFactory();
        // 获取代理对象
        TrainStation proxyObject = proxyFactory.getTrainStation();
        // 对象调离对象中的卖票方法
        proxyObject.sell();
    }
}
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23

(6).三种代理的对比

JDK代理和GCLIB代理

使用GCLIB实现动态代理，GCLIB底层采用ASM字节码生成框架，使用字节码技术生成代理类，在JDK1.6之前比使用Java反射效率要高。唯一需要注意的是,GCLIB不能对声明finnal的类或者方法进行动态代理，因为GCLIB原理是动态生成被代理类的子类。

在JDK1.6、JDK1.7、JDK1.8逐步对JDK动态代理优化之后，在调用次数较少的情况下，JDK代理效率高于GCLIB代理效率，只有当进行大量调用的时候，JDK1.6和JDK1.7比GCLIB代理效率低一点，但是到JDK1.8的时候，JDK代理效率高于GCLIB代理，所以如果有接口使用JDK动态代理，如果没有接口使用GCLIB代理。

动态代理和静态代理

动态代理与静态代理相比较，最大的好处是接口中声明的所有方法都被转义到调用处理器一个几种的方法中处理。这样,在接口方法数量比较多的时候，我们可以更加灵活处理，而不需要像静态代理那样每一个方法都需要中转，

如果接口增加一个方法，静态代理模式除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护的复杂度。而动态代理不会出现这个问题。

(7).代理模式的优缺点

优点:

代理模式在客户端与目标对象之间起到一个中介作用和保护目标对象的作用。
代理对象可以扩展目标对象的功能
代理模式能将客户端与目标对象分离,在一定程度上降低了系统的耦合度。

缺点:

增加了系统的复杂度

(8).使用场景

远程代理
本地服务通过网络请求远程服务。为了实现本地到远程的通信,我们需要实现网络通信,处理其中可能的异常。为良好的代码设计和可维护性，我们将网络通信部分隐藏起来，只暴露给本地服务一个接口，通过该接口即可访问远程服务的功能，而不必过多关系通信的细节。
防护墙代理(VPN)
当你将浏览器配置成功使用代理功能时，防火墙就将我们的浏览器的请求转发给互联网;当互联网返回响应时，代理服务器再把它转给你的浏览器。
保护代理
控制对一个对象的访问，如果需要可以给不同的用户提供不同级别的使用权限。

2.适配器模式

(1).概述

如果去欧洲国家去旅游的话,它们的插座如下图最左边，是欧洲的标准。为我们使用的插头如下图最右边的。因此我们的笔记本电脑，收集在当地不能直接充电的，所以需要一个插座转换器，转换器第一面插入地面的插座，第二面供我们充电，这样使得我们的插头就能在当地使用。生活中这样的列子很多，收集充电器(将220v转换为5v的电压)，读卡器等，其实就是使用到了适配器模式。

定义:将一个类的接口转换为客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的那些类能够一起工作。适配器模式分为类适配器模式和对象适配器模式,前者类之间的耦合度比后者高,且要求程序员了解现有组件库中的相关组件的内部结构，所以应用相对较少。

(2).结构

适配器模式包含以下主要角色:

目标接口: 当前系统业务所期待的接口，它可以是抽象类或者接口(中国接口)
适配者类: 它是被访问和适配的现存组件库中的组件接口(欧洲接口)
适配器类: 他是一个转换器，通过继承或引用适配者的对象，把适配者接口转换为目标接口，让客户按照目标接口的格式访问适配者。(转换器)

(3).类适配器模式实现

实现方式: 定义一个适配器类(转换器)来实现当前系统的业务接口(中国)，同时又继承现有组件库中已经存在的组件(欧洲)。

eg: 读卡器

现在已经有一台电脑只能读取SD卡(目标接口)，而要读取TE卡中的内容就需要使用到适配器模式。创建一个读卡器，将TE卡中的内容读取出来。

目标接口(中国)

package com.jsxs.structure.adapter.class_adapter;
/**
 * @Author Jsxs
 * @Date 2023/4/20 18:47
 * @PackageName:com.jsxs.structure.adapter.class_adapter
 * @ClassName: SDScard
 * @Description: TODO  目标接口  (SD卡)
 * @Version 1.0
 */
public interface SDCard {
    // 从SD卡中读取数据
    String readSD();
    //往SD卡中写数据
    void writeSD(String msg);
}
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17

package com.jsxs.structure.adapter.class_adapter;
/**
 * @Author Jsxs
 * @Date 2023/4/20 18:49
 * @PackageName:com.jsxs.structure.adapter.class_adapter
 * @ClassName: SDCardIml
 * @Description: TODO
 * @Version 1.0
 */
public class SDCardIml implements SDCard{
    @Override
    public String readSD() {
        String msg="SDCard red msg : hello word";
        return msg;
    }
    @Override
    public void writeSD(String msg) {
        System.out.println("SDCard write msg:"+msg);
    }
}
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23

适配者类()欧洲

package com.jsxs.structure.adapter.class_adapter;
/**
 * @Author Jsxs
 * @Date 2023/4/20 18:42
 * @PackageName:com.jsxs.structure.adapter.class_adapter
 * @ClassName: TFCard
 * @Description: TODO  适配者类的接口
 * @Version 1.0
 */
public interface TFCard {
    // 从TF卡中读取数据
    String readTF();
    // 网TF卡中写数据
    void writeTF(String msg);
}
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18

package com.jsxs.structure.adapter.class_adapter;
/**
 * @Author Jsxs
 * @Date 2023/4/20 18:44
 * @PackageName:com.jsxs.structure.adapter.class_adapter
 * @ClassName: TFCardImi
 * @Description: TODO  适配者类
 * @Version 1.0
 */
public class TFCardImi implements TFCard{
    @Override
    public String readTF() {
        String msg="TFCARD READ MSG:  HELLO WORLD";
        return msg;
    }
    @Override
    public void writeTF(String msg) {
        System.out.println("TFCARD WRITE MSG:"+msg);
    }
}
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23

计算机类

package com.jsxs.structure.adapter.class_adapter;
/**
 * @Author Jsxs
 * @Date 2023/4/20 18:54
 * @PackageName:com.jsxs.structure.adapter.class_adapter
 * @ClassName: Computer
 * @Description: TODO  计算机类
 * @Version 1.0
 */
public class Computer {
    // 从SD卡中读取数据
    public String readSD(SDCard sdCard){
        if (sdCard==null){
            throw new RuntimeException("SDCard is not null");
        }
        return sdCard.readSD();
    }
}
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21

适配器类()转换器

package com.jsxs.structure.adapter.class_adapter;
/**
 * @Author Jsxs
 * @Date 2023/4/20 18:59
 * @PackageName:com.jsxs.structure.adapter.class_adapter
 * @ClassName: SDAdapterTF
 * @Description: TODO  适配器类  (转换器)
 * @Version 1.0
 */
public class SDAdapterTF extends TFCardImi implements SDCard{ //实现当前业务的接口、同时继承已经存在的的组件。
    @Override
    public String readSD() {
        return this.readTF();
    }
    @Override
    public void writeSD(String msg) {
        this.writeTF(msg);
    }
}
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22

测试类

package com.jsxs.structure.adapter.class_adapter;
/**
 * @Author Jsxs
 * @Date 2023/4/20 18:56
 * @PackageName:com.jsxs.structure.adapter.class_adapter
 * @ClassName: Client
 * @Description: TODO
 * @Version 1.0
 */
public class Client {
    public static void main(String[] args) {
        // 创建计算机对象
        Computer computer = new Computer();
        //读取SD卡中的数据
        String s = computer.readSD(new SDCardIml());
        System.out.println(s);
        System.out.println("--------------------------");
        // 使用该计算机读取TF卡中的数据
        // 定义适配器类
        SDAdapterTF sdAdapterTF = new SDAdapterTF();
        // 适配器可以访问TF卡
        String s1 = sdAdapterTF.readTF();
        System.out.println(s1);
    }
}
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27

类适配器模式违背了合成复用原则。类适配器是客户类有一个接口规范的情况下可以，反之不可

(4).对象适配器模式

实现方式: 对象适配器模式可采用将现有组件库中已经实现的组件引入适配器类中，该类同时实现当前系统的业务接口。

目标接口(中国)

package com.jsxs.structure.adapter.class_adapter;
/**
 * @Author Jsxs
 * @Date 2023/4/20 18:47
 * @PackageName:com.jsxs.structure.adapter.class_adapter
 * @ClassName: SDScard
 * @Description: TODO  目标接口  (SD卡)
 * @Version 1.0
 */
public interface SDCard {
    // 从SD卡中读取数据
    String readSD();
    //往SD卡中写数据
    void writeSD(String msg);
}
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17

package com.jsxs.structure.adapter.class_adapter;
/**
 * @Author Jsxs
 * @Date 2023/4/20 18:49
 * @PackageName:com.jsxs.structure.adapter.class_adapter
 * @ClassName: SDCardIml
 * @Description: TODO
 * @Version 1.0
 */
public class SDCardIml implements SDCard{
    @Override
    public String readSD() {
        String msg="SDCard red msg : hello word";
        return msg;
    }
    @Override
    public void writeSD(String msg) {
        System.out.println("SDCard write msg:"+msg);
    }
}
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23

适配者类()欧洲

package com.jsxs.structure.adapter.class_adapter;
/**
 * @Author Jsxs
 * @Date 2023/4/20 18:42
 * @PackageName:com.jsxs.structure.adapter.class_adapter
 * @ClassName: TFCard
 * @Description: TODO  适配者类的接口
 * @Version 1.0
 */
public interface TFCard {
    // 从TF卡中读取数据
    String readTF();
    // 网TF卡中写数据
    void writeTF(String msg);
}
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18

package com.jsxs.structure.adapter.class_adapter;
/**
 * @Author Jsxs
 * @Date 2023/4/20 18:44
 * @PackageName:com.jsxs.structure.adapter.class_adapter
 * @ClassName: TFCardImi
 * @Description: TODO  适配者类
 * @Version 1.0
 */
public class TFCardImi implements TFCard{
    @Override
    public String readTF() {
        String msg="TFCARD READ MSG:  HELLO WORLD";
        return msg;
    }
    @Override
    public void writeTF(String msg) {
        System.out.println("TFCARD WRITE MSG:"+msg);
    }
}
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23

计算机类

package com.jsxs.structure.adapter.class_adapter;
/**
 * @Author Jsxs
 * @Date 2023/4/20 18:54
 * @PackageName:com.jsxs.structure.adapter.class_adapter
 * @ClassName: Computer
 * @Description: TODO  计算机类
 * @Version 1.0
 */
public class Computer {
    // 从SD卡中读取数据
    public String readSD(SDCard sdCard){
        if (sdCard==null){
            throw new RuntimeException("SDCard is not null");
        }
        return sdCard.readSD();
    }
}
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21

这里修改成聚合

package com.jsxs.structure.adapter.object_adpater;
/**
 * @Author Jsxs
 * @Date 2023/4/20 18:59
 * @PackageName:com.jsxs.structure.adapter.class_adapter
 * @ClassName: SDAdapterTF
 * @Description: TODO  适配器类  (转换器)
 * @Version 1.0
 */
public class SDAdapterTF implements SDCard { //实现当前业务的接口、同时继承已经存在的的组件。
    // 聚合适配者类
    private TFCard tfCard;
    // 设置有参构造方法,目的是使用哪个实现类
    public SDAdapterTF(TFCard tfCard) {
        this.tfCard = tfCard;
    }
    @Override
    public String readSD() {
        return  tfCard.readTF();
    }
    @Override
    public void writeSD(String msg) {
        tfCard.writeTF(msg);
    }
}
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32

package com.jsxs.structure.adapter.object_adpater;
/**
 * @Author Jsxs
 * @Date 2023/4/20 18:56
 * @PackageName:com.jsxs.structure.adapter.class_adapter
 * @ClassName: Client
 * @Description: TODO
 * @Version 1.0
 */
public class Client {
    public static void main(String[] args) {
        // 创建计算机对象
        Computer computer = new Computer();
        //读取SD卡中的数据
        String s = computer.readSD(new SDCardIml());
        System.out.println(s);
        System.out.println("--------------------------");
        // 使用该计算机读取TF卡中的数据
        // 定义适配器类
        SDAdapterTF sdAdapterTF = new SDAdapterTF(new TFCardImi());
        String s1 = sdAdapterTF.readSD();
        System.out.println(s1);
    }
}
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26

以上的方法实现了接口复用。聚合

注意: 还有一个适配器模式是接口适配器模式。当不希望实现一个接口中的所有方法，可以抽像一个Adapter，实现所有方法。而我们只需要继承该抽象类即可。

(5).应用场景

以前开发的系统存在满足新系统功能需求的类，但其接口同新系统的接口不一致
使用第三方提供的组件，但组件接口定义和自己要求的接口定义不同

(6).JDK源码解析

Reader(字符流)、InputStream(字节流)的适配使用的是InputStreamReader。

InputStreamReader继承自Java.io包中的Reader,对其中的抽象方法给出了实践。

3.桥接模式

(1).概述

现在有一个需求，需要创建不同的图形，并且每个图形都有可能会有不同的颜色。我们可以利用继承的方式来设计类的关系。

我们可以发现有很多的类，假如我们再增加一种颜色或一个形状，就需要创建更多的类。

试想,在一个多种可能会变化的维度的系统中,用继承方式会造成类爆炸，扩展起来不灵活。每次在一个维度上新增一个具体实现都要增加多个子类，为了更加灵活的设计系统，我们此时可以考虑使用桥接模式。

定义：

将抽象与实现分离,使他们可以独立变化。他是用组合关系代理继承关系来实现，从而降低了抽象和实现这两个可唯独的耦合度。

(2).结构

桥接模式包含以下角色:

抽象化角色: 定义抽象类，并包含一个对实现话对象的引用
扩展抽象化角色: 是抽象化角色的子类，实现父类中的业务方法，并通过组合关系调用实现化角色中的业务方法。
实现化角色: 定义实现化角色的接口，供扩展抽象化角色调用
具体实现化角色: 给出实现化角色接口的具体实现。

(3).案列

eg: 视频播放器

需要开发一个跨平台视频播放器，可以在不同操作系统平台(如windows,mac,Linux等)上播放多种格式的视频文件，常见的视频格式包括RMVB、AVI、WMV等。该播放器包含两个维度，适合使用桥接模式。

实现化角色

package com.jsxs.structure.Bride;
/**
 * @Author Jsxs
 * @Date 2023/4/21 20:43
 * @PackageName:com.jsxs.structure
 * @ClassName: Bride
 * @Description: TODO 实现化角色
 * @Version 1.0
 */
public interface VideoFile {
    // 解码
    void decode(String fileName);
}
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15

具体的实现化角色

package com.jsxs.structure.Bride;
/**
 * @Author Jsxs
 * @Date 2023/4/21 20:44
 * @PackageName:com.jsxs.structure.Bride
 * @ClassName: AVI
 * @Description: TODO  具体的实现化角色
 * @Version 1.0
 */
public class AVI implements VideoFile{
    @Override
    public void decode(String fileName) {
        System.out.println("AVI视频文件:"+fileName);
    }
}
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17

package com.jsxs.structure.Bride;
/**
 * @Author Jsxs
 * @Date 2023/4/21 20:45
 * @PackageName:com.jsxs.structure.Bride
 * @ClassName: MP4
 * @Description: TODO 具体的实现化角色
 * @Version 1.0
 */
public class MP4 implements VideoFile{
    @Override
    public void decode(String fileName) {
        System.out.println("MP4:"+fileName);
    }
}
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17

抽象化角色

package com.jsxs.structure.Bride;
/**
 * @Author Jsxs
 * @Date 2023/4/21 20:46
 * @PackageName:com.jsxs.structure.Bride
 * @ClassName: OS
 * @Description: TODO 抽象化角色
 * @Version 1.0
 */
public abstract class OS {
    // 聚合: 设置的类型为保护类型目的是为了让子类访问。
    protected VideoFile videoFile;
    // 因为我们设置有参构造函数，所以子类必须要赋值
    public OS(VideoFile videoFile) {
        this.videoFile = videoFile;
    }
    public abstract void play(String fileName);
}
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21

扩展抽象化角色

package com.jsxs.structure.Bride;
/**
 * @Author Jsxs
 * @Date 2023/4/21 21:00
 * @PackageName:com.jsxs.structure.Bride
 * @ClassName: Windows
 * @Description: TODO 扩展抽象化角色
 * @Version 1.0
 */
public class Windows extends OS{
    public Windows(VideoFile videoFile) {
        super(videoFile);
    }
    @Override
    public void play(String fileName) {
        videoFile.decode(fileName);
    }
}
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21

package com.jsxs.structure.Bride;
/**
 * @Author Jsxs
 * @Date 2023/4/21 21:03
 * @PackageName:com.jsxs.structure.Bride
 * @ClassName: Mac
 * @Description: TODO  扩展抽象化角色
 * @Version 1.0
 */
public class Mac extends OS{
    public Mac(VideoFile videoFile) {
        super(videoFile);
    }
    @Override
    public void play(String fileName) {
        videoFile.decode(fileName);
    }
}
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21

package com.jsxs.structure.Bride;
/**
 * @Author Jsxs
 * @Date 2023/4/21 21:04
 * @PackageName:com.jsxs.structure.Bride
 * @ClassName: Client
 * @Description: TODO
 * @Version 1.0
 */
public class Client {
    public static void main(String[] args) {
        // 创建Mac系统对象
        OS mac = new Mac(new AVI());
        // 使用操作系统播放文件
        mac.play("战狼4");
    }
}
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19

好处:

桥接模式提高了系统的可扩充性，在两个变化维度中任意扩展一个维度，都不需要改变原有维度。如:“如果现在有一种视频wmv，我们只需要再定以一个类实现VideoFile接口即可，其他类不需要在变化”
实现细节对客户透明

(4).使用场景

当一个类存在两个独立的维度的时候,且这两个维度都需要进行扩展时。
当一个系统不希望使用继承或因为多层次导致系统类的个数急剧增加。
当一个系统需要在构建的抽象化角色和具体化角色之间增加更多的灵活性时，避免在两个层次之间建立静态的继承连接，通过桥接模式可以使他门在抽象层建立一个关联关系。

4.装饰者模式

(1).概述

我们先来看一个快餐店的例子。

快餐店有炒面、炒饭这些快餐。可以额外的附加加鸡蛋、火腿、培根这些配菜，当然加配菜需要额外的加钱，每个配菜的价钱通常不太一样，那么计算总价就会显得比较麻烦。

使用继承的方式去

使用继承的方式存在的问题:

扩展性不好
如果要再一种配料(培根)，我们就会发现需要给炒米和炒面条分别定义一个子类。如果要新增一个快餐品类(炒河粉)的话，就需要定义更更多的子类。
产生过多的子类

(2).结构

定义: 旨在不该现有对象结构的情况下，动态的给该对象增加一些职责(即增加其他额外的功能)的模式。

装饰模式的角色:

抽象构建角色: 定义一个抽象接口以规范准备接受附加责任的对象。
具体构建角色: 实现抽象构建，通过装饰角色为其添加一些职责。
抽象装饰角色: 继承或实现抽象构建，并包含具体构建的实列，可以通过其子类扩展具体构建的功能。
具体装饰角色: 实现抽象装饰的相关方法，并给具体构建对象添加附加的责任。

(3).案列

我们使用装饰者模式对快餐店案列进行改进，体会装饰者模式的精髓。

类图如下:

抽象构建角色

package com.jsxs.structure.decorator;
/**
 * @Author Jsxs
 * @Date 2023/4/21 17:52
 * @PackageName:com.jsxs.structure.decorator
 * @ClassName: FastFood
 * @Description: TODO  抽象构建角色
 * @Version 1.0
 */
public  abstract class FastFood {
    private float price;
    private String desc;
    public FastFood(float price, String desc) {
        this.price = price;
        this.desc = desc;
    }
    public FastFood() {
    }
    public float getPrice() {
        return price;
    }
    public void setPrice(float price) {
        this.price = price;
    }
    public String getDesc() {
        return desc;
    }
    public void setDesc(String desc) {
        this.desc = desc;
    }
    public abstract float cost();
}
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41

具体构建角色

package com.jsxs.structure.decorator;
/**
 * @Author Jsxs
 * @Date 2023/4/21 17:57
 * @PackageName:com.jsxs.structure.decorator
 * @ClassName: rice
 * @Description: TODO  炒饭具体构建
 * @Version 1.0
 */
public class rice extends FastFood{
    public rice(){  //无参创建对象
        super(10,"炒饭");  // 设定继承父类的参数
    }
    @Override
    public float cost() {
        return this.getPrice();
    }
}
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21

package com.jsxs.structure.decorator;
/**
 * @Author Jsxs
 * @Date 2023/4/21 18:01
 * @PackageName:com.jsxs.structure.decorator
 * @ClassName: noddles
 * @Description: TODO
 * @Version 1.0
 */
public class noddles extends FastFood{
    public noddles(){
        super(20,"面条");
    }
    @Override
    public float cost() {
        return this.getPrice();
    }
}
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22

抽象装饰者类

package com.jsxs.structure.decorator;
/**
 * @Author Jsxs
 * @Date 2023/4/21 18:02
 * @PackageName:com.jsxs.structure.decorator
 * @ClassName: Granish
 * @Description: TODO  抽象装饰者类
 * @Version 1.0
 */
public abstract class Granish extends FastFood{
    // 聚合快餐
    private FastFood fastFood;
    public Granish(float price, String desc, FastFood fastFood) {
        super(price, desc);
        this.fastFood = fastFood;
    }
    public FastFood getFastFood() {
        return fastFood;
    }
    public void setFastFood(FastFood fastFood) {
        this.fastFood = fastFood;
    }
}
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28

具体装饰角色

package com.jsxs.structure.decorator;
/**
 * @Author Jsxs
 * @Date 2023/4/21 18:06
 * @PackageName:com.jsxs.structure.decorator
 * @ClassName: egg
 * @Description: TODO
 * @Version 1.0
 */
public class egg extends Granish{
    public egg(FastFood fastFood){
        super(1,"鸡蛋",fastFood);  //定义鸡蛋
    }
    @Override
    public float cost() {
        return this.getPrice()+this.getFastFood().cost();   //鸡蛋价格+快餐价格
    }
    @Override
    public String getDesc() {
        return super.getDesc()+getFastFood().getDesc();  // 鸡蛋描述+米饭描述
    }
}
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26

package com.jsxs.structure.decorator;
/**
 * @Author Jsxs
 * @Date 2023/4/21 18:20
 * @PackageName:com.jsxs.structure.decorator
 * @ClassName: Bacon
 * @Description: TODO
 * @Version 1.0
 */
public class Bacon extends Granish{
    public Bacon(FastFood fastFood){
        super(1,"培根",fastFood);  //定义鸡蛋
    }
    @Override
    public float cost() {
        return this.getPrice()+this.getFastFood().cost();   //鸡蛋价格+快餐价格
    }
    @Override
    public String getDesc() {
        return super.getDesc()+getFastFood().getDesc();  // 鸡蛋描述+米饭描述
    }
}
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26

客户端

package com.jsxs.structure.decorator;
/**
 * @Author Jsxs
 * @Date 2023/4/21 18:22
 * @PackageName:com.jsxs.structure.decorator
 * @ClassName: Client
 * @Description: TODO
 * @Version 1.0
 */
public class Client {
    public static void main(String[] args) {
        // 点一份炒饭
        FastFood rice = new rice();
        System.out.println(rice.getDesc()+rice.getPrice());
        // 炒饭中加一个鸡蛋
        rice = new egg(rice);
        System.out.println(rice.getDesc()+" "+rice.cost());
        rice=new Bacon(rice);
        System.out.println(rice.getDesc()+" "+rice.cost());
    }
}
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23

好处:

装饰者模式可以带来比较更加灵活性的扩展功能，使用更加方便，可以通过组合不同的装饰者对象来获取不同行为状态的多样化的结构。装饰者模式比继承更具备灵活的扩展性，完美的遵循开闭原则，继承是静态的附加责任，装饰者则是动态的附加责任。
装饰类和被装饰类可以独立发展，不会相互耦合，装饰模式是继承的一个替代模式，装饰模式可以动态扩展一个实现类的功能。

(4).使用场景

当不能采用继承的方式对系统进行扩充或者采用继承不利于系统扩展和维护时。

不能次啊用继承的情况主要有两类:
-(1).第一类是系统中存在大量独立的扩展，为支持每一种组合将产生大量的子类，使得子类数目呈爆炸性增长。
-(2).第二类是因为类定义不能继承(如 final)

在不影响其他对象的情况下，以动态、透明的方式给单个对象添加职责
当对象的功能要求可以动态地添加，也可以再动态的撤销时。

(5).JDK源码解析

IO流中的包装类使用到了装饰模式。BufferedInputStream,BufferedOutputStream,BufferedReader,BufferedWriter。

(6).代理和装饰者的区别

静态代理和装饰者模式的区别:

相同点:

都要实现与目标类相同的业务接口
在两个类中都要声明目标对象
都可以在不修改目标类的前提下增强目标方法

不同点

目的不同: “装饰者是为了增强目标对象,静态代理是为了保护和隐藏目标对象”
获取目标对象构建的地方不同:“装饰者是由外界传递进来的，可以通过构造方法传递，静态代理时在代理内部创建，以此来隐藏目标对象”

三.1.2.3.4

(三)、结构性模式(7种)

1.代理模式

(1).概述

(2).结构

(3).静态代理

(4).JDK动态代理

(5).GCLIB动态代理

(6).三种代理的对比

(7).代理模式的优缺点

(8).使用场景

2.适配器模式

(1).概述

(2).结构

(3).类适配器模式实现

(4).对象适配器模式

(5).应用场景

(6).JDK源码解析

3.桥接模式

(1).概述

(2).结构

(3).案列

(4).使用场景

4.装饰者模式

(1).概述

(2).结构

(3).案列

(4).使用场景

(5).JDK源码解析

(6).代理和装饰者的区别

热门文章

最新文章

相关电子书