经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » Java相关 » 设计模式 » 查看文章
Java面试题：Spring框架除了IOC和AOP，还有哪些好玩的设计模式？
来源：cnblogs　　作者：猫鱼吐泡泡　　时间：2024/5/15 16:52:50　　对本文有异议

Spring是一个基于Java的企业级应用程序开发框架，它使用了多种设计模式来实现其各种特性和功能。本文将介绍一些在Spring中使用的常见设计模式以及相应的代码示例和说明。

单例模式

单例模式是Spring中最常用的设计模式之一。在ApplicationContext中，Bean默认为单例模式。当我们创建一个Bean时，默认情况下它就是单例的。这意味着当Bean被请求时，Spring会返回相同的实例。下面是一个示例代码：

  1. public class MyBean {
  2.     // ...
  3. }
  4.  
  5. @Configuration
  6. public class AppConfig {
  7.  
  8.     @Bean
  9.     public MyBean myBean() {
  10.         return new MyBean();
  11.     }
  12.  
  13. }

在上面的代码中，myBean()方法返回了MyBean类的实例，这个实例将作为单例对象存在于ApplicationContext中。

 

在Spring AOP中，切面默认为单例模式。这意味着切面对象只会创建一次，并与所有目标对象共享。下面的代码演示了如何在Spring AOP中配置一个单例切面：

  1. @Aspect
  2. @Component
  3. public class LoggingAspect {
  4.  
  5.     @Before("execution(* com.example.service.*.*(..))")
  6.     public void logBefore(JoinPoint joinPoint) {
  7.         // ...
  8.     }
  9.  
  10. }

这里，LoggingAspect类用@Aspect注解进行了标注，它包含了@Before通知，该通知将在com.example.service包中的所有方法执行前执行。由于LoggingAspect是一个@Component，所以它将被Spring自动扫描并创建一个单例实例。

在Spring MVC中，控制器（Controller）也通常是单例的。下面是一个简单的控制器类示例：

  1. @Controller
  2. public class UserController {
  3.     @Autowired
  4.     private UserService userService;
  5.  
  6.     @GetMapping("/users/{id}")
  7.     public ResponseEntity<User> getUserById(@PathVariable Long id) {
  8.         User user = userService.getUserById(id);
  9.         return ResponseEntity.ok(user);
  10.     }
  11.  
  12. }

 

工厂模式

在Spring框架中工厂模式是一种常用的模式之一。下面我将介绍Spring中使用工厂模式的几个具体示例：

BeanFactory

Spring 的核心容器是BeanFactory和其子接口ApplicationContext。其中，BeanFactory使用了工厂模式来创建和管理bean实例。它包含了创建、配置和管理 bean 的所有功能，如下所示：

  1. public interface BeanFactory {
  2.     Object getBean(String name) throws BeansException;
  3.  
  4.     <T> T getBean(String name, Class<T> requiredType) throws BeansException;
  5.  
  6.     boolean containsBean(String name);
  7. }

上述代码中，BeanFactory接口定义了一个getBean()方法，通过传入bean的名称或类型，返回相应的bean实例。这里的getBean()方法就是工厂方法。

 

FactoryBean

FactoryBean 是 Spring 中另一个使用工厂模式的类。它用于创建复杂的 bean，这些 bean 可以有自己的生命周期、作用域和依赖项等。

  1. public interface FactoryBean<T> {
  2.  
  3.     T getObject() throws Exception;
  4.  
  5.     Class<?> getObjectType();
  6.  
  7.     boolean isSingleton();
  8. }

述代码中，FactoryBean 定义了一个getObject()方法，用于创建并返回一个特定类型的bean。该方法会在应用程序需要访问bean时被调用。

 

MessageSource

Spring 的国际化支持是基于MessageSource接口实现的。MessageSource为应用程序提供了访问消息资源的方法，如下所示：

  1. public interface MessageSource {
  2.     String getMessage(String code, Object[] args, String defaultMessage, Locale locale);
  3. }

上述代码中，getMessage()方法使用工厂模式创建和管理消息资源。它接收消息代码、参数、默认消息和语言环境等参数，并返回相应的消息字符串。

 

代理模式

在Spring AOP中，代理模式被广泛应用。Spring使用JDK动态代理和CGLIB代理来创建切面。下面是一个简单的使用注解方式配置切面的示例：

  1. @Aspect
  2. @Component
  3. public class LoggingAspect {
  4.  
  5.     @Before("execution(public * com.example.service.*.*(..))")
  6.     public void logBefore(JoinPoint joinPoint) {
  7.         // ...
  8.     }
  9.  
  10. }

在上面的代码中，LoggingAspect类使用了@Aspect和@Component注解进行标注，表明它是一个切面，并会被Spring自动扫描并创建代理对象。在@Before通知中，执行方法调用前进行日志记录。

 

在Spring事务管理中，代理模式也被广泛使用。Spring使用动态代理技术来实现声明式事务管理。下面是一个使用@Transactional注解来声明事务的示例：

  1. @Service
  2. public class UserServiceImpl implements UserService {
  3.     @Autowired
  4.     private UserRepository userRepository;
  5.  
  6.     @Override
  7.     @Transactional
  8.     public User createUser(User user) {
  9.         return userRepository.save(user);
  10.     }
  11.  
  12. }

在上面的代码中，createUser()方法使用@Transactional注解标记，Spring将在该方法调用之前创建一个代理对象。当然，这只是一个简单的示例，实际上，在复杂的应用程序中，Spring可以再通过多种方式来声明式事务。

 

对于Spring MVC中的控制器类，我们也可以使用代理模式来增强其功能，例如在控制器方法之前和之后添加日志记录。下面是一个基于注解方式实现AOP拦截器的示例：

  1. @Aspect
  2. @Component
  3. public class LoggingInterceptor {
  4.  
  5.     @Before("execution(* com.example.controller.*.*(..))")
  6.     public void logBefore(JoinPoint joinPoint) {
  7.         // ...
  8.     }
  9.  
  10.     @AfterReturning(value = "execution(* com.example.controller.*.*(..))", returning = "result")
  11.     public void logAfterReturning(JoinPoint joinPoint, Object result) {
  12.         // ...
  13.     }
  14.  
  15. }

在上面的代码中，LoggingInterceptor类使用了@Aspect和@Component注解进行标注，表明它是一个切面，并且会被Spring自动扫描并创建代理对象。在@Before通知中，执行方法调用前进行日志记录，在@AfterReturning通知中，执行方法调用后进行日志记录。

 

观察者模式

Spring中的事件机制也是基于观察者模式实现的。在Spring中，所有的Bean都可以作为事件源发布事件，其他的Bean则可以通过注册监听器来响应这些事件。

ApplicationEventPublisher

ApplicationEventPublisher是Spring 框架中使用观察者模式的一个类。它负责发布事件并通知已注册的监听器。以下是ApplicationEventPublisher的代码示例：

  1. public interface ApplicationEventPublisher {
  2.     void publishEvent(ApplicationEvent event);
  3. }

上述代码中，publishEvent()方法用于发布一个事件，并通知已注册的所有监听器。具体的监听器实现可以通过实现ApplicationListener接口来完成。

 

ApplicationContext 

ApplicationContext是Spring的核心接口之一。它扩展了BeanFactory接口，并在其基础上添加了更多的功能，例如事件发布和提供环境信息等。以下是 ApplicationContext使用观察者模式的代码示例：

  1. public interface ApplicationContext extends EnvironmentCapable, ListableBeanFactory, HierarchicalBeanFactory,
  2.         MessageSource, ApplicationEventPublisher, ResourcePatternResolver {
  3.  
  4.     void publishEvent(ApplicationEvent event);
  5.  
  6.     String[] getBeanNamesForType(ResolvableType type);
  7.  
  8.     <T> Map<String, T> getBeansOfType(Class<T> type) throws BeansException;
  9. }

上述代码中，publishEvent()方法也用于发布事件，并通知已注册的所有监听器。与 ApplicationEventPublisher不同的是，ApplicationContext继承了多个接口，这使得它可以处理各种类型的事件。

 

BeanPostProcessor 

BeanPostProcessor是Spring框架中一个可插入的回调接口，用于在bean实例化和配置的过程中提供扩展点。以下是BeanPostProcessor使用观察者模式的代码示例：

  1. public interface BeanPostProcessor {
  2.     Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;
  3.     Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;
  4. }

postProcessBeforeInitialization()和postProcessAfterInitialization()方法分别在bean实例化和初始化之前/之后被调用。可以将这些方法视为钩子函数，可以在其中添加自定义逻辑以修改或扩展bean的默认行为。

 

责任链模式 

责任链模式是一种行为型设计模式，它允许你将请求沿着处理链传递，直到其中一个处理程序处理该请求。

HandlerInterceptor 

HandlerInterceptor是Spring MVC中使用责任链模式的一个类。它提供了多个方法，例如 preHandle()、postHandle()和afterCompletion()等，可以在请求处理过程中拦截并修改请求和响应。以下是HandlerInterceptor的代码示例：

  1. public interface HandlerInterceptor {
  2.  
  3.     boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception;
  4.  
  5.     void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
  6.                     @Nullable ModelAndView modelAndView) throws Exception;
  7.  
  8.     void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler,
  9.                          @Nullable Exception ex) throws Exception;
  10. }

上述代码中，HandlerInterceptor提供了三个方法，分别在请求处理前、处理后、以及完成后调用。通过实现这些方法，在请求处理过程中可以执行自定义逻辑，例如验证用户身份、记录日志等。

 

AbstractRequestLoggingFilter

AbstractRequestLoggingFilter是Spring中使用责任链模式的另一个类。它提供了预先和后续处理请求和响应的方法，可以进行访问日志记录。

以下是 AbstractRequestLoggingFilter的代码示例：

  1. public abstract class AbstractRequestLoggingFilter extends OncePerRequestFilter {
  2.  
  3.     protected void beforeRequest(HttpServletRequest request, String message) {}
  4.  
  5.     protected void afterRequest(HttpServletRequest request, String message) {}
  6. }

上述代码中，AbstractRequestLoggingFilter的beforeRequest()和afterRequest()方法分别在请求处理前和处理后调用。通过实现这些方法，可以记录访问日志，包括请求的地址、参数等信息。

 

HandlerExceptionResolver

HandlerExceptionResolver是Spring MVC中使用责任链模式的另一个类。它提供了多个方法，例如resolveException()和shouldHandle()等，可以处理异常并决定是否继续执行下一个处理器。以下是HandlerExceptionResolver的代码示例：

  1. public interface HandlerExceptionResolver {
  2.  
  3.     @Nullable
  4.     ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, @Nullable Object handler,
  5.             Exception ex);
  6.  
  7.     boolean shouldHandle(HttpServletRequest request, @Nullable Exception ex);
  8. }

上述代码中，HandlerExceptionResolver的resolveException()方法用于处理异常并返回ModelAndView对象，该对象可以包含自定义的错误页面或其他错误信息。而 shouldHandle()方法则用于判断是否应该由当前处理器处理异常，如果返回false，则会继续执行下一个处理器。

 

模板方法模式 

模板方法模式是一种行为型设计模式，它定义了一个算法的骨架，并允许子类实现算法中的某些步骤。在Spring框架中，JdbcTemplate和HibernateTemplate就是使用了模板方法模式的例子。

JdbcTemplate 

JdbcTemplate是Spring中使用模板方法模式的一个类。它提供了多个方法，例如 update()、query()等，可以执行SQL语句并返回结果。以下是JdbcTemplate的代码示例：

  1. public class JdbcTemplate {
  2.  
  3.     public <T> T execute(ConnectionCallback<T> action) throws DataAccessException {
  4.         // ...
  5.     }
  6.  
  7.     // ...
  8.  
  9.     public int update(String sql, Object... args) throws DataAccessException {
  10.         // ...
  11.     }
  12.  
  13.     public <T> List<T> query(String sql, Object[] args, RowMapper<T> rowMapper) throws DataAccessException {
  14.         // ...
  15.     }
  16.  
  17.     // ...
  18. }

上述代码中，JdbcTemplate 提供了execute()、update()和query()等方法，它们都使用了模板方法模式。其中，execute()方法是一个模板方法，它接受一个 ConnectionCallback对象并执行其中的doInConnection()方法，该方法由子类实现。而 update()和 query()方法也是模板方法，它们都调用了execute()方法，并传入不同的参数。

 

HibernateTemplate 

HibernateTemplate是Spring中使用模板方法模式的另一个类。它提供了多个方法，例如 save()、delete()等，可以操作Hibernate实体并返回结果。以下是HibernateTemplate 的代码示例：

  1. public class HibernateTemplate extends HibernateAccessor {
  2.  
  3.     public Object execute(HibernateCallback<?> action) throws DataAccessException {
  4.         // ...
  5.     }
  6.  
  7.     // ...
  8.  
  9.     public void save(Object entity) throws DataAccessException {
  10.         // ...
  11.     }
  12.  
  13.     public void delete(Object entity) throws DataAccessException {
  14.         // ...
  15.     }
  16.  
  17.     // ...
  18. }

上述代码中，HibernateTemplate提供了 execute()、save()和 delete()等方法，它们也都使用了模板方法模式。其中，execute()方法是一个模板方法，它接受一个 HibernateCallback对象并执行其中的doInHibernate()方法，该方法由子类实现。而 save()和delete()方法也是模板方法，它们都调用了execute()方法，并传入不同的参数。

 

策略模式

在Spring框架中，策略模式被广泛应用于各种场景，例如事务管理、缓存管理等。以下是 Spring中使用策略模式的几个具体示例：

事务管理 

Spring提供了多种事务管理方式，其中之一就是基于策略模式实现的。该模式下，开发人员需要将不同的事务属性（如传播行为、隔离级别等）封装到TransactionDefinition 接口的实现类中，并将其作为参数传递给PlatformTransactionManager的方法。以下是一个示例代码：

  1. public class TransactionalTest {
  2.  
  3.     private PlatformTransactionManager transactionManager;
  4.  
  5.     public void setTransactionManager(PlatformTransactionManager transactionManager) {
  6.         this.transactionManager = transactionManager;
  7.     }
  8.  
  9.     public void doTransactional() {
  10.         DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
  11.         definition.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
  12.         definition.setIsolationLevel(TransactionDefinition.ISOLATION_READ_COMMITTED);
  13.  
  14.         TransactionStatus status = transactionManager.getTransaction(definition);
  15.  
  16.         try {
  17.             // 执行事务操作
  18.             transactionManager.commit(status);
  19.         } catch (Exception e) {
  20.             transactionManager.rollback(status);
  21.         }
  22.     }
  23. }

上述代码中，TransactionalTest类使用了策略模式来管理事务。它将 DefaultTransactionDefinition对象作为参数传递给PlatformTransactionManager的方法，并在try-catch块中执行事务操作。

 

缓存管理 

Spring 提供了多种缓存管理方式，其中之一就是基于策略模式实现的。该模式下，开发人员需要将不同的缓存属性（如缓存类型、缓存超时时间等）封装到CacheManager和Cache 接口的实现类中，并将其作为参数传递给CacheResolver和Cache的方法。以下是一个示例代码：

  1. public class CacheTest {
  2.  
  3.     private CacheResolver cacheResolver;
  4.  
  5.     public void setCacheResolver(CacheResolver cacheResolver) {
  6.         this.cacheResolver = cacheResolver;
  7.     }
  8.  
  9.     public void doCached() {
  10.         Cache cache = cacheResolver.resolveCache("myCache");
  11.  
  12.         Object value = cache.get("myKey");
  13.         if (value == null) {
  14.             // 从数据库或其他存储介质中获取数据
  15.             value = "myValue";
  16.  
  17.             cache.put("myKey", value);
  18.         }
  19.     }
  20. }

上述代码中，CacheTest类使用了策略模式来管理缓存。它将CacheResolver对象作为参数传递给resolveCache()方法，并根据缓存的键值对判断是否需要从缓存中获取数据。

 

往期面试题：

Java面试题：如果你这样做，你会后悔的，两次启动同一个线程~~~

Java面试题：@PostConstruct、init-method和afterPropertiesSet执行顺序？

Java面试题：SimpleDateFormat是线程安全的吗？使用时应该注意什么？

Java面试题：细数ThreadLocal大坑，内存泄露本可避免

Java面试题：请谈谈对ThreadLocal的理解？

Java面试题：为什么HashMap不建议使用对象作为Key?

Java面试题：你知道Spring的IOC吗？那么，它为什么这么重要呢？

Java面试题：线程池内“闹情绪”的线程，怎么办？

Java面试题：Spring Bean线程安全？别担心，只要你不写并发代码就好了！

 

原文链接：https://www.cnblogs.com/marsitman/p/18191973

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

设计模式热门文章

  • java设计模式-装饰者模式详解
  • 设计模式之迭代器与组合模式（四）
  • asp.net Core 中AuthorizationHandler 实现自定义授权
  • 高校宿舍管理系统详细需求分析说明书
  • 依赖注入与控制反转
  • 设计模式-工厂方法模式 实战演习 代码实现 - Code-CHAN
  • 报刊订阅管理系统的设计与实现
  • 深入浅出设计模式 PDF下载高清完整扫描原版
  • TypeScript实现设计模式——生成器模式
  • 小账本软件设计之数据库设计模式构建

    • 设计模式推荐文章

  • 设计模式：代理模式详解
  • 设计模式之工厂模式（学习笔记）
  • Java设计模式总结
  • Java面试题：Spring框架除了IOC和AOP，还有哪些好玩的设计模式？
  • 什么是设计模式？
  • 设计模式学习（一）单例模式的几种实现方式
  • 我们在SqlSugar开发框架中，用到的一些设计模式
  • 3分钟看懂设计模式01：策略模式
  • 设计模式浅析(三) &#183;装饰者模式
  • GOF23--23种设计模式（一）

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号