乐趣区

关于后端:结构型模式一

作者：

jiezi

在

适配器模式

所谓适配器模式，就是把一个类的构造转换成另外一个类的接口。使得本来因为接口不兼容而不能工作的类都可能一起工作。

在生活中比拟常见的就是当咱们想连贯显示器的时候，vga须要转成hdmi，还有电源适配，比方可能须要220v的充电头，然而只有110v的充电头，那么就须要将220v的充电头适配成110v的充电头。

Adaptee： 须要适配的就代码，旧接口

Adapter： 将调用转发给Adaptee 的适配器类

Target： 反对的新接口

适配器模式UML

类适配器模式

Target

public interface Target {
    void output110v();
}

Adaptee

public class Adaptee {
    public void output220v() {
        System.out.println("输入电压");
    }
}

Adapter

public class Adapter extends Adaptee implements Target {
    @Override
    public void output110v() {
        this.output220v();
    }
}

这里须要留神的是Adapter 是继承了源类而实现了指标类

Client

public class Client {
    public static void main(String[] args) {
        Target target = new Adapter();
        target.output110v();
    }
}

尽管咱们是应用了output110v的充电头，然而通过Adapter后，最终通过this.output220v() 会调用output220v的充电头，这就是把output220v适配成了output110v。

对象适配器模式

其实说得这么高大上，其实就是Adaptor 的实现形式不同，类适配器模式采纳继承了源类（也就是须要适配的类）实现了指标类。

这样就存在一个问题，当咱们须要适配多个类的时候就会呈现问题，因为java中是容许实现多个接口，然而只能继承一个类。

为了解决这个问题，咱们能够把须要适配的类作为Adapter 的成员变量，而后通过构造函数进行适配

public class NewAdapter implements Target{
    Adaptee adaptee;

    public NewAdapter(Adaptee adaptee) {
        this.adaptee = adaptee;
    }

    @Override
    public void output110v() {
        adaptee.output220v();
    }
}

代理模式

代理模式也算是比拟罕用的设计模式之一，大家接触最多的spring aop，就是采纳动静代理模式来实现的。代理模式能够分为一般代理模式，强制代理模式，动静代理模式，也是本文着重解说的，当然还有其代理模式。

先来用一段代码来领会代理模式，场景是玩家打游戏。

Subject: 独特接口，客户端应用的现有接口

RealSubject： 实在对象的类

ProxySubject： 代理对象类

代理模式UML

一般代理模式

通过下面的例子，置信对大家都对代理模式有点感觉了，然而如同又不那么失当，下面的测试类种，还是须要新建一个player，这就相当于什么，相当于咱们是在手机上登录了游戏，而后再把手机给代练者代练。而事实上，常常是把账号密码给代练即可。

这就引出了一般代理模式，客户端不能拜访实在角色，只能拜访代理角色，咱们可能晓得代理的存在。

Subject

public interface SubjectNormalGamePlayer {
    public void login();
    public void upgrade();
    public void matches();
}

RealSubject

public class RealSubjectNormalPlayerImpl implements SubjectNormalGamePlayer {
    private String name;
    private String password;

    public RealSubjectNormalPlayerImpl(String name, String password) {
        this.name = name;
        this.password = password;
    }

    @Override
    public void login() {
        if(name.equals("cutey") && password.equals("123456")) {
            System.out.println(name + "登录胜利");
        }
    }

    @Override
    public void upgrade() {  
        System.out.println(name + "降级");
    }

    @Override
    public void matches() {
        System.out.println(name + "打排位赛");
    }
}

ProxySubject

public class ProxySubjectNormalPlayerImpl implements SubjectNormalGamePlayer {
    SubjectNormalGamePlayer gamePlayer;

    //留神这里的区别，咱们是拿账号和明码去登录实在角色
    //并不是间接拿实在角色的手机来打
    public ProxySubjectNormalPlayerImpl(String name, String password) {
        gamePlayer = new RealSubjectNormalPlayerImpl(name, password);
    }

    @Override
    public void login() {
        System.out.print("代练:");
        gamePlayer.login();
    }

    @Override
    public void upgrade() {
        System.out.print("代练:");
        gamePlayer.upgrade();
    }

    @Override
    public void matches() {
        System.out.print("代练:");
        gamePlayer.matches();
    }
}

Client

public class Client {
    public static void main(String[] args) {
        //通过测试类也很显著区别，不必要显示结构实在角色类
        SubjectNormalGamePlayer proxy = new ProxySubjectNormalPlayerImpl("cutey", "123456");
        proxy.login();
        proxy.upgrade();
        proxy.matches();
    }
}

强制代理

一般代理呢是去找到一个代理对象帮打，然而强制代理呢，次要是体现在“强制”，角色类会指定一个代理，其它形式找来的代理不能帮我打，肯定要用我指定的代理才行。

Subject

和一般代理模式大部分代码一样，不同的是加了一个强制指定代理对象。

public interface SubjectForceGamePlayer {
       //省略登录、降级和打排位等办法
    
    //强制指定代理对象
    public SubjectForceGamePlayer getForceProxy();
}

RealSubject

public class ForceGamePlayerImpl implements IForceGamePlayer {
    private String name;
    private String password;

    private IForceGamePlayer proxy = null;      //指定须要谁来代理


    public ForceGamePlayerImpl(String name, String password) {
        this.name = name;
        this.password = password;
    }
    
    @Override
    public IForceGamePlayer getForceProxy() {
        //强制指定代理类，并且只有这样能力给proxy赋值
        proxy =  new ForceProxyGamePlayerImpl(this);
        return proxy;
    }

    @Override
    public void login() {
        //只有不是本人指定的proxy，其它形式proxy必定是null
        if(proxy != null) {
            if(name.equals("imperfect") && password.equals("123456")) {
                System.out.println(name + "登录胜利");
            }
        } else {
            System.out.println("须要代理");
        }

    }

    @Override
    public void upgrade() {
        if(proxy != null) {
            System.out.println(name + "降级");
        } else {
            System.out.println("须要代理");
        }

    }

    @Override
    public void matches() {
        if(proxy != null) {
            System.out.println(name + "打排位赛");
        } else {
            System.out.println("须要代理");
        }

    }
}

ProxySubject

public class ProxySubjectForcePlayerImpl implements SubjectForceGamePlayer {

    private SubjectForceGamePlayer gamePlayer;

    //接管被代理对象的指定
    public ProxySubjectForcePlayerImpl(SubjectForceGamePlayer gamePlayer) {
        this.gamePlayer = gamePlayer;
    }


    //省略登录、降级和打较量的办法

    //没有代理对象，临时返回本人
    @Override
    public SubjectForceGamePlayer getForceProxy() {
        return this;
    }

}

Client

public class Client {
    public static void main(String[] args) {
        wrongProxy1();
        wrongProxy2();
        correctProxy();
    }

    public static void correctProxy() {
        SubjectForceGamePlayer player = new RealSubjectForcePlayerImpl("cutey", "123456");

        //你这个代理必须是我指定的，并且强制要有
        SubjectForceGamePlayer proxy = player.getForceProxy();
        proxy.login();
        proxy.upgrade();
        proxy.matches();
    }

    public static void wrongProxy1() {
        SubjectForceGamePlayer player = new RealSubjectForcePlayerImpl("cutey", "123456");
        SubjectForceGamePlayer proxy = new ProxySubjectForcePlayerImpl(player);
        proxy.login();
        proxy.upgrade();
        proxy.matches();
    }

    public static void wrongProxy2() {
        SubjectForceGamePlayer player = new RealSubjectForcePlayerImpl("cutey", "123456");
        player.login();
        player.upgrade();
        player.matches();
    }
}

动静代理

这个应该是代理模式中用的比拟多的，也是我感觉最须要各位小伙伴了解并且把握的。所谓动静代理是指，不必在编译器指定为谁代理，而是在运行期再取得被代理的对象并且执行代理的办法。

上面将要讲的例子是利用jdk中提供的InvocationHandler和Proxy类

Subject 、RealSubject 都和一般代理模式一样

ProxySubject

咱们不晓得要给谁代理，所以要用到的是继承InvocationHandler类

public class ProxySubjectDynamicPlayerImpl implements InvocationHandler {
    Class cls = null;    //要代理的类
    Object obj = null;    //须要代理的对象

    //指定须要代理的对象
    public ProxySubjectDynamicPlayerImpl(Object obj) {
        this.obj = obj;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //调用代理对象的办法
        Object result = method.invoke(this.obj, args);
        if(method.getName().equalsIgnoreCase("login")) {
            System.out.println("异地登陆揭示：有人登录我的账户");
        }
        return result;
    }
}

Client

public class Client {
    public static void main(String[] args) {
        SubjectDynamicPlayer player = new RealSubjectDynamicPlayerImpl("imperfect", "123456");

        //把须要代理的信息交给handler，还记得invoke办法吗
        //在invoke办法中曾经实现了被代理对象的办法
        InvocationHandler handler = new ProxySubjectDynamicPlayerImpl(player);

        //获取被代理类的类加载属性
        ClassLoader cl = player.getClass().getClassLoader();

        //获取被代理类的接口
        Class[] interfaces = player.getClass().getInterfaces();

        //把上述的三个信息交给Proxy创立出一个代理类
        SubjectDynamicPlayer proxy = (SubjectDynamicPlayer) Proxy.newProxyInstance(cl, interfaces, handler);

        proxy.login();
        proxy.upgrade();
        proxy.matches();
    }
}

在编译时咱们是齐全不晓得给谁代理，一切都是在运行时才晓得，这就是“动静”

装璜模式

装璜模式就是动静地给一个对象增加一些恩爱的职责，就减少性能来说，装璜模式比生成子类更为灵便。

无论干什么，最重要的都是取长补短，对于卖手机也是如此，必定是把卖点具体地介绍，而对于毛病能不提就不提。

Component： 定义一个对象的接口，能够给这些对象动静地增加职责

ConcreteComponent： 具体的对象

Decorator： 装璜抽象类，继承了Component，从外类来扩大Component

ConcentrateDecorator： 具体的装璜类

装璜模式UML

装璜模式

Component

public abstract class ComponentMobile {
    //产品名字
    private String name;

    //省略get，set，tostring办法

    public abstract void showDetails();

    public abstract void onSale(String userName);

}

Concentrate Component

public class ConcreteComponentOnePlus extends ComponentMobile {

    public ConcreteComponentOnePlus(String name) {
        super(name);
    }

    @Override
    public void showDetails() {
        System.out.println("处理器：骁龙888 \r\n拍照：哈苏业余模式 \r\n屏幕：2k+120hz 柔性屏 \r\n充电：65w快充");
    }

    @Override
    public void onSale(String userName) {
        System.out.println(userName + "购买了" + getName());
    }
}

Decorator

public abstract class Decorator extends ComponentMobile {

    //把要装璜的手机拿给我
    private ComponentMobile mobile;

    public Decorator(String name, ComponentMobile mobile) {
        super(name);
        this.mobile = mobile;
    }

    //细节还是要展现的
    //只不过怎么展现呢，子类能够加以润饰
    public void showDetails() {
        mobile.showDetails();
    }

    //手机也是要发售的
    public void onSale(String name) {
        mobile.onSale(name);
    }

}

留神，咱们手机的细节还是要展现的，不能说做的不好就不说进去，坑骗消费者。能把你认出来叫化妆，不能把你认出来叫整容，咱们讲的是装璜模式，不是整容模式。

Concrete Decorator

public class ConcreteDecoratorSystem extends Decorator {

    public ConcreteDecoratorSystem(String name, ComponentMobile mobile) {
        super(name, mobile);
    }

    //装璜零碎
    public void decorateScreen() {
        System.out.println("出厂装备了ColorOS，其它型号的手机也会逐渐适配");

    }

    @Override
    public void showDetails() {
        //想先介绍了零碎，再说其余参数
        decorateScreen();
        super.showDetails();
    }
}
public class ConcreteDecoratorPrice extends Decorator {


    public ConcreteDecoratorPrice(String name, ComponentMobile mobile) {
        super(name, mobile);
    }

    //颁布价格
    public void decoratePrice() {
        System.out.println("8 + 128：4999");
        System.out.println("8 + 256: 5499");
    }

    @Override
    public void showDetails() {
        super.showDetails();
        //介绍完其它的后，颁布性价比较高的价格
        decoratePrice();
    }
}

Client

public class Client {
    public static void main(String[] args) {
        //手机发布会，原产品
        ComponentMobile mobile = new ConcreteComponentOnePlus("OnePlus 9 Pro");
        //装璜下零碎
        mobile = new ConcreteDecoratorSystem(mobile.getName(), mobile);
        //装璜下价格
        mobile = new ConcreteDecoratorPrice(mobile.getName(), mobile);
        mobile.showDetails();

        //用户一看，诶，不错不错，买了
        mobile.onSale("cutey");
    }
}

评论

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注

这个站点使用 Akismet 来减少垃圾评论。了解你的评论数据如何被处理。

更多文章