Java学习——设计模式—

Java学习——设计模式——结构型模式1

文章目录

结构型模式
- 代理模式
- 适配器模式

结构型模式

结构型模式主要涉及如何组合各种对象以便获得更好、更灵活的结构。虽然面向对象的继承机制提供了最基本的子类扩展父类的功能，但结构型模式不仅仅简单地使用继承，而更多地通过组合与运行期的动态组合来实现更灵活的功能。

包括：
1、适配器
2、桥接
3、组合
4、装饰器
5、外观
6、享元
7、代理

代理模式

访问对象不适合或者不能直接引用目标对象，代理对象作为访问对象和目标对象之间的中介

Java中的代理按照代理类生产时机不同又分为静态代理和动态代理。

静态代理类在编译期就生成，而动态代理类则是在Java运行时动态生成。动态代理又有JDK代理和CGLib代理两种

结构
1、抽象主题类
2、真实主题类
3、代理类

静态代理

在这里插入图片描述

SellTickets
ProxyPoint
TrainStation
client

public class ProxyPoint implements SellTickets {

    private TrainStation station=new TrainStation();
    @Override
    public void sell() {
        System.out.println("代理点收取服务费用");
        station.sell();
    }
}

JDK动态代理
Java中提供了一个动态代理类Proxy，Proxy并不是上面的代理对象的类，而是提供了一个创建代理对象的静态方法来获取代理对象

SellTickets
ProxyFactory
TrainStation
client

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

public class ProxyFactory {
    private TrainStation station=new TrainStation();
    
    public SellTickets getproxyObject(){
        SellTickets sellTickets= (SellTickets) Proxy.newProxyInstance(station.getClass().getClassLoader(),
                station.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("代理点收取服务费用");
                        Object result=method.invoke(station,args);
                        return result;
                    }
                });
        return sellTickets;
    }
}

ProxyFactory不是代理模式中所说的代理类，而代理类是程序在运行过程中动态的内存中生产的类。

CGLIB
如果没有定义SellTickets接口，只定义了TrainStation，JDK代理无法使用。

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

CGLIB是第三方提供的包，需要引入jar包

        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>2.2.2</version>
        </dependency>

ProxyFactory
TrainStation
client

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
public class ProxyFactory implements MethodInterceptor{
    private TrainStation target=new ProxyFactory();
    public TrainStation getProxyObject() {
        //创建Enhancer对象，类似于JDK代理中的Proxy类
        Enhancer enhancer = new Enhancer();
        //设置父类的字节码对象。指定父类
        enhancer.setSuperclass(TrainStation.class);
        //设置回调函数
        enhancer.setCallback(this);
        //创建代理对象
        TrainStation proxyObject = (TrainStation) enhancer.create();
        return proxyObject;
    }

    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("代售点收取一定的服务费用(CGLib代理)");
        //要调用目标对象的方法
        Object obj = method.invoke(station, objects);
        return obj;
    }
}

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

代理模式优点：

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

缺点：增加了系统的复杂度

适配器模式

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

结构
1、目标接口
2、适配者类：被访问和适配的现存组件库中的组件接口
3、适配器类：是一个转换器，把适配者接口转换成目标接口

类适配器
在这里插入图片描述

public class SDAdapterTF extends TFCardImpl implements SDCard{

    @Override
    public String readSD() {
        System.out.println("adapter read tf card");
        return readTF();
    }

    @Override
    public void writeSD(String msg) {
        System.out.println("adapter write tf: "+msg);
        writeTF(msg);
    }
}

类适配器模式违背了合成复用原则。

类适配器是客户类有一个接口规范的情况下可用，反之不可用

对象适配器

在这里插入图片描述

public class SDAdapterTF implements SDCard {

    private TFCard tfCard;

    public SDAdapterTF(TFCard tfCard) {
        this.tfCard=tfCard;
    }

    @Override
    public String readSD() {
        System.out.println("adapter read tf card");
        return tfCard.readTF();
    }

    @Override
    public void writeSD(String msg) {
        System.out.println("adapter write tf: "+msg);
        tfCard.writeTF(msg);
    }
}