fauxjsp下载fauxjsp源代码下载

FAUXJSP

FAUXJSP是一个Java服务器页面（JSP）实现，以便在开发过程中使用：JSP懒惰（而不是编译），可减少应用程序和页面启动时间，在JSPS更改并且不需要服务器重新启动时加快页面重新加载。如果规格合规并不关键，则最能使用开发时使用，也可以在生产中使用。

tl; dr

web.xml:
< servlet >
        < servlet-name >FauxJsp</ servlet-name >
        < servlet-class >fauxjsp.servlet.JspServlet</ servlet-class >
</ servlet >

< servlet-mapping >
	< servlet-name >FauxJsp</ servlet-name >
	< url-pattern >*.jsp</ url-pattern >
</ servlet-mapping >

以下版本（包括）1.2.3在Maven Central中：

pom.xml:
< dependency >
	< groupId >com.github.ggeorgovassilis</ groupId >
	< artifactId >fauxjsp</ artifactId >
	< version >1.2.3</ version >
</ dependency >

1.2.3之后的版本需要一个存储库：

< repositories >
		< repository >
			< id >fauxjsp-repo</ id >
			< url >https://github.com/ggeorgovassilis/fauxjsp/raw/gh-pages/</ url >
			< snapshots >
				< enabled >true</ enabled >
				< updatePolicy >always</ updatePolicy >
			</ snapshots >
		</ repository >
</ repositories >

更改日志

1.2.7-Snapshot（未在Maven Central上发布）

改进的Scriptlet执行性能

1.2.3

不太积极的HTML逃脱（不要逃脱高端Unicode字符）

1.2.2

性能测试扩展到脚本，次要重构

1.2.1

解决方案类Path中的固定错误包括

1.2.0

在“生产”模式下永久缓存的JSP和Tagfiles解析

1.1.0

简化的EL表达处理，改进的渲染性能

1.0.0

处理trimDirectiveWhiteSpaces ， c:set实现的身体内容

0.0.9

释放到Maven Central，否则与0.0.5-Snapshot相同

0.0.5-snapshot

实施<％@page％>内容类型和字符编码指令
能够在类路径位置处理标记和JSP
更新的依赖项Servlet-API 4.0.1，Tomcat 9.0.8
处理Unicode响应
修复了foreach处理中的错误
修复了XML名称空间解析中的错误
家政

0.0.4-snapshot

实施JSP评论
将上下文和会话属性作为JSP变量
添加了sessionscope，contextscope，requestScope隐式对象
添加了空applicationscope cope隐式对象
能够迭代阵列

另一个JSP实现？

是的。简而言之：

一个。没有那么多（我只知道两个，Oracle JSP和Jasper）
b。比其他实现更快地重新加载页面，因为它解释了JSP，而不是将其编译为字节代码
c。对于语法和运行时错误，没有内存泄漏，更健壮，更精确和有用的错误消息
d。可扩展
e。如果合规性和性能不是最重要的优先事项，则具有标准JSP的一些整洁功能，例如加载TagFiles和Class Path的JSP。

对于你们中的大多数人来说，JSP酷时都非常过时，但是我喜欢将其用于原型和标记。令人遗憾的是，令人惊讶的是，尽管Tagfiles是一种能够创建可重复使用的Web UI组件的良好和成熟的技术，但并没有多少人知道他们。

启动JSP繁重的应用程序很慢，因为其他JSP实现将首先将JSP和TagFiles编译到Java源代码，然后将其汇编为字节代码，然后转到机器代码。同样，在更改JSP文件时，必须重复整个过程，这会减慢开发。在某个时候，您甚至会出现无法解释的编译错误，类加载错误，内存等内容，您会知道您已经受够了，并且会重新启动Servlet容器。

FAUXJSP实现了JSP解释器和JSP Servlet，该解释器会读取JSP文件并随机解释它们，从而完全跳过汇编。这带来了即时页面重新加载，快速应用程序的启动时间和稳健性的好处（没有类载荷器！），但是显然，生成的JSP页面在负载下的负载较慢，而标准实现可能是生产中的问题。

当前实现的功能：

渲染JSP页面
渲染标记
支持大多数核心JSTL Taglibs
支持脚本
是模块化的
支持从classpath加载标记和JSP的惯用方式

约束和缺失功能：

开箱即用的只有核心Taglibs得到支持。这意味着像c:out这样的核心Taglib会起作用，但是除非您重新实现FAUXJSP，否则诸如DisplayTag之类的第三方Taglibs不会。
并非所有核心Taglib都得到了支持，并且并非所有受支持的功能的所有功能都不是故意的遗漏。如果您认为缺少某些东西，请提交错误报告。
我没有阅读JSP/JSPL/Servlet规范，而是实现是经验的（又称“为我工作”）。
Servlet容器需要提供一些EL 3.0实施（即与Tomcat 8一起使用，而不是Tomcat 7）
我没有阅读可变范围的读取；范围与Java块中的可变范围相似。
编码固定在UTF-8上。
并非所有JSP隐式对象都可用。
输出中的NewLine处理可能与标准JSP实现不同。
Scriptlet是通过Beanshell实现的，这意味着与Jasper等人在Jasper等人中处理的方式可能存在偏差。
JSP语言生态系统非常复杂。 HTML，JSTL，EL和Scriptlet经常在同一文件中混合，这很难解析。 FauxJSP使用一个非常简单的解析器，这意味着它很可能会被XML中具有特殊含义的EL表达式中的字符混淆，例如“ <”或“>”作为Scriptlets中的字符串，作为El中的字符串，“ {”或“}” - 您可能必须使用命名实体。请注意，发行0.0.4可显着改善此类字符的处理。
不支持网络片段
使用classpath:在类路径中解决标语和JSP的前缀。不支持解决集体路径资源的标准方式。

有了所有这些限制，为什么要打扰？

因为：

JSP和TagFiles重新加载可立即节省您的大量时间和服务器重新启动。
FAUXJSP实现了JSP规范的子集；如果它在FAUXJSP中起作用，它也可能在Jasper中起作用。
它在大而复杂的页面上进行了测试，重要的事情似乎有效

奖金：

如果您愿意放弃标准的JSP实现，那么FauxJSP具有一些整洁的额外功能和简化的标准JSP

入门

将依赖性添加到您的项目中

< dependency >
	< groupId >com.github.ggeorgovassilis</ groupId >
	< artifactId >fauxjsp</ artifactId >
	< version >1.1.0</ version >
</ dependency >

或者

下载资源并编译

git clone https://github.com/ggeorgovassilis/fauxjsp.git
cd fauxjsp
mvn install

在web.xml中声明jspservlet的实例：

< servlet >
        < servlet-name >FauxJsp</ servlet-name >
        < servlet-class >fauxjsp.servlet.JspServlet</ servlet-class >
<!-- optionally specify a root for resource lookup, defaults to "/"
		<init-param>
			<param-name>base-path</param-name>
			<param-value>/WEB-INF/jsp/</param-value>
		</init-param>
-->
</ servlet >

< servlet-mapping >
	< servlet-name >FauxJsp</ servlet-name >
	< url-pattern >*.jsp</ url-pattern >
</ servlet-mapping >

运行时依赖性

JSP API 2.0
Java EL 3.0 API
JSTL 1.2
Servlet API 4.0
Commons-lang 2.6
Beanshell 2.0b5
log4j 4

Servlet API，JSTL，EL被provided ，因为Servlet容器或Web应用程序贡献了这些依赖性

log4j，beanshell被provided ，因为它们是可选的

CONSONS-LANG被范围为compile ，因为它是强制性的

有关最新详细信息，请参阅POM。

扩展FAUXJSP的功能并解决错误

当您找到错误或需要实现功能时，请提交错误报告。现在，在真实的（项目）生活中，您可能会紧迫，不想等待正式解决方案。 FAUXJSP是模块化的，易于扩展。因此，请查看有关FAUXJSP的体系结构的下一章，该章节将帮助您了解各种相当简单的组件，如何修改它们并实现新功能。

体系结构概述

Jspservlet

JspServlet接受HTTP请求并呈现请求的JSP。整个序列看起来像这样：

从ServletRequest获取请求的JSP文件的名称
查看JSP文件的jspbase （请参阅JspServlet的Javadocs）
向JspParserFactory询问新的JspParser
将JSP文件提供给解析，递归解决依赖并返回JspPage JspParser
创建一个新的RenderSession
向新的JspRenderer询问JspRendererFactory
将JspPage和RenderSession给JspRenderer呈现
将结果流到浏览器

JspServlet具有一堆受保护的方法，这些方法构建了前面提到的各种工厂。如果您需要特殊的设置，然后覆盖这些构造方法，则可以指定自己的工厂，该工厂可以返回经过修改或全新的解析器和渲染器实现。

jspparser

JspParser ，更具体地说，其唯一的实现JspParserImpl是一个JSP文件位置，将其呈现并返回分析结果。详细：

JspParser.parse(path)被赋予JSP文件的路径
解析器给出了ResourceResolver实例的路径（ JspParserFactory集合一个up），该实例将JSP文件返回为字符串。
解析器通过JSP文件读取创建JspNode s的树。
当解析器找到Taglib（或Tagfile）声明时，它将其放入TagLibDefinitionCache中，该声明确保在每个请求中仅读取一次Taglibs。
当解析器遇到Tagfile声明时，它要求JspParserFactory递归解析Tagfile的新解析器。

不幸的是，目前不可能在Tagfiles以外加载Taglibs。但是，可以通过为FauxjSP自己提供特殊实现来使用缺少的Taglibs。根据Taglib的不同，您要模拟这可能会或可能不是一项劳动密集型任务。有关一些示例，请看一下JstlCoreTaglib*类。 DefaultJspParserFactoryImpl工厂将其设置为特殊名称空间，每个taglib方法一个。

支持的Taglibs

指令

 <%@ taglib prefix uri tagdir %>

<@ include file %>

<%@ attribute name required rtexprvalue type %>

< jsp : attribute name = " ... " >...</ jsp : attribute >

< jsp : body >...</ jsp : body >

< jsp : doBody />

核心Taglib

< c : out value = " ... " />

< c : choose test = " ... " >...</ c : choose >

< c : when test = " ... " >...</ c : when >

< c : otherwise >...</ c : otherwise >

< c : forEach var = " ... " items = " ... " varStatus = " ... " begin = " ... " end = " ... " >...</ c : forEach >

< c : if test = " ... " >...</ c : if >

< c : set var = " ... " value = " ... " />

格式和国际化

< fmt : message key = " ... " />

< fmt : setBundle basename = " ... " />

< fmt : formatNumber value = " ... " .../>

< fmt : formatDate value = " ... " .../>

< fmt : setLocale value = " ... " />

功能

FAUXJSP代表应用程序服务器使用的标准JSTL函数实现，因此所有内容都应开箱即用。

如果您需要更多功能taglibs，请不要忘记在Web.xml中声明它们：

< jsp-config > 
	< taglib >
		< taglib-uri >http://java.sun.com/jstl/core-rt</ taglib-uri >
		< taglib-location >META-INF/c-1_0-rt.tld</ taglib-location >
	</ taglib >
</ jsp-config >

Taglib-Location可以是服务器或类Path的资源路径。

我怎么...

...添加缺少的标签库？

如前所述，FauxJSP不能使用Taglibs，而必须效仿它们，这意味着某人必须编程模仿。

步骤1 ：创建TAGLIB实现。只需找到一个已经模拟的Taglibs之一

 public class TaglibAdd extends TaglibDefinition {

	protected void runAdd ( RenderSession session , JspTaglibInvocation invocation ) {
		String xExpression = invocation . getArguments (). get ( "x" );
		if ( xExpression == null )
			throw new RuntimeException ( "Missing x argument" );
		Object x = session . elEvaluation . evaluate ( xExpression , session );

		String yExpression = invocation . getArguments (). get ( "y" );
		if ( yExpression == null )
			throw new RuntimeException ( "Missing y argument" );
		Object y = session . elEvaluation . evaluate ( yExpression , session );
		
		try {
		    int ix = ( Number ) x ;
		    int iy = ( Number ) y ;
		    String s = "" +( ix + iy );
			session . response . getOutputStream (). write (( s ). getBytes ( session . response . getCharacterEncoding ()));
		} catch ( Exception e ) {
			throw new JspRenderException ( invocation , e );
		}
	}

	@ Override
	public void render ( RenderSession session , JspTaglibInvocation invocation ) {
		runAdd ( session , invocation );
	}
	
	public TaglibAdd () {
		this . name = "add" ;
		this . attributes . put ( "x" , new AttributeDefinition ( "x" , Integer . class . getName (), true , true ));
		this . attributes . put ( "y" , new AttributeDefinition ( "y" , Integer . class . getName (), true , true ));
	}
}

步骤2 ：扩展DefaultJspparserFactoryImpl并覆盖setup方法。在这里您可以注册您写的新的Taglib

	public class MyJspParserFactory extends DefaultJspParserFactoryImpl {
		
	protected void setup ( JspParserImpl parser ) {
	  super . setup ( parser );
		parser . registerTaglibDefinition (
				"http://mytaglibs/add" ,
				new TaglibAdd ());
	}		
	}

步骤3 ：扩展Jspservlet并覆盖getJspParserFactory ，以便返回您的新工厂

	public class MyJspServlet extends JspServlet {

	protected JspParserFactory getJspParserFactory ( ServletConfig config ){
		ResourceResolver location = new ServletResourceResolver ( jspBase , getServletContext ());
		DefaultJspParserFactoryImpl factory = new MyJspParserFactory ( location );
		return factory ;
	}
		
	}

步骤4 ：在web.xml中使用新的JSPSERVLET实现，而不是旧的Jspservlet

< servlet >
        < servlet-name >FauxJsp</ servlet-name >
        < servlet-class >MyJspServlet</ servlet-class >
</ servlet >

< servlet-mapping >
	< servlet-name >FauxJsp</ servlet-name >
	< url-pattern >*.jsp</ url-pattern >
</ servlet-mapping >

...使记录能够查看发生了什么事？

JspServlet通过log4j登录，如果在类路径上找到，则可以通过标准的JDK日志记录机构进行登录。 log4j.properties中可能的日志记录设置可能看起来像：

 log4j.rootLogger=INFO, stdout
log4j.logger.fauxjsp=INFO, stdout
log4j.additivity.fauxjsp.impl.parser.JspParserImpl=false

log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n

...与Scriptlet合作？

使用Beanshell实现了脚本，因此可以期待与标准脚本行为的某些偏差。除非在类路径上找到beanshell解释器，否则不会启用脚本。当前限制是：

并非所有隐式对象都可用。
Beanshell的语法宽大；您可以在Beanshell中做您在Java中无法做的事情。
beanshell不了解vararg方法签名，例如，除非将参数打包到对象数组中，否则您不能使用string.format。有关更多信息，请参见使用Beanshell的字符串格式。

...处理FAUXJSP限制吗？

理想情况下，您会找到一种在生产JSP环境和FAUXJSP中都起作用的方法。一个示例是我们之前谈论的脚本中使用的varargs的情况。 FAUXJSP Parser可能会被EL表达式和脚本中出现的字符串混淆，这些字符串用作其他地方用作<，>，>，{，}等的定界符等。

...参考标记或JSP位于classPath中？

用例是您的tagfiles或jsps引用位于classPath中的其他标签文件或JSP（例如，JAR文件）。不要使用tagdir ，而是在包括资源时使用uri ，例如：

<%@ taglib prefix = " cp " uri = " classpath:/tagfiles " %>

...与春天一起做这项工作？

您可能注意到JstlView和InternalViewResolver不起作用，Spring找不到您的JSP。在引擎盖下，弹簧应将模型（MVC中的M）填充到HttpServletRequest属性中，并将请求转发到fauxjsp，但事实并非如此。我们可以实现这样的简单转发机制：

 import java . util . Locale ;

import org . springframework . stereotype . Component ;
import org . springframework . web . servlet . View ;
import org . springframework . web . servlet . ViewResolver ;

@ Component
public class ForwardingViewResolver implements ViewResolver {

	@ Override
	public View resolveViewName ( String viewName , Locale locale ) throws Exception {
		ForwardingView view = new ForwardingView ();
		view . setUrl ( "classpath:/jsp/" + viewName + ".jsp" );
		return view ;
	}
}

 import java . util . Map ;
import javax . servlet . RequestDispatcher ;
import javax . servlet . http . HttpServletRequest ;
import javax . servlet . http . HttpServletRequestWrapper ;
import javax . servlet . http . HttpServletResponse ;

import org . springframework . web . servlet . view . InternalResourceView ;

public class ForwardingView extends InternalResourceView {

	@ SuppressWarnings ( "unchecked" )
	@ Override
	public void render ( Map < String , ?> model , HttpServletRequest request , HttpServletResponse response )
			throws Exception {
		HttpServletRequestWrapper wrapper = new HttpServletRequestWrapper ( request ) {
			
			@ Override
			public String getServletPath () {
				return getUrl ();
			}
		};
		exposeModelAsRequestAttributes (( Map < String , Object >) model , wrapper );
		exposeHelpers ( wrapper );
		RequestDispatcher rd = request . getServletContext (). getNamedDispatcher ( "FauxJsp" );
		rd . forward ( wrapper , response );
	}

}

Web应用程序上下文中这两个组件的简单存在应该足以使它们被拾取并激活。

...启用缓存？

可以将JspServlet配置为缓存解析的JSP。这是一个较小的性能改进，因为通常渲染速度比解析要慢。

< servlet >
        < servlet-name >FauxJsp</ servlet-name >
        < servlet-class >fauxjsp.servlet.JspServlet</ servlet-class >
		< init-param >
			< param-name >cachePages</ param-name >
			< param-value >true</ param-value >
		</ init-param >
</ servlet >

如何去除过多的空白和线路断裂？

指定servlet init参数trimDirectiveWhiteSpaces

< servlet >
        < servlet-name >FauxJsp</ servlet-name >
        < servlet-class >fauxjsp.servlet.JspServlet</ servlet-class >
		< init-param >
			< param-name >trimDirectiveWhiteSpaces</ param-name >
			< param-value >true</ param-value >
		</ init-param >
</ servlet >