设计模式 | Automannn的学习园地

# 概述

# 产生背景

最初出现在建筑领域设计中
1995年，GoF出版《设计模式：可复用面向对象软件的基础》，收录23个设计模式，是设计模式领域里程碑事件
直到今天，狭义设计模式，还是指的该教程的23种经典设计模式。

# 概念与意义

概念
- 一套被反复使用、多数人知晓的，代码设计经验的总结
- 是解决特定问题的一系列套路，具有一定的普遍性
意义
- 提高思维能力，编程能力，设计能力
- 程序设计更加标准化，代码更加工程化
- 代码可重用性高、可读性强、可靠性高、灵活性好

# 基本要素

模式名称
问题：解释设计问题和问题存在的前因后果，以及必须满足的一系列先决条件;
解决方案: 提供设计问题的抽象描述，以及具有一般意义的元素组合。
效果：模式的优缺点

# GOF的23种设计模式

# 分类

根据目的划分为：
- 创建型模式
- 结构型模式
- 行为型模式
根据作用范围划分为：
- 类模式
- 对象模式

范围\目的	创建型	结构型	行为型
类模式	工厂方法	(类)适配器	模板方法解释器
对象模式	单例原型抽象工厂建造者	代理 (对象)适配器桥接装饰外观享元组合	策略命令职责链状态观察者中介者迭代器访问者备忘录

# 正确使用设计模式

技术永远为业务服务，技术只是满足业务需求的一个工具
许多设计模式的功能类似，界限不是特别清楚;
设计模式，只是实现七大设计原则的具体方式，套用太多设计模式，只会陷入模式套路陷阱,最后代码写的凌乱不堪;

# 创建型模式

# 模式概要

主要关注点是怎样创建对象？
主要特点是将对象的创建与使用分离

# 单例模式

某个类只能生成一个实例，提供一个全局访问点供外部获取该实例

# 在开源框架中的应用

jdk的体现

public class Runtime {
    private static Runtime currentRuntime = new Runtime();
    
    public static Runtime getRuntime() {
        return currentRuntime;
    }
    
    /*xxx: 禁用构造函数*/
    private Runtime() {}
    
}

spring中的体现(容器级别的单例)

public interface BeanFactory {
	/*xxx: 根据指定的名称，从bean容器获取bean*/
	Object getBean(String name) throws BeansException;
}

public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {
    /*xxx: 单例对象的缓存*/
	private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
    
 	@Override
	public Object getBean(String name) throws BeansException {
		return doGetBean(name, null, null, false);
	}
    
    protected <T> T doGetBean(
			String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
			throws BeansException {
     	Object sharedInstance = getSingleton(beanName);   
    }
    
    public Object getSingleton(String beanName) {
		return getSingleton(beanName, true);
	}
   
	protected Object getSingleton(String beanName, boolean allowEarlyReference) {
     	Object singletonObject = this.singletonObjects.get(beanName);   
    }
    
}

spring的单例bean实例的创建，使通过代码自己控制的，单例bean保存在一个ConcurrentHashMap中，不是典型的单例模式的实现。

此处的spring的单例，是在IOC容器中，实际开发中，还涉及到线程间单例以及分布式多进程间单例。线程间单例，可以通过ThreadLocal实现，进程间单例要借助分布式锁以及单例实例的序列号与反序列化.

# 需要注意的问题

是否懒加载
是否线程安全问题;

# 原型模式

将一个对象作为原型，通过对其进行复制，而克隆出多个和原型类似的新实例。

# 在开源框架中的应用

spring中的体现

/*xxx: package org.springframework.beans; */
public abstract class BeanUtils {
    
    public static void copyProperties(Object source, Object target) throws BeansException {
		copyProperties(source, target, null, (String[]) null);
	}
    
    /*xxx: 深拷贝*/
	private static void copyProperties(Object source, Object target, @Nullable Class<?> editable,
			@Nullable String... ignoreProperties) throws BeansException {
     /*xxx: 获取属性信息*/
	PropertyDescriptor[] targetPds = getPropertyDescriptors(actualEditable);
        
        /*xxx: 遍历属性信息 */
		for (PropertyDescriptor targetPd : targetPds) {
         	/*xxx: 获取目标对象的setter方法 */
			Method writeMethod = targetPd.getWriteMethod();
            
            /*xxx: 从源对象中，获取 setter方法，对应的属性*/
			PropertyDescriptor sourcePd = getPropertyDescriptor(source.getClass(), targetPd.getName());
            
            /*xxx: 获取源对象中的read方法*/
			Method readMethod = sourcePd.getReadMethod();
            
            /*xxx: 从源对象读取出属性 */
			Object value = readMethod.invoke(source);
            
            /*xxx: 写入目标对象*/
			writeMethod.invoke(target, value);
        }
        
    }
}

commons-beanutils中的体现

//package org.apache.commons.beanutils;
public class BeanUtilsBean {
    
    public Object cloneBean(Object bean)
            throws IllegalAccessException, InstantiationException,
            InvocationTargetException, NoSuchMethodException {

        Object newBean = null;
		/*xxx: 实例化新实例*/
        newBean = bean.getClass().newInstance();
        /*xxx: 拷贝属性到新实例中*/        
        getPropertyUtils().copyProperties(newBean, bean);
        return (newBean);

    }
    
}

public class PropertyUtilsBean {
    public void copyProperties(Object dest, Object orig)
            throws IllegalAccessException, InvocationTargetException,
            NoSuchMethodException {
       if (orig instanceof DynaBean) {
           /*xxx: 省略抽象...*/
       }else if (orig instanceof Map) {
           /*xxx: 省略抽象...*/
       } else  {
           /*xxx: 获取源对象的所有属性*/
           PropertyDescriptor[] origDescriptors =
                getPropertyDescriptors(orig);
           /*xxx: 对属性进行遍历*/
           for (int i = 0; i < origDescriptors.length; i++) {
                String name = origDescriptors[i].getName();
               if (isReadable(orig, name) && isWriteable(dest, name)) {
                   	/*xxx: 获取源属性的值*/
                	Object value = getSimpleProperty(orig, name);   
                   /*xxx: 设置目标属性的值*/
                   setSimpleProperty(dest, name, value);
               }
           }
       }
    }
}

# 工厂模式

定义一个用于生产产品的接口，由子类决定生产什么产品.

# 在开源框架中的应用

spring中的体现

/*xxx: 顶级接口，通知器链工厂*/
public interface AdvisorChainFactory {
    /*xxx: 获取拦截器以及动态拦截通知*/
	List<Object> getInterceptorsAndDynamicInterceptionAdvice(Advised config, Method method, @Nullable Class<?> targetClass);
}

/*xxx: 顶级接口，bean容器*/
public interface BeanFactory {
 	/*xxx: 根据指定的名称，从bean容器获取bean*/
	Object getBean(String name) throws BeansException;   
}


/*xxx: 代理工厂*/
public class ProxyFactory extends ProxyCreatorSupport {
    /*xxx: 获取代理对象,具有多个重载方法，最终都是通过这个流程完成*/
	public Object getProxy() {
		return createAopProxy().getProxy();
	}
}


/*xxx: 顶级接口，aop动态代理工厂*/
public interface AopProxyFactory {
    
 	/*xxx: 根据被代理对象的配置信息，创建aop动态代理*/
	AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException;   
}

mybatis中的体现

public interface SqlSessionFactory {
 	SqlSession openSession(boolean autoCommit);   
}

/*xxx: 该工厂负责 创建代理对象*/
  /*xxx: 映射代理工厂*/
public class MapperProxyFactory<T> {
    /*xxx: 当前MapperProxyFactory对象，可以创建实现了mapperInterface接口的代理对象*/
  private final Class<T> mapperInterface;
  /*xxx: 缓存，key是 mapperInterface接口中某方法对应的Method对象，value是对应的MapperMethod对象*/
  private final Map<Method, MapperMethodInvoker> methodCache = new ConcurrentHashMap<>();
    
 	protected T newInstance(MapperProxy<T> mapperProxy) {
    /*xxx: 创建 实现了 mapperInterface接口的代理对象*/
    return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
  }

  /*xxx: 负责创建实现了 mapperInterface 接口的代理对象的功能*/
  public T newInstance(SqlSession sqlSession) {
    /*xxx: 创建 MapperProxy对象，每次调用都会创建新的 MapperProxy对象*/
    final MapperProxy<T> mapperProxy = new MapperProxy<>(sqlSession, mapperInterface, methodCache);
    return newInstance(mapperProxy);
  }   
}

# 抽象工厂模式

提供一个创建产品族的接口，每个子类生产一系列相关的产品;

# 在开源框架中的应用

jdk中的体现

public interface Connection  extends Wrapper, AutoCloseable {
    //xxx: 返回普通的sql执行器
     Statement createStatement() throws SQLException;
    
    //xxx: 返回具有参数化预编译功能的sql执行器
    PreparedStatement prepareStatement(String sql)
        throws SQLException;
    
    //xxx: 返回可以执行存储过程的sql执行器
    CallableStatement prepareCall(String sql) throws SQLException;
}

在Java生态系统中，许多知名的开源项目和框架都使用了抽象工厂模式。这种设计模式主要用于创建一系列相关或依赖的对象，而无需指定它们的具体类。以下是几个典型的知名开源项目及其如何体现抽象工厂模式的示例：

# 1. Spring Framework

Spring 是 Java 开发中最流行的框架之一，广泛用于企业级应用开发。

# 抽象工厂模式的体现：

BeanFactory 和 ApplicationContext： Spring 的核心容器（如 BeanFactory 和 ApplicationContext）可以看作是抽象工厂模式的一种实现。它们负责创建和管理 Bean 对象（即应用程序中的对象），而具体的 Bean 类型由配置决定。
多数据源支持：在多数据源场景下，Spring 使用抽象工厂模式来创建不同类型的 DataSource 对象（如 MySQL、PostgreSQL 等）。通过配置不同的工厂类（如 DataSourceBuilder），Spring 可以动态生成相应的数据源对象。

# 示例代码片段：

// 抽象工厂接口
public interface DataSourceFactory {
    DataSource createDataSource();
}

// 具体工厂：MySQL 数据源工厂
public class MySQLDataSourceFactory implements DataSourceFactory {
    @Override
    public DataSource createDataSource() {
        return DataSourceBuilder.create().type(HikariDataSource.class).build();
    }
};

// 客户端代码
DataSourceFactory factory = new MySQLDataSourceFactory();
DataSource dataSource = factory.createDataSource();

# 2. Hibernate ORM

Hibernate 是一个强大的 ORM 框架，用于将 Java 对象映射到数据库表。

# 抽象工厂模式的体现：

SessionFactory： Hibernate 中的 SessionFactory 是一个抽象工厂，用于创建 Session 对象（与数据库交互的核心接口）。具体实现根据配置文件（如 XML 或注解）动态生成对应的 Session 实例。
Dialect 工厂： Hibernate 支持多种数据库（如 MySQL、Oracle、PostgreSQL），它通过抽象工厂模式为每种数据库提供对应的 SQL 方言（Dialect）。例如，MySQLDialect 和 PostgreSQLDialect 是具体产品，而 DialectFactory 是抽象工厂。

# 示例代码片段：

// 抽象工厂接口
public interface DialectFactory {
    Dialect createDialect();
}

// 具体工厂：MySQL 方言工厂
public class MySQLDialectFactory implements DialectFactory {
    @Override
    public Dialect createDialect() {
        return new MySQLDialect();
    }
}

# 3. Apache Commons Pool

Apache Commons Pool 是一个通用的对象池库，用于管理昂贵资源（如数据库连接、线程等）的复用。

# 抽象工厂模式的体现：

PooledObjectFactory： PooledObjectFactory 是一个抽象工厂接口，用于创建、销毁和验证池中的对象。具体实现（如 BasePooledObjectFactory）定义了如何创建和管理具体的对象实例。

# 示例代码片段：

// 抽象工厂接口
public interface PooledObjectFactory<T> {
    PooledObject<T> makeObject() throws Exception;
    void destroyObject(PooledObject<T> p) throws Exception;
    boolean validateObject(PooledObject<T> p);
}

// 具体工厂：数据库连接工厂
public class ConnectionFactory implements PooledObjectFactory<Connection> {
    @Override
    public PooledObject<Connection> makeObject() throws Exception {
        return new DefaultPooledObject<>(DriverManager.getConnection("jdbc:mysql://localhost:3306/test"));
    }

    @Override
    public void destroyObject(PooledObject<Connection> p) throws Exception {
        p.getObject().close();
    }

    @Override
    public boolean validateObject(PooledObject<Connection> p) {
        return !p.getObject().isClosed();
    }
}

# 4. Log4j

Log4j 是一个流行的日志记录框架，用于在应用程序中记录日志信息。

# 抽象工厂模式的体现：

LoggerFactory： Log4j 中的 LoggerFactory 是一个抽象工厂，用于创建不同类型的 Logger 对象（如控制台日志、文件日志等）。具体实现根据配置文件动态选择合适的日志记录器。

# 示例代码片段：

// 抽象工厂接口
public interface LoggerFactory {
    Logger createLogger();
}

// 具体工厂：文件日志工厂
public class FileLoggerFactory implements LoggerFactory {
    @Override
    public Logger createLogger() {
        return new FileLogger();
    }
}

# 建造者模式

将一个复杂对象分解成多个相对简单的部分，然后根据不同需要，分别创建它们，最后构建成该复杂对象.

# 在开源框架中的应用

spring中的体现

public final class BeanDefinitionBuilder {
    
    public BeanDefinitionBuilder addPropertyValue(String name, @Nullable Object value) {
		this.beanDefinition.getPropertyValues().add(name, value);
		return this;
	}
    
    public BeanDefinitionBuilder addAutowiredProperty(String name) {
		this.beanDefinition.getPropertyValues().add(name, AutowiredPropertyMarker.INSTANCE);
		return this;
	}
    
    /*xxx: 省略其它抽象...*/
    
    /*xxx: 从构造器中，获取实际的bean信息*/
    public AbstractBeanDefinition getBeanDefinition() {
		this.beanDefinition.validate();
		return this.beanDefinition;
	}
}

springSecurity中的体现

public interface SecurityBuilder<O> {
	/*xxx: 过滤链的构造*/
	O build() throws Exception;
}

public abstract class AbstractSecurityBuilder<O> implements SecurityBuilder<O> {
	private AtomicBoolean building = new AtomicBoolean();
    
    /*xxx: 过滤链*/
	private O object;
 
    /*xxx: 执行构建*/
	protected abstract O doBuild() throws Exception;
}

public abstract class AbstractConfiguredSecurityBuilder<O, B extends SecurityBuilder<O>>
		extends AbstractSecurityBuilder<O> {
    //xxx: 既用了构造模式，也用了泛型
 	public <C extends SecurityConfigurer<O, B>> C apply(C configurer) throws Exception {
		add(configurer);
		return configurer;
	}   
}

public final class HttpSecurity extends
		AbstractConfiguredSecurityBuilder<DefaultSecurityFilterChain, HttpSecurity>
		implements SecurityBuilder<DefaultSecurityFilterChain>,
		HttpSecurityBuilder<HttpSecurity> {
            
    public OAuth2LoginConfigurer<HttpSecurity> oauth2Login() throws Exception {
		return getOrApply(new OAuth2LoginConfigurer<>());
	}   
            
   public FormLoginConfigurer<HttpSecurity> formLogin() throws Exception {
		return getOrApply(new FormLoginConfigurer<>());
	}
            
   public OpenIDLoginConfigurer<HttpSecurity> openidLogin() throws Exception {
		return getOrApply(new OpenIDLoginConfigurer<>());
	}
            
  /*xxx: 省略其它抽象...*/
}

jdk中的体现

public final class StringBuilder
    extends AbstractStringBuilder
    implements java.io.Serializable, CharSequence
{
     @Override
    public StringBuilder append(String str) {
        super.append(str);
        return this;
    }
    
    /*xxx: 省略其它抽象...*/
    
    @Override
    public String toString() {
        return new String(value, 0, count);
    }
    
}

# 结构型模式

# 模式概要

主要关注点是如何将类或对象按某种布局组成更大的结构
分为类结构型模式、对象结构型模式，类结构模式通过继承机制来组织接口和类，对象结构模式通过组合或聚合来组织对象
组合关系或者聚合关系，比继承关系耦合度更低，满足合成复用原则，所以对象结构模型比类结构模型具有更大的灵活性.
除了适配器模式分为类结构模式和对象结构模式外，其它都是属于对象型模式

# 代理模式

对某对象提供一种代理，以控制对该对象的访问。即消费者通过代理，间接地访问对象，从而限制、增强、或修改该对象的一些特性.

# 开源框架中的体现

springWeb中的体现

/*xxx: springSecurity与web集成时候的入口类*/
public class DelegatingFilterProxy extends GenericFilterBean {
    @Nullable
	/*xxx: 代理对象*/
	private volatile Filter delegate;
    
    public DelegatingFilterProxy(Filter delegate) {
		this.delegate = delegate;
	}
    
    @Override
	/*xxx: 作为一个过滤器 在 容器的 applicationFilterChain 进行过滤*/
	public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain)
			throws ServletException, IOException {
     	/*xxx: 懒实例化过滤器代理对象 */
		Filter delegateToUse = this.delegate;
        /*省略部分抽象...*/
        
        /*xxx: 执行过滤器代理*/
		invokeDelegate(delegateToUse, request, response, filterChain);
    }
    
    protected void invokeDelegate(
			Filter delegate, ServletRequest request, ServletResponse response, FilterChain filterChain)
			throws ServletException, IOException {
		/*xxx: 通过过滤器代理进行过滤操作*/
		delegate.doFilter(request, response, filterChain);
	}
}

jdk中的动态代理

/*xxx: 通过这一个接口，将所有的方法进行聚合*/
public interface InvocationHandler {
    public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable;
}

/*xxx: 该方法需要使用强转，转为实际的接口 */
public class Proxy implements java.io.Serializable {
    
    protected InvocationHandler h;
    
    public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
        /*xxx: 省略抽象*/
    }
}

# 适配器模式

将一个类的接口转换成消费者希望的另外一个接口。使得原本由于接口不兼容而不能一起工作的那些类能一起工作。

# 开源框架中的体现

springSecurity中的体现

public abstract class WebSecurityConfigurerAdapter implements
		WebSecurityConfigurer<WebSecurity> {
    
    /*xxx: 正常情况下，该接口是用于 单个配置器的初始化工作，此处用于新增过滤链了*/
    public void init(final WebSecurity web) throws Exception {
     	final HttpSecurity http = getHttp();
        /*xxx: 省略其它抽象...*/
        web.addSecurityFilterChainBuilder(http);
    }
    
    @Override
    /*xxx: 正常情况下，该接口由于编织单条过滤链，此处不做处理*/
	public void configure(WebSecurity web) throws Exception {
	}
    
}

springWebMVC中的体现

public abstract class AbstractHandlerMethodAdapter extends WebContentGenerator implements HandlerAdapter, Ordered {
    
	@Override
	@Nullable
	public final ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {

		return handleInternal(request, response, (HandlerMethod) handler);
	}
    
    @Nullable
	protected abstract ModelAndView handleInternal(HttpServletRequest request,
			HttpServletResponse response, HandlerMethod handlerMethod) throws Exception;
}

# 桥接模式

将抽象与实现分离，使它们可以独立变化.通过利用组合关系，降低了抽象和实现这两个可变维度的耦合度。

可以理解为 通过变量传递，实现接口定义与实际实现的分离

# 开源框架中的体现

spring中的体现

public interface CacheManager {
    @Nullable
	Cache getCache(String name);
}


public interface FlashMapManager {
    
 	FlashMap retrieveAndUpdate(HttpServletRequest request, HttpServletResponse response);
    
    void saveOutputFlashMap(FlashMap flashMap, HttpServletRequest request, HttpServletResponse response);
}

jdbc中的体现

public class DriverManager {
 	@CallerSensitive
    public static Connection getConnection(String url,
        java.util.Properties info) throws SQLException {

        return (getConnection(url, info, Reflection.getCallerClass()));
    }   
    
    private static Connection getConnection(
        String url, java.util.Properties info, Class<?> caller) throws SQLException {
     	
        /*xxx: 省略其它抽象...*/
        for(DriverInfo aDriver : registeredDrivers) {
         	Connection con = aDriver.driver.connect(url, info);
            /*xxx: 省略其它抽象...*/
             return (con);
        }
    }
}

springCloud中的体现

public class EnvironmentManager implements ApplicationEventPublisherAware {
    
    private ConfigurableEnvironment environment;
    
 	public Object getProperty(String name) {
		return this.environment.getProperty(name);
	}   
}

# 装饰模式

动态地给对象增加一些职责，即增加其额外的功能;

# 开源框架中的体现

mybatis中的体现

public interface Cache {
 	void putObject(Object key, Object value);
    
    Object getObject(Object key);
}

public class LoggingCache implements Cache {
   	private final Cache delegate;
    
    private final Log log;
    
  @Override
  public void putObject(Object key, Object object) {
    delegate.putObject(key, object);
  }
    
  @Override
  public Object getObject(Object key) {
    final Object value = delegate.getObject(key);
      /*xxx: 省略其它抽象...*/
    if (log.isDebugEnabled()) {
      log.debug("Cache Hit Ratio [" + getId() + "]: " + getHitRatio());
    }
    return value;
  }
    
}

public class LruCache implements Cache {
 	private final Cache delegate;
    
    private Map<Object, Object> keyMap;
    
    
  @Override
  public Object getObject(Object key) {
    keyMap.get(key);
    return delegate.getObject(key);
  }
}

# 外观模式

为多个复杂的子系统提供一个一致的接口，使这些子系统更加容易被访问

# 开源框架中的体现

tomcat中的体现

public class ApplicationContextFacade implements ServletContext {
    
    private final ApplicationContext context;
 	
    /*xxx: 记录方法，与参数对象信息 */
    private final Map<String,Class<?>[]> classCache;
    
    private void initClassCache(){
        Class<?>[] clazz = new Class[]{String.class};
        classCache.put("getContext", clazz);
        classCache.put("getMimeType", clazz);
        classCache.put("getResourcePaths", clazz);
        classCache.put("getResource", clazz);
        classCache.put("getResourceAsStream", clazz);
        classCache.put("getRequestDispatcher", clazz);
        classCache.put("getNamedDispatcher", clazz);
        classCache.put("getServlet", clazz);
        classCache.put("setInitParameter", new Class[]{String.class, String.class});
        classCache.put("createServlet", new Class[]{Class.class});
        classCache.put("addServlet", new Class[]{String.class, String.class});
        classCache.put("createFilter", new Class[]{Class.class});
        classCache.put("addFilter", new Class[]{String.class, String.class});
        classCache.put("createListener", new Class[]{Class.class});
        classCache.put("addListener", clazz);
        classCache.put("getFilterRegistration", clazz);
        classCache.put("getServletRegistration", clazz);
        classCache.put("getInitParameter", clazz);
        classCache.put("setAttribute", new Class[]{String.class, Object.class});
        classCache.put("removeAttribute", clazz);
        classCache.put("getRealPath", clazz);
        classCache.put("getAttribute", clazz);
        classCache.put("log", clazz);
        classCache.put("setSessionTrackingModes", new Class[]{Set.class} );
        classCache.put("addJspFile", new Class[]{String.class, String.class});
        classCache.put("declareRoles", new Class[]{String[].class});
        classCache.put("setSessionTimeout", new Class[]{int.class});
        classCache.put("setRequestCharacterEncoding", new Class[]{String.class});
        classCache.put("setResponseCharacterEncoding", new Class[]{String.class});
    }
    
    
    @Override
    public ServletContext getContext(String uripath) {
     	theContext = (ServletContext)
                doPrivileged("getContext", new Object[]{uripath});   
    }
    
    private Object doPrivileged(final String methodName, final Object[] params) {
    	return invokeMethod(context, methodName, params);
    }
    
    private Object invokeMethod(ApplicationContext appContext,
                                final String methodName,
                                Object[] params)
        throws Throwable{
     	 method = appContext.getClass()
                    .getMethod(methodName, classCache.get(methodName));
                objectCache.put(methodName, method);
        
         return executeMethod(method,appContext,params);
    }
    
    private Object executeMethod(final Method method,
                                 final ApplicationContext context,
                                 final Object[] params)
            throws PrivilegedActionException,
                   IllegalAccessException,
                   InvocationTargetException {
                       
    	 return method.invoke(context, params);                   
    }
}

# 享元模式

运用共享技术，来有效地支持大量细粒度对象的复用。

# 开源框架中的体现

jdk中的体现

public final class Integer extends Number implements Comparable<Integer> {
 	public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }
    
    private static class IntegerCache {
     	static final Integer cache[];
        /*xxx: 省略其它抽象...*/
    }
}

springSeuciry中的体现

# 组合模式

将对象组合成树状层次结构，使用户对单个对象和组合对象具有一致的访问性.

# 开源框架中的体现

mybatis中的体现

public interface SqlNode {
 	 boolean apply(DynamicContext context);   
}

public class TrimSqlNode implements SqlNode {
 	/*xxx: 调用子节点的 apply方法进行解析*/
    boolean result = contents.apply(filteredDynamicContext);
    /*xxx: filteredDynamicContext.applyAll 处理前缀 和 后缀*/
    filteredDynamicContext.applyAll();
    return result;
}

public class WhereSqlNode extends TrimSqlNode {

  private static List<String> prefixList = Arrays.asList("AND ","OR ","AND\n", "OR\n", "AND\r", "OR\r", "AND\t", "OR\t");

  public WhereSqlNode(Configuration configuration, SqlNode contents) {
    super(configuration, contents, "WHERE", prefixList, null, null);
  }

}

springSecurity中的体现

public final class WebSecurity extends
		AbstractConfiguredSecurityBuilder<Filter, WebSecurity> implements
		SecurityBuilder<Filter>, ApplicationContextAware {
    
 	@Override
	protected Filter performBuild() throws Exception {
        int chainSize = ignoredRequests.size() + securityFilterChainBuilders.size();
		List<SecurityFilterChain> securityFilterChains = new ArrayList<>(
				chainSize);
        
       /*xxx: 省略其它抽象...*/
     	FilterChainProxy filterChainProxy = new FilterChainProxy(securityFilterChains);
        
        Filter result = filterChainProxy;
        
        return result;
    }
}

# 行为型模式

# 模式概要

主要关注点是描述程序在运行时，复杂的流程控制，即描述多个类或对象之间怎样相互协作，共同完成单个对象无法完成的任务。涉及算法与对象间职责的分配。
分为类行为模式和对象行为模式,类行为模式，通过继承机制在类间分派行为,对象行为模式，通过组合或聚合在对象间分配行为。

# 模板方法模式

定义一个操作的算法骨架，将算法的一些步骤延迟到子类中，使得子类在可以不改变该算法结构的情况下，重定义该算法的某些特定步骤。

# 开源框架中的体现

spring中的体现
springWebMVC中的体现

public abstract class HttpServletBean extends HttpServlet implements EnvironmentCapable, EnvironmentAware {
 	public final void init() throws ServletException {
    	initServletBean();
    }
    
    protected void initServletBean() throws ServletException {
	}
    
}

public abstract class FrameworkServlet extends HttpServletBean implements ApplicationContextAware {
 	@Override
	protected final void initServletBean() throws ServletException {
     	this.webApplicationContext = initWebApplicationContext();
        
        initFrameworkServlet();
    }
    
    public void onApplicationEvent(ContextRefreshedEvent event) {
		this.refreshEventReceived = true;
		synchronized (this.onRefreshMonitor) {
			onRefresh(event.getApplicationContext());
		}
	}
    
    protected void onRefresh(ApplicationContext context) {
	}
    
    @Override
	protected void service(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
        processRequest(request, response);   
    }
    
    protected final void processRequest(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
        /*xxx: 实际处理请求入口*/
		doService(request, response);
    }
    
    protected abstract void doService(HttpServletRequest request, HttpServletResponse response)
			throws Exception;
}


public class DispatcherServlet extends FrameworkServlet {
 	@Override
	/*xxx: 该方法 是  DispatcherServlet 的入口方法*/
	protected void onRefresh(ApplicationContext context) {
		/*xxx: 初始化9个组件*/
		initStrategies(context);
	}
    
    protected void initStrategies(ApplicationContext context) {
		/*xxx: 1.MultipartResolver组件*/
		initMultipartResolver(context);
		/*xxx: 2.localeResolver组件*/
		initLocaleResolver(context);
		/*xxx: 3.themeResolver组件*/
		initThemeResolver(context);
		/*xxx: 4.handlerMapping组件*/
		initHandlerMappings(context);
		/*xxx: 5.handlerAdapter组件*/
		initHandlerAdapters(context);
		/*xxx: 6.handlerExceptionResolver组件*/
		initHandlerExceptionResolvers(context);
		/*xxx: 7.requestToViewNameTranslator组件*/
		initRequestToViewNameTranslator(context);
		/*xxx: 8.viewResolver组件*/
		initViewResolvers(context);
		/*xxx: 9.flashMapManager组件*/
		initFlashMapManager(context);
	}
    
    @Override
	protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {
     	/*xxx: 进行分发处理*/
		doDispatch(request, response);   
    }
    
    protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
     	/*xxx: 根据 request 找到 handler*/
		mappedHandler = getHandler(processedRequest);   
        
        /*xxx: 根据handler找到 handlerAdapter*/
		HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
        
        mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
        
        /*xxx: 处理上面处理之后的结果 (包括 处理异常，渲染页面，发出完成通知触发  Interceptor 的 afterCompletion)*/
		processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
    }
    
    /*xxx: 处理分发结果 */
	private void processDispatchResult(HttpServletRequest request, HttpServletResponse response,
			@Nullable HandlerExecutionChain mappedHandler, @Nullable ModelAndView mv,
			@Nullable Exception exception) throws Exception {
        /*xxx： 渲染页面，具体在 render方法中执行*/
		render(mv, request, response);
    }
    
    protected void render(ModelAndView mv, HttpServletRequest request, HttpServletResponse response) throws Exception {
     	view = resolveViewName(viewName, mv.getModelInternal(), locale, request);
        
        view.render(mv.getModelInternal(), request, response);
    }
    
    protected View resolveViewName(String viewName, @Nullable Map<String, Object> model,
			Locale locale, HttpServletRequest request) throws Exception {
        /*xxx: 省略其它抽象...*/
        View view = viewResolver.resolveViewName(viewName, locale);
    }
}

# 策略模式

定义一系列算法，并将算法封装起来，使它们可以相互替换，且算法的改变不会影响使用算法的客户。

# 开源框架中的体现

spring中的体现

public interface InstantiationStrategy {
    
	Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner)
			throws BeansException;
	/*xxx: 省略其他抽象...*/
}

public class SimpleInstantiationStrategy implements InstantiationStrategy {
 	@Override
	public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
        constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod;
        
        /*xxx: 最终，通过 BeanUtils进行实例化，通过构造方法*/
		return BeanUtils.instantiateClass(constructorToUse);
    }
}

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
		implements AutowireCapableBeanFactory {
 	/*xxx: 创建bean实例的策略*/
	private InstantiationStrategy instantiationStrategy;
    
    public AbstractAutowireCapableBeanFactory() {
        /*xxx: 省略其他抽象...*/
		if (IN_NATIVE_IMAGE) {
			this.instantiationStrategy = new SimpleInstantiationStrategy();
		}
		else {
			this.instantiationStrategy = new CglibSubclassingInstantiationStrategy();
		}
	}
    
    public void setInstantiationStrategy(InstantiationStrategy instantiationStrategy) {
		this.instantiationStrategy = instantiationStrategy;
	}
    
    protected InstantiationStrategy getInstantiationStrategy() {
		return this.instantiationStrategy;
	}
    
    @Override
	public Object autowire(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException {
        bean = getInstantiationStrategy().instantiate(bd, null, this);
        /*xxx: 省略其它抽象...*/
        populateBean(beanClass.getName(), bd, new BeanWrapperImpl(bean));
		return bean;
    }
}

springAop中的体现

public class DefaultAopProxyFactory implements AopProxyFactory, Serializable {
 	@Override
	/*xxx: 创建AOP动态代理*/
	public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
     	if (!IN_NATIVE_IMAGE &&
				(config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config))) {
            /*xxx: 如果被代理对象是 接口，则动态代理采用 jdk的动态代理进行编织*/
			if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
				return new JdkDynamicAopProxy(config);
			}
			/*xxx: 如果被代理对象是 实例类，则动态代理采用 cglib的动态代理进行编织*/
			return new ObjenesisCglibAopProxy(config);
        }else{
            /*xxx: 当前环境是否是原生环境，原生环境，则只能使用 jdk动态代理*/
			return new JdkDynamicAopProxy(config);
        }
    }
}

# 命令模式

将一个请求封装为一个对象，使发出请求的责任和执行请求的责任分隔开。

# 开源框架中的体现

tomcat中的体现

/*xxx: 适配器，用于找到请求对应的 组件*/
public class CoyoteAdapter implements Adapter {
 	 @Override
    /*xxx: 可以看成tomcat的核心流程的处理起点 多线程环境*/
    public void service(org.apache.coyote.Request req, org.apache.coyote.Response res)
            throws Exception {
     	 request = connector.createRequest();
         request.setCoyoteRequest(req);
         response = connector.createResponse();
         response.setCoyoteResponse(res);   
        
        request.setResponse(response);
        response.setRequest(request);
        
         /*xxx: 3.得到当前引擎的第一个Valve并执行(invoke),以完成客户端请求处理*/
                /*xxx: 由于pipieline和 valve为职责链模式，因此执行第一个Valve即保证了整个Valve链的执行*/
        /*xxx: 省略其它抽象...*/
        connector.getService().getContainer().getPipeline().getFirst().invoke(
                        request, response);
        
    }
}

# 职责链模式

把请求链中的一个对象，传到下一个对象，直到请求被响应为止。通过这种方式去除对象之间的耦合。

# 开源框架中的体现

tomcat中的体现

/*xxx: 应用过滤器，由tomcat 实现的servlet 过滤器规范   */
public final class ApplicationFilterChain implements FilterChain {
 	@Override
    /*xxx: 进行过滤动作  */
    public void doFilter(ServletRequest request, ServletResponse response)
        throws IOException, ServletException {
     	internalDoFilter(request,response);   
    }
    
    /*xxx: 实际过滤动作 */
    private void internalDoFilter(ServletRequest request,
                                  ServletResponse response)
        throws IOException, ServletException {
     	 /*xxx: 过滤器 往下迭代， 注意此处迭代的 是原生的过滤器。 */
        if (pos < n) {
            /*xxx: 从原生过滤器配置信息 数组中进行迭代  */
            ApplicationFilterConfig filterConfig = filters[pos++];
            
            /*xxx: 根据过滤器配置信息，获取实际的过滤器实例  */
            Filter filter = filterConfig.getFilter();
            
            /*xxx: 根据获取到的过滤器  执行 过滤，并将当前的 过滤器实例作为参数传入 */
            filter.doFilter(request, response, this);
        }
    }
}

springMVC中的体现

public class DispatcherServlet extends FrameworkServlet {
 	/*xxx: 需要注意，HandlerMapping 具有优先级关系*/
	/*xxx: 在前的优先*/
	@Nullable
	protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
		if (this.handlerMappings != null) {
			for (HandlerMapping mapping : this.handlerMappings) {
				HandlerExecutionChain handler = mapping.getHandler(request);
				if (handler != null) {
					return handler;
				}
			}
		}
		return null;
	}
    
    /*xxx: handlerAdapter也具有优先级关系*/
	/*xxx: 在前的优先 */
	protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
		if (this.handlerAdapters != null) {
			for (HandlerAdapter adapter : this.handlerAdapters) {
				if (adapter.supports(handler)) {
					return adapter;
				}
			}
		}
		/*xxx: 省略其它抽象...*/
	}
}

# 状态模式

允许一个对象，在其内部状态发生改变时，改变其行为能力。

# 开源框架中的体现

spring中的体现

public final class ParseState {
 	private final ArrayDeque<Entry> state;
    
    public ParseState() {
		this.state = new ArrayDeque<>();
	}
    
    public void pop() {
		this.state.pop();
	}
    
    public void push(Entry entry) {
		this.state.push(entry);
	}
}

class ConfigBeanDefinitionParser implements BeanDefinitionParser {
 	@Override
	@Nullable
	public BeanDefinition parse(Element element, ParserContext parserContext) {
        /*xxx: 省略其它抽象...*/
     	List<Element> childElts = DomUtils.getChildElements(element);
		for (Element elt: childElts) {
			String localName = parserContext.getDelegate().getLocalName(elt);
			if (POINTCUT.equals(localName)) {
				parsePointcut(elt, parserContext);
			}
			else if (ADVISOR.equals(localName)) {
				parseAdvisor(elt, parserContext);
			}
			else if (ASPECT.equals(localName)) {
				parseAspect(elt, parserContext);
			}
		}   
    }
    
    private AbstractBeanDefinition parsePointcut(Element pointcutElement, ParserContext parserContext) {
     	this.parseState.push(new PointcutEntry(id));
        
        pointcutDefinition = createPointcutDefinition(expression);
		pointcutDefinition.setSource(parserContext.extractSource(pointcutElement));
        
        String pointcutBeanName = id;
        
        parserContext.getRegistry().registerBeanDefinition(pointcutBeanName, pointcutDefinition);
        /*xxx: 省略其他抽象...*/
        
        this.parseState.pop();
    }
}

springBoot中的体现

class SpringApplicationRunListeners {
  	void contextLoaded(ConfigurableApplicationContext context) {
		doWithListeners("spring.boot.application.context-loaded", (listener) -> listener.contextLoaded(context));
	}
    
    void environmentPrepared(ConfigurableBootstrapContext bootstrapContext, ConfigurableEnvironment environment) {
		doWithListeners("spring.boot.application.environment-prepared",
				(listener) -> listener.environmentPrepared(bootstrapContext, environment));
	}
    
    /*xxx: 省略其它抽象...*/
    
    private void doWithListeners(String stepName, Consumer<SpringApplicationRunListener> listenerAction,
			Consumer<StartupStep> stepAction) {
		StartupStep step = this.applicationStartup.start(stepName);
		this.listeners.forEach(listenerAction);
		if (stepAction != null) {
			stepAction.accept(step);
		}
		step.end();
	}
 }

# 观察者模式

多个对象间，存在一对多关系，当一个对象发生改变时，把这种改变通知给其它多个对象，从而影响其它对象的行为。

# 开源框架中的体现

spring中的体现

/*xxx: 应用事件发布器 */
public interface ApplicationEventPublisher {
 	/*xxx: 发布事件（对象类型）*/
	void publishEvent(Object event);   
}

/*xxx: 抽象应用上下文*/
public abstract class AbstractApplicationContext extends DefaultResourceLoader
		implements ConfigurableApplicationContext {
    
    @Nullable
    /*xxx: 当前上下文使用的 事件发布器*/
	private ApplicationEventMulticaster applicationEventMulticaster;
    
 	@Override
	public void publishEvent(Object event) {
		publishEvent(event, null);
	}
    
    protected void publishEvent(Object event, @Nullable ResolvableType eventType) {
        /*xxx: 省略其它抽象...*/
     	getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType);   
    }
}

public interface ApplicationEventMulticaster {
 	/*xxx: 新增应用监听器，交由抽象实现*/
	void addApplicationListener(ApplicationListener<?> listener);
    
    /*xxx: 上下文发布事件，实际调用的是该方法，交由具体类实现*/
	void multicastEvent(ApplicationEvent event);
    
    /*xxx: 省略其它抽象...*/
}

public abstract class AbstractApplicationEventMulticaster
		implements ApplicationEventMulticaster, BeanClassLoaderAware, BeanFactoryAware {
    
    private final DefaultListenerRetriever defaultRetriever = new DefaultListenerRetriever();
    
 	@Override
	public void addApplicationListener(ApplicationListener<?> listener) {
     	this.defaultRetriever.applicationListeners.add(listener);   
    }
    
    protected Collection<ApplicationListener<?>> getApplicationListeners(
			ApplicationEvent event, ResolvableType eventType) {
        /*xxx: 省略其它抽象...*/
     	newRetriever = new CachedListenerRetriever();   
        /*xxx: 从所有的监听器中，遴选出 符合条件的 监听器群组*/
		return retrieveApplicationListeners(eventType, sourceType, newRetriever);
    }
    
    private Collection<ApplicationListener<?>> retrieveApplicationListeners(
			ResolvableType eventType, @Nullable Class<?> sourceType, @Nullable CachedListenerRetriever retriever) {
     	List<ApplicationListener<?>> allListeners = new ArrayList<>();
        
        synchronized (this.defaultRetriever) {
			listeners = new LinkedHashSet<>(this.defaultRetriever.applicationListeners);
			listenerBeans = new LinkedHashSet<>(this.defaultRetriever.applicationListenerBeans);
		}
        
        for (ApplicationListener<?> listener : listeners) {
			if (supportsEvent(listener, eventType, sourceType)) {
				if (retriever != null) {
					filteredListeners.add(listener);
				}
				allListeners.add(listener);
			}
		}
        
        /*xxx: 省略其它抽象...*/
        
        /*xxx: 将所有的监听器进行排序*/
        AnnotationAwareOrderComparator.sort(allListeners);
        
        return allListeners;
    }

    private class DefaultListenerRetriever {
     	public final Set<ApplicationListener<?>> applicationListeners = new LinkedHashSet<>();   
        
    }
}

public class SimpleApplicationEventMulticaster extends AbstractApplicationEventMulticaster {
 	    @Override
	public void multicastEvent(ApplicationEvent event) {
		multicastEvent(event, resolveDefaultEventType(event));
	}
    
    @Override
	public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {
        /*xxx: 从这里可以看出，对监听器的执行是通过遍历执行的*/
		for (ApplicationListener<?> listener : getApplicationListeners(event, type)) {
            /*xxx: 异步执行*/
         	if (executor != null) {
				executor.execute(() -> invokeListener(listener, event));
			}/*xxx: 同步执行*/ 
            else {
				invokeListener(listener, event);
			}
        }
    }
    
    protected void invokeListener(ApplicationListener<?> listener, ApplicationEvent event) {
        /*xxx: 省略其它抽象...*/
     	listener.onApplicationEvent(event);   
    }
}

# 中介者模式

定义一个，中介对象来简化原有对象之间交互关系，降低系统中对象间的耦合性，使原有对象之间不必相互了解。

# 开源框架中的体现

jdk中的体现

public class Timer {
 	private final TaskQueue queue = new TaskQueue();
    
    private final TimerThread thread = new TimerThread(queue);
    
    public Timer(String name) {
        thread.setName(name);
        thread.start();
    }
    
    public void schedule(TimerTask task, long delay) {
     	sched(task, System.currentTimeMillis()+delay, 0);   
    }
    
    public void schedule(TimerTask task, Date time) {
        sched(task, time.getTime(), 0);
    }
    
    /*xxx: 省略其它抽象...*/
    
    private void sched(TimerTask task, long time, long period) {
     	synchronized(queue) {
            /*xxx: 省略其它抽象...*/
        	queue.add(task);
            if (queue.getMin() == task)
                queue.notify();
        }
    }
}

class TaskQueue {
    private TimerTask[] queue = new TimerTask[128];
    
    TimerTask getMin() {
        return queue[1];
    }
}

class TimerThread extends Thread {
 	private TaskQueue queue;
    
    public void run() {
     	mainLoop();   
    }
    
    private void mainLoop() {
     	while (true) {
         	synchronized(queue) {   
                while (queue.isEmpty() && newTasksMayBeScheduled)
                        queue.wait();
                
                task = queue.getMin();
                synchronized(task.lock) {
                 	currentTime = System.currentTimeMillis();
                    executionTime = task.nextExecutionTime;  
                    
                    taskFired = (executionTime<=currentTime);
                    
                    if (!taskFired) 
                        queue.wait(executionTime - currentTime);
                }
                
                if (taskFired) 
                    task.run();
            }
        }
    }
}

# 迭代器模式

提供一种方法来顺序访问聚合对象中的一系列数据，而不暴露聚合对象的内部表示。

# 开源框架中的体现

jdk中的体现

public interface Iterator<E> {
 	boolean hasNext();
    
    E next();
    
    /*xxx: 省略其它抽象...*/
}

# 访问者模式

在不改变集合元素的前提下，为一个集合中的每个元素，提供多种访问方式，即每个元素有多个访问者对象访问。
曾经看过一个说法，说访问者模式是最难理解的一种模式。始终耿耿于怀。时隔多年，试图剖析了这个心魔。 绝大多数谈设计的时候，都是从抽象行为来谈，也就是接口为中心来谈。而访问者则是以对象为中心来谈。简言之，实体已定，但实体属性支持动态改变。
访问者模式，其行为是固化的，不明白当时为什么有人说访问者模式最难理解，导致自己总是如鲠在喉。

# 开源框架中的体现

spring中的体现

public class BeanDefinitionVisitor {
 	@Nullable
	private StringValueResolver valueResolver;
    
    public BeanDefinitionVisitor(StringValueResolver valueResolver) {
		this.valueResolver = valueResolver;
	}
    
    protected void visitScope(BeanDefinition beanDefinition) {
     	String scope = beanDefinition.getScope();
		if (scope != null) {
			String resolvedScope = resolveStringValue(scope);
			if (!scope.equals(resolvedScope)) {
				beanDefinition.setScope(resolvedScope);
			}
		}   
    }
    
    protected void visitPropertyValues(MutablePropertyValues pvs) {
		PropertyValue[] pvArray = pvs.getPropertyValues();
		for (PropertyValue pv : pvArray) {
			Object newVal = resolveValue(pv.getValue());
			if (!ObjectUtils.nullSafeEquals(newVal, pv.getValue())) {
				pvs.add(pv.getName(), newVal);
			}
		}
	}
    
    /*xxx: 省略其它抽象...*/
    
    public void visitBeanDefinition(BeanDefinition beanDefinition) {
		visitParentName(beanDefinition);
		visitBeanClassName(beanDefinition);
		visitFactoryBeanName(beanDefinition);
		visitFactoryMethodName(beanDefinition);
		visitScope(beanDefinition);
		if (beanDefinition.hasPropertyValues()) {
			visitPropertyValues(beanDefinition.getPropertyValues());
		}
		if (beanDefinition.hasConstructorArgumentValues()) {
			ConstructorArgumentValues cas = beanDefinition.getConstructorArgumentValues();
			visitIndexedArgumentValues(cas.getIndexedArgumentValues());
			visitGenericArgumentValues(cas.getGenericArgumentValues());
		}
	}
}

public abstract class PlaceholderConfigurerSupport extends PropertyResourceConfigurer
		implements BeanNameAware, BeanFactoryAware {
    
 	protected void doProcessProperties(ConfigurableListableBeanFactory beanFactoryToProcess,
			StringValueResolver valueResolver) {
        
     	BeanDefinitionVisitor visitor = new BeanDefinitionVisitor(valueResolver);
		String[] beanNames = beanFactoryToProcess.getBeanDefinitionNames();
        
        for (String curName : beanNames) {
         	visitor.visitBeanDefinition(bd);   
        }
    }
}

jdk中的体现

public final class Files {
    
 	public static Path walkFileTree(Path start,
                                    Set<FileVisitOption> options,
                                    int maxDepth,
                                    FileVisitor<? super Path> visitor)
        throws IOException
    {
        FileTreeWalker walker = new FileTreeWalker(options, maxDepth);
        
        FileTreeWalker.Event ev = walker.walk(start);
        
        switch (ev.type()) {
         	case ENTRY :
                result = visitor.visitFile(ev.file(), ev.attributes());
                break;
                
            case START_DIRECTORY :
                result = visitor.preVisitDirectory(ev.file(), ev.attributes());
                break;
                
            case END_DIRECTORY :
                result = visitor.postVisitDirectory(ev.file(), ev.ioeException());
                break;
                
            default :
                throw new AssertionError("Should not get here");
                
        }
        
    }
}

public interface FileVisitor<T> {
 	FileVisitResult visitFile(T file, BasicFileAttributes attrs)
        throws IOException;
    
    FileVisitResult preVisitDirectory(T dir, BasicFileAttributes attrs)
        throws IOException;
    
    /*xxx: 省略其它抽象...*/
    
}

# 备忘录模式

在不破坏封装性的前提下，获取并保存一个对象的内部状态，以便以后回复它。

# 开源框架中的体现

springWebFlow中的体现

public interface StateManageableMessageContext extends MessageContext {
 	Serializable createMessagesMemento();
    
    void restoreMessages(Serializable messagesMemento);
}

# 解释器模式

提供如何定义语言的文法，以及对语言句子的解释方法，即解释器。

# 开源框架中的体现

jdk中的体现

public final class Pattern
    implements java.io.Serializable
{
 	public static Pattern compile(String regex) {
        return new Pattern(regex, 0);
    }
    
    public static boolean matches(String regex, CharSequence input) {
        Pattern p = Pattern.compile(regex);
        Matcher m = p.matcher(input);
        return m.matches();
    }
    
    /*xxx: 省略其它抽象...*/
}

spring中的体现

public interface ExpressionParser {
 	Expression parseExpression(String expressionString) throws ParseException; 
    
    /*xxx: 省略其它抽象...*/
}

← 多线程网络编程 →