文章详情

登录

短信预约-IT技能 免费直播动态提醒

选择考试省份

  • 北京
  • 上海
  • 天津
  • 重庆
  • 河北
  • 山东
  • 辽宁
  • 黑龙江
  • 吉林
  • 甘肃
  • 青海
  • 河南
  • 江苏
  • 湖北
  • 湖南
  • 江西
  • 浙江
  • 广东
  • 云南
  • 福建
  • 海南
  • 山西
  • 四川
  • 陕西
  • 贵州
  • 安徽
  • 广西
  • 内蒙
  • 西藏
  • 新疆
  • 宁夏
  • 兵团

请输入下面的图形验证码

提交验证

短信预约提醒成功

趣谈设计模式，你学会了吗？

2024-11-30 00:50

关注

文章提纲

图片

设计理念

最为Java开发者，程序员基本修养名言绝句：

我们简单归纳为2个核心词：高内聚、低耦合。

很小的时候看过动画片，封神演义中哪吒：三头八臂显威力，千征百战斗魔法。（串台了。。。）

图片

我们根据这首歌词抽象一下，哪吒：三头八臂是静态特征，千征百战是动态技能。把这些特征归纳映射一下：类 = 属性 + 方法如下图：

图片

以上是高内聚的概念，什么是低耦合？

如果可能，我写一本神话《封神演戏》，说哪吒有：三头九臂。你肯定和我吵吵，要给它再配一把兵器。虽然还没想好是啥，但是有个总则：绝对不影响先前这八臂的演技。这就是低耦合！！！所谓程序健壮、拓展性强，也是这个道理。我们真诚地希望：

图片

上述例子不是特别恰当，但是对于设计模式，我们终级的理念是：封装变化的内容，保留不变的宗旨。

设计原则

设计原则可以归纳为2大类：

规定：软件中的对象（类、模块、函数等等）应该对于扩展是开放的，但是对于修改是封闭的。换句话说，一个实体是允许在不改变它的源代码的前提下变更它的行为。

规定：一个类只应该有一个职责，只有一个改变它的原因

Spring中的设计模式

在Spring框架中，各种设计模式被广泛应用以支持其强大的功能和灵活性。下面我将结合Spring的源码，鉴赏下Spring中常见的几种设计模式。

1. 单例模式

Spring框架中的Bean默认就是单例的。Spring IoC容器负责创建对象实例，并确保在整个应用中，针对同一个Bean的ID，只实例化一次对象。DefaultSingletonBeanRegistry类是Spring管理单例Bean的核心类。

// DefaultSingletonBeanRegistry类中的部分源码
public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
    // ...
    private final Map singletonObjects = new ConcurrentHashMap<>(256);
    // ...
    @Override
    public Object getSingleton(String beanName) {
        return getSingleton(beanName, true);
    }
    
    protected Object getSingleton(String beanName, boolean allowEarlyReference) {
        // ... 省略部分代码
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
            synchronized (this.singletonObjects) {
                singletonObject = this.earlySingletonObjects.get(beanName);
                if (singletonObject == null && allowEarlyReference) {
                    ObjectFactory singletonFactory = this.singletonFactories.get(beanName);
                    if (singletonFactory != null) {
                        singletonObject = singletonFactory.getObject();
                        this.earlySingletonObjects.put(beanName, singletonObject);
                        this.singletonFactories.remove(beanName);
                    }
                }
            }
        }
        return (singletonObject != NULL_OBJECT ? singletonObject : null);
    }
    // ...
}

2. 工厂模式

Spring使用工厂模式通过BeanFactory、ApplicationContext等接口创建和管理Bean对象。DefaultListableBeanFactory是Spring中Bean工厂的实现类。

// DefaultListableBeanFactory类中的部分源码
public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
        implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {
    // ...
    @Override
    public  T getBean(String name, Class requiredType) throws BeansException {
        return doGetBean(name, requiredType, null, false);
    }

    @Override
    public  T getBean(Class requiredType) throws BeansException {
        return doGetBean(null, requiredType, null, false);
    }
    
    // ... 省略部分代码
}

3. 代理模式

Spring AOP（面向切面编程）的实现就是基于代理模式。Spring创建目标对象的代理对象，并在代理对象中织入切面逻辑。JdkDynamicAopProxy和CglibAopProxy是Spring AOP中创建代理的两个核心类。

// JdkDynamicAopProxy类中的部分源码
public class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable {
    // ...
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // ... 省略部分代码
        // 获取AdvisedSupport对象，包含了切面等AOP相关信息
        final AdvisedSupport advised = this.advised;
        // ... 省略部分代码
        // 获取拦截器链（切面链）
        List chain = advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
        // ... 省略部分代码
        // 执行链式调用
        return invokeJoinpointUsingReflection(target, method, args, targetClass, chain);
    }
    // ...
}
4. 观察者模式（监听模式）
在Spring中，事件处理机制就是基于观察者模式实现的。当事件发生时，所有注册的观察者都会收到通知并作出响应。ApplicationEventMulticaster接口和SimpleApplicationEventMulticaster类是Spring事件处理机制的核心。
// SimpleApplicationEventMulticaster类中的部分源码
public class SimpleApplicationEventMulticaster extends AbstractApplicationEventMulticaster {
    // ...
    @Override
    public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {
        ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
        for (ApplicationListener listener : getApplicationListeners(event, type)) {```java
            // 调用监听器的方法处理事件
            invokeListener(listener, event);
        }
    }

    private void invokeListener(ApplicationListener listener, ApplicationEvent event) {
        ErrorHandler errorHandler = getErrorHandler();
        if (errorHandler != null) {
            try {
                doInvokeListener(listener, event);
            } catch (Throwable err) {
                errorHandler.handleError(err);
            }
        } else {
            doInvokeListener(listener, event);
        }
    }

    private void doInvokeListener(ApplicationListener listener, ApplicationEvent event) {
        try {
            // 调用监听器的onApplicationEvent方法
            listener.onApplicationEvent(event);
        } catch (ClassCastException ex) {
            // ... 省略部分代码，处理类型不匹配异常
        }
    }
    // ...
}
5. 责任链模式
在Spring中，HandlerInterceptor和HandlerInterceptorAdapter等类在处理请求拦截时，采用的就是责任链模式。一个请求会按照定义的拦截器顺序，逐个被处理，直到找到对应的处理器或者遍历完所有的拦截器。
// HandlerInterceptor接口定义
public interface HandlerInterceptor {
    boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws Exception;

    void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
            ModelAndView modelAndView) throws Exception;

    void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
            throws Exception;
}

// 实现HandlerInterceptor接口的自定义拦截器
public class CustomInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws Exception {
        // 在这里执行前置处理逻辑
        return true; // 返回true表示继续向下执行，返回false表示中断请求
    }

    // ... 其他方法实现
}
6. 模版模式
Spring中的JdbcTemplate、HibernateTemplate等类就是模版模式的典型应用。它们定义了一个操作数据库或Hibernate的骨架方法，允许子类在不改变算法结构的情况下重定义某些步骤的具体内容。
// JdbcTemplate部分源码
public class JdbcTemplate extends JdbcAccessor implements JdbcOperations, BeanFactoryAware {
    // ...
    public  T query(String sql, RowMapper rowMapper) {
        return query(sql, new Object[0], rowMapper);
    }

    public  T query(String sql, Object[] args, RowMapper rowMapper) {
        return query(sql, args, rowMapper, true);
    }

    // ... 省略部分代码，这里是模版方法的实现
    // 真正的SQL执行和结果集处理逻辑在这里，但是允许子类通过RowMapper来定制结果集的处理方式
    // ...
}

// 自定义RowMapper实现
public class CustomRowMapper implements RowMapper {
    @Override
    public MyObject mapRow(ResultSet rs, int rowNum) throws SQLException {
        // 在这里定制如何从ResultSet中映射到MyObject对象
        return new MyObject();
    }
}
这些设计模式在Spring框架中被广泛应用，能够灵活地应对各种复杂场景，提供强大且可扩展的功能。
实战应用
假设有这样一个需求：
  1. 业务登录商城用户鉴权
  2. 购买产品下订单
  3. 校验订单填写是否合法
  4. 记录接口中的参数
  5. 订单确认后给买家发短信通知
根据业务场景，我们大致可拆分为：用户流程、订单流程
用户登录流程
在用户登录流程中，可能用到拦截器做鉴权校验，日志记录接口参数等，使用了一些常见的设计模式。
场景一、用户鉴权校验
责任链模式
拦截器通常按照定义的顺序执行，每个拦截器检查特定的条件或执行特定的任务。
// 拦截器接口
public interface Interceptor {
    boolean intercept(AuthenticationContext context);
}

// 用户校验拦截器
public class UserValidationInterceptor implements Interceptor {
    @Override
    public boolean intercept(AuthenticationContext context) {
        // 用户校验逻辑
        if (isValidUser(context.getUser())) {
            return true;
        }
        return false;
    }

    private boolean isValidUser(User user) {
        // 校验用户是否有效
        return true; // 示例，实际中应有具体校验逻辑
    }
}

// 鉴权校验拦截器
public class AuthorizationInterceptor implements Interceptor {
    @Override
    public boolean intercept(AuthenticationContext context) {
        // 鉴权校验逻辑
        if (isAuthorized(context.getUser(), context.getCredentials())) {
            return true;
        }
        return false;
    }

    private boolean isAuthorized(User user, Credentials credentials) {
        // 校验用户是否有权限
        return true; // 示例，实际中应有具体校验逻辑
    }
}

// 拦截器链
public class InterceptorChain {
    private List interceptors = new ArrayList<>();

    public void addInterceptor(Interceptor interceptor) {
        interceptors.add(interceptor);
    }

    public boolean execute(AuthenticationContext context) {
        for (Interceptor interceptor : interceptors) {
            if (!interceptor.intercept(context)) {
                // 如果拦截器返回false，则中断链的执行
                return false;
            }
        }
        return true;
    }
}
场景二、记录用户登录信息
单例模式
日志记录器通常设计为单例，确保全局只有一个实例。
Logger logger = LoggerFactory.getLoggerFactoryInstance().getLogger();  
logger.log("This is a user log message");
在这行代码中，体现了单例模式的核心思想，确保了无论多少次调用LoggerFactory.getLoggerFactoryInstance()，都只会返回一个LoggerFactory实例。事实上，我们从源码中也可以看到。
订单流程
根据业务场景，核心订单流程如下：
场景三、订单校验
工厂模式
使用工厂模式实现的CheckOrderFactory，它用于创建不同类型的订单校验服务实例。
同时，我们定义一个校验接口ICheckOrderService，并创建了两个实现类:购买数量校验：CountCheckOrder和订单参数校验：ParamCheckOrder。
public interface ICheckOrderService {
    boolean checkOrder(Object order);
    String getErrorMessage();
}
购买数量校验的实现类CountCheckOrder：
public class CountCheckOrder implements ICheckOrderService {
    @Override
    public boolean checkOrder(Object order) {
        // 假设order是一个包含购买数量的对象
        int quantity = ((Order) order).getQuantity();
        return quantity > 0; // 只允许购买数量大于0
    }

    @Override
    public String getErrorMessage() {
        return "购买数量必须大于0。";
    }
}
订单参数校验的实现类ParamCheckOrder：
public class ParamCheckOrder implements ICheckOrderService {
    @Override
    public boolean checkOrder(Object order) {
        // 假设order是一个包含各种订单参数的对象
        // 这里可以添加具体的订单参数校验逻辑
        return true; // 示例代码，默认返回true
    }

    @Override
    public String getErrorMessage() {
        return "订单参数校验失败。";
    }
}
工厂类CheckOrderFactory，用于创建不同类型的校验服务实例：
public class CheckOrderFactory {
    public static ICheckOrderService createCheckOrderService(String type) {
        switch (type) {
            case "count":
                return new CountCheckOrder();
            case "param":
                return new ParamCheckOrder();
            default:
                throw new IllegalArgumentException("不支持的校验类型: " + type);
        }
    }
}
使用工厂模式有利于业务类的实现和拓展，但是有时候也存在过度设计，导致写了很多的业务类。
场景四、短信通知
观察者模式（监听模式）
在Spring框架中，我们可以使用ApplicationEvent和ApplicationListener来实现事件发布和监听的功能。
假设我们要下发一个购买成功的短信提醒，那么就可以发布一个自定义的PurchaseSuccessEvent事件。
import org.springframework.context.ApplicationEvent;

public class PurchaseSuccessEvent extends ApplicationEvent {
    private final String buyerPhoneNumber;
    private final String orderId;

    public PurchaseSuccessEvent(Object source, String buyerPhoneNumber, String orderId) {
        super(source);
        this.buyerPhoneNumber = buyerPhoneNumber;
        this.orderId = orderId;
    }

    public String getBuyerPhoneNumber() {
        return buyerPhoneNumber;
    }

    public String getOrderId() {
        return orderId;
    }
}
接着定义一个SmsNotificationListener类，它实现了ApplicationListener接口，用于监听PurchaseSuccessEvent事件：
import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;

@Component
public class SmsNotificationListener implements ApplicationListener {
    
    @Override
    public void onApplicationEvent(PurchaseSuccessEvent event) {
        String message = "亲爱的买家，您的订单 " + event.getOrderId() + " 购买成功！";
        sendSms(event.getBuyerPhoneNumber(), message);
    }

    private void sendSms(String phoneNumber, String message) {
        // 在这里实现发送短信的逻辑
        System.out.println("Sending SMS to " + phoneNumber + ": " + message);
    }
}
然后，在Spring的配置中启用事件发布功能。配置一个ApplicationEventPublisher的bean：
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.support.GenericApplicationContext;

@Configuration
public class AppConfig {
    
    @Bean
    public ApplicationEventPublisher applicationEventPublisher() {
        return new GenericApplicationContext();
    }
}
最后，在业务逻辑中发布PurchaseSuccessEvent事件。
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.stereotype.Service;

@Service
public class PurchaseService {

    private final ApplicationEventPublisher applicationEventPublisher;

    @Autowired
    public PurchaseService(ApplicationEventPublisher applicationEventPublisher) {
        this.applicationEventPublisher = applicationEventPublisher;
    }

    public void completePurchase(String buyerPhoneNumber, String orderId) {
        // 模拟购买完成的业务逻辑
        // ...

        // 发布购买成功事件
        applicationEventPublisher.publishEvent(new PurchaseSuccessEvent(this, buyerPhoneNumber, orderId));
    }
}
总结
  • 使用设计模式的宗旨：封装变化的部分，维护不变的宗旨
  • 好处：提高代码拓展性，程序更优雅更健壮
  • 对开源框架设计模式的使用，要提高鉴赏能力
  • 考虑可读性，不可为了设计模式而过度设计


来源：码易有道内容投诉
免责声明：
① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的，并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据，供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。 
② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341
软考中级精品资料免费领 
  • 历年真题答案解析
  • 备考技巧名师总结
  • 高频考点精准押题
  • 资料下载
  • 历年真题
  • 2024年上半年信息系统项目管理师第二批次真题及答案解析（完整版）
     难度      813人已做 
     查看 
  • 【考后总结】2024年5月26日信息系统项目管理师第2批次考情分析
     难度      354人已做 
     查看 
  • 【考后总结】2024年5月25日信息系统项目管理师第1批次考情分析
     难度      318人已做 
     查看 
  • 2024年上半年软考高项第一、二批次真题考点汇总（完整版）
     难度      435人已做 
     查看 
  • 2024年上半年系统架构设计师考试综合知识真题
     难度      224人已做 
     查看 
相关文章
发现更多好内容
猜你喜欢
AI推送时光机
趣谈设计模式，你学会了吗？
后端开发设计模式2024-11-30
浅谈DDD，你学会了吗？
后端开发定义DDD2024-11-30
浅谈CRM系统建设，你学会了吗？
后端开发CRM系统2024-12-13
多语言设计，你学会了吗？
后端开发系统设计语言2024-11-29
有趣的 CSS 数学函数，你学会了吗？
后端开发架构函数2024-11-30
浅谈CSS权重计算规则，你学会了吗？
后端开发CSS权重计算2024-11-29
闲谈Java9到Java20，你学会了吗？
后端开发java9java212024-11-30
JAVA设计模式---原型模式你了解吗
后端开发2024-04-02
聊聊Restful设计原则，你学会了吗？
后端开发restfulHTTP2024-11-30
浅谈链路聚合，你学会了吗？
后端开发链路聚合2024-11-30
大模型应用设计与实现指南，你学会了吗？
后端开发应用设计模型2024-11-30
C++设计模式中的桥模式你了解吗
后端开发2024-04-02
JAVA设计模式中的策略模式你了解吗
后端开发2024-04-02
Python设计模式中的状态模式你了解吗
后端开发2024-04-02
如何设计一个排行榜？你学会了吗？
后端开发排行榜MySQL2024-11-30
架构设计的简单原则，你学会了吗？
后端开发架构设计2024-11-29
浅谈前端开发规范，你学会了吗？
后端开发前端开发2024-12-02
Java23种设计模式中的单例模式你了解吗
后端开发2024-04-02
C# 单例模式的多种实现，你学会了吗？
后端开发C#单例2024-11-28
让我们一起学习管道模式，你会了吗?
后端开发管道模式2024-12-03
 位置：首页-资讯-后端开发
 咦！没有更多了？去看看其它编程学习网 内容吧 
首页课程
资料下载问答资讯