在一个工程中如果想要使用 SpringMVC的话，只需要两个步骤
在web.xml中配置一个DispatcherServlet。需要配置一个org.springframework.web.servlet.DispatcherServlet的servlet。
定义一个dispatcherServlet-servlet.xml配置文件。在这个配置文件里面我们只需要扩展一个路径映射关系，定义一个视图解析器，再定义一个业务逻辑的处理流程规则。
这样就可以搞定一个最基本的Spring MVC的应用了。
对于spring MVC框架中，有三个组件是用户必须定义和扩展的：
&&& 定义URL映射规则：handlerMapping
&&& 实现业务逻辑的handler实例对象：handlerAdapter
&&& 渲染模版资源：ViewResolver
下面是传统的配置示例：
&!-- web.xml --&
&servlet-name&countries&/servlet-name&
&servlet-class&org.springframework.web.servlet.DispatcherServlet&/servlet-class&
&load-on-startup&2&/load-on-startup&
&/servlet&
&servlet-mapping&
&servlet-name&countries&/servlet-name&
&url-pattern&*.htm&/url-pattern&
&/servlet-mapping
&!-- dispatcherServlet-servlet.xml --&
派遣器收到请求后,把不同的页面派遣到不同的控制器进行处理
Spring有两种MAPPING的机制,默认为BeanNameUrlHandlerMapping,在DispatcherServlet.properties文件中配置
我们这里采用的是SimpleUrlHandlerMapping. --&
&bean id="urlMapping" class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping"&
&property name="mappings"&
&prop key="/home.htm"&countriesController&/prop&
&/property&
&!-- 在控制器处理前,我们可以将其拦截,进行一些特殊或通用处理;拦截器可以选用Spring已经实现的或我们自己实现的
&property name="interceptors"&
&ref local="localeChangeInterceptor"/&
&ref local="themeChangeInterceptor"/&
&ref local="copyInterceptor"/&
&/property&
&bean id="countriesController" class="cn.jephon.demo.CountriesController" /&
下面是用freemaker引擎的配置示例：
&!--web.xml 配置 spring 的DispatcherServlet--&
&servlet-name&SpringMVC&/servlet-name&
&servlet-class&org.springframework.web.servlet.DispatcherServlet&/servlet-class&
&init-param&
&param-name&contextConfigLocation&/param-name&
&!--给出框架配置文件所在的路径--&
&param-value&classpath:conf/freemarker-servlet.xml&/param-value&
&/init-param&
&/servlet&
&!--freemarker-servlet在conf/freemarker-servlet.xml文件中的参数配置如下--&
&!-- freemark --&
&bean id="freemarkerConfig"
class="org.springframework.web.servlet.view.freemarker.FreeMarkerConfigurer"&
&property name="templateLoaderPath" value="/WEB-INF/ftl/" /&
&property name="defaultEncoding" value="UTF-8" /&
&bean id="viewResolver"
class="org.springframework.web.servlet.view.freemarker.FreeMarkerViewResolver"&
&property name="cache" value="true" /&
&property name="prefix" value="" /&
&property name="suffix" value=".ftl" /&
&property name="exposeSpringMacroHelpers" value="true" /&
&property name="exposeRequestAttributes" value="true" /&
&property name="exposeSessionAttributes" value="true" /&
&property name="requestContextAttribute" value="request" /&
&property name="contentType" value="text/ charset=utf-8" /&
SpringMVC的入口是DispatchServlet，它的工作大致可以分为两个部分，一个是初始化，另外一个是请求处理。
DispatcherServlet初始化
//DispatcherServlet的初始化方法
public final void init() throws ServletException {
if (logger.isDebugEnabled()) {
logger.debug("Initializing servlet '" + getServletName() + "'");
// Set bean properties from init parameters.
PropertyValues pvs = new ServletConfigPropertyValues(getServletConfig(), this.requiredProperties);
BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(this);
ResourceLoader resourceLoader = new ServletContextResourceLoader(getServletContext());
bw.registerCustomEditor(Resource.class, new ResourceEditor(resourceLoader, this.environment));
　　　　 //只有HttpServletBean覆盖了此方法，
　　　　 //所以由HttpServletBean读取配置在ServletContext中的bean属性参数，即web.xml中的context-param，然后创建和设置这些bean属性
initBeanWrapper(bw);
bw.setPropertyValues(pvs, true);
catch (BeansException ex) {
logger.error("Failed to set bean properties on servlet '" + getServletName() + "'", ex);
//由FrameServlet执行此方法，调用FrameworkServlet的createWebApplicationContext方法，初始化spring容器。
　　//调用FrameworkServlet的onRefresh方法完成配置文件的加载，配置文件的加载是先查找servlet的init-param参数中设置的路径，如果没有，就会根据namespace+Servlet的名称来查找XML文件。
　　//Spring容器加载的时候会调用DispatcherServlet的initStrategies方法来初始化springMVC框架所需要的八个组件，　　//这八个组件对应的八个bean对应都保存在DispatcherServlet类中。
　　initServletBean();
if (logger.isDebugEnabled()) {
logger.debug("Servlet '" + getServletName() + "' configured successfully");
protected void initStrategies(ApplicationContext context) {
//初始化MultipartResolver，主要是处理文件上传服务。
initMultipartResolver(context);
//用于处理应用的国际化问题
initLocaleResolver(context);
//用于定义一个主题
initThemeResolver(context);
//用于定义用户设置的请求映射关系
initHandlerMappings(context);
//用于根据Handler的类型定义不同的处理规则
initHandlerAdapters(context);
//当Handler处理错误的时候，通过这个handler来做统一的处理
initHandlerExceptionResolvers(context);
//将指定的ViewName按照定义的RequestToViewNameTranslator替换成想要的格式。
initRequestToViewNameTranslator(context);
//用于将view解析成页面
initViewResolvers(context);
//用于映射flash管理的。
initFlashMapManager(context);
要做的8件事是如下。
initMultipartResolver：初始化MultipartResolver，用于处理文件上传服务，如果有文件上传，那么会将当前的HttpServletRequest包装成DefaultMultipartHttp ServletRequest，并且将每个上传的内容封装成CommonsMultipartFile对象。
initLocaleResolver：用于处理应用的国际化问题，通过解析请求的Locale和设置响应的Locale来控制应用中的字符编码问题。
initThemeResolver：用于定义一个主题，例如，可以根据用户的喜好来设置用户访问的页面的样式，可以将这个样式作为一个Theme Name保存，用于请求的Cookie中或者保存在服务端的Session中，以后每次请求根据这个Theme Name来返回特定的内容。
initHandlerMappings：用于定义用户设置的请求映射关系，例如，前面示例中的SimpleUrlHandlerMapping把用于用户请求的URL映射成一个个Handler实例。HandlerMapping必须定义，如果没有定义，将获取DispatcherServlet.properties文件中默认的两个HandlerMapping，分别是BeanNameUrlHandlerMapping和DefaultAnnotationHandlerMapping。
initHandlerAdapters：用于根据Handler的类型定义不同的处理规则，例如，定义SimpleControllerHandlerAdapter处理所有Controller的实例对象，在HandlerMapping中将URL映射成一个Controller实例，那么Spring MVC在解析时SimpleController HandlerAdapter就会调用这个Controller实例。同样HandlerAdapters也必须定义，如果没有定义，将获取DispatcherServlet.properties文件中默认的四个Handler Adapters，分别是HttpRequestHandlerAdapter、SimpleControllerHandlerAdapter、ThrowawayControllerHandlerAdapter和AnnotationMethodHandlerAdapter。
initHandlerExceptionResolvers：当Handler处理出错时，通过这个Handler来统一做处理，默认的实现类是SimpleMappingExceptionResolver，将错误日志记录在log文件中，并且转到默认的错误页面。
initRequestToViewNameTranslator：将指定的ViewName按照定义的RequestToVie wNameTranslator替换成想要的格式，如加上前缀或者后缀等。
initViewResolvers：用于将View解析成页面，在ViewResolvers中可以设置多个解析策略，如可以根据JSP来解析，或者按照Velocity模板解析。默认的解析策略是InternalResourceViewResolver，按照JSP页面来解析。
上面的是springMVC的工作原理图：
1、客户端发出一个http请求给web服务器，web服务器对http请求进行解析，如果匹配DispatcherServlet的请求映射路径（在web.xml中指定），web容器将请求转交给DispatcherServlet.
2、DipatcherServlet接收到这个请求之后将根据请求的信息（包括URL、Http方法、请求报文头和请求参数Cookie等）以及HandlerMapping的配置找到处理请求的处理器（Handler）。
3-4、DispatcherServlet根据HandlerMapping找到对应的Handler,将处理权交给Handler（Handler将具体的处理进行封装），再由具体的HandlerAdapter对Handler进行具体的调用。
5、Handler对数据处理完成以后将返回一个ModelAndView()对象给DispatcherServlet。
6、Handler返回的ModelAndView()只是一个逻辑视图并不是一个正式的视图，DispatcherSevlet通过ViewResolver将逻辑视图转化为真正的视图View。
7、Dispatcher通过model解析出ModelAndView()中的参数进行解析最终展现出完整的view并返回给客户端。
HandlerMapping初始化：
将URL与Handler的对应关系保存在HandlerMapping集合中，并将所有的interceptors对象保存在adaptedInterceptors数组中，等请求到来的时候执行所有的adaptedIntercoptors数组中的interceptor对象。所有的interceptor必须实现HandlerInterceptor接口。
HandlerAdapter初始化：
Spring MVC中提供了如下三个典型的简单HandlerAdapter实现类。
SimpleServletHandlerAdapter：可以继承HttpRequestHandler接口，所有的Handler可以实现其void handleRequest(HttpServletRequest request, HttpServletResponse response)方法，这个方法没有返回值。
SimpleControllerHandlerAdapter：可以继承Controller接口，所有的Handler可以实现其public ModelAndView handle(HttpServletRequest request, HttpServletRes ponse response, Object handler)方法，该方法会返回ModelAndView对象，用于后续的模板渲染。
SimpleServletHandlerAdapter：可以直接继承Servlet接口，可以将一个Servlet作为一个Handler来处理这个请求。
Spring MVC的HandlerAdapter机制可让Handler的实现更加灵活，不需要和其他框架那样只能和某个Handler接口绑定起来。
对于handlerAdapter的初始化没有什么特别之处，只是简单的创建一个handlerAdapter对象，将这个对象保存在DispatcherServlet的HandlerAdapters集合中。当Spring MVC将某个URL对应到某个Handler时候，在handlerAdapters集合中查询那个handlerAdapter对象supports这个Handler，handlerAdapter对象将会被返回，然后调用这个handlerAdapter接口对应的方法。如果这个handlerAdapter对象是SimpleControllerHandlerAdapter，将调用Controller接口的public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)方法。
Control的调用逻辑：
整个Spring MVC的调用是从DispatcherServlet的doService方法开始的，在doService方法中会将ApplicationContext、localeResolver、themeResolver等对象添加到request中便于在后面使用，接着就调用doDispatch方法，这个方法是主要的处理用户请求的地方。&
对于control的处理关键就是：DispatcherServlet的handlerMappings集合中根据请求的URL匹配每一个handlerMapping对象中的某个handler,匹配成功之后将会返回这个handler的处理连接handlerExecutionChain对象。而这个handlerExecutionChain对象中将会包含用户自定义的多个handlerInterceptor对象。
protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
for (HandlerMapping hm : this.handlerMappings) {
if (logger.isTraceEnabled()) {
logger.trace(
"Testing handler map [" + hm + "] in DispatcherServlet with name '" + getServletName() + "'");
HandlerExecutionChain handler = hm.getHandler(request);
if (handler != null) {
return null;
对于handlerInterceptor接口中定义的三个方法中，preHandler和postHandler分别在handler的执行前和执行后执行，afterCompletion在view渲染完成、在DispatcherServlet返回之前执行。当preHandler返回false时，当前的请求将在执行完afterCompletion后直接返回,handler也将不会执行。
在类HandlerExecutionChain中的getHandler()方法是返回object对象的；这里的handler是没有类型的，handler的类型是由handlerAdapter决定的。dispatcherServlet会根据handlerAdapters集合中第一个支持该handler对象的HandlerAdapter对象。接下来去执行handler对象的相应方法了，如果该handler对象的相应方法返回一个ModelAndView对象(SampleControllerHandlerAdapter)接下来就是去执行View渲染了。
如果handler返回了ModelAndView对象，那么说明Handler需要传一个Model实例给view去渲染模版。除了渲染页面需要model实例，在业务逻辑层通常也有Model实例。
ModelAndView对象是连接业务逻辑层与view展示层的桥梁，对spring MVC来说它也是连接Handler与view的桥梁。ModelAndView对象顾名思义会持有一个ModelMap对象和一个View对象或者View的名称(譬如hello.vm模板名字)。ModelMap对象就是执行模版渲染时候所需要的变量对应的实例，如jsp的通过request.getAttribute(String)获取的JSTL标签名对应的对象。velocity中context.get(String)获取$foo对应的变量实例。
public class ModelAndView {
/** View instance or view name String */
/** Model Map */
private ModelM
/** Indicates whether or not this instance has been cleared with a call to {@link #clear()} */
private boolean cleared = false;
ModelMap其实也是一个Map,Handler中将模版中需要的对象存在这个Map中，然后传递到view对应的ViewResolver中。
不同的ViewResolver会对这个Map中的对象有不同的处理方式；
velocity中将这个Map保存到VelocityContext中。
freemarker模板引擎来说将ModelMap包装成freemarker.template. TemplateHash Model
JSP中将每一个ModelMap中的元素分别设置到request.setAttribute(modelName,modelValue);
在spring MVC中，view模块需要两个组件来支持：RequestToViewNameTranslator和ViewResolver
public interface RequestToViewNameTranslator {
String getViewName(HttpServletRequest request) throws E
public interface ViewResolver {
View resolveViewName(String viewName, Locale locale) throws E
RequestToViewNameTranslator：主要支持用户自定义对viewName的解析，如将请求的ViewName加上前缀或者后缀，或者替换成特定的字符串等。
ViewResolver：主要是根据用户请求的viewName创建适合的模版引擎来渲染最终的页面，ViewResolver会根据viewName创建一个view对象，调用view对象的Void render方法渲染出页面。
public interface View {
void render(Map&String, ?& model, HttpServletRequest request, HttpServletResponse response) throws E
UrlBasedViewResolver类实现了AbstractCachingViewResolver抽象类，通过设置ViewClass来创建View对象。如果使用FreeMarkerViewResolver类，会将ViewClass设置为FreeMarkerView.class；使用VelocityViewResolver类，会将ViewClass设置为VelocityView.class。InternalResourceViewResolver类可以通过注入的方式设置ViewClass属性来初始化自定义的View对象。由于AbstractCachingViewResolver抽象类也继承了WebApplicationObjectSupport，所以所有的AbstractCachingViewResolver子类可以通过覆盖initApplicationContext方法在Spring MVC框架启动时完成初始化工作。如FreeMarkerViewResolver和VelocityViewResolver就是在启动调用setViewClass方法时设置ViewClass属性的。JSP的ViewResolver对应的是InternalResourceViewResolver类，当调用resolveViewName方法时会调用createView方法，将ViewClass属性对应的InternalResourceView类实例化。最后调用InternalResourceView的render方法渲染出JSP页面。
&Spring MVC解析View的逻辑：
dispatcherServlet调用getDefaultViewName（）方法；
调用RequestToViewNameTranslator的getViewName方法；
调用LocaleResolver接口的resolveLocale方法；
调用ViewResolver接口的resolveViewName方法，返回view对象
调用render方法渲染出页面
JSP的ViewResolver对应的是InternalResourceViewResolver类，当调用resolveViewName方法时会调用createView方法，将ViewClass属性对应的InternalResourceView类实例化。最后调用InternalResourceView的render方法渲染出JSP页面。
总的时序图
阅读(...) 评论()> Struts,spring工作机制(小结)
Struts,spring工作机制(小结)
发布时间： & &
浏览：1 & &
回复：0 & &
悬赏：0.0希赛币
Struts,spring工作机制(总结)
　　1,Struts1 工作流程：
　　web.xml:
　　&servlet&　
&servlet-name&action&/servlet-name& 　
&servlet-class&org.apache.struts.action.ActionServlet&/servlet-class& &/servlet& &servlet-mapping& 　
&servlet-name&action&/servlet-name& 　
&url-pattern&*.do&/url-pattern& &/servlet-mapping&
　　在web应用启动时就会加载初始化ActionServlet,ActionServlet从struts-config.xml文件中读取配置信息,把它们存放到各种配置对象当ActionServlet接收到一个客户请求时,将执行如下流程.-(1)检索和用户请求匹配的ActionMapping实例,如果不存在,就返回请求路径无效信息; -(2)如果ActionForm实例不存在,就创建一个ActionForm对象,把客户提交的表单数据保存到ActionForm对象中; -(3)根据配置信息决定是否需要表单验证.如果需要验证,就调用ActionForm的validate()方法; -(4)如果ActionForm的validate()方法返回null或返回一个不包含ActionMessage的ActuibErrors对象, 就表示表单验证成功; -(5)ActionServlet根据ActionMapping所包含的映射信息决定将请求转发给哪个Action,如果相应的 Action实例不存在,就先创建这个实例,然后调用Action的execute()方法; -(6)Action的execute()方法返回一个ActionForward对象,ActionServlet在把客户请求转发给 ActionForward对象指向的JSP组件; -(7)ActionForward对象指向JSP组件生成动态网页,返回给客户;
　　2,Struts2的工作机制
　　web.xml
　　&filter&　　 　
&filter-name&struts2&/filter-name&　　 　
&filter-class&　　 　
org.apache.struts2.dispatcher.FilterDispatcher　　
&/filter-class&　　 &/filter&　　
　　&filter-mapping&　　 　
&filter-name&struts2&/filter-name&　　 　
&url-pattern&/*&/url-pattern&　　 &/filter-mapping&　
　　1、客户端初始化一个指向Servlet容器（例如Tomcat）的请求；2、这个请求经过一系列的过滤器（Filter）（这些过滤器中有一个叫做ActionContextCleanUp的可选过滤器，这个过滤器对于Struts2和其他框架的集成很有帮助，例如：SiteMesh Plugin）；3、接着FilterDispatcher被调用，FilterDispatcher询问ActionMapper来决定这个请求是否需要调用某个Action；4、如果ActionMapper决定需要调用某个Action，FilterDispatcher把请求的处理交给ActionProxy；5、ActionProxy通过Configuration Manager询问框架的配置文件，找到需要调用的Action类；6、ActionProxy创建一个ActionInvocation的实例。7、ActionInvocation实例使用命名模式来调用，在调用Action的过程前后，涉及到相关拦截器（Intercepter）的调用。8、一旦Action执行完毕，ActionInvocation负责根据struts.xml中的配置找到对应的返回结果。返回结果通常是（但不总是，也可能是另外的一个Action链）一个需要被表示的JSP或者FreeMarker的模版。在表示的过程中可以使用Struts2 框架中继承的标签。在这个过程中需要涉及到ActionMapper。
　　包名 说明 orponents 该包封装视图组件，Struts2在视图组件上有了很大加强，不仅增加了组件的属性个数，更新增了几个非常有用的组件，如updownselect、doubleselect、datetimepicker、token、tree等。 ornfig 该包定义与配置相关的接口和类。实际上，工程中的xml和properties文件的读取和解析都是由WebWork完成的，Struts只做了少量的工作。 org.apache.struts2.dispatcher Struts2的核心包，最重要的类都放在该包中。 org.apache.struts2.impl 该包只定义了3个类，他们是StrutsActionProxy、StrutsActionProxyFactory、StrutsObjectFactory，这三个类都是对xwork的扩展。 org.apache.struts2.interceptor 定义内置的截拦器。 org.apache.struts2.util 实用包。 org.apache.struts2.validators 只定义了一个类：DWRValidator。 org.apache.struts2.views 提供freemarker、jsp、velocity等不同类型的页面呈现。
　　3，Spring工作机制
　　web.xml
　　&web-app& 　 &servlet&
　　&servlet-name&Dispatcher&/servlet-name& 　　　 &servlet-class& 　　　　　 org.springframework.web.servlet.DispatcherServlet
　　　 &/servlet-class& 　　　 &init-param& 　　　　　 &param-name&contextConfigLocation&/param-name& 　　　　　 &param-value&/WEB-INF/applicationContext.xml&/param-value& 　　　
&/init-param& 　　　
&load-on-startup&1&/load-on-startup& 　
&/servlet& 　
&servlet-mapping& 　　　
&servlet-name&Dispatcher&/servlet-name& 　　　
&url-pattern&*.do&/url-pattern& 　
&/servlet-mapping& &/web-app&
　　spring mvc请所有的请求都提交给DispatcherServlet,它会委托应用系统的其他模块负责负责对请求进行真正的处理工作。DispatcherServlet查询一个或多个HandlerMapping,找到处理请求的Controller.DispatcherServlet请请求提交到目标ControllerController进行业务逻辑处理后，会返回一个ModelAndViewDispathcher查询一个或多个ViewResolver视图解析器,找到ModelAndView对象指定的视图对象视图对象负责渲染返回给客户端。
本问题标题：
本问题地址：
温馨提示：本问题已经关闭，不能解答。
暂无合适的专家
&&&&&&&&&&&&&&&
希赛网 版权所有 & &&spring自动扫描机制
& & & & &记得之前的项目中leader曾经要求我自己写一个类似spring的自动代码扫描器以便扫描我们代码中一些自定义的method，annotation或者注释方式，并且我们要对扫描结果做自己的处理。 & & & & &
& & & & &这就促使我去看spring中是如何自动扫描的，按照我的认识，应该不外乎2种方法。一是装载配置的根路径及其子文件夹下所有的类文件，并且根据每个被装载的文件的反射属性得到我们想要的annotation或者method等metadata，这个方法按理说比较完美，也比较简单，因为反射能够保证得到的metadata的正确性，但是如果对每个class都装载并反射，应该会非常的慢速，并且没有得到lazyload的好处；二是扫描所有根路径及其子文件下的所有源文件，直接分析源文件的文本属性，同样能得到这些metadata，但是这个方式缺点较多，首先要保证各种写法下都能够正确的解析metadata，如果严格起来就类似词法分析了，另外并非所有源文件都会被放到生产环境中（所以这个方法几乎是不可能的），但是这种方式相对于前一种应该会较快些。
& & & & &为了能够对这个扫描机制有更深的认识，我还是决定一探spring的究竟。首先我找到ComponentScanAnnotationParser，这个类是负责处理ComponentScan的，中间最重要的方法就是parse, parse是一个很长的方法，请容我将中间不重要的代码省略，这时你发现，parse实际上调用了scanner的doScan方法。
public Set&BeanDefinitionHolder& parse(Map&String, Object& componentScanAttributes) {
ClassPathBeanDefinitionScanner scanner =
new ClassPathBeanDefinitionScanner(registry, (Boolean)componentScanAttributes.get(&useDefaultFilters&));
return scanner.doScan(basePackages.toArray(new String[]{}));
好吧，我们顺着挖进去，scanner的doScan方法又做了什么呢，对于我们配置的所有包的位置，他都会调用findCandidateComponents去找到候选的component（之所以是候选，因为找到的component未必生效）
protected Set&BeanDefinitionHolder& doScan(String... basePackages) {
Assert.notEmpty(basePackages, &At least one base package must be specified&);
Set&BeanDefinitionHolder& beanDefinitions = new LinkedHashSet&BeanDefinitionHolder&();
for (String basePackage : basePackages) {
Set&BeanDefinition& candidates = findCandidateComponents(basePackage);
for (BeanDefinition candidate : candidates) {
return beanD
}& & & & 看起来，findCandidateComponenets这个方法就已经得到了反射的annotation了，我们再挖进去，findCandidateComponenets首先调用this.resourcePatternResolver.getResources()得到一堆resource，然后对每个resource调用this.metadataReaderFactory.getMetadataReader(resource)得到MetadataReader，最后判断该metadataReader是否是candidate，如果是，加入集合，所有resource都判断完以后，返回集合。其实这里的MetadataReader就可以得到我们class的元信息，因此，势必要再挖一下MetadataReader。
& & & & & 但是在那之前，我们可以先看看spring是如何配置和定义Resource的，resourcePatternResolver事实上是PathMatchingResourcePatternResolver的实例。通过getResources及其子方法（有兴趣可以自己去挖代码），我们可以看出来，他会处理带通配符和不带通配符的配置，其中带通配符的配置又可以分为3种，分别是jar文件，vfs协议的文件以及普通文件，其中jar文件会装载所有的子文件。这里不免疑问，得到一堆Resource有什么好处，实际上，好处正是隐藏了背后的所有文件类型，将所有的资源抽象。
public Set&BeanDefinition& findCandidateComponents(String basePackage) {
Set&BeanDefinition& candidates = new LinkedHashSet&BeanDefinition&();
String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
resolveBasePackage(basePackage) + &/& + this.resourceP
Resource[] resources = this.resourcePatternResolver.getResources(packageSearchPath);
for (Resource resource : resources) {
if (resource.isReadable()) {
MetadataReader metadataReader = this.metadataReaderFactory.getMetadataReader(resource);
if (isCandidateComponent(metadataReader)) {
ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
sbd.setResource(resource);
sbd.setSource(resource);
if (isCandidateComponent(sbd)) {
if (debugEnabled) {
logger.debug(&Identified candidate component class: & + resource);
candidates.add(sbd);
catch (Throwable ex) {
throw new BeanDefinitionStoreException(
&Failed to read candidate component class: & + resource, ex);
catch (IOException ex) {
throw new BeanDefinitionStoreException(&I/O failure during classpath scanning&, ex);
& & & & & 接下来，从metadataReaderFactory得到MetadataReader，事实上这里的metadataReaderFactory是一个CachingMetadataReaderFactory，它用cache做了唯一性处理，如下。
public MetadataReader getMetadataReader(Resource resource) throws IOException {
if (getCacheLimit() &= 0) {
return super.getMetadataReader(resource);
synchronized (this.classReaderCache) {
MetadataReader metadataReader = this.classReaderCache.get(resource);
if (metadataReader == null) {
metadataReader = super.getMetadataReader(resource);
this.classReaderCache.put(resource, metadataReader);
return metadataR
& & & & &构造SimpleMetadataReader的过程中，会同时构造AnnotationMetadataReadingVisitor(继承自ClassVisitor)，并且调用classReader.accept()，这是什么呢？原来这里的classReader跟classVisitor是asm提供的字节码访问类，从字面上就能看出来，其使用了visitor模式，事实上就是classReader.accept的时候会遍历整个类的字节码，遍历的时候如果碰到method，就会调用ClassVisitor中定义的visitMethod，碰到field，就会调用visitField（同样是回调）。asm的介绍见参考文档。
SimpleMetadataReader(Resource resource, ClassLoader classLoader) throws IOException {
InputStream is = resource.getInputStream();
ClassReader classReader =
classReader = new ClassReader(is);
} finally {
is.close();
AnnotationMetadataReadingVisitor visitor = new AnnotationMetadataReadingVisitor(classLoader);
classReader.accept(visitor, true);
this.annotationMetadata =
// (since AnnotationMetadataReader extends ClassMetadataReadingVisitor)
this.classMetadata =
this.resource =
& & & & &总之，真象大白了，spring做代码扫描的确是通过编译好的字节码去做的，与之前设想的类似，但是是通过asm对字节码的处理，个人认为应该比反射要快，这样就避免了前述的缺点。来到这里，要写一个代码扫描工具就并不是很困难了。
参考文档：
& & & & &Java字节码框架ASM-读写字节码的用法
赶脚有点复杂的样子，大神能提供源码瞻仰下不？
本分类共有文章1篇,更多信息详见
& 2012 - 2016 &
&All Rights Reserved. &
/*爱悠闲图+*/
var cpro_id = "u1888441";}