Java项目中比较常使用的设计模式_除了单例模式,你在生产环境中还用过什么设计模式?java-优快云博客

本文链接：https://blog.youkuaiyun.com/m0_37638307/article/details/137156203

在Java项目中，我经常使用多种设计模式来提高代码的可读性、可维护性和可扩展性。以下是一些我在实际项目中应用的设计模式及其应用场景：

单例模式（Singleton Pattern）：这种模式用于确保一个类仅有一个实例，并提供一个全局访问点。在项目中，我经常使用它来管理数据库连接池、配置信息等全局唯一的资源。

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

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

工厂模式（Factory Pattern）：工厂模式用于创建对象，它隐藏了对象的具体实现细节，使代码更加灵活和可扩展。在项目中，我使用它来管理不同种类的对象创建，如日志记录器、数据库访问对象等。

public interface Product {
    void use();
}

public class ConcreteProductA implements Product {
    @Override
    public void use() {
        System.out.println("Using product A");
    }
}

public class ProductFactory {
    public Product createProduct(String type) {
        if ("A".equals(type)) {
            return new ConcreteProductA();
        }
        // 其他产品创建逻辑
        return null;
    }
}

观察者模式（Observer Pattern）：这种模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。当主题对象状态发生变化时，它的所有依赖者（观察者）都会自动收到通知并更新。在项目中，我使用它来实现事件监听、消息通知等功能。

public interface Observer {
    void update(String message);
}

public class Subject {
    private List<Observer> observers = new ArrayList<>();
    private String message;

    public void attach(Observer observer) {
        observers.add(observer);
    }

    public void detach(Observer observer) {
        observers.remove(observer);
    }

    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(message);
        }
    }

    public void setMessage(String message) {
        this.message = message;
        notifyObservers();
    }
}

建造者模式（Builder Pattern）：建造者模式将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。在项目中，我使用它来构建具有多个可选参数的对象，如配置类、订单类等。

public class Product {
    private String partA;
    private String partB;
    // 其他属性...

    private Product(Builder builder) {
        this.partA = builder.partA;
        this.partB = builder.partB;
        // 设置其他属性...
    }

    public static class Builder {
        private String partA;
        private String partB;
        // 其他属性...

        public Builder setPartA(String partA) {
            this.partA = partA;
            return this;
        }

        public Builder setPartB(String partB) {
            this.partB = partB;
            return this;
        }

        // 设置其他属性的方法...

        public Product build() {
            return new Product(this);
        }
    }
}

除了之前提到的设计模式，我在Java项目中还使用了以下一些设计模式：

策略模式（Strategy Pattern）：策略模式定义了一系列的算法，并将每一个算法封装起来，使它们可以互相替换。策略模式使得算法可以独立于使用它的客户端变化。在项目中，我使用策略模式来处理不同业务逻辑或算法需求，比如支付方式的选择、排序算法的选择等。

public interface Strategy {
    int doOperation(int num1, int num2);
}

public class OperationAdd implements Strategy {
    @Override
    public int doOperation(int num1, int num2) {
        return num1 + num2;
    }
}

public class Context {
    private Strategy strategy;

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

    public int executeStrategy(int num1, int num2) {
        return strategy.doOperation(num1, num2);
    }
}

模板方法模式（Template Method Pattern）：模板方法模式在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重新定义该算法的某些特定步骤。在项目中，我使用模板方法模式来处理那些有固定步骤但某些步骤实现不同的业务流程。

public abstract class AbstractClass {
    public final void templateMethod() {
        specificMethod1();
        specificMethod2();
    }

    protected abstract void specificMethod1();

    protected abstract void specificMethod2();
}

public class ConcreteClassA extends AbstractClass {
    @Override
    protected void specificMethod1() {
        System.out.println("ConcreteClassA specificMethod1");
    }

    @Override
    protected void specificMethod2() {
        System.out.println("ConcreteClassA specificMethod2");
    }
}

装饰器模式（Decorator Pattern）：装饰器模式动态地给一个对象添加一些额外的职责。就增加功能来说，装饰器模式相比生成子类更为灵活。在项目中，我使用装饰器模式来增强对象的功能，而不是通过继承的方式。

public interface Component {
    void operation();
}

public class ConcreteComponent implements Component {
    @Override
    public void operation() {
        System.out.println("ConcreteComponent operation");
    }
}

public abstract class Decorator implements Component {
    protected Component component;

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

    @Override
    public void operation() {
        if (component != null) {
            component.operation();
        }
    }
}

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

    @Override
    public void operation() {
        super.operation();
        addedState();
    }

    public void addedState() {
        System.out.println("ConcreteDecoratorA addedState");
    }
}

适配器模式（Adapter Pattern）：适配器模式将一个类的接口转换成客户期望的另一个接口，使得原本由于接口不兼容而无法协同工作的类可以一起工作。在项目中，我经常使用适配器模式来处理第三方库或旧代码的接口不兼容问题。

public interface Target {
    void request();
}

public class Adaptee {
    public void specificRequest() {
        System.out.println("Called specificRequest()");
    }
}

public class Adapter implements Target {
    private Adaptee adaptee;

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

    @Override
    public void request() {
        adaptee.specificRequest();
    }
}

除了之前提到的设计模式，在Java项目中，还有一些其他常用的设计模式可以帮助我们更好地构建和维护代码。以下是其中的几个例子：

观察者模式（Observer Pattern）：观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。当主题对象状态发生变化时，它的所有依赖者（观察者）都会自动收到通知并更新。在Java中，可以通过实现Observable类和Observer接口来实现观察者模式。这种模式常用于实现事件驱动的系统，如GUI编程或网络编程中的回调机制。

import java.util.Observable;
import java.util.Observer;

public class Subject extends Observable {
    public void notifyObservers() {
        setChanged();
        notifyObservers("Subject state changed");
    }
}

public class ObserverA implements Observer {
    @Override
    public void update(Observable o, Object arg) {
        System.out.println("ObserverA received update: " + arg);
    }
}

// 在主程序中
Subject subject = new Subject();
ObserverA observerA = new ObserverA();
subject.addObserver(observerA);
subject.notifyObservers(); // ObserverA will be notified

迭代器模式（Iterator Pattern）：迭代器模式提供一种方法来访问一个聚合对象中的各个元素，而又不需要暴露该对象的内部表示。在Java中，迭代器模式通过Iterator接口实现，使得我们可以遍历如集合（Collection）或列表（List）等数据结构，而无需了解它们的具体实现。

import java.util.ArrayList;
import java.util.Iterator;

public class Collection {
    private ArrayList<String> items = new ArrayList<>();

    public void add(String item) {
        items.add(item);
    }

    public Iterator<String> createIterator() {
        return new Iterator<String>() {
            private int index = 0;

            @Override
            public boolean hasNext() {
                return index < items.size();
            }

            @Override
            public String next() {
                if (hasNext()) {
                    return items.get(index++);
                }
                throw new IllegalStateException("No more elements");
            }
        };
    }
}

// 在主程序中
Collection collection = new Collection();
collection.add("Item 1");
collection.add("Item 2");
Iterator<String> iterator = collection.createIterator();
while (iterator.hasNext()) {
    System.out.println(iterator.next());
}

责任链模式（Chain of Responsibility Pattern）：责任链模式为请求创建了一个接收者对象的链。这种模式给予请求的处理者组织的灵活性，并允许动态地添加或修改处理一个请求的结构。请求沿着这条链传递，直到有一个对象处理它为止。在Java中，可以通过实现一系列的处理器对象，并将它们链接起来实现责任链模式。这种模式常用于处理具有多个潜在处理者的请求，例如异常处理或事件分发。

abstract class Handler {
    protected Handler nextHandler;
    protected String name;

    public Handler(String name) {
        this.name = name;
    }

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

    public abstract void handleRequest(String request);
}

class ConcreteHandlerA extends Handler {
    public ConcreteHandlerA(String name) {
        super(name);
    }

    @Override
    public void handleRequest(String request) {
        if (request.equals("A")) {
            System.out.println(name + " handled request " + request);
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        }
    }
}

// 在主程序中创建处理器链并发送请求
Handler handlerA = new ConcreteHandlerA("HandlerA");
Handler handlerB = new ConcreteHandlerB("HandlerB"); // 假设有一个ConcreteHandlerB类
handlerA.setNext(handlerB);
handlerA.handleRequest("A"); // HandlerA will handle this request
handlerA.handleRequest("B"); // HandlerB will handle this request, since HandlerA passed it on

这些设计模式为Java开发者提供了丰富的工具，可以帮助我们解决各种常见的软件设计问题。每种设计模式都有其特定的应用场景和优势，但同样重要的是要理解它们的局限性，并根据实际情况做出合适的选择。过度使用或误用设计模式可能会导致代码复杂性增加，反而降低系统的可维护性和可读性。因此，在设计软件时，我们应该审慎地考虑是否需要使用设计模式，并理解每种模式的最佳实践。

在使用设计模式时，需要注意以下几点：

理解问题上下文：在决定使用哪种设计模式之前，首先要深入理解所面临的问题。理解问题的本质、涉及的实体以及它们之间的交互，有助于我们找到最适合的设计模式。
避免过度设计：有时，我们可能会为了使用设计模式而强行引入不必要的复杂性。如果简单直接的实现方式就能满足需求，那么就不必刻意使用设计模式。过度使用设计模式可能导致代码变得难以理解和维护。
保持代码清晰：使用设计模式时，要确保代码的可读性和可维护性。避免引入过于复杂的逻辑和过多的抽象层。设计模式应该使代码更加清晰和易于理解，而不是相反。
关注性能：某些设计模式可能会引入额外的性能开销。在选择设计模式时，要考虑到系统的性能需求，并在必要时进行性能测试和调优。
学习与实践：设计模式是经验总结的产物，需要通过不断的学习和实践来掌握。在实际项目中应用设计模式，并总结经验和教训，是提高自己设计能力的重要途径。

除了上述提到的设计模式外，还有许多其他的设计模式可供我们学习和使用。例如，策略模式（Strategy Pattern）允许在运行时根据上下文选择算法的行为；模板方法模式（Template Method Pattern）定义了一个操作的算法框架，而将某些步骤延迟到子类中实现；状态模式（State Pattern）允许一个对象在其内部状态改变时改变它的行为，等等。

总之，设计模式是构建高质量Java项目的有力工具。通过学习和实践这些设计模式，我们可以提高软件设计的灵活性、可维护性和可扩展性，从而开发出更加健壮和可靠的应用程序。然而，我们也要避免滥用设计模式，而是要根据实际情况和需求来选择合适的模式，并注重代码的可读性和性能。

如何避免过度设计

避免过度设计是软件开发中一项至关重要的技能。过度设计通常表现为在项目中引入不必要的复杂性，这会增加开发成本、降低代码的可读性和可维护性，并可能导致项目延期。以下是一些避免过度设计的建议和示例：

保持简单：
- 示例：假设正在开发一个简单的用户注册功能。初始需求只是收集用户的姓名和电子邮件。避免一开始就设计复杂的用户管理系统，包含用户角色、权限、历史记录等。先实现基本功能，然后根据实际需求和反馈逐步扩展。
不要过早优化：
- 示例：在开发一个搜索功能时，可能认为一开始就使用复杂的算法和数据结构可以提高性能。然而，如果初始数据量很小，这种优化可能是多余的，甚至可能降低代码的可读性。先实现基本的搜索功能，当数据量增长到需要优化时再进行优化。
按需扩展：
- 示例：当开发一个电商网站时，最初可能只需要支持简单的商品展示和购买功能。不必一开始就设计支持多种支付方式、复杂的物流系统或用户积分系统。随着业务的扩展，可以逐步添加这些功能。
避免过度抽象：
- 示例：在设计类和方法时，不要过度追求通用性和抽象性。如果某个接口或类只在一个地方使用，或者其实现非常简单，那么可能不需要将其抽象出来。过度抽象可能导致代码难以理解和维护。
关注业务需求：
- 示例：当与产品经理或客户讨论需求时，确保理解并关注实际的业务需求。不要为了展示技术能力而引入不必要的复杂性。始终将业务需求放在首位，并根据实际需求进行设计和开发。
重构与审查：
- 在开发过程中，定期回顾和审查代码，识别并移除不必要的复杂性和冗余代码。使用重构技巧来简化代码结构，提高代码的可读性和可维护性。
遵循KISS原则（Keep It Simple, Stupid）：
- 这个原则强调保持设计和实现的简单性。尽量使用最简单、最直接的方法来实现功能，避免不必要的复杂性和额外的步骤。