如何使用结构型模式

这篇文章主要讲解了“如何使用结构型模式”，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来研究和学习“如何使用结构型模式”吧！

在成都网站设计、成都做网站过程中，需要针对客户的行业特点、产品特性、目标受众和市场情况进行定位分析，以确定网站的风格、色彩、版式、交互等方面的设计方向。创新互联公司还需要根据客户的需求进行功能模块的开发和设计，包括内容管理、前台展示、用户权限管理、数据统计和安全保护等功能。

适配器模式

所谓适配器模式，就是把一个类的结构转换成另外一个类的接口。使得原本由于接口不兼容而不能工作的类都能够一起工作。

在生活中比较常见的就是当我们想连接显示器的时候，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");
    }
}

感谢各位的阅读，以上就是“如何使用结构型模式”的内容了，经过本文的学习后，相信大家对如何使用结构型模式这一问题有了更深刻的体会，具体使用情况还需要大家实践验证。这里是创新互联，小编将为大家推送更多相关知识点的文章，欢迎关注！