Netty学习-IO体系架构系统回顾 & 装饰模式Decorator的具体使用

Netty学习-IO体系架构系统回顾

IO和NIO的学习

NIO - 1.4 开始出的

在网络应用框架中，NIO得到了大量的使用，特别是netty里面

前提：对IO及其了解

对IO的总结和回顾

• 理解Java I/O系统
• 熟悉使用Java.io包中的相关类和接口进行I/O编程
• 掌握Java IO的设计原则与使用的设计模式

Thinking in java - Java编程思想

对程序语言设计者来说，设计一个令人满意的IO系统是件及其艰巨的任务

几个基础概念

流的概念

输入/输出流概念

输入/输出类

字节流和字符流

• 输入流 读数据的逻辑：

1. open a stream
2. while more information
3. read information
4. close the stream

• 输出流 写数据的逻辑：

1. open a steam
2. while more information
3. write information
4. close the stream

这里，输入流就是输入流，输出流就是输出流。不会说有一个流及时输入又是输出。这个是和NIO差距非常大的一个区分差别。

• 流的分类

1. 节点流：从特定的地方读写的流类，例如：磁盘或者一块内存区域
2. 过滤流：使用节点流作为输入或者输出。（buffer流）过滤流是对节点流的包装。过滤流是使用一个已经存在的输入流或者输出流链接创建的。

• Java.io包中InputSteam的类层次

• Java.io包中OutputSteam的类层次

• IO流的链接

1. Input Stream Chain
2. OutPut Stream Chain

设计模式 *（装饰模式 Decorator 设计模式）

流的调用
AAA
BBB
CCC
new CCC(new BBB(new AAA()));
new BBB(new AAA());
new AAA();

装饰模式的概念：

• 装饰模式又名包装（wrapper）模式
• 装饰模式以对客户端透明的方式扩展对象的功能，是集成关系的一个替代方案
• 装饰模式以对客户透明的方式动态的给一个对象附加上更多的责任。换言之，客户端并不会觉得对象在装饰前和装饰后有什么不同。
• 装饰模式可以在不创造更多子类的情况下，将对象的功能加以扩展。
• 装饰模式把客户端的调用委派到被装饰类。装饰模式的关键在于这种扩展完全是透明的。
• 装饰模式是在不必改变原类文件和使用继承的情况下，动态的扩展一个对象的功能。它是通过创建一个包装对象，也就是装饰来包裹真是的对象。

装饰模式的角色：

• 抽象构建角色（Component）：给出一个抽象接口，以规范准备接受附加责任的对象。
• 具体构建角色（Concrete Component）：定义一个将要接受附加责任的类。
• 装饰角色（Decorator）：持有一个构建（Component）对象的引用，并定义一个与构想构建接口一致的接口。
• 具体装饰角色（Concrete Decorator）：负责给构建对象"贴上"附加的责任。

装饰模式的特点

• 装饰对象和真是对象有相同的接口。这样客户端对象就可以以真实对象相同的方式和装饰对象交互。
• 装饰对象包含一个真实 对象的引用（reference）
• 装饰对象接收所有来自客户端的请求。它把这些请求转发给真是的对象。
• 装饰对象可以在转发这些请求以前或者以后增加一些附加功能。这样就确保了在运行时，不用修改给定对象的结构就可以在外部增加附加的功能。在面向对象的设计模式中，通常是通过继承来实现对给丁磊的功能扩展。

编码实现装饰模式

package com.dawa.decorator;

public interface Component  {
    void doSomething();
}

package com.dawa.decorator;

public class ConcreteComponent implements Component {
    @Override
    public void doSomething() {
        System.out.println("功能A");
    }
}

package com.dawa.decorator;
//核心类，满足装饰模式的特点
public class Decorator implements Component {
    private Component component;

    public Decorator(Component component) {
        this.component = component;
    }

    @Override
    public void doSomething() {
            component.doSomething();
    }
}

package com.dawa.decorator;

public class ConcreteDecorator1 extends Decorator {
    public ConcreteDecorator1(Component component) {
        super(component);
    }

    @Override
    public void doSomething() {
        super.doSomething();
        this.doAnotherThing();
    }

    private void doAnotherThing() {
        System.out.println("功能a");
    }
}

package com.dawa.decorator;

public class ConcreteDecorator2 extends Decorator {

    public ConcreteDecorator2(Component component) {
        super(component);
    }

    @Override
    public void doSomething() {
        super.doSomething();
        this.doAnotherThing();
    }

    private void doAnotherThing() {
        System.out.println("功能b");
    }
}

package com.dawa.decorator;

public class Client {
    public static void main(String[] args) {
        Component component = new ConcreteDecorator2(new ConcreteDecorator1(new ConcreteComponent()));
        component.doSomething();
    }
}

---

** 在整个IO体系中，装饰模式是无处不在的 **

从源码中，寻找装饰模式是如何使用的

BufferInputStream extends FilterInputSteam

FilterInputSteam extends InputStream (里面有 InputStream 对象)

ps:volatile关键字：1-可见性 2-顺序性。在 FilterInputSteam 里面有用到。自行扩展。

volatile 保证可见性和有序性，不保证原子性。

为什么IO中要用到这种设计模式？

IO体系中使用设计模式很大程度的避免了有更多自雷的产生。并且可以在运行期去丰富我们构造出来的对象所具备的功能。

因为IO体系中已经有很多很多的类了，如果不适用这种设计模式，会导致类的急剧膨胀。并且实现起来非常不灵活。

在很大程度上，让功能保持健全，此外，在IO体系中类的数量不至于过多的膨胀。

---

所以说：以后面试官再问题，IO流的问题和用到的设计模式，你还怕吗？哈哈