526互联

Week 4

发布时间 2023-10-08 19:57:22作者: 鹏懿如斯

week 4

进阶知识

设计模式

行为型设计模式

  • 模板方法模式

模板方法模式是一种行为型设计模式，它在一个抽象类中定义了一个算法的骨架，将一些步骤的具体实现延迟到子类中。这样使得子类可以在不改变该算法结构的情况下，重新定义算法中的某些步骤。

首先，我们创建一个抽象类，定义算法的骨架和一些抽象方法：

public abstract class AbstractTemplate {

    // 模板方法，定义算法的骨架
    public final void templateMethod() {
        step1();
        step2();
        step3();
    }

    // 具体步骤1
    protected abstract void step1();

    // 具体步骤2
    protected abstract void step2();

    // 具体步骤3
    protected void step3() {
        System.out.println("执行步骤3");
    }
}

接下来，我们创建一个具体的子类，实现抽象方法：

public class ConcreteTemplate extends AbstractTemplate {

    @Override
    protected void step1() {
        System.out.println("执行步骤1");
    }

    @Override
    protected void step2() {
        System.out.println("执行步骤2");
    }
}

最后，我们在主函数中使用模板方法模式：

public class Main {
    public static void main(String[] args) {
        AbstractTemplate template = new ConcreteTemplate();
        template.templateMethod();
    }
}

运行结果：

执行步骤1
执行步骤2
执行步骤3
  • 命令模式

命令模式是一种行为设计模式，它允许您将一个请求封装为一个对象，从而使您可以使用不同的请求对客户进行参数化，对请求排队或记录请求日志，以及支持可撤销的操作。

首先，我们创建一个命令接口：

public interface Command {
    void execute();
    void undo();
}

然后，我们创建一个具体的命令类，实现命令接口：

public class ConcreteCommand implements Command {
    private Receiver receiver;
    private String command;

    public ConcreteCommand(Receiver receiver, String command) {
        this.receiver = receiver;
        this.command = command;
    }

    @Override
    public void execute() {
        receiver.action(command);
    }

    @Override
    public void undo() {
        receiver.undoAction();
    }
}

接下来，我们创建一个接收者类，用于执行和撤销命令：

public class Receiver {
    public void action(String command) {
        System.out.println("执行命令：" + command);
    }

    public void undoAction() {
        System.out.println("撤销命令");
    }
}

最后，我们在主函数中使用命令模式：

public class CommandPatternDemo {
    public static void main(String[] args) {
        Receiver receiver = new Receiver();
        String command = "打印Hello World";
        Command commandObj = new ConcreteCommand(receiver, command);
        commandObj.execute();
        commandObj.undo();
    }
}

运行上述代码，输出结果如下：

执行命令：打印Hello World
撤销命令
  • 迭代器模式

迭代器模式是一种行为设计模式，它提供了一种方法来顺序访问一个聚合对象（如列表、数组等）中的各个元素，而又不暴露该对象的内部表示。

首先，我们创建一个可迭代的对象类：

import java.util.Iterator;

public class IterableCollection<E> implements Iterable<E> {
    private E[] elements;

    public IterableCollection(E[] elements) {
        this.elements = elements;
    }

    @Override
    public Iterator<E> iterator() {
        return new Iterator<E>() {
            private int index = 0;

            @Override
            public boolean hasNext() {
                return index < elements.length;
            }

            @Override
            public E next() {
                System.out.print("my-iterator:");
                return elements[index++];
            }
        };
    }
}

接下来，我们在主函数中使用迭代器模式：

public class IteratorPatternDemo {
    public static void main(String[] args) {
        Integer[] numbers = {1, 2, 3, 4, 5};
        IterableCollection<Integer> iterableCollection = new IterableCollection<>(numbers);
        Iterator<Integer> iterator = iterableCollection.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

运行上述代码，输出结果如下：

my-iterator:1
my-iterator:2
my-iterator:3
my-iterator:4
my-iterator:5
  • 观察者模式

观察者模式是一种行为设计模式，它定义了对象之间的一对多依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。

首先，我们创建一个主题接口：

public interface Subject {
    void registerObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObservers();
}

然后，我们创建一个具体的主题类：

import java.util.ArrayList;
import java.util.List;

public class ConcreteSubject implements Subject {
    private List<Observer> observers;
    private int state;

    public ConcreteSubject() {
        observers = new ArrayList<>();
    }

    @Override
    public void registerObserver(Observer observer) {
        observers.add(observer);
    }

    @Override
    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

    @Override
    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(state);
        }
    }

    public void setState(int state) {
        this.state = state;
        notifyObservers();
    }
}

接下来，我们创建一个观察者接口：

public interface Observer {
    void update(int state);
}

然后，我们创建一个具体的观察者类：

public class ConcreteObserver implements Observer {
    private int state;

    @Override
    public void update(int state) {
        this.state = state;
        System.out.println("状态已更新为：" + state);
    }
}

最后，我们在主函数中使用观察者模式：

public class ObserverPatternDemo {
    public static void main(String[] args) {
        ConcreteSubject subject = new ConcreteSubject();
        Observer observer1 = new ConcreteObserver();
        Observer observer2 = new ConcreteObserver();
        subject.registerObserver(observer1);
        subject.registerObserver(observer2);
        subject.setState(1);
        subject.setState(2);
    }
}

运行上述代码，输出结果如下：

状态已更新为：1
状态已更新为：1
状态已更新为：2
状态已更新为：2
  • 中介者模式

中介者模式是一种行为设计模式，它通过引入一个中介对象来封装一系列对象的交互。中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。

观察者模式是单向的，一堆对象观察一个东西，等待这个东西的更新通知；中介者模式，一堆对象谁都能发送广播通知，其他对象接到通知后进行相应的操作。

首先，我们创建一个中介者接口：

public interface Mediator {
    void send(String message, Colleague colleague);
}

然后，我们创建一个具体的中介者类：

import java.util.ArrayList;
import java.util.List;

public class ConcreteMediator implements Mediator {
    private List<Colleague> colleagues;

    public ConcreteMediator() {
        colleagues = new ArrayList<>();
    }

    @Override
    public void send(String message, Colleague colleague) {
        for (Colleague c : colleagues) {
            if (c != colleague) {
                c.receive(message);
            }
        }
    }

    public void addColleague(Colleague colleague) {
        colleagues.add(colleague);
    }
}

接下来，我们创建一个具体的同事类：

public abstract class Colleague {
    protected Mediator mediator;

    public Colleague(Mediator mediator) {
        this.mediator = mediator;
    }

    public abstract void send(String message);

    public abstract void receive(String message);
}

然后，我们创建两个具体的同事类：

public class ConcreteColleagueA extends Colleague {
    public ConcreteColleagueA(Mediator mediator) {
        super(mediator);
    }

    @Override
    public void send(String message) {
        System.out.println("同事A发送消息：" + message);
    }

    @Override
    public void receive(String message) {
        System.out.println("同事A接收消息：" + message);
    }
}

public class ConcreteColleagueB extends Colleague {
    public ConcreteColleagueB(Mediator mediator) {
        super(mediator);
    }

    @Override
    public void send(String message) {
        System.out.println("同事B发送消息：" + message);
    }

    @Override
    public void receive(String message) {
        System.out.println("同事B接收消息：" + message);
    }
}

最后，我们在主函数中使用中介者模式：

public class MediatorPatternDemo {
    public static void main(String[] args) {
        ConcreteMediator mediator = new ConcreteMediator();
        ConcreteColleagueA colleagueA = new ConcreteColleagueA(mediator);
        ConcreteColleagueB colleagueB = new ConcreteColleagueB(mediator);
        mediator.addColleague(colleagueA);
        mediator.addColleague(colleagueB);
        mediator.send("hello", colleagueA); // colleagueA 发送广播消息
        mediator.send("world", colleagueB);
    }
}

运行上述代码，输出结果如下：

同事B接收消息：hello
同事A接收消息：world
  • 备忘录模式

备忘录模式（Memento Pattern）是一种行为型设计模式，它通过在不破坏封装的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样以后就可以将该对象恢复到原先保存的状态。

首先，我们创建一个Memento类来存储对象的状态：

public class Memento {
    private String state;

    public Memento(String state) {
        this.state = state;
    }

    public String getState() {
        return state;
    }
}

接下来，我们创建一个Originator接口，它包含一个createState方法用于创建状态，以及一个saveState方法用于保存状态：

public interface Originator {
    Memento createState();
    void saveState(Memento memento);
    void restoreState(Memento memento);
}

然后，我们创建一个具体的Originator实现，例如Game类：

public class Game implements Originator {
    private String state;

    @Override
    public Memento createState() {
        return new Memento(state);
    }

    @Override
    public void saveState(Memento memento) {
        this.state = memento.getState();
    }

    @Override
    public void restoreState(Memento memento) {
        this.state = memento.getState();
    }
}

最后，我们创建一个MementoHolder类，用于保存和恢复Memento对象：

public class MementoHolder {
    private Memento memento;

    public MementoHolder(Memento memento) {
        this.memento = memento;
    }

    public Memento getMemento() {
        return memento;
    }
}

使用示例：

public class Main {
    public static void main(String[] args) {
        Game game = new Game();
        game.saveState(game.createState()); // 保存当前状态
        game.state = "New State"; // 更改状态
        Memento memento = game.createState(); // 创建新状态的Memento对象
        game.restoreState(memento); // 恢复之前保存的状态
        System.out.println(game.state); // 输出：New State
    }
}
  • 解释器模式

解释器模式（Interpreter Pattern）是一种行为型设计模式，它通过定义一个语法表示，然后使用解释器来解释该语法表示。

首先，我们创建一个Expression接口，用于表示表达式：

public interface Expression {
    int interpret();
}

接下来，我们创建一些具体的表达式实现，例如加法、减法和乘法：

public class AddExpression implements Expression {
    private Expression left;
    private Expression right;

    public AddExpression(Expression left, Expression right) {
        this.left = left;
        this.right = right;
    }

    @Override
    public int interpret() {
        return left.interpret() + right.interpret();
    }
}

然后，我们创建一个Context类，用于存储解释器的上下文信息：

public class Context {
    private Expression expression;

    public void setExpression(Expression expression) {
        this.expression = expression;
    }

    public int getResult() {
        return expression.interpret();
    }
}

最后，我们可以使用以下代码来测试解释器模式：

public class InterpreterPatternDemo {
    public static void main(String[] args) {
        Expression add = new AddExpression(new Integer(3), new Integer(5));

        Context context = new Context();
        context.setExpression(add);
        System.out.println("Result: " + context.getResult()); // 输出：Result: 8
    }
}
  • 状态模式

状态模式（State Pattern）是一种行为型设计模式，它允许对象在其内部状态改变时改变它的行为。这种模式主要用于实现有限状态机。

首先，我们创建一个State接口，用于表示状态：

public interface State {
    void handle(Context context);
}

接下来，我们创建一些具体的State实现，例如StartState、RunningState和StopState：

public class StartState implements State {
    @Override
    public void handle(Context context) {
        System.out.println("开始执行");
        context.setState(new RunningState());
    }
}

public class RunningState implements State {
    @Override
    public void handle(Context context) {
        System.out.println("正在运行");
        context.setState(new StopState());
    }
}

public class StopState implements State {
    @Override
    public void handle(Context context) {
        System.out.println("停止执行");
    }
}

然后，我们创建一个Context类，用于维护状态：

public class Context {
    private State state;

    public Context(State state) {
        this.state = state;
    }

    public void setState(State state) {
        this.state = state;
    }

    public void request() {
        state.handle(this);
    }
}

最后，我们可以使用以下代码来测试状态模式：

public class StatePatternDemo {
    public static void main(String[] args) {
        Context context = new Context(new StartState());
        context.request(); // 输出：开始执行
        context.request(); // 输出：正在运行
        context.request(); // 输出：停止执行
    }
}
  • 策略模式

策略模式（Strategy Pattern）是一种行为型设计模式，它定义了一系列算法，并将每个算法封装在一个具有共同接口的独立类中，使得它们可以相互替换。策略模式让算法的变化独立于使用它们的客户端。

首先，我们创建一个Strategy接口，用于表示策略：

public interface Strategy {
    void execute();
}

接下来，我们创建一些具体的策略实现，例如ConcreteStrategyA和ConcreteStrategyB：

public class ConcreteStrategyA implements Strategy {
    @Override
    public void execute() {
        System.out.println("执行策略A");
    }
}

public class ConcreteStrategyB implements Strategy {
    @Override
    public void execute() {
        System.out.println("执行策略B");
    }
}

然后，我们创建一个Context类，用于维护策略：

public class Context {
    private Strategy strategy;

    public Context(Strategy strategy) {
        this.strategy = strategy;
    }

    public void setStrategy(Strategy strategy) {
        this.strategy = strategy;
    }

    public void executeStrategy() {
        strategy.execute();
    }
}

最后，我们可以使用以下代码来测试策略模式：

public class StrategyPatternDemo {
    public static void main(String[] args) {
        Context context = new Context(new ConcreteStrategyA());
        context.executeStrategy(); // 输出：执行策略A

        context.setStrategy(new ConcreteStrategyB());
        context.executeStrategy(); // 输出：执行策略B
    }
}
  • 责任链模式

责任链模式（Chain of Responsibility）是一种行为型设计模式，它使多个对象都有机会处理请求，从而避免了请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递请求，直到有一个对象处理它为止。

首先，我们创建一个Handler接口，用于表示处理器：

public interface Handler {
    void setNext(Handler handler);
    void handleRequest(String request);
}

接下来，我们创建一些具体的Handler实现，例如ConcreteHandlerA和ConcreteHandlerB：

public class ConcreteHandlerA implements Handler {
    private Handler next;

    @Override
    public void setNext(Handler handler) {
        this.next = handler;
    }

    @Override
    public void handleRequest(String request) {
        if ("A".equals(request)) {
            System.out.println("处理器A处理请求");
        } else if (next != null) {
            next.handleRequest(request);
        } else {
            System.out.println("没有处理器可以处理该请求");
        }
    }
}

public class ConcreteHandlerB implements Handler {
    private Handler next;

    @Override
    public void setNext(Handler handler) {
        this.next = handler;
    }

    @Override
    public void handleRequest(String request) {
        if ("B".equals(request)) {
            System.out.println("处理器B处理请求");
        } else if (next != null) {
            next.handleRequest(request);
        } else {
            System.out.println("没有处理器可以处理该请求");
        }
    }
}

然后，我们创建一个Context类，用于维护处理器：

public class Context {
    private Handler handler;

    public Context(Handler handler) {
        this.handler = handler;
    }

    public void setHandler(Handler handler) {
        this.handler = handler;
    }

    public void handleRequest(String request) {
        handler.handleRequest(request);
    }
}

最后，我们可以使用以下代码来测试责任链模式：

public class ChainOfResponsibilityPatternDemo {
    public static void main(String[] args) {
        Context context = new Context(new ConcreteHandlerA());
        context.handleRequest("A"); // 输出：处理器A处理请求
        context.setHandler(new ConcreteHandlerB());
        context.handleRequest("B"); // 输出：处理器B处理请求
        context.handleRequest("C"); // 输出：没有处理器可以处理该请求
    }
}
  • 访问者模式

访问者模式（Visitor Pattern）是一种行为型设计模式，它允许在不改变对象结构的情况下，定义一组操作来处理具有相同接口的对象。这有助于将数据结构和操作分离，使得算法可以独立于使用它的数据结构。

首先，我们创建一个Element接口，用于表示元素：

public interface Element {
    void accept(Visitor visitor);
}

接下来，我们创建一些具体的元素实现，例如ElementA和ElementB：

public class ElementA implements Element {
    @Override
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }
}

public class ElementB implements Element {
    @Override
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }
}

然后，我们创建一个Visitor接口，用于表示访问者：

public interface Visitor {
    void visit(ElementA elementA);
    void visit(ElementB elementB);
}

接下来，我们创建一些具体的访问者实现，例如ConcreteVisitorA和ConcreteVisitorB：

public class ConcreteVisitorA implements Visitor {
    @Override
    public void visit(ElementA elementA) {
        System.out.println("访问者A处理元素A");
    }

    @Override
    public void visit(ElementB elementB) {
        System.out.println("访问者A处理元素B");
    }
}

public class ConcreteVisitorB implements Visitor {
    @Override
    public void visit(ElementA elementA) {
        System.out.println("访问者B处理元素A");
    }

    @Override
    public void visit(ElementB elementB) {
        System.out.println("访问者B处理元素B");
    }
}

最后，我们可以使用以下代码来测试访问者模式：

public class VisitorPatternDemo {
    public static void main(String[] args) {
        Element elementA = new ElementA();
        Element elementB = new ElementB();
        Visitor visitorA = new ConcreteVisitorA();
        Visitor visitorB = new ConcreteVisitorB();

        elementA.accept(visitorA); // 输出：访问者A处理元素A
        elementA.accept(visitorB); // 输出：访问者B处理元素A
        elementB.accept(visitorA); // 输出：访问者A处理元素B
        elementB.accept(visitorB); // 输出：访问者B处理元素B
    }
}

网络编程

常用协议

tcp、udp、http、https、ftp、smtp

  • Java实现ftp

服务器端代码：

import org.apache.commons.net.ftp.FTPServer;
import java.io.IOException;

public class FTPServerExample {
    public static void main(String[] args) throws IOException {
        // 创建FTP服务器对象并监听指定端口
        FTPServer server = new FTPServer();
        server.listen(21);
        System.out.println("FTP Server started on port 21");

        // 等待客户端连接
        while (true) {
            FTPClient client = server.accept();
            System.out.println("New client connected: " + client.getRemoteAddress());
            // 处理客户端请求
            handleClientRequest(client);
            // 关闭客户端连接
            client.close();
        }
    }

    private static void handleClientRequest(FTPClient client) throws IOException {
        // 获取客户端请求的文件名
        String fileName = client.getFileName();
        if (fileName != null && fileName.endsWith(".txt")) {
            // 读取本地文件内容并发送给客户端
            byte[] buffer = new byte[4096];
            int bytesRead = -1;
            File localFile = new File("local-file.txt");
            InputStream inputStream = new FileInputStream(localFile);
            OutputStream outputStream = client.retrieveFileStream(fileName);
            while ((bytesRead = inputStream.read(buffer)) != -1) {
                outputStream.write(buffer, 0, bytesRead);
            }
            inputStream.close();
            outputStream.close();
        } else {
            // 其他请求交给下一个处理器处理
            nextHandler.handleClientRequest(client);
        }
    }

    private static final NextHandler nextHandler = new NextHandler();

    private static class NextHandler {
        public void handleClientRequest(FTPClient client) {
            // 处理其他类型的请求，例如列出目录、删除文件等
            // ...
        }
    }
}

客户端代码：

import org.apache.commons.net.ftp.FTPClient;
import java.io.IOException;

public class FTPClientExample {
    public static void main(String[] args) {
        // 创建FTP客户端对象并连接到FTP服务器
        FTPClient client = new FTPClient();
        try {
            client.connect("localhost", 21);
            System.out.println("Connected to FTP server");
            // 登录FTP服务器
            client.login("username", "password");
            System.out.println("Logged in to FTP server");
            // 切换到指定目录
            client.changeWorkingDirectory("/path/to/directory");
            System.out.println("Changed working directory");
            // 下载文件
            File localFile = new File("local-file.txt");
            InputStream inputStream = new FileInputStream(localFile);
            OutputStream outputStream = client.retrieveFileStream("remote-file.txt");
            byte[] buffer = new byte[4096];
            int bytesRead = -1;
            while ((bytesRead = inputStream.read(buffer)) != -1) {
                outputStream.write(buffer, 0, bytesRead);
            }
            inputStream.close();
            outputStream.close();
            // 上传文件
            File fileToUpload = new File("file-to-upload.txt");
            InputStream fis = new FileInputStream(fileToUpload);
            client.storeFile("remote-file.txt", fis);
            fis.close();
            // 删除文件
            client.deleteFile("remote-file.txt");
            // 断开连接
            client.logout();
            client.disconnect();
            System.out.println("Disconnected from FTP server");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

这个示例代码演示了如何使用FTPClient类连接到FTP服务器、登录、切换目录、下载和上传文件以及断开连接。需要注意的是，在实际使用中，应该根据具体情况进行异常处理和资源管理。