当前位置：首页 > news >正文

Spring框架中的设计模式

news 2025/7/6 0:11:28

🎉欢迎来到Spring专栏：Spring框架中的设计模式

📜其他专栏：java面试数据结构源码解读故障分析

🎬作者简介：大家好，我是小徐🥇
☁️博客首页：CSDN主页小徐的博客
🌄每日一句：好学而不勤非真好学者

📜 欢迎大家关注！ ❤️

前言

设计模式有助于遵循良好的编程实践。作为最流行的Web框架之一的Spring框架也使用其中的一些。本文将介绍Spring Framework中使用的设计模式。本文们将分析Spring框架中使用的八种设计模式。每部分都从源码角度解释设计模式的原理。紧接着，将会使用Spring的一个例子来加深理解

一、解释器设计模式

在现实世界中，我们人类需要解释手势。他们可以对文化有不同的含义。这是我们的解释，给他们一个意义。在编程中，我们还需要分析一件事情，并决定它是什么意思。我们可以用解释设计模式来做。

此模式基于表达式和评估器部分。第一个代表一个要分析的事情。这个分析是由评价者来做出的，它们知道构成表达的人物的意义。不必要的操作是在一个上下文中进行的。

Spring主要以Spring Expression Language（Spel）为例。这里快速提个醒，SpEL是一种由Spring的org.springframework.expression.ExpressionParser实现分析和执行的语言。这些实现使用作为字符串给出的Spel表达式，并将它们转换为org.springframework.expression.Expression的实例。上下文组件由org.springframework.expression.EvaluationContext实现表示，例如：StandardEvaluationContext。

举个Spel的一个例子

Writer writer = new Writer();
writer.setName("Writer's name");
StandardEvaluationContext modifierContext = new StandardEvaluationContext(subscriberContext);
modifierContext.setVariable("name", "Overriden writer's name");
parser.parseExpression("name = #name").getValue(modifierContext);
System.out.println("writer's name is : " + writer.getName());

输出应打印“Overriden writer’s name”。如你所见，一个对象的属性是通过一个表达式name = #name进行修改的，这个表达式只有在ExpressionParser才能理解，因为提供了context（前面的样例中的modifierContext实例）。

二、建设者模式

建设者设计模式是属于创建对象模式三剑客的第一种模式。该模式用于简化复杂对象的构造。要理解这个概念，想象一个说明程序员简历的对象。在这个对象中，我们想存储个人信息（名字，地址等）以及技术信息（知识语言，已实现的项目等）。该对象的构造可能如下所示：

// with constructor
Programmer programmer = new Programmer("first name", "last name", "address Street 39", "ZIP code", "City", "Country", birthDateObject, new String[] {"Java", "PHP", "Perl", "SQL"}, new String[] {"CRM system", "CMS system for government"});
// or with setters
Programmer programmer = new Programmer();
programmer.setName("first name");
programmer.setLastName("last name");
// ... multiple lines after
programmer.setProjects(new String[] {"CRM system", "CMS system for government"});

Builder允许我们通过使用将值传递给父类的内部构建器对象来清楚地分解对象构造。所以对于我们这个程序员简历的对象的创建，构建器可以看起来像：

public class BuilderTest {@Testpublic void test() {Programmer programmer = new Programmer.ProgrammerBuilder().setFirstName("F").setLastName("L").setCity("City").setZipCode("0000A").setAddress("Street 39").setLanguages(new String[] {"bash", "Perl"}).setProjects(new String[] {"Linux kernel"}).build();assertTrue("Programmer should be 'F L' but was '"+ programmer+"'", programmer.toString().equals("F L"));}}class Programmer {private String firstName;private String lastName;private String address;private String zipCode;private String city;private String[] languages;private String[] projects;private Programmer(String fName, String lName, String addr, String zip, String city, String[] langs, String[] projects) {this.firstName = fName;this.lastName = lName;this.address = addr;this.zipCode = zip;this.city = city;this.languages = langs;this.projects = projects;}public static class ProgrammerBuilder {private String firstName;private String lastName;private String address;private String zipCode;private String city;private String[] languages;private String[] projects;public ProgrammerBuilder setFirstName(String firstName) {this.firstName = firstName;return this;}public ProgrammerBuilder setLastName(String lastName) {this.lastName = lastName;return this;}public ProgrammerBuilder setAddress(String address) {this.address = address;return this;}public ProgrammerBuilder setZipCode(String zipCode) {this.zipCode = zipCode;return this;}public ProgrammerBuilder setCity(String city) {this.city = city;return this;}public ProgrammerBuilder setLanguages(String[] languages) {this.languages = languages;return this;}public ProgrammerBuilder setProjects(String[] projects) {this.projects = projects;return this;}public Programmer build() {return new Programmer(firstName, lastName, address, zipCode, city, languages, projects);}}@Overridepublic String toString() {return this.firstName + " "+this.lastName;}}

可以看出，构建器后面隐藏了对象构造的复杂性，内部静态类接受链接方法的调用。在Spring中，我们可以在org.springframework.beans.factory.support.BeanDefinitionBuilder类中检索这个逻辑。这是一个允许我们以编程方式定义bean的类。我们可以在关于bean工厂后处理器的文章中看到它，BeanDefinitionBuilder包含几个方法，它们为AbstractBeanDefinition抽象类的相关实现设置值，比如作用域，工厂方法，属性等。想看看它是如何工作的，请查看以下这些方法：

public class BeanDefinitionBuilder {/*** The {@code BeanDefinition} instance we are creating.*/private AbstractBeanDefinition beanDefinition;// ... some not important methods for this article// Some of building methods/*** Set the name of the parent definition of this bean definition.*/public BeanDefinitionBuilder setParentName(String parentName) {this.beanDefinition.setParentName(parentName);return this;}/*** Set the name of the factory method to use for this definition.*/public BeanDefinitionBuilder setFactoryMethod(String factoryMethod) {this.beanDefinition.setFactoryMethodName(factoryMethod);return this;}/*** Add an indexed constructor arg value. The current index is tracked internally* and all additions are at the present point.* @deprecated since Spring 2.5, in favor of {@link #addConstructorArgValue}*/@Deprecatedpublic BeanDefinitionBuilder addConstructorArg(Object value) {return addConstructorArgValue(value);}/*** Add an indexed constructor arg value. The current index is tracked internally* and all additions are at the present point.*/public BeanDefinitionBuilder addConstructorArgValue(Object value) {this.beanDefinition.getConstructorArgumentValues().addIndexedArgumentValue(this.constructorArgIndex++, value);return this;}/*** Add a reference to a named bean as a constructor arg.* @see #addConstructorArgValue(Object)*/public BeanDefinitionBuilder addConstructorArgReference(String beanName) {this.beanDefinition.getConstructorArgumentValues().addIndexedArgumentValue(this.constructorArgIndex++, new RuntimeBeanReference(beanName));return this;}/*** Add the supplied property value under the given name.*/public BeanDefinitionBuilder addPropertyValue(String name, Object value) {this.beanDefinition.getPropertyValues().add(name, value);return this;}/*** Add a reference to the specified bean name under the property specified.* @param name the name of the property to add the reference to* @param beanName the name of the bean being referenced*/public BeanDefinitionBuilder addPropertyReference(String name, String beanName) {this.beanDefinition.getPropertyValues().add(name, new RuntimeBeanReference(beanName));return this;}/*** Set the init method for this definition.*/public BeanDefinitionBuilder setInitMethodName(String methodName) {this.beanDefinition.setInitMethodName(methodName);return this;}// Methods that can be used to construct BeanDefinition/*** Return the current BeanDefinition object in its raw (unvalidated) form.* @see #getBeanDefinition()*/public AbstractBeanDefinition getRawBeanDefinition() {return this.beanDefinition;}/*** Validate and return the created BeanDefinition object.*/public AbstractBeanDefinition getBeanDefinition() {this.beanDefinition.validate();return this.beanDefinition;}
}

三、工厂方法

创建对象模式三剑客的第二个成员是工厂方法设计模式。它完全适于使用动态环境作为Spring框架。实际上，这种模式允许通过公共静态方法对象进行初始化，称为工厂方法。在这个概念中，我们需要定义一个接口来创建对象。但是创建是由使用相关对象的类创建的。

但是在跳到Spring世界之前，让我们用Java代码做一个例子：

public class FactoryMethodTest {@Testpublic void test() {Meal fruit = Meal.valueOf("banana");Meal vegetable = Meal.valueOf("carrot");assertTrue("Banana should be a fruit but is "+fruit.getType(), fruit.getType().equals("fruit"));assertTrue("Carrot should be a vegetable but is "+vegetable.getType(), vegetable.getType().equals("vegetable"));}}class Meal {private String type;public Meal(String type) {this.type = type;}public String getType() {return this.type;}// Example of factory method - different object is created depending on current contextpublic static Meal valueOf(String ingredient) {if (ingredient.equals("banana")) {return new Meal("fruit");}return new Meal("vegetable");}
}

在Spring中，我们可以通过指定的工厂方法创建bean。该方法与以前代码示例中看到的valueOf方法完全相同。它是静态的，可以采取没有或多个参数。为了更好地了解案例，让我们来看一下实例。首先搞定下配置：

<bean id="welcomerBean" class="com.mysite.Welcomer" factory-method="createWelcomer"><constructor-arg ref="messagesLocator"></constructor-arg>
</bean><bean id="messagesLocator" class="com.mysite.MessageLocator"><property name="messages" value="messages_file.properties"></property>
</bean>

现在请关注这个bean的初始化：

public class Welcomer {private String message;public Welcomer(String message) {this.message = message;}public static Welcomer createWelcomer(MessageLocator messagesLocator) {Calendar cal = Calendar.getInstance();String msgKey = "welcome.pm";if (cal.get(Calendar.AM_PM) == Calendar.AM) {msgKey = "welcome.am";}return new Welcomer(messagesLocator.getMessageByKey(msgKey));}
}

当Spring将构造welcomerBean时，它不会通过传统的构造函数，而是通过定义的静态工厂方法createWelcomer来实现。还要注意，这个方法接受一些参数（MessageLocator bean的实例包含所有可用的消息）标签，通常保留给传统的构造函数。

四、抽象工厂

最后一个，抽象的工厂设计模式，看起来类似于工厂方法。不同之处在于，我们可以将抽象工厂视为这个词的工业意义上的工厂，即。作为提供所需对象的东西。工厂部件有：抽象工厂，抽象产品，产品和客户。更准确地说，抽象工厂定义了构建对象的方法。抽象产品是这种结构的结果。产品是具有同样结构的具体结果。客户是要求创造产品来抽象工厂的人。

同样的，在进入Spring的细节之前，我们将首先通过示例Java代码说明这个概念：

public class FactoryTest {// Test method which is the client@Testpublic void test() {Kitchen factory = new KitchenFactory();KitchenMeal meal = factory.getMeal("P.1");KitchenMeal dessert = factory.getDessert("I.1");assertTrue("Meal's name should be 'protein meal' and was '"+meal.getName()+"'", meal.getName().equals("protein meal"));assertTrue("Dessert's name should be 'ice-cream' and was '"+dessert.getName()+"'", dessert.getName().equals("ice-cream"));}}// abstract factory
abstract class Kitchen {public abstract KitchenMeal getMeal(String preferency);public abstract KitchenMeal getDessert(String preferency);
}// concrete factory
class KitchenFactory extends Kitchen {@Overridepublic KitchenMeal getMeal(String preferency) {if (preferency.equals("F.1")) {return new FastFoodMeal();} else if (preferency.equals("P.1")) {return new ProteinMeal();}return new VegetarianMeal();}@Overridepublic KitchenMeal getDessert(String preferency) {if (preferency.equals("I.1")) {return new IceCreamMeal();}return null;}
}// abstract product
abstract class KitchenMeal {public abstract String getName();
}// concrete products
class ProteinMeal extends KitchenMeal {@Overridepublic String getName() {return "protein meal";}
}class VegetarianMeal extends KitchenMeal {@Overridepublic String getName() {return "vegetarian meal";}
}class FastFoodMeal extends KitchenMeal {@Overridepublic String getName() {return "fast-food meal";}
}class IceCreamMeal extends KitchenMeal {@Overridepublic String getName() {return "ice-cream";}
}

我们可以在这个例子中看到，抽象工厂封装了对象的创建。对象创建可以使用与经典构造函数一样使用的工厂方法模式。在Spring中，工厂的例子是org.springframework.beans.factory.BeanFactory。通过它的实现，我们可以从Spring的容器访问bean。根据采用的策略，getBean方法可以返回已创建的对象（共享实例，单例作用域）或初始化新的对象（原型作用域）。在BeanFactory的实现中，我们可以区分：ClassPathXmlApplicationContext，XmlWebApplicationContext，StaticWebApplicationContext，StaticPortletApplicationContext，GenericApplicationContext，StaticApplicationContext。

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"file:test-context.xml"})
public class TestProduct {@Autowiredprivate BeanFactory factory;@Testpublic void test() {System.out.println("Concrete factory is: "+factory.getClass());assertTrue("Factory can't be null", factory != null);ShoppingCart cart = (ShoppingCart) factory.getBean("shoppingCart");assertTrue("Shopping cart object can't be null", cart != null);System.out.println("Found shopping cart bean:"+cart.getClass());}
}

在这种情况下，抽象工厂由BeanFactory接口表示。具体工厂是在第一个System.out中打印的，是org.springframework.beans.factory.support.DefaultListableBeanFactory的实例。它的抽象产物是一个对象。在我们的例子中，具体的产品就是被强转为ShoppingCart实例的抽象产品（Object）。

第一篇文章介绍了通过设计模式来正确组织的我们实现良好的编程风格。在这里，我们可以看到在Spring框架中使用解释器，构建器，工厂方法和工厂。第一个是帮助解释以SpEL表达的文本。三个最后的模式属于创建设计模式的三剑客，它们在Spring中的主要目的是简化对象的创建。他们通过分解复杂对象（构建器）的初始化或通过集中在公共点的初始化来做到对象的创建(要不然怎么叫工厂呢，必须有通用点的)。

五、代理模式

面向对象编程（OOP）可能是编程中最流行的概念。然而，Spring引入了另一种编码规范，面向切面编程（AOP）。为了简化定义，AOP是面向系统特定点的一种编程，如：异常抛出，特定类别方法的执行等.AOP允许在执行这些特定点之前或之后执行补充动作。如何实现这种操作？它可以通过监听器(listeners)进行。但在这种情况下，我们应该在只要可能存在调用的地方都需要定义监听器来进行监听（比如在一个方法的开始的地方）。这就是为什么Spring不采用这个idea。相反，Spring实现了一种能够通过额外的方法调用完成任务的设计模式 - 代理设计模式。

代理就像对象的镜像一样。也正因为如此，代理对象不仅可以覆盖真实对象，还可以扩展其功能。因此，对于只能在屏幕上打印一些文本的对象，我们可以添加另一个对象来过滤显示单词。可以通过代理来定义第二个对象的调用。代理是封装真实对象的对象。例如，如果您尝试调用Waiter bean，那么您将调用该Bean的代理，其行为方式完全相同。

代理设计模式的一个很好的例子是org.springframework.aop.framework.ProxyFactoryBean。该工厂根据Spring bean构建AOP代理。该类实现了定义**getObject()**方法的FactoryBean接口。此方法用于将需求Bean的实例返回给bean factory。在这种情况下，它不是返回的实例，而是AOP代理。在执行代理对象的方法之前，可以通过调用补充方法来进一步“修饰”代理对象(其实所谓的静态代理不过是在装饰模式上加了个要不要你来干动作行为而已，而不是装饰模式什么也不做就加了件衣服，其他还得由你来全权完成)。

ProxyFactory的一个例子是：

public class TestProxyAop {@Testpublic void test() {ProxyFactory factory = new ProxyFactory(new House());factory.addInterface(Construction.class);factory.addAdvice(new BeforeConstructAdvice());factory.setExposeProxy(true);Construction construction = (Construction) factory.getProxy();construction.construct();assertTrue("Construction is illegal. "+ "Supervisor didn't give a permission to build "+ "the house", construction.isPermitted());}}interface Construction {public void construct();public void givePermission();public boolean isPermitted();
}class House implements Construction{private boolean permitted = false;@Overridepublic boolean isPermitted() {return this.permitted;}@Overridepublic void construct() {System.out.println("I'm constructing a house");}@Overridepublic void givePermission() {System.out.println("Permission is given to construct a simple house");this.permitted = true;}
}class BeforeConstructAdvice implements MethodBeforeAdvice {@Overridepublic void before(Method method, Object[] arguments, Object target) throws Throwable {if (method.getName().equals("construct")) {((Construction) target).givePermission();}}}

这个测试应该通过，因为我们不直接在House实例上操作，而是代理它。代理调用第一个BeforeConstructAdvice的before方法（指向在执行目标方法之前执行，在我们的例子中为construct()）通过它，给出了一个“权限”来构造对象的字段（house）。代理层提供了一个额外新功能，因为它可以简单地分配给另一个对象。要做到这一点，我们只能在before方法之前修改过滤器。

六、复合模式

另一种结构模式是复合模式。在关于Spring中设计模式的第一篇文章中，我们使用构建器来构造复杂对象。另一种实现方法是使用复合模式。这种模式是基于具有共同行为的多个对象的存在，用于构建更大的对象。较大的对象仍然具有与最小对象相同的特征。那么用它来定义相同的行为。

复合对象的非Spring示例可以是一个写入HTML的文本对象，由包含span或em标签的段落组成

public class CompositeTest {@Testpublic void test() {TextTagComposite composite = new PTag();composite.addTag(new SpanTag());composite.addTag(new EmTag());// sample client codecomposite.startWrite();for (TextTag leaf : composite.getTags()) {leaf.startWrite();leaf.endWrite();}composite.endWrite();assertTrue("Composite should contain 2 tags but it contains "+composite.getTags().size(), composite.getTags().size() == 2);}}interface TextTag {public void startWrite();public void endWrite();
}interface TextTagComposite extends TextTag {public List<TextTag> getTags();public void addTag(TextTag tag);
}class PTag implements TextTagComposite {private List<TextTag> tags = new ArrayList<TextTag>();@Overridepublic void startWrite() {System.out.println("<p>");}@Overridepublic void endWrite() {System.out.println("</p>");}@Overridepublic List<TextTag> getTags() {return tags;}@Overridepublic void addTag(TextTag tag) {tags.add(tag);}
}class SpanTag implements TextTag {@Overridepublic void startWrite() {System.out.println("<span>");}@Overridepublic void endWrite() {System.out.println("</span>");}}class EmTag implements TextTag {@Overridepublic void startWrite() {System.out.println("<em>");}@Overridepublic void endWrite() {System.out.println("</em>");}}

在这种情况下，可以看到一个复合对象。我们可以区分复合与非复合对象，因为第一个可以容纳一个或多个非复合对象（PTag类中的private List tags字段）。非复合对象称为叶子。TextTag接口被称为组件，因为它为两个对象类型提供了共同的行为规范(有点像Linux文件管理系统的有共同点的文件放在一个文件夹下进行管理，其实就是节点管理)。

在Spring世界中，我们检索复合对象的概念是org.springframework.beans.BeanMetadataElement接口，用于配置bean对象。它是所有继承对象的基本界面。现在，在一方面，我们有一个叶子，由org.springframework.beans.factory.parsing.BeanComponentDefinition表示，另一边是复合org.springframework.beans.factory.parsing.CompositeComponentDefinition。CompositeComponentDefinition类似于组件，因为它包含addNestedComponent（ComponentDefinition component）方法，它允许将叶添加到私有final列表中nestedComponents。您可以看到，由于此列表，BeanComponentDefinition和CompositeComponentDefinition的组件是org.springframework.beans.factory.parsing.ComponentDefinition。

七、策略模式

本文描述的第三个概念是策略设计模式。策略定义了通过不同方式完成相同事情的几个对象。完成任务的方式取决于采用的策略。举个例子说明，我们可以去一个国家。我们可以乘公共汽车，飞机，船甚至汽车去那里。所有这些方法将把我们运送到目的地国家。但是，我们将通过检查我们的银行帐户来选择最适应的方式。如果我们有很多钱，我们将采取最快的方式（可能是私人飞行）。如果我们没有足够的话，我们会采取最慢的（公车，汽车）。该银行账户作为确定适应策略的因素。

Spring在org.springframework.web.servlet.mvc.multiaction.MethodNameResolver类(过时，但不影响拿来研究)中使用策略设计模式。它是MultiActionController(同样过时)的参数化实现。在开始解释策略之前，我们需要了解MultiActionController的实用性。这个类允许同一个类处理几种类型的请求。作为Spring中的每个控制器，MultiActionController执行方法来响应提供的请求。策略用于检测应使用哪种方法。解析过程在MethodNameResolver实现中实现，例如在同一个包中的ParameterMethodNameResolver中。方法可以通过多个条件解决：属性映射，HTTP请求参数或URL路径。

@Override
public String getHandlerMethodName(HttpServletRequest request) throws NoSuchRequestHandlingMethodException {String methodName = null;// Check parameter names where the very existence of each parameter// means that a method of the same name should be invoked, if any.if (this.methodParamNames != null) {for (String candidate : this.methodParamNames) {if (WebUtils.hasSubmitParameter(request, candidate)) {methodName = candidate;if (logger.isDebugEnabled()) {logger.debug("Determined handler method '" + methodName +"' based on existence of explicit request parameter of same name");}break;}}}// Check parameter whose value identifies the method to invoke, if any.if (methodName == null && this.paramName != null) {methodName = request.getParameter(this.paramName);if (methodName != null) {if (logger.isDebugEnabled()) {logger.debug("Determined handler method '" + methodName +"' based on value of request parameter '" + this.paramName + "'");}}}if (methodName != null && this.logicalMappings != null) {// Resolve logical name into real method name, if appropriate.String originalName = methodName;methodName = this.logicalMappings.getProperty(methodName, methodName);if (logger.isDebugEnabled()) {logger.debug("Resolved method name '" + originalName + "' to handler method '" + methodName + "'");}}if (methodName != null && !StringUtils.hasText(methodName)) {if (logger.isDebugEnabled()) {logger.debug("Method name '" + methodName + "' is empty: treating it as no method name found");}methodName = null;}if (methodName == null) {if (this.defaultMethodName != null) {// No specific method resolved: use default method.methodName = this.defaultMethodName;if (logger.isDebugEnabled()) {logger.debug("Falling back to default handler method '" + this.defaultMethodName + "'");}}else {// If resolution failed completely, throw an exception.throw new NoSuchRequestHandlingMethodException(request);}}return methodName;
}

正如我们在前面的代码中可以看到的，方法的名称通过提供的参数映射，URL中的预定义属性或参数存在来解决（默认情况下，该参数的名称是action）。

八、模板模式

本文提出的最后一个设计模式是模板方法。此模式定义了类行为的骨架，并将子步骤的某些步骤的延迟执行(具体就是下面例子中一个方法放在另一个方法中，只有调用另一方方法的时候这个方法才会执行,而且还可能会在其他行为方法之后按顺序执行)。其中写了一种方法(下面例子中的construct())，注意定义为final，起着同步器的角色。它以给定的顺序执行由子类定义的方法。在现实世界中，我们可以将模板方法与房屋建设进行比较。独立于建造房屋的公司，我们需要从建立基础开始，只有在我们完成之后才能做其他的工作。这个执行逻辑将被保存在一个我们不能改变的方法中。例如基础建设或刷墙会被作为一个模板方法中的方法，具体到建筑房屋的公司。我们可以在给定的例子中看到它：

public class TemplateMethod {public static void main(String[] args) {HouseAbstract house = new SeaHouse();house.construct();}}abstract class HouseAbstract {protected abstract void constructFoundations();protected abstract void constructWall();// template methodpublic final void construct() {constructFoundations();constructWall();}
}class EcologicalHouse extends HouseAbstract {@Overrideprotected void constructFoundations() {System.out.println("Making foundations with wood");}@Overrideprotected void constructWall() {System.out.println("Making wall with wood");}}class SeaHouse extends HouseAbstract {@Overrideprotected void constructFoundations() {System.out.println("Constructing very strong foundations");}@Overrideprotected void constructWall() {System.out.println("Constructing very strong wall");}}

该代码应该输出：

Constructing very strong foundations
Constructing very strong wall

Spring在org.springframework.context.support.AbstractApplicationContext类中使用模板方法。他们不是一个模板方法（在我们的例子中是construct ），而是多个。例如，getsFreshBeanFactory返回内部bean工厂的新版本，调用两个抽象方法：refreshBeanFactory（刷新工厂bean）和getBeanFactory（以获取更新的工厂bean）。这个方法和其他一些方法一样，用在public void refresh()中，抛出构造应用程序上下文的BeansException，IllegalStateException方法(这里会在后面Spring中与应用程序上下文分析中再次提到)。

我们可以从同一个包中的GenericApplicationContext找到一些通过模板方法所实现的抽象方法的实现的例子(说的有点拗口，多读几遍就好):

/*** Do nothing: We hold a single internal BeanFactory and rely on callers* to register beans through our public methods (or the BeanFactory's).* @see #registerBeanDefinition*/
@Override
protected final void refreshBeanFactory() throws IllegalStateException {if (this.refreshed) {throw new IllegalStateException("GenericApplicationContext does not support multiple refresh attempts: just call 'refresh' once");}this.beanFactory.setSerializationId(getId());this.refreshed = true;
}@Override
protected void cancelRefresh(BeansException ex) {this.beanFactory.setSerializationId(null);super.cancelRefresh(ex);
}/*** Not much to do: We hold a single internal BeanFactory that will never* get released.*/
@Override
protected final void closeBeanFactory() {this.beanFactory.setSerializationId(null);
}/*** Return the single internal BeanFactory held by this context* (as ConfigurableListableBeanFactory).*/
@Override
public final ConfigurableListableBeanFactory getBeanFactory() {return this.beanFactory;
}/*** Return the underlying bean factory of this context,* available for registering bean definitions.* <p><b>NOTE:</b> You need to call {@link #refresh()} to initialize the* bean factory and its contained beans with application context semantics* (autodetecting BeanFactoryPostProcessors, etc).* @return the internal bean factory (as DefaultListableBeanFactory)*/
public final DefaultListableBeanFactory getDefaultListableBeanFactory() {return this.beanFactory;
}