《Velocity java开发指南》中文版(上)转载

时间：2023-01-15 04:53:07

文章引自：http://sakyone.iteye.com/blog/524289

1.开始入门
Velocity是一基于java语言的模板引擎，使用这个简单、功能强大的开发工具，可以很容易的将数据对象灵活的与格式化文档组装到一起；希望本文能指引使用velocity在开发基于servlet或一般java应用程序的应用上快速起步。

1.Getting Started

取得Velocity并在你的机器上开始运行很容易,以下是全部详细的说明:

取得Velocity发布版本，go here。

目录及文件说明:

Velocity-X.jar 完整的velocity jar包一般命名格式为velocity-X.jar，其中X是当前版本号。注意这个jar包不包含Velocity所必须依赖的其它jar包(具体见后)。

SRC:完整的源文件代码目录

Examples. 完整的aplication或web App例子。

docs :Veocity文档目录

build: 使用ant编译源码时所需的lib.

OK，现在就可以开始使用了.请将Velocity-x.jar放到你的classpath中或webapp的lib下。

当然，我们强烈建议你先运行其中的例子，以感受Velocity的优异之处.

2.Dependencies 依赖资源

Velocity可运行于JDK1.4或JRE1.4及其以上版本.

Velocity也依赖于其它一些jar包，在分发版本的 build/lib 有,如果你下载的是二进制分发版本，需要到以下地址下载其它依赖包.

Jakarta Commons Collections – 必须.

Jakarta Avalon Logkit – 可选，但强列建议加上，以便输出日志信息.

Jakarta ORO – 可选，仅当用到org.apache.velocity.convert.WebMacro template 这个模板转换工具时.

2.参考资源：

一些优秀的资源和例程列表如下：

开发者邮件列表 mail-lists.

邮件档案表 : http://www.mail-archive.com是很好的一个资源库.可以以’Velocity’为关键字进行搜索。

源代码(源码分发版本) : src/java/... : 含有Velocity project的所有源码

应用程序例程1 : examples/app_example1 : 一个很简单的示例如何在一般应用程序中使用Velocity.

应用程序例程1 2 : examples/app_example2 : 如何在应用程序中使用Velocity工具类.

servlet example : examples/servlet_example1 :示例如何在servlet中用Velocity 输出模板.

logger example : examples/logger_example : 如何定制Velocity的日志工具.

XML example : examples/xmlapp_example : 使用 JDOM 从 Velocity 模板读取内容. 还包含一个递归调用宏的示例.

event example : examples/event_example : 在Velocity 1.1 中使用事件处理API。

Anakia application : examples/anakia : 示例用stylesheet 美化 xml 数据。

Forumdemo web app : examples/forumdemo : 一个基于servlet的论坛功能实现示例.

templates : test/templates :全面展示VTL(Velocity Template Lanauage)功能的模板集合。

context example : examples/context_example : 两个示例如何重写(继承) Velocity context 功能的例子(针对高级用户).

3.它是如何工作的？

1.基本使用模式

在application program或servlet中使用Velocity中，一般通过如下步骤：

对于所有应用，第一步是要初始化Velocity, 一般使用唯一实例模式(Singleton)，如Velocity.init().

创建一个Context object.

将你的数据对象加入到Context对象中.

使用Velocity选择一个模板.

合并模板和数据导出到输出流.

下面的代码，通过使用org.apache.velocity.app.Velocity的单实例模式，合并输出：

  1. import java.io.StringWriter;
  2. import org.apache.velocity.VelocityContext;
  3. import org.apache.velocity.Template;
  4. import org.apache.velocity.app.Velocity;
  5. import org.apache.velocity.exception.ResourceNotFoundException;
  6. import org.apache.velocity.exception.ParseErrorException;
  7. import org.apache.velocity.exception.MethodInvocationException;
  8. //初始化
  9. Velocity.init();
  10. //取得VelocityContext对象
  11. VelocityContext context = new VelocityContext();
  12. //向context中放入要在模板中用到的数据对象
  13. context.put( "name", new String("Velocity") );
  14. Template template = null;
  15. //选择要用到的模板
  16. try
  17. {
  18. template = Velocity.getTemplate("mytemplate.vm");
  19. }
  20. catch( ResourceNotFoundException rnfe )
  21. {
  22. // couldn't find the template
  23. }
  24. catch( ParseErrorException pee )
  25. {
  26. // syntax error : problem parsing the template
  27. }
  28. catch( MethodInvocationException mie )
  29. {
  30. // something invoked in the template
  31. // threw an exception
  32. }
  33. catch( Exception e )
  34. {}
  35. StringWriter sw = new StringWriter();
  36. //合并输出
  37. template.merge( context, sw );

以上是基本的使用模式，看起来非常简洁！这些都是一般情况下使用Velocity所必须的步骤. 但你可能不想这样按部就班的编写代码
–Velocity提供了一些工具以更容易的方式在servlet或应用程序中使用。在这个指南的后面,
我们将讨论在servlet和普通应用程序中更好的用法.

4.单实例还是多实例(To Singleton Or Not To Singleton...)?

1.Singleton Model

这是系统默认的模式, 这样在jvm(应用程序)或web aplication(一个web程序)中只存在一个Velocity
engine实例共享使用。. 这对于配置和共享资源来说非常方便. 比如, 这非常适合用于支持 Servlet 2.2+ 的web
application中，每一个web app持有它自己的唯一Velocity实例, 它们可以共享templates, a logger等资源.
Singleton可以直接通过使用org.apache.velocity.app.Velocity 类, 如下例子:

  1. import org.apache.velocity.app.Velocity;
  2. import org.apache.velocity.Template;
  3. /*
  4. * Configure the engine - as an example, we are using
  5. * ourselves as the logger - see logging examples
  6. */
  7. Velocity.setProperty( Velocity.RUNTIME_LOG_LOGSYSTEM, this);
  8. /*
  9. * now initialize the engine
  10. */
  11. Velocity.init();
  12. Template t = Velocity.getTemplate("foo.vm");

2.Separate Instance

在1.2版本以后, 可以在 JVM (or web
application.)创建，配置，使用多个Velocity实例；当你希望在同一程序中，对每个实例独立配置时它们的 template
directories, loggers等资源时，这是非常方便的. 多实例化时，我们要用到
org.apache.velocity.app.VelocityEngine类. 下面是一个例子，请注意和上面singleton
example同法时的不同:

  1. import org.apache.velocity.app.VelocityEngine;
  2. import org.apache.velocity.Template;
  3. ...
  4. /*
  5. * create a new instance of the engine
  6. */
  7. VelocityEngine ve = new VelocityEngine();
  8. /*
  9. * configure the engine. In this case, we are using
  10. * ourselves as a logger (see logging examples..)
  11. */
  12. ve.setProperty( VelocityEngine.RUNTIME_LOG_LOGSYSTEM, this);
  13. /*
  14. * initialize the engine
  15. */
  16. ve.init();
  17. ...
  18. Template t = ve.getTemplate("foo.vm");

可以看到，这是非常简单的直接使用就行了.无论用singleton 或 separate instances都不需要改变你程序的上层结构及模板内容.

对于开发人员而言, 你应在以下两个类中二者择一的使用

org.apache.velocity.app.Velocity 应用于 singleton model,
org.apache.velocity.app.VelocityEngine一般用于non-singleton model ('separate
instance').

5. The Context

1.The Basics

'context' 是Velocity中的一个核心概念, 这是一个从系统的”数据容器(a container of
data)”引出的一个常见概念. 这里的context在java程序层和模板视图层(template layer ( or the
designer ))之间扮演着一个”数据对象传送者”'(carrier')的角色.

做为程序员，你可以将你程序生成的不同类型的数据对象放入context中，对于视图设计来说，这些对象(包含它们的数据域和命令)将在模板元素
中被引用到(references)。一般来说，你将和视图设计者一起决定应用需要哪些数据，可以说，你放入context中的数据对象在这里成为一
种”API”,由视图设计者在模板中来访问.因此，在向context中决定放放哪些数据对象时，程序的设计者需要仔细分析视图表现所需的数据内容。

虽然Velocity中你可以创建自己的Context类来支持一些个性化的应用(比如，一个访问，保存LDAP Server服务的context),你可以实现VelocityContext这个己封装较为完务的基类。

VelocityContext对象基本上可满足大多的应用, 我们强烈建议你除非在特别的情况下，否则不要创建自己的Context实现！

VelocityContext用法十分简单，类似于Hashtable class.下面是这个接口提供的两个基本用法：

public Object put(String key, Object value);

public Object get(String key);

很像Hashtable吧,这里的value必须是一个java.lang.Object类(不能是原始类型，像int,boolean),
也不能是null值. 原始类型(Fundamental types like int or
float)必须被包装为一个适当对应的Object型.

OK,以上就是context 对象的用法概念，很简单我们却哆嗦这么：）. 关于其更多的介绍，请见API documentation.

2.在模板中用#foreach指令支持迭代对象

在放入context前，你对对象有着全面的操作*. 但就像所有的*一样,
你必须遵守一些规则，承担一些责任，因此，你必须理解Velocity是如何使用对象的，Velocity的VTL支持多种类型的集合类型
(collection types) 使用#foreach().

Object [] 一般对象数组. Velocity将内功能会将它包装成功之为一个实现Iterator interface对象, 这个转换是不需要程序员或视图设计者参与.

java.util.Collection :Velocity会使用他们的标准iterator() 得到一个可以迭代中使用的
Iterator对象,如果你使用自己的实现了Collection interface的对象，要确保它的iterator()
命令返回一个可用的Iterator.

java.util.Map接口对象,Velocity 使用其顶层接口的values() 命令得到一个实现 Collection interface的对象, 应用其iterator()再返回一个Iterator.

java.util.Iterator使用特别注意 : 如果一个Iterator对象被放置到context中，当在模板中有多个 #foreach()指令中,这些#foreach() 将顺序执行，如果第一个调用失败，后面的将阻塞且不能重置.

java.util.Enumeration USE WITH CAUTION : 如同java.util.Iterator一样的道理,Velocity将使用的是一个不能重置（'non-resettablity'）或者说一个final型的对象.

因此，仅当在不得己的情况下，Iterator and Enumeration 对象才有必要放入context中---也许你有更好的办法不使用他们.

例如，你可以将如下代码:

Vector v = new Vector();

v.addElement("Hello");

v.addElement("There");

context.put("words", v.iterator() );

替换为:

context.put("words", v );

3.Context Chaining

另外一个新引入的概念是context chaining.有时也叫做context wrapping(有点类似与servlet中的chain), 这个高级特性让你可以连结多个独立的Velocity的contexts,以便在template中使用.

以下是这种用法的代码示例 :

  1. VelocityContext context1 = new VelocityContext();
  2. context1.put("name","Velocity");
  3. context1.put("project", "Jakarta");
  4. context1.put("duplicate", "I am in context1");
  5. VelocityContext context2 = new VelocityContext( context1 );
  6. context2.put("lang", "Java" );
  7. context2.put("duplicate", "I am in context2");
  8. template.merge( context2, writer );

在
上面的代码中, context2 做为context1的chains. 这意味着你在模板中可以使用放入这两个context中的任何一个对象,
当两个context中有相同的key中，在模板中输出时，将会输出最后一个key的值，如上例key为duplicate的值将输出为 "I am
in context2".

其实，在上例中不存在duplication, 或'covering', context1中的string "I am in
context1" 依然可以通过context1.get("duplicate")方法得到. 但在上例中，模板中引用 '$duplicate'
将会返回 'I am in context2', 而且模板不能再访问到context1中的'I am in context1'.

另外要注意的是，当你尝试在模板中加入信息，比如使用#set()声明,这将对所己输出的模板产生影响.

如前所述， Velocity context类也是或扩展的, 但在这份指南中没有述及.
如果你有兴趣,可以查看org.apache.velocity.context 中的代码以了解contexts
是如何生成，java数据对象以何机制传出的. 例程 examples/context_example有一些示例展现.

4.模板中的己创建对象

Java代码中的数据对象与模板交互有两种常见方式：

模板设计者从模板中执行程序员放入到context中的java对象的命令:

#set($myarr = ["a","b","c"] )

$foo.bar( $myarr )

当模板加入一个对象到context中，模板合并输出后，java代码将可以访问这些对象.

#set($myarr = ["a","b","c"] )

#set( $foo = 1 )

#set( $bar = "bar")

这里述及这些技巧有些过早,但现在必须理解以下概念:

The VTL通过context或method所传的 [ 1..10 ] and ObjectArray ["a","b"] 是java.util.ArrayList对象. 因此你的对象的命令设计时，要具有兼容性.

Numbers在context中将被包装为Integers, strings，当然就是Strings了.

Velocity会适当的根据调用的参数类型适配对象的调用命令, setFoo( int i )将一个 int 放入context 和 #set()是不会冲突的.

5.Context对象的其它用法

每一个VelocityContext（或任意源自AbstractContext）的对象，都是一个封装好指定规则的的存储节点，对于一般开发都来说,只需使用就是.但这里还有一些你应知道的特性：

考虑以下情况:

你的模板重复使用VelocityContext object.

Template caching is off.

反复调用getTemplate() 命令.

这都有可能引起 VelocityContext的内存泄露( 'leak' memory )---当它汇集过多的数据对象时,因此强烈建议你做到以下几点 :

在每个模板渲染过种中(template render process)创建一个新的VelocityContext.
这会防止过多的cache data. 当需要重用一个 VelocityContext 因为它内部己放置了数据对象,
你只需要像这样简单的包装一下:VelocityContext useThis = new VelocityContext(
populatedVC );具体可以参看 Context chaining 获取更多信息.

打开模板的caching功能. 以防止重复解析模板,当然，这会要求服务器有更高的性能.

在迭代操作时，要重用模板对象. 这样将不会对Velocity造成过大压力, 如果缓存关闭, 就需要每次都读取和解析模板, 导致 VelocityContext 中每次都要保存大量新的信息.

6.Using Velocity In Servlets

1.Servlet Programming

Velocity最通常用在servlet中做为www服务. 有非常多的理由告诉你这项任务是最适合Velocity完成的,最重要的一个就是Velocity's可以分离视图(表现层和)代码层.在这里可以看到更多的理由this.

在servlet中使用Velocity是非常简单的. 你只需要extend 己有的 VelocityServlet class和一个必须实现的方法： handleRequest().

public Template handleRequest( HttpServletRequest, HttpServletResponse, Context )

这个方法直接传送HttpServletRequest 和 HttpServletResponse objects,.
这个方法可以返回null值表示所有处理己经完成, 相对而言，指示velocity调用velocity requestCleanup()更为常用.
如下代码示例(在例程中有)

  1. public class SampleServlet extends VelocityServlet
  2. {
  3. public Template handleRequest( HttpServletRequest request,
  4. HttpServletResponse response,
  5. Context context )
  6. {
  7. String p1 = "Jakarta";
  8. String p2 = "Velocity";
  9. Vector vec = new Vector();
  10. vec.addElement( p1 );
  11. vec.addElement( p2 );
  12. context.put("list", vec );
  13. Template template = null;
  14. try
  15. {
  16. template = getTemplate("sample.vm");
  17. }
  18. catch( ResourceNotFoundException rnfe )
  19. {
  20. // couldn't find the template
  21. }
  22. catch( ParseErrorException pee )
  23. {
  24. // syntax error : problem parsing the template
  25. }
  26. catch( Exception e )
  27. {}
  28. return template;
  29. }
  30. }

看起来好熟悉吧? 除过处理一些异常，基本的功能Velocity都己为你准备好了, 就连在应用程序中要你写的merge()
这一步，VelocityServlet自己也己处理,这就是基本的用法：取得context, 加入我们自己的对象最后返回模板 template.

默认的 Context是作为 handleRequest() 传入的. 可以使用以下常量直接访问
request和response对象，VelocityServlet.REQUEST (value = 'req') and
VelocityServlet.RESPONSE (value = 'res') ,如下是java例程 :

  1. public Template handleRequest( Context context )
  2. {
  3. HttpServletRequest request = (HttpServletRequest) context.get( REQUEST );
  4. HttpServletResponse response = (HttpServletResponse) context.get( RESPONSE );
  5. ...
  6. }

可以在模板中如下访问:

#set($name = $req.getParameter('name') )

一些更高级的用法，如VelocityServlet base class 可以在处理请求时重写更多的签名方法 :

Properties loadConfiguration( ServletConfig )

这可以重写常规的配置方法. 这常用在修改日志路径或运行时改写webapp root的绝对路径.

Context createContext(HttpServletRequest, HttpServletResponse )

你可以创建自己的Context object. 这可以使用更高级的技术, 如数据链或预载数据和工具类. 默认的实理仅返回一个己内置request and response 对象的VelocityContext.你直以在模板中直接访问他们的命令。

void setContentType( HttpServletRequest,HttpServletResponse )

你可以自己定义contentType, 或提取client定义的. 默认的contentType类型在velocity.properties文件中配置, 一般来说，默认的"text/html" 类型是不够详细的.

void mergeTemplate( Template, Context, HttpServletResponse )

你可以生成输出流(output stream). VelocityServlet使用含有多种输出对象的池, 在特定情形下，重写这个命令是有用的.

void requestCleanup( HttpServletRequest, HttpServletResponse , Context )

这个调用一般在处理完后做资源的清理工作，如有需要，在这个命令的重写内容中加上你的代码.

protected void error( HttpServletRequest, HttpServletResponse, Exception )

在处理中，当错误发生时，这个方法会被调用. 默认的实现是将发送一个简单的HTML格式的错误内容到客户端. 你可以重写以定制错误处理.

更多的信息，请参考 API documentation.

2.Deployment

发布基于Velocity的servlets 时，需要参数来配置 Velocity runtime. 在Tomcat上,
一个简单的方法是将velocity.properties文件放到你的webApp root目录下 (webapps/appname ) 然后在
WEB-INF/web.xml 文件中加上以下几行 :

引用
<servlet>

<servlet-name>MyServlet</servlet-name>

<servlet-class>com.foo.bar.MyServlet</servlet-class>

<init-param>

      <param-name>properties</param-name>

      <param-value>/velocity.properties</param-value>

</init-param>

</servlet>

以上配置将确保MyServlet 可以被载入，Velocity也将会使velocity.properties来初始化.

注意： Velocity 在运行时使用的是单实例模式, 因此将 velocity-XX.jar放到YourWebAPP/WEB-INF/lib目录即可. 但当多个webApp要使用时，放入CLASSPATH 或Servlet容器的顶层 lib是最好的选择.

7. Using Velocity In General Applications

Velocity被设计为一个通用的功具包,它也常用于一般的应用程序中. 如这篇指南开始所讨论的那样, 另外，这里还有一些对一般应用程序来说很有用的工具类:

1.The Velocity Helper Class

Velocity 提供一个 utility class ( org.apache.velocity.app.Velocity ). 这个类中提共一个初始化Velocity所必需的方法, 具体的细节可以到文档中查看.

Velocity runtime engine在运行时是单实便模式，它可以给
Velocity的用户通过同一个jvm提供日志，资源访问方法. 这个engine运行时仅初始化一次.
当然，你可以尝初对init()进行多次调用, 但只有第一次有效. The Velocity utility class
目前提供5个命令来配置运行时engine:

这5个配置方法是 :

setProperty( String key, Object o )

这么简单，不用解释了吧.

Object getProperty( String key )

嗯，也不说了

init()

用默认的参数文件初始化

init( Properties p )

用一个特定的java.util.Properties对象初始化.

init( String filename )

用指定名字的参数文件初始化

注意：除非你指定了，否则初始时会使用默认参数. 仅当在调用init()时的配置会对系统生效。

通用的 initializing Velocity 一般步骤如下:

设置你指定的配置参数值在文件org/apache/velocity/runtime/defaults
/velocity.properties中，或放入java.util.Properties, 在第一次调用init( filename )或
init( Properties ) .

单独设置每个配置参数通过调用 setProperty(),最后调用init(). 这适合一些一有自己的CMS系统(configuration management system )程序。

运行时一但初始化, 你就可以开始工作了.. 只需要考虑组装什么样的数据对象到你的输出模板上, Velocity utility class 可以帮你更容易做到这些.这里有一些命令摘要描述如下 :

  1. evaluate( Context context, Writer out, String logTag, String instring )
  2. evaluate( Context context, Writer writer, String logTag, InputStream instream )

这个命令用来修饰输入流,你可以将包含TVL的模板文件从内置的String对象、DB、或非文件系统的数据源输入，.

invokeVelocimacro( String vmName, String namespace, String params[], Context context, Writer writer )

你可以直接访问Velocimacros. 也可以通过evaluate()命令来完成,这里你只需简单的传入VM文件名(模板文件), 创建一组VM参数放到Context,然后输出. 注意放入Context的参数必须是键-值对出现的.

mergeTemplate( String templateName, Context context, Writer writer )

这个命令用来执行Velocity的模板合并和渲染功能. 它将应用context中的数据对象到指定文件名的模板中.将结果输出的指定的Writer. 当然，如果没有特别的需要，不建议这么做.

boolean templateExists( String name )

检测当前配置的资源中，是否存在name的模板名.

这样，我们就更容易编写使用Velocity的java代码了. Here it is

  1. import java.io.StringWriter;
  2. import org.apache.velocity.app.Velocity;
  3. import org.apache.velocity.VelocityContext;
  4. public class Example2
  5. {
  6. public static void main( String args[] )
  7. {
  8. /* first, we init the runtime engine. Defaults are fine. */
  9. Velocity.init();
  10. /* lets make a Context and put data into it */
  11. VelocityContext context = new VelocityContext();
  12. context.put("name", "Velocity");
  13. context.put("project", "Jakarta");
  14. /* lets render a template */
  15. StringWriter w = new StringWriter();
  16. Velocity.mergeTemplate("testtemplate.vm", context, w );
  17. System.out.println(" template : " + w );
  18. /* lets make our own string to render */
  19. String s = "We are using $project $name to render this.";
  20. w = new StringWriter();
  21. Velocity.evaluate( context, w, "mystring", s );
  22. System.out.println(" string : " + w );
  23. }
  24. }

运行如上程序，在运行程序的目录下将得到模板文件testtemplate.vm (默认配置中模板文件的输出位置是当前目录):

引用
template : Hi! This Velocity from the Jakarta project.

string : We are using Jakarta Velocity to render this.

where the template we used, testtemplate.vm, is

Hi! This $name from the $project project.

在这里，我们不得不使用 mergeTemplate() and evaluate() in our program. 这主要是为了示例. 在一般应用中，这是很少使用到的，但我们提供了根据具体需要*使用的途径.

这有点不和我们这篇文张本意的“基础功能指南”这一意图, 但我想这是必须知道的. 首先, 你得到一个放置了数据对象的context对象,
不用的是使用了命令 mergeTemplate(), mergeTemplate() 所做的工作是合并模板,
在运行时调用低层功能(lower-level). 接下来，通过evaluate()方法使用一个String动态生成模板.

这是同样简单的使用Velocity engine的方式，这些可选功能也许可以帮你做一些重复的工作，比如生成模板的模板：）

2.Exceptions

There are three exceptions that Velocity will throw during the parse
/ merge cycle在解析/合并(parse/merge)模板周期中，Velocity或能出现三个Velocity异常.另外，还可能会有
IO problems, etc. Velocity自定义的异常可以在package
org.apache.velocity.exception:

ResourceNotFoundException

当velocity的资源管理器无法找到系统请求的资源时出现.

ParseErrorException

当parse模板文件中的 VTL 语法出错时出现.

MethodInvocationException

Thrown when a method of object in the context thrown an exception during render time,当处理模板中，context中的对象的命令调用出错时.

当然，每一次出错时，相关的消息内容会保存到运行时的日志文件中，获取更多资料，请查看API文档。

3.其它细节

在以上的一些例程中，使用默认的properties配置你的程序非常方便.
但你可以根据自己的需要，用自己的配置文件通过在Velocity中调用init(String yourFileName)命令传入你的配置文件名,
或创建一个保存了你的配置参数的 java.util.Properties对象，通过调用 init(Properties)命令来实现.
这其中后一个方式是很便捷的, 你可以直接将一个独立的参数文件通过load()调用，将其中的配置参数置入Properties对象中.
你还可以做得列好---你可以在运行时运态的从你的程序框架中加入参数.
这样，你应可以将Velocity的配置参数和你原来应用的配置在不做大的更改情况下共用。

当需要从一个指定的目录提取模板文件时(默认为当前目录),你可以这样做 :

  1. import java.util.Properties;
  2. ...
  3. public static void main( String args[] )
  4. {
  5. /* first, we init the runtime engine. */
  6. Properties p = new Properties();
  7. p.setProperty("file.resource.loader.path", "/opt/templates");
  8. Velocity.init( p );
  9. /* lets make a Context and put data into it */
  10. ...

这样，Velocity在需要时，将自动到/opt/templates目录下查找模板文件,如果有问题可以查看velocity.log中所记录的出详细出错信息。它会帮你有效的消息错误.

相关文章