Spring设计模式：不常用设计模式

Spring设计模式：不常用设计模式

引言

Spring 框架不仅广泛使用了经典设计模式，还应用了一些较少被提及的设计模式。

这些模式在 Spring 内部同样发挥着重要作用。

通过理解这些设计模式在 Spring 中的应用，开发者可以更深入地掌握 Spring 框架的设计哲学和实现细节。

不常用设计模式

组合模式（Composite Pattern）

• 应用场景：处理树形结构的数据，如 Spring MVC 的HandlerMapping结构。
• 示例：

// 组合模式示例：处理树形结构的HandlerMapping
public interface HandlerMapping {
    void handleRequest();
}

public class CompositeHandlerMapping implements HandlerMapping {
    private List<HandlerMapping> handlers = new ArrayList<>();

    public void addHandler(HandlerMapping handler) {
        handlers.add(handler);
    }

    @Override
    public void handleRequest() {
        for (HandlerMapping handler : handlers) {
            handler.handleRequest();
        }
    }
}

桥接模式（Bridge Pattern）

• 应用场景：Spring的JDBC抽象（如JdbcTemplate）。
• 示例：

// 桥接模式示例：JDBC抽象
public interface DataSource {
    Connection getConnection();
}

public class JdbcTemplate {
    private DataSource dataSource;

    public JdbcTemplate(DataSource dataSource) {
        this.dataSource = dataSource;
    }

    public void executeQuery(String sql) {
        Connection connection = dataSource.getConnection();
        // 执行查询逻辑
    }
}

责任链模式（Chain of Responsibility Pattern）

• 应用场景：Spring Security框架中的过滤器链（Filter Chain）。

• 示例：

// 责任链模式示例：过滤器链
public interface Filter {
    void doFilter(Request request, Response response, FilterChain chain);
}

public class FilterChain {
    private List<Filter> filters = new ArrayList<>();
    private int index = 0;

    public void addFilter(Filter filter) {
        filters.add(filter);
    }

    public void doFilter(Request request, Response response) {
        if (index < filters.size()) {
            Filter filter = filters.get(index++);
            filter.doFilter(request, response, this);
        }
    }
}

备忘录模式（Memento Pattern）

• 应用场景：事务管理的回滚点设置。
• 示例：

// 备忘录模式示例：事务回滚
public class Transaction {
    private String state;

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

    public Memento saveState() {
        return new Memento(state);
    }

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

public class Memento {
    private String state;

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

    public String getState() {
        return state;
    }
}

命令模式（Command Pattern）

• 应用场景：Spring的AOP支持。
• 示例：

// 命令模式示例：AOP拦截器
public interface Command {
    void execute();
}

public class LoggingInterceptor implements Command {
    @Override
    public void execute() {
        System.out.println("Logging before method execution");
    }
}

public class TransactionInterceptor implements Command {
    @Override
    public void execute() {
        System.out.println("Starting transaction");
    }
}

迭代器模式（Iterator Pattern）

• 应用场景：遍历BeanDefinition列表。
• 示例：

// 迭代器模式示例：遍历BeanDefinition
public interface Iterator<T> {
    boolean hasNext();
    T next();
}

public class BeanDefinitionIterator implements Iterator<BeanDefinition> {
    private List<BeanDefinition> beanDefinitions;
    private int position = 0;

    public BeanDefinitionIterator(List<BeanDefinition> beanDefinitions) {
        this.beanDefinitions = beanDefinitions;
    }

    @Override
    public boolean hasNext() {
        return position < beanDefinitions.size();
    }

    @Override
    public BeanDefinition next() {
        return beanDefinitions.get(position++);
    }

}

结论

Spring 框架通过综合运用多种设计模式，实现了灵活性、扩展性和可维护性，满足了现代企业级应用开发的多样需求。

开发者应深入理解这些设计模式在 Spring 中的应用，以更好地掌握 Spring 框架的设计哲学和实现细节。

– 欢迎点赞、关注、转发、收藏【我码玄黄】，各大平台同名。