实际案例演示：从理论到实践，如何落地应用设计模式

大家在学习设计模式应该都会有个疑问，学完了。到底项目上怎么来用呢，好像没有思路。如果你也有这个疑问可以试试用chatgpt辅助你。不仅给了说明，还会给你提供代码demo,可以打开自己的思路。

以下就是详细的结果：

在开发Java版电子签章项目中，我们可以使用多种设计模式来提高代码的可维护性、可扩展性和可重用性。下面是几个常见的设计模式及其在电子签章项目中的应用：

1）工厂模式：

电子签章项目可能需要创建不同类型的印章，例如椭圆形印章、矩形印章、圆形印章等，这时可以考虑使用工厂模式来封装印章对象的创建过程，并根据需要创建相应的印章对象。

public class SealFactory {
    public static Seal createSeal(SealType type) {
        switch (type) {
            case ELLIPSE:
                return new EllipseSeal();
            case RECTANGLE:
                return new RectangleSeal();
            case CIRCLE:
                return new CircleSeal();
            default:
                throw new IllegalArgumentException("invalid seal type");
        }
    }
}

2）观察者模式：

电子签章项目中可能需要不断更新印章的状态信息，例如位置、颜色、字体等，这时可以考虑使用观察者模式来实现状态更新通知。

public class Seal implements Observable {
    private List<Observer> observers;

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

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

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

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

    // 其他方法省略
}

3）建造者模式：

电子签章项目中可能需要灵活组装不同属性的印章，例如大小、形状、字体等，这时可以考虑使用建造者模式来实现印章对象的构建过程，并支持多种属性组合方式。

public class SealBuilder {
    private int width;
    private int height;
    private String text;
    private Font font;

    public SealBuilder setWidth(int width) {
        this.width = width;
        return this;
    }

    public SealBuilder setHeight(int height) {
        this.height = height;
        return this;
    }

    public SealBuilder setText(String text) {
        this.text = text;
        return this;
    }

    public SealBuilder setFont(Font font) {
        this.font = font;
        return this;
    }

    public Seal build() {
        // 根据属性创建印章对象
        Seal seal = new Seal();
        seal.setWidth(width);
        seal.setHeight(height);
        seal.setText(text);
        seal.setFont(font);
        return seal;
    }
}

以上是几个常见的设计模式及其在电子签章项目中的应用。通过合理地应用设计模式，可以使代码更加灵活、可维护和可扩展，提高开发效率和代码质量。

4）装饰器模式：

对于印章的一些额外处理（例如添加水印、修改颜色等），可以使用装饰器模式来对签章进行包装，从而增加功能并且不影响原有的签章结构。

以下是一个简单的示例代码，演示如何使用装饰器模式为印章添加水印和修改颜色：

// 印章接口
public interface Seal {
    void draw();
}

// 基本印章类
public class BasicSeal implements Seal {

    @Override
    public void draw() {
        System.out.println("绘制基本印章");
    }
}

// 抽象装饰器类
public abstract class SealDecorator implements Seal {

    protected Seal seal;

    public SealDecorator(Seal seal) {
        this.seal = seal;
    }

    @Override
    public void draw() {
        seal.draw();
    }
}

// 水印装饰器类
public class WatermarkDecorator extends SealDecorator {

    public WatermarkDecorator(Seal seal) {
        super(seal);
    }

    @Override
    public void draw() {
        super.draw();
        System.out.println("添加水印");
    }
}

// 颜色装饰器类
public class ColorDecorator extends SealDecorator {

    public ColorDecorator(Seal seal) {
        super(seal);
    }

    @Override
    public void draw() {
        super.draw();
        System.out.println("修改颜色");
    }
}

// 客户端代码示例
public class Client {
    public static void main(String[] args) {
        // 创建基本印章对象
        Seal basicSeal = new BasicSeal();

        // 添加水印
        Seal watermarkSeal = new WatermarkDecorator(basicSeal);

        // 修改颜色
        Seal colorSeal = new ColorDecorator(watermarkSeal);

        // 绘制印章
        colorSeal.draw();
    }
}

在上面的示例中，我们定义了一个Seal接口，并实现了一个基本签章类BasicSeal。然后，我们使用抽象装饰器类SealDecorator来扩展基本印章类，并分别实现了添加水印和修改颜色的装饰器类。

在客户端代码中，我们通过创建基本印章对象，并依次使用水印装饰器和颜色装饰器来包装签章对象。最终，在调用colorSeal.draw()方法时，会按照顺序执行所有装饰器的处理逻辑，并输出完整的印章信息。

这样，我们就可以很方便地为印章添加各种额外的处理功能，而无需修改原有的印章结构。

5）策略模式（Strategy Pattern）：

是一种常用的设计模式，它定义了一系列算法，并将每个算法封装成单独的类，使得它们可以相互替换。在 Java 中，可以使用策略模式来实现不同类型的签章。

以下是一个简单的示例代码，演示如何使用策略模式实现单页签章、多页签章和骑缝签章：

// 签章策略接口
public interface SignStrategy {
    void sign();
}

// 单页签章策略类
public class SinglePageSignStrategy implements SignStrategy {

    @Override
    public void sign() {
        System.out.println("单页签章");
    }
}

// 多页签章策略类
public class MultiPageSignStrategy implements SignStrategy {

    @Override
    public void sign() {
        System.out.println("多页签章");
    }
}

// 骑缝签章策略类
public class SaddleStitchSignStrategy implements SignStrategy {

    @Override
    public void sign() {
        System.out.println("骑缝签章");
    }
}

// 签章上下文类
public class SignContext {

    private SignStrategy strategy;

    public SignContext(SignStrategy strategy) {
        this.strategy = strategy;
    }

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

    public void sign() {
        strategy.sign();
    }
}

// 客户端代码示例
//当然在springmvc下通过注解来实现单页、多页、骑缝章之间的切换
public class Client {
    public static void main(String[] args) {
        // 创建签章上下文对象并设置策略为单页签章
        SignContext context = new SignContext(new SinglePageSignStrategy());

        // 绘制签章
        context.sign();

        // 切换策略为多页签章
        context.setStrategy(new MultiPageSignStrategy());

        // 绘制签章
        context.sign();

        // 切换策略为骑缝签章
        context.setStrategy(new SaddleStitchSignStrategy());

        // 绘制签章
        context.sign();
    }
}

在上面的示例中，我们定义了一个SignStrategy接口，并实现了三个不同类型的签章策略类：单页签章、多页签章和骑缝签章。然后，我们使用签章上下文类SignContext来维护当前的签章策略，并在调用sign()方法时根据当前策略签章。

6）享元模式：

对于签章中可能会出现重复的元素（例如相同字体、相同颜色等），可以使用享元模式来共享这些元素，从而减少内存占用和提高性能。

以下是一个简单的 Java 代码示例，演示如何使用享元模式来共享相同的字体对象：

import java.util.HashMap;
import java.util.Map;

public class Font {
    private final String name;
    private final int size;

    public Font(String name, int size) {
        this.name = name;
        this.size = size;
    }

    public String getName() {
        return name;
    }

    public int getSize() {
        return size;
    }
}

public class FontFactory {
    private static Map<String, Font> fonts = new HashMap<>();

    public static Font getFont(String name, int size) {
        String key = name + "_" + size;
        Font font = fonts.get(key);
        if (font == null) {
            font = new Font(name, size);
            fonts.put(key, font);
        }
        return font;
    }
}

public class Text {
    private final String content;
    private final Font font;

    public Text(String content, Font font) {
        this.content = content;
        this.font = font;
    }

    public String getContent() {
        return content;
    }

    public Font getFont() {
        return font;
    }
}

public class Document {
    private final List<Text> texts = new ArrayList<>();

    public void addText(String content, String fontName, int fontSize) {
        Font font = FontFactory.getFont(fontName, fontSize);
        Text text = new Text(content, font);
        texts.add(text);
    }
}

在这个示例中，Font 和 Text 类分别表示字体和文本。FontFactory 类是享元工厂，用于存储和共享字体对象。Document 类包含多个 Text 对象，并使用 FontFactory 来获取共享的字体对象。

当创建新的 Text 对象时，它会使用 FontFactory 来获取具有相同字体名称和大小的现有 Font 对象（如果存在），或者创建一个新的 Font 对象并添加到享元池中。这样可以避免创建大量相同的 Font 对象，从而减少内存占用和提高性能。

============================================

如果文章对你有帮助，不要忘记加个关注、点个赞！！