盘点各种设计模式：单例模式，工厂模式，装饰者模式等

本人是准大二学生，有一个任务是手写tomcat，在历经艰辛万苦之后，终是略有成效，在这篇文章下面就来盘点一些设计模式，虽然我觉得这些东西真的有点高端，我就斗胆来写一些。

1.单例模式（Singleton Pattern）

描述：确保一个类只有一个实例，并提供全局访问点。这个模式在我学Java基础的时候其实就接触过了，如今在查看tomcat源码的时候还能重新相见。

示例：在tomcat中，org.apache.catalina.startup.Catalina类使用了单例模式:

public class Catalina {
    private static Catalina instance = null;
    
    private Catalina() {
        // 私有构造函数
    }

    public static synchronized Catalina getInstance() {
        if (instance == null) {
            instance = new Catalina();
        }
        return instance;
    }
}

 其实，单例模式可以分为懒汉式和饿汉式：

上面的tomcat的单例模式是使用的懒汉式；

饿汉式：

public class Singlen {
    private static Singlen s = new Singlen();

    private Singlen() {
    }

    public static Singlen getSingle() {
        return s;
    }
}

/**
 *          懒汉式         饿汉式
 * 效率       低             高    懒汉式每次都要进行比较，比较浪费时间，所以效率比饿汉式低
 * 内存       少             多    懒汉式只有在需要的时候才会创建出来，而饿汉式不换、管是否
 *                                 使用，在做开始的时候就会把对象创建出来，所以占用内存
 */

2.工厂模式（Factory Pattern） 

描述：定义一个创建对象的接口，但让子类决定要实例化的类是哪一个。

示例：在Tomcat中，org.apache.catalina.connector.Connector类使用了工厂模式。

public class Connector {
    private ProtocolHandler protocolHandler;

    public Connector(String protocol) {
        if (protocol.equals("HTTP/1.1")) {
            this.protocolHandler = new Http11Protocol();
        } else if (protocol.equals("AJP/1.3")) {
            this.protocolHandler = new AjpProtocol();
        }
    }
}

3.装饰者模式（Decorator Pattern）

 描述：动态地给一个对象添加一些额外的职责，就增加功能来说，装饰者模式相比生成子类更为灵活。

示例：在Tomcat中，org.apache.catalina.valves包中的各种Valve类使用了装饰者模式。

public class Request {
    public void process() {
        // 处理请求
    }
}

public class RequestDecorator extends Request {
    protected Request request;

    public RequestDecorator(Request request) {
        this.request = request;
    }

    @Override
    public void process() {
        // 增加额外的处理
        request.process();
    }
}

public class LoggingRequestDecorator extends RequestDecorator {
    public LoggingRequestDecorator(Request request) {
        super(request);
    }

    @Override
    public void process() {
        // 添加日志记录功能
        System.out.println("Logging request");
        super.process();
    }
}

4. 观察者模式（Observer Pattern）

 描述：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

示例：在Tomcat中，org.apache.catalina.Lifecycle接口及其实现类使用了观察者模式。
 

public interface LifecycleListener {
    void lifecycleEvent(LifecycleEvent event);
}

public class LifecycleEvent {
    private Object source;

    public LifecycleEvent(Object source) {
        this.source = source;
    }

    public Object getSource() {
        return source;
    }
}

public class Lifecycle {
    private List<LifecycleListener> listeners = new ArrayList<>();

    public void addLifecycleListener(LifecycleListener listener) {
        listeners.add(listener);
    }

    public void removeLifecycleListener(LifecycleListener listener) {
        listeners.remove(listener);
    }

    public void notifyListeners() {
        for (LifecycleListener listener : listeners) {
            listener.lifecycleEvent(new LifecycleEvent(this));
        }
    }
}

public class MyListener implements LifecycleListener {
    @Override
    public void lifecycleEvent(LifecycleEvent event) {
        System.out.println("Lifecycle event triggered by: " + event.getSource());
    }
}

5. 责任链模式（Chain of Responsibility Pattern）

描述:为请求创建一个处理对象的链。

示例:在Tomcat中，org.apache.catalina.valves.ValveBase和org.apache.catalina.core.StandardPipeline类使用了责任链模式。

public interface Valve {
    void invoke(Request request, Response response, ValveContext context);
}

public class ValveBase implements Valve {
    protected Valve next;

    public void setNext(Valve next) {
        this.next = next;
    }

    @Override
    public void invoke(Request request, Response response, ValveContext context) {
        if (next != null) {
            next.invoke(request, response, context);
        }
    }
}

public class ValveContext {
    private Valve first;
    private Valve current;

    public ValveContext(Valve first) {
        this.first = first;
        this.current = first;
    }

    public void invokeNext(Request request, Response response) {
        if (current != null) {
            Valve nextValve = current;
            current = current.getNext();
            nextValve.invoke(request, response, this);
        }
    }
}

  这些设计模式在Tomcat中被广泛应用，使得代码结构清晰、职责分明、易于扩展和维护。通过这些设计模式，Tomcat实现了高效、稳定和可扩展的Web容器。