欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识！
您现在的位置是： 首页

JSF 源代码赏析之FacesServlet  

程序员文章站 2024-02-02 11:52:34
...

学习JSF 多日，现在开始看看源代码。
首先是FacesServlet类了，作为一个前端控制器，每一个JSF请求都要通过FacesServlet，然后再到其他阶段，那么，FacesServlet 到底做了些什么操作呢？

文件头部的注释
  1. /**
  2. *

    FacesServlet is a servlet that manages the request

  3. * processing lifecycle for web applications that are utilizing JavaServer
  4. * Faces to construct the user interface.

  5. */
头部注释说的很明白，管理请求的处理周期。至于怎么管理，下面先来看一看到底声明了什么变量
变量
  2. public static final String CONFIG_FILES_ATTR =
  3. "javax.faces.CONFIG_FILES";
  5. public static final String LIFECYCLE_ID_ATTR =
  6. "javax.faces.LIFECYCLE_ID";
  8. private static final Logger LOGGER =
  9. Logger.getLogger("javax.faces.webapp", "javax.faces.LogStrings");
  10. private FacesContextFactory facesContextFactory = null;
  11. private Lifecycle lifecycle = null;
  12. private ServletConfig servletConfig = null;

上面这些变量都是FacesServlet的全局变量，也就是整个JSF 应用的全局变量，其中最主要的我都加粗了，可以看出，主要涉及到FacesContextFactory、LifeCycle和ServletConfig对象，其中的ServletConfig对象不难理解，基于Servlet技术的表现层框架都需要这个类，而FacesContextFactory和LifeCycle则有些研究了。

FacesContextFactory是一个实现了工厂模式的抽象类，用来创建（如果没有的话）和返回一个FacesContext实例，并且把这个实例初始化，以便处理request和response对象。至于这个FacesContext对象，则是始终贯彻在JSF中的一个对象，下面自然会慢慢讲解，现在需要知道的是，FacesContext也是一个抽象类就可以。
现在先看一下FacesContextFactory对象和FacesContext的关系。顾名思义，工厂模式，就是专门生产产品的，FacesContextFactory工厂则是专门产生FacesContext对象的，FacesContextFactory对象提供了下面的方法：
FacesContextFactory
  1. public abstract FacesContext getFacesContext
  2. (Object context, Object request,
  3. Object response, Lifecycle lifecycle)
  4. throws FacesException;

来产生FacesContext对象，并且这是一个抽象方法，如何调用，则是JSF实现的事情了，并且FacesContextFactory会为每一个Request请求返回一个FacesContext对象。注意，这里用的是“返回”，而不是生成，是因为FacesContextFactory并不一定会为每一个请求生成一个新的FacesContext对象，FacesContext对象有一个release方法，这个方法负责释放FacesContext的资源，在调用这个方法之前，通过FacesContext.getCurrentInstance可以返回当前线程上的实例，这样实现FacesContext在某种程度上的重用和pool。
下面应该来看看在FacesServlet中如何调用FacesContextFactory来产生一个FacesContext对象了。
首先要产生一个FacesContextFactory对象，这是通过FacesServlet的init方法来实现的：
FacesServlet的init方法
  1. public void init(ServletConfig servletConfig) throws ServletException {
  3. // Save our ServletConfig instance
  4. this.servletConfig = servletConfig;
  6. // Acquire our FacesContextFactory instance
  7. try {
  8. facesContextFactory = (FacesContextFactory)
  9. FactoryFinder.getFactory
  10. (FactoryFinder.FACES_CONTEXT_FACTORY);
  11. } catch (FacesException e) {
  12. ResourceBundle rb = LOGGER.getResourceBundle();
  13. String msg = rb.getString("severe.webapp.facesservlet.init_failed");
  14. Throwable rootCause = (e.getCause() != null) ? e.getCause() : e;
  15. LOGGER.log(Level.SEVERE, msg, rootCause);
  16. throw new UnavailableException(msg);
  17. }
  19. // Acquire our Lifecycle instance
  20. try {
  21. LifecycleFactory lifecycleFactory = (LifecycleFactory)
  22. FactoryFinder.getFactory(FactoryFinder.LIFECYCLE_FACTORY);
  23. String lifecycleId ;
  25. // First look in the servlet init-param set
  26. if (null == (lifecycleId = servletConfig.getInitParameter(LIFECYCLE_ID_ATTR))) {
  27. // If not found, look in the context-param set
  28. lifecycleId = servletConfig.getServletContext().getInitParameter
  29. (LIFECYCLE_ID_ATTR);
  30. }
  32. if (lifecycleId == null) {
  33. lifecycleId = LifecycleFactory.DEFAULT_LIFECYCLE;
  34. }
  35. lifecycle = lifecycleFactory.getLifecycle(lifecycleId);
  36. } catch (FacesException e) {
  37. Throwable rootCause = e.getCause();
  38. if (rootCause == null) {
  39. throw e;
  40. } else {
  41. throw new ServletException(e.getMessage(), rootCause);
  42. }
  43. }
  45. }

在这个init方法中，FacesServlet通过FactoryFinder对象来创建一个具体的Factory对象，这样就把创建Factory对象的工作给托管给其他的类了，同时这个FactoryFinder还可以创建其他的工厂类，因此可以说FactoryFinder是“工厂的工厂”，是专门创造工厂的类。通过FactoryFinder.FACES_CONTEXT_FACTORY参数指明是创建FacesContextFactory，FactoryFinder就给创建出一个FacesContextFactory。
下面我们就来看看FactoryFinder是通过什么算法，来查找和创建JSF实现中的各个工厂类。
FactoryFinder通过实现标准的发现算法，可以查找所有在JSF API中指定的factory对象，这个算法是这样的：
1.如果web应用的WEB-INF目录下存在JSF的configuration 文件，并且含有factory节点，而且这个factory节点中含有正在查找的factory对象的类名称，那么就加载这个类。
2.如果在ServletContext的初始化参数中有javax.faces.CONFIG_FILES参数，并且这个参数值指定的配置文件中有factory节点，并且这个节点中含有目前正在查找的factory类名，那么就加载这个对象。
3.如果在ServletContext的资源目录下的Jar包中的 META-INF目录下含有JSF配置文件，并且正在查找的factory类名存在于factory节点中，则加载这个类。最晚加载的类优先。
4.如果META-INF/service/目录下有当前正在查找的类名称，会加载之。
5.如果上面的规则都没有匹配，则会使用JSF实现中的特定类。

这种算法的缺点就是每一个Web应用都会有一个自己的factory实例，不管这个JSF实现是包含在Web应用chengx程序之中还是在容器中作为一个共享库存在。

这个FactoryFinder还是蛮复杂的，以后有时间将另外撰文研究。
下面的事情就是LifecycleFactory的加载了，其加载过程不必多言。
LifecycleFactory对象加载后，会查找JSF中是否配置了javax.faces.LIFECYCLE_ID参数，根据这个参数加载lifecycleId，整个过程是这样的：
加载LifecycleFactory
  1. //AcquireourLifecycleinstance
  2. try{
  3. LifecycleFactorylifecycleFactory=(LifecycleFactory)
  4. FactoryFinder.getFactory(FactoryFinder.LIFECYCLE_FACTORY);
  5. StringlifecycleId;
  7. //Firstlookintheservletinit-paramset
  8. if(null==(lifecycleId=servletConfig.getInitParameter(LIFECYCLE_ID_ATTR))){
  9. //Ifnotfound,lookinthecontext-paramset
  10. lifecycleId=servletConfig.getServletContext().getInitParameter
  11. (LIFECYCLE_ID_ATTR);
  12. }
  14. if(lifecycleId==null){
  15. lifecycleId=LifecycleFactory.DEFAULT_LIFECYCLE;
  16. }
  17. lifecycle=lifecycleFactory.getLifecycle(lifecycleId);
  18. }catch(FacesExceptione){
  19. ThrowablerootCause=e.getCause();
  20. if(rootCause==null){
  21. throwe;
  22. }else{
  23. thrownewServletException(e.getMessage(),rootCause);
  24. }
  25. }


通过加载不同实现的LifecycleFactory对象，就可以允许加载不同的Lifecycle对象，这对于扩展JSF的功能是非常重要的，
当没有显示表明lifecycleId时，lifecycleFactory就会加载默认的lifecycleId，并根据lifecycleId加载Lifecycle对象
Lifecycle类负责JSF请求处理的全过程，主要是通过执行其中的execute方法和render方法实现的，FacesServlet的service方法很好的说明了这一点：

java 代码
  1. publicvoidservice(ServletRequestrequest,
  2. ServletResponseresponse)
  3. throwsIOException,ServletException{
  5. //Ifprefixmapped,thenensurerequestsfor/WEB-INFare
  6. //notprocessed.
  7. StringpathInfo=((HttpServletRequest)request).getPathInfo();
  8. if(pathInfo!=null){
  9. pathInfo=pathInfo.toUpperCase();
  10. if(pathInfo.startsWith("/WEB-INF/")
  11. ||pathInfo.equals("/WEB-INF")
  12. ||pathInfo.startsWith("/META-INF/")
  13. ||pathInfo.equals("/META-INF")){
  14. ((HttpServletResponse)response).
  15. sendError(HttpServletResponse.SC_NOT_FOUND);
  16. return;
  17. }
  18. }
  20. //AcquiretheFacesContextinstanceforthisrequest
  21. FacesContextcontext=facesContextFactory.getFacesContext
  22. (servletConfig.getServletContext(),request,response,lifecycle);
  24. //Executetherequestprocessinglifecycleforthisrequest
  25. try{
  26. lifecycle.execute(context);
  27. lifecycle.render(context);
  28. }catch(FacesExceptione){
  29. Throwablet=e.getCause();
  30. if(t==null){
  31. thrownewServletException(e.getMessage(),e);
  32. }else{
  33. if(tinstanceofServletException){
  34. throw((ServletException)t);
  35. }elseif(tinstanceofIOException){
  36. throw((IOException)t);
  37. }else{
  38. thrownewServletException(t.getMessage(),t);
  39. }
  40. }
  41. }
  42. finally{
  43. //ReleasetheFacesContextinstanceforthisrequest
  44. context.release();
  45. }
  47. }


好了，FacesServlet的源码我们就看到这里，下一篇中我们将深入研究Lifecycle对象的执行过程，在最后，就让我们用myFaces的FacesServlet实现来结束吧：

myfaces之FacesServlet：
  1. publicfinalclassFacesServletimplementsServlet{
  2. privatestaticfinalLoglog=LogFactory.getLog(FacesServlet.class);
  3. publicstaticfinalStringCONFIG_FILES_ATTR="javax.faces.CONFIG_FILES";
  4. publicstaticfinalStringLIFECYCLE_ID_ATTR="javax.faces.LIFECYCLE_ID";
  6. privatestaticfinalStringSERVLET_INFO="FacesServletoftheMyFacesAPIimplementation";
  7. privateServletConfig_servletConfig;
  8. privateFacesContextFactory_facesContextFactory;
  9. privateLifecycle_lifecycle;
  11. publicFacesServlet(){
  12. super();
  13. }
  15. publicvoiddestroy(){
  16. _servletConfig=null;
  17. _facesContextFactory=null;
  18. _lifecycle=null;
  19. if(log.isTraceEnabled())
  20. log.trace("destroy");
  21. }
  23. publicServletConfiggetServletConfig(){
  24. return_servletConfig;
  25. }
  27. publicStringgetServletInfo(){
  28. returnSERVLET_INFO;
  29. }
  31. privateStringgetLifecycleId(){
  32. StringlifecycleId=_servletConfig.getServletContext()
  33. .getInitParameter(LIFECYCLE_ID_ATTR);
  34. returnlifecycleId!=null?lifecycleId
  35. :LifecycleFactory.DEFAULT_LIFECYCLE;
  36. }
  38. publicvoidinit(ServletConfigservletConfig)throwsServletException{
  39. if(log.isTraceEnabled())
  40. log.trace("initbegin");
  41. _servletConfig=servletConfig;
  42. _facesContextFactory=(FacesContextFactory)FactoryFinder
  43. .getFactory(FactoryFinder.FACES_CONTEXT_FACTORY);
  44. //TODO:null-checkforWeblogic,thattriestoinitializeServlet
  45. //beforeContextListener
  47. //Javadocsays:Lifecycleinstanceissharedacrossmultiple
  48. //simultaneousrequests,itmustbeimplementedinathread-safe
  49. //manner.
  50. //Sowecanacquireithereonce:
  51. LifecycleFactorylifecycleFactory=(LifecycleFactory)FactoryFinder
  52. .getFactory(FactoryFinder.LIFECYCLE_FACTORY);
  53. _lifecycle=lifecycleFactory.getLifecycle(getLifecycleId());
  54. if(log.isTraceEnabled())
  55. log.trace("initend");
  56. }
  58. publicvoidservice(ServletRequestrequest,ServletResponseresponse)
  59. throwsIOException,ServletException{
  61. HttpServletRequesthttpRequest=((HttpServletRequest)request);
  62. StringpathInfo=httpRequest.getPathInfo();
  64. //ifitisaprefixmapping...
  65. if(pathInfo!=null
  66. &&(pathInfo.startsWith("/WEB-INF")||pathInfo
  67. .startsWith("/META-INF"))){
  68. StringBufferbuffer=newStringBuffer();
  70. buffer.append("Someoneistryingtoaccessasecureresource:"
  71. +pathInfo);
  72. buffer
  73. .append("/nremoteaddressis"
  74. +httpRequest.getRemoteAddr());
  75. buffer.append("/nremotehostis"+httpRequest.getRemoteHost());
  76. buffer.append("/nremoteuseris"+httpRequest.getRemoteUser());
  77. buffer.append("/nrequestURIis"+httpRequest.getRequestURI());
  79. log.warn(buffer.toString());
  81. //WhydoesRIreturna404andnota403,SC_FORBIDDEN?
  83. ((HttpServletResponse)response)
  84. .sendError(HttpServletResponse.SC_NOT_FOUND);
  85. return;
  86. }
  88. if(log.isTraceEnabled())
  89. log.trace("servicebegin");
  90. FacesContextfacesContext=_facesContextFactory.getFacesContext(
  91. _servletConfig.getServletContext(),request,response,
  92. _lifecycle);
  93. try{
  94. _lifecycle.execute(facesContext);
  95. _lifecycle.render(facesContext);
  96. }catch(Throwablee){
  97. if(einstanceofIOException){
  98. throw(IOException)e;
  99. }elseif(einstanceofServletException){
  100. throw(ServletException)e;
  101. }elseif(e.getMessage()!=null){
  102. thrownewServletException(e.getMessage(),e);
  103. }else{
  104. thrownewServletException(e);
  105. }
  106. }finally{
  107. facesContext.release();
  108. }
  109. if(log.isTraceEnabled())
  110. log.trace("serviceend");
  111. }
  112. }

上一篇： 关于for循环的一个错误

下一篇： 循环出来的Select选项问题

推荐阅读