网站开发上线ftp怎么用,网站建设年费,图门市建设局网站,关于建设网站的书本#x1f3af; 设计模式实战指南#xff1a;从源码解析到Java后端架构的艺术
概述
本文档基于设计模式分类#xff0c;详细介绍Java后端开发中各种设计模式的实际应用场景#xff0c;结合Spring、MyBatis、Redis等主流框架的源码分析#xff0c;帮助开发者深入理解设计模… 设计模式实战指南从源码解析到Java后端架构的艺术
概述
本文档基于设计模式分类详细介绍Java后端开发中各种设计模式的实际应用场景结合Spring、MyBatis、Redis等主流框架的源码分析帮助开发者深入理解设计模式在实践中的价值。
一、创建型模式
1. 单例模式Singleton Pattern
应用场景
数据库连接池缓存管理器配置管理器日志记录器
Spring框架中的应用
Spring IoC容器本身就是单例模式的典型应用
// Spring ApplicationContext 单例实现
public class AnnotationConfigApplicationContext extends GenericApplicationContext {private final AnnotatedBeanDefinitionReader reader;private final ClassPathBeanDefinitionScanner scanner;public AnnotationConfigApplicationContext() {this.reader new AnnotatedBeanDefinitionReader(this);this.scanner new ClassPathBeanDefinitionScanner(this);}
}Spring Bean的默认作用域就是单例
// Spring BeanFactory 中的单例管理
public class DefaultSingletonBeanRegistry extends FactoryBeanRegistrySupport {// 单例对象缓存private final MapString, Object singletonObjects new ConcurrentHashMap(256);protected Object getSingleton(String beanName, boolean allowEarlyReference) {Object singletonObject this.singletonObjects.get(beanName);if (singletonObject null isSingletonCurrentlyInCreation(beanName)) {// 单例创建逻辑}return singletonObject;}
}Redis客户端单例应用
// JedisPool 单例模式实现
public class RedisManager {private static volatile JedisPool jedisPool;public static JedisPool getInstance() {if (jedisPool null) {synchronized (RedisManager.class) {if (jedisPool null) {JedisPoolConfig config new JedisPoolConfig();config.setMaxTotal(100);config.setMaxIdle(10);jedisPool new JedisPool(config, localhost, 6379);}}}return jedisPool;}
}2. 工厂方法模式Factory Method Pattern
应用场景
数据库连接工厂消息队列工厂缓存工厂序列化器工厂
Spring框架中的应用
BeanFactory - Spring的核心工厂
// Spring BeanFactory 接口
public interface BeanFactory {Object getBean(String name) throws BeansException;T T getBean(String name, ClassT requiredType) throws BeansException;T T getBean(ClassT requiredType) throws BeansException;
}// 具体实现类
public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactoryimplements ConfigurableListableBeanFactory, BeanDefinitionRegistry {Overridepublic T T getBean(ClassT requiredType) throws BeansException {return getBean(requiredType, (Object[]) null);}
}MyBatis中的工厂应用
// MyBatis SqlSessionFactory
public interface SqlSessionFactory {SqlSession openSession();SqlSession openSession(boolean autoCommit);SqlSession openSession(Connection connection);
}// 默认实现
public class DefaultSqlSessionFactory implements SqlSessionFactory {Overridepublic SqlSession openSession() {return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false);}
}3. 抽象工厂模式Abstract Factory Pattern
应用场景
数据库访问层抽象消息中间件抽象缓存系统抽象
Spring JDBC中的应用
// 数据源抽象工厂
public interface DataSource extends CommonDataSource, Wrapper {Connection getConnection() throws SQLException;Connection getConnection(String username, String password) throws SQLException;
}// 具体实现
public class HikariDataSource extends HikariConfig implements DataSource {Overridepublic Connection getConnection() throws SQLException {return getConnection(username, password);}
}4. 建造者模式Builder Pattern
应用场景
复杂对象构建配置对象构建查询条件构建
MyBatis中的应用
// MyBatis SqlSessionFactoryBuilder
public class SqlSessionFactoryBuilder {public SqlSessionFactory build(InputStream inputStream) {return build(inputStream, null, null);}public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {try {XMLConfigBuilder parser new XMLConfigBuilder(inputStream, environment, properties);return build(parser.parse());} catch (Exception e) {throw ExceptionFactory.wrapException(Error building SqlSession., e);}}
}Spring Boot配置构建
// Spring Boot ApplicationBuilder
public class SpringApplicationBuilder {private final SpringApplication application;public SpringApplicationBuilder(Class?... sources) {this.application new SpringApplication(sources);}public SpringApplicationBuilder properties(String... defaultProperties) {this.application.setDefaultProperties(StringUtils.toStringArray(defaultProperties));return this;}
}5. 原型模式Prototype Pattern
应用场景
对象克隆配置复制模板复制
Spring中的应用
// Spring Bean的prototype作用域
public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory {Overridepublic Object getBean(String name) throws BeansException {return doGetBean(name, null, null, false);}protected T T doGetBean(String name, ClassT requiredType, Object[] args, boolean typeCheckOnly) {// 对于prototype作用域的bean每次都创建新实例if (mbd.isPrototype()) {Object prototypeInstance null;try {beforePrototypeCreation(beanName);prototypeInstance createBean(beanName, mbd, args);} finally {afterPrototypeCreation(beanName);}bean getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);}}
}二、结构型模式
1. 适配器模式Adapter Pattern
应用场景
接口适配数据格式转换第三方库集成
Spring MVC中的应用
// HandlerAdapter 适配不同类型的处理器
public interface HandlerAdapter {boolean supports(Object handler);ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception;
}// RequestMappingHandlerAdapter 适配 RequestMapping 注解的处理器
public class RequestMappingHandlerAdapter extends AbstractHandlerMethodAdapter {Overridepublic boolean supports(Object handler) {return handler instanceof HandlerMethod;}Overrideprotected ModelAndView handleInternal(HttpServletRequest request, HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {// 处理逻辑}
}MyBatis中的适配器
// MyBatis TypeHandler 适配器
public interface TypeHandlerT {void setParameter(PreparedStatement ps, int i, T parameter, JdbcType jdbcType) throws SQLException;T getResult(ResultSet rs, String columnName) throws SQLException;T getResult(ResultSet rs, int columnIndex) throws SQLException;T getResult(CallableStatement cs, int columnIndex) throws SQLException;
}// 具体实现
public class StringTypeHandler extends BaseTypeHandlerString {Overridepublic void setNonNullParameter(PreparedStatement ps, int i, String parameter, JdbcType jdbcType) throws SQLException {ps.setString(i, parameter);}Overridepublic String getNullableResult(ResultSet rs, String columnName) throws SQLException {return rs.getString(columnName);}
}2. 桥接模式Bridge Pattern
应用场景
抽象与实现分离多维度变化平台无关性
JDBC桥接模式
// JDBC驱动桥接
public interface Driver {Connection connect(String url, Properties info) throws SQLException;boolean acceptsURL(String url) throws SQLException;
}// MySQL驱动实现
public class Driver implements java.sql.Driver {Overridepublic Connection connect(String url, Properties info) throws SQLException {// MySQL连接实现}
}// PostgreSQL驱动实现
public class Driver implements java.sql.Driver {Overridepublic Connection connect(String url, Properties info) throws SQLException {// PostgreSQL连接实现}
}3. 组合模式Composite Pattern
应用场景
树形结构菜单系统权限管理
Spring Security中的应用
// Spring Security 权限组合
public interface GrantedAuthority extends Serializable {String getAuthority();
}// 角色权限组合
public class SimpleGrantedAuthority implements GrantedAuthority {private final String role;public SimpleGrantedAuthority(String role) {this.role role;}Overridepublic String getAuthority() {return this.role;}
}4. 装饰器模式Decorator Pattern
应用场景
功能增强缓存装饰日志装饰
Spring AOP装饰器
// Spring AOP 代理装饰
public interface AopProxy {Object getProxy();Object getProxy(ClassLoader classLoader);
}// JDK动态代理装饰
public class JdkDynamicAopProxy implements AopProxy, InvocationHandler {Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {// 前置增强// 目标方法调用// 后置增强}
}MyBatis插件装饰器
// MyBatis Interceptor 装饰器
public interface Interceptor {Object intercept(Invocation invocation) throws Throwable;Object plugin(Object target);void setProperties(Properties properties);
}// 分页插件装饰器
public class PageInterceptor implements Interceptor {Overridepublic Object intercept(Invocation invocation) throws Throwable {// 分页逻辑装饰return invocation.proceed();}
}5. 外观模式Facade Pattern
应用场景
复杂子系统封装API简化统一接口
Spring Boot自动配置外观
// Spring Boot 自动配置外观
SpringBootApplication
public class Application {public static void main(String[] args) {SpringApplication.run(Application.class, args);}
}// 内部封装了复杂的配置过程
public class SpringApplication {public static ConfigurableApplicationContext run(Class?[] primarySources, String[] args) {return new SpringApplication(primarySources).run(args);}
}6. 享元模式Flyweight Pattern
应用场景
对象池缓存字符串常量池
数据库连接池
// HikariCP 连接池享元模式
public class HikariDataSource extends HikariConfig implements DataSource {private final HikariPool pool;Overridepublic Connection getConnection() throws SQLException {return pool.getConnection();}
}// 连接池管理
public class HikariPool extends PoolBase {private final ConcurrentBagPoolEntry connectionBag;public Connection getConnection() throws SQLException {PoolEntry poolEntry connectionBag.borrow(connectionTimeout, MILLISECONDS);return poolEntry.createProxyConnection(now(), leakTaskFactory.schedule(poolEntry));}
}7. 代理模式Proxy Pattern
应用场景
远程代理虚拟代理保护代理缓存代理
Spring AOP代理
// Spring AOP 代理实现
public class ProxyFactory extends ProxyCreatorSupport {public Object getProxy() {return createAopProxy().getProxy();}
}// CGLIB代理
public class CglibAopProxy implements AopProxy {Overridepublic Object getProxy() {return getProxy(null);}Overridepublic Object getProxy(ClassLoader classLoader) {// CGLIB代理创建逻辑}
}MyBatis动态代理
// MyBatis Mapper代理
public class MapperProxyT implements InvocationHandler, Serializable {private final SqlSession sqlSession;private final ClassT mapperInterface;Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {// 动态代理逻辑return sqlSession.selectOne(statement, args);}
}三、行为型模式
1. 责任链模式Chain of Responsibility Pattern
应用场景
过滤器链异常处理链权限验证链
Spring Security过滤器链
// Spring Security 过滤器链
public class FilterChainProxy extends GenericFilterBean {private ListSecurityFilterChain filterChains;Overridepublic void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {doFilterInternal(request, response, chain);}private void doFilterInternal(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {// 过滤器链执行逻辑for (Filter filter : filters) {filter.doFilter(request, response, chain);}}
}MyBatis插件链
// MyBatis 插件责任链
public class Plugin implements InvocationHandler {private final Object target;private final Interceptor interceptor;Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {return interceptor.intercept(new Invocation(target, method, args));}
}2. 命令模式Command Pattern
应用场景
操作封装事务管理异步处理
Spring事务命令
// Spring 事务命令模式
public interface TransactionTemplate {T T execute(TransactionCallbackT action) throws TransactionException;
}// 具体实现
public class TransactionTemplate extends DefaultTransactionDefinition implements TransactionOperations {Overridepublic T T execute(TransactionCallbackT action) throws TransactionException {TransactionStatus status this.transactionManager.getTransaction(this);T result;try {result action.doInTransactionWithoutResult(status);} catch (RuntimeException | Error ex) {rollbackOnException(status, ex);throw ex;}this.transactionManager.commit(status);return result;}
}3. 解释器模式Interpreter Pattern
应用场景
表达式解析配置解析查询语言解析
MyBatis SQL解析
// MyBatis SQL解析器
public class SqlSourceBuilder {public SqlSource parse(String originalSql, Class? parameterType, MapString, Object additionalParameters) {ParameterMappingTokenHandler handler new ParameterMappingTokenHandler(configuration, parameterType, additionalParameters);GenericTokenParser parser new GenericTokenParser(#{, }, handler);String sql parser.parse(originalSql);return new StaticSqlSource(configuration, sql, handler.getParameterMappings());}
}4. 迭代器模式Iterator Pattern
应用场景
集合遍历分页查询流式处理
Spring Data分页迭代
// Spring Data 分页迭代器
public interface PageT extends SliceT {int getTotalPages();long getTotalElements();ListT getContent();
}// 具体实现
public class PageImplT implements PageT {private final ListT content;private final Pageable pageable;private final long total;Overridepublic IteratorT iterator() {return content.iterator();}
}5. 中介者模式Mediator Pattern
应用场景
组件通信事件处理协调管理
Spring事件机制
// Spring 事件中介者
public interface ApplicationEventPublisher {void publishEvent(ApplicationEvent event);void publishEvent(Object event);
}// 具体实现
public class SimpleApplicationEventMulticaster extends AbstractApplicationEventMulticaster {Overridepublic void multicastEvent(ApplicationEvent event) {multicastEvent(event, resolveDefaultEventType(event));}Overridepublic void multicastEvent(final ApplicationEvent event, ResolvableType type) {// 事件分发逻辑for (ApplicationListener? listener : getApplicationListeners(event, type)) {invokeListener(listener, event);}}
}6. 备忘录模式Memento Pattern
应用场景
状态保存事务回滚撤销操作
Spring事务状态管理
// Spring 事务状态备忘录
public interface TransactionStatus extends SavepointManager, Flushable {boolean isNewTransaction();boolean hasTransaction();boolean isRollbackOnly();boolean isCompleted();
}// 具体实现
public class DefaultTransactionStatus extends AbstractTransactionStatus {private final Object transaction;private final boolean newTransaction;private boolean rollbackOnly;private boolean completed;
}7. 观察者模式Observer Pattern
应用场景
事件通知状态同步日志记录
Spring事件机制
// Spring 观察者模式
public interface ApplicationListenerE extends ApplicationEvent extends EventListener {void onApplicationEvent(E event);
}// 具体实现
Component
public class UserEventListener implements ApplicationListenerUserCreatedEvent {Overridepublic void onApplicationEvent(UserCreatedEvent event) {// 处理用户创建事件System.out.println(User created: event.getUser());}
}8. 状态模式State Pattern
应用场景
状态机工作流订单状态
Spring状态机
// Spring Statemachine 状态模式
public interface StateMachineS, E {StateS, E getState();void sendEvent(E event);void start();void stop();
}// 具体实现
Configuration
EnableStateMachine
public class OrderStateMachineConfig extends StateMachineConfigurerAdapterOrderState, OrderEvent {Overridepublic void configure(StateMachineStateConfigurerOrderState, OrderEvent states) throws Exception {states.withStates().initial(OrderState.CREATED).state(OrderState.PAID).state(OrderState.SHIPPED).end(OrderState.DELIVERED);}
}9. 策略模式Strategy Pattern
应用场景
算法选择支付方式缓存策略
Spring缓存策略
// Spring 缓存策略
public interface CacheManager {Cache getCache(String name);CollectionString getCacheNames();
}// Redis缓存策略
public class RedisCacheManager implements CacheManager {Overridepublic Cache getCache(String name) {return new RedisCache(name, redisTemplate);}
}// EhCache缓存策略
public class EhCacheCacheManager implements CacheManager {Overridepublic Cache getCache(String name) {return new EhCacheCache(name, ehcache);}
}10. 模板方法模式Template Method Pattern
应用场景
算法框架流程控制代码复用
Spring JdbcTemplate
// Spring JdbcTemplate 模板方法
public class JdbcTemplate extends JdbcAccessor implements JdbcOperations {Overridepublic T T queryForObject(String sql, ClassT requiredType, Object... args) throws DataAccessException {return queryForObject(sql, args, requiredType);}Overridepublic T T queryForObject(String sql, Object[] args, ClassT requiredType) throws DataAccessException {ListT results queryForList(sql, args, requiredType);return DataAccessUtils.singleResult(results);}// 模板方法子类可以重写protected T ListT queryForList(String sql, Object[] args, ClassT elementType) throws DataAccessException {return query(sql, args, getSingleColumnRowMapper(elementType));}
}11. 访问者模式Visitor Pattern
应用场景
数据结构操作编译优化代码生成
Spring Bean访问者
// Spring Bean访问者
public interface BeanDefinitionVisitor {void visitBeanDefinition(BeanDefinition beanDefinition);
}// 具体实现
public class BeanDefinitionVisitorImpl implements BeanDefinitionVisitor {Overridepublic void visitBeanDefinition(BeanDefinition beanDefinition) {// 访问Bean定义String beanClassName beanDefinition.getBeanClassName();// 处理逻辑}
}四、设计原则在Java后端开发中的应用
1. 单一职责原则SRP
// 好的设计职责分离
Service
public class UserService {public User createUser(UserDTO userDTO) {// 只负责用户创建逻辑}
}Service
public class EmailService {public void sendWelcomeEmail(User user) {// 只负责邮件发送逻辑}
}2. 开闭原则OCP
// 通过接口扩展对修改关闭
public interface PaymentStrategy {void pay(BigDecimal amount);
}Component
public class AlipayStrategy implements PaymentStrategy {Overridepublic void pay(BigDecimal amount) {// 支付宝支付逻辑}
}Component
public class WechatPayStrategy implements PaymentStrategy {Overridepublic void pay(BigDecimal amount) {// 微信支付逻辑}
}3. 里氏替换原则LSP
// 子类可以替换父类
public interface Cache {void put(String key, Object value);Object get(String key);
}public class RedisCache implements Cache {Overridepublic void put(String key, Object value) {// Redis实现}Overridepublic Object get(String key) {// Redis实现}
}public class EhCache implements Cache {Overridepublic void put(String key, Object value) {// EhCache实现}Overridepublic Object get(String key) {// EhCache实现}
}4. 接口隔离原则ISP
// 接口分离避免胖接口
public interface UserReader {User findById(Long id);ListUser findAll();
}public interface UserWriter {User save(User user);void delete(Long id);
}public interface UserService extends UserReader, UserWriter {// 组合多个小接口
}5. 依赖倒置原则DIP
// 依赖抽象而不是具体实现
Service
public class OrderService {private final PaymentStrategy paymentStrategy;public OrderService(PaymentStrategy paymentStrategy) {this.paymentStrategy paymentStrategy;}public void processOrder(Order order) {paymentStrategy.pay(order.getAmount());}
}6. 迪米特法则LoD
// 减少对象间的耦合
Service
public class OrderService {private final UserService userService;public void createOrder(OrderDTO orderDTO) {// 不直接访问User的内部属性User user userService.getUserById(orderDTO.getUserId());// 通过User的方法获取需要的信息if (user.canCreateOrder()) {// 创建订单逻辑}}
}7. 合成复用原则CRP
// 优先使用组合而不是继承
Service
public class OrderService {private final UserService userService;private final ProductService productService;private final PaymentService paymentService;// 通过组合复用功能而不是继承public Order createOrder(OrderDTO orderDTO) {User user userService.getUserById(orderDTO.getUserId());Product product productService.getProductById(orderDTO.getProductId());// 创建订单逻辑return order;}
}五、设计模式的最佳实践
1. 模式选择原则
优先使用组合而非继承针对接口编程而非实现遵循开闭原则保持简单性
2. 常见反模式
过度设计不要为了使用模式而使用模式模式滥用避免在不合适的地方使用设计模式忽略性能某些模式可能带来性能开销
3. 性能考虑
// 单例模式的双重检查锁定
public class Singleton {private static volatile Singleton instance;public static Singleton getInstance() {if (instance null) {synchronized (Singleton.class) {if (instance null) {instance new Singleton();}}}return instance;}
}4. 测试友好性
// 依赖注入便于测试
Service
public class UserService {private final UserRepository userRepository;private final EmailService emailService;public UserService(UserRepository userRepository, EmailService emailService) {this.userRepository userRepository;this.emailService emailService;}// 方法便于单元测试public User createUser(UserDTO userDTO) {User user new User(userDTO);user userRepository.save(user);emailService.sendWelcomeEmail(user);return user;}
}总结
设计模式是Java后端开发中的重要工具它们帮助我们
提高代码质量通过模式化的设计代码更加清晰、可维护增强可扩展性遵循开闭原则便于功能扩展提升开发效率复用成熟的设计方案避免重复造轮子改善团队协作统一的代码风格和架构模式
在实际开发中应该根据具体场景选择合适的模式避免过度设计同时注重性能和可测试性。通过深入理解Spring、MyBatis等主流框架的源码我们可以更好地掌握设计模式的实际应用。
