在前面的文章中，如果我们要启动tomcat容器，我们需要使用Bootstrap类来实例化连接器、servlet容器、Wrapper实例和其他组件，然后调用各个对象的set方法将它们关联起来；这种配置应用程序的方法有一个明显的缺陷，即所有的配置都必须硬编码。调整组件配置和属性值都必须要重新编译Bootstrap类。幸运的是，Tomcat的设计者使用了一种更加优雅的配置方式，即使用一个名为server.xml的XML文件来对应用程序进行配置。server.xml文件中的每个元素都会转换为一个java对象，元素的属性会用于设置java对象的属性，这样，就可以通过简单的编辑server.xml文件来修改tomcat的配置。
Tomcat使用了开源库Digester来将xml文件中的元素转换成java对象。
由于一个Context实例表示一个Web应用程序，因此配置Web应用程序是通过对已经实例化的Context实例进行配置完成的。用来配置Web应用程序的XML文件的名称是web.xml，该文件位于Web应用程序的WEB-INF目录下。
下面来介绍Digester库，Digester库是Apache软件基金会的Jatarta项目下的子Commons项目下的一个开源项目，它的主页地址是http://commons.apache.org/proper/commons-digester/
org.apache.commons.digester3.Digester类是Digester库中的主类，该类可用于解析XML文件，对于XML文件中的每个元素，Digester对象都会检查它是否要做事先预定义的事件，在调用Digester对象的parse()方法之前，程序员要先定义好Digester对象执行哪些动作。
因此，程序员要先定义好模式，然后将每个模式与一条或多条规则相关联。
模式通常是xml文件里面元素的路径，类似于xpath的语法路径
规则指明了当Digester对象遇到了某个特殊的模式时要执行的一个或多个动作，规则是org.apache.commons.digester3.Rule类的实例，Digester类开源包含0个或多个Rule对象，在Digester实例中，这些规则和其相关联的模式都存储在由org.apache.commons.digester3.Rules接口表示的一类存储器中，每当把一条规则添加到Digester实例中时，Rule对象都会被添加到Rules对象中。
另外，Rule类有begin()方法和end()方法，在解析xml文件时，当Digester实例遇到匹配某个模式的元素的开始标签时，它会调用相应的Rule对象的begin()方法，而当Digester实例遇到相应元素的结束标签时，它会调用Rule对象的end()方法。
在使用Digester库时，我们需要先导入相关依赖jar
<
dependency
>
<
groupId
>
org.apache.commons
</
groupId
>
<
artifactId
>
commons-digester3
</
artifactId
>
<
version
>
3.2
</
version
>
<
classifier
>
with-deps
</
classifier
>
</
dependency
>
第一个示例应用程序演示如何使用Digester库动态的创建对象，并设置相应的属性值。
employee1.xml文件内容如下
<?
xml version="1.0" encoding="ISO-8859-1"
?>
<
employee
firstName
="Brian"
lastName
="May"
>
</
employee
>
我们需要根据上面的xml文件创建Employee对象，并设置相应属性，Employee类代码如下：
public
class
Employee {
private
String firstName;
private
String lastName;
private
ArrayList offices =
new
ArrayList();
public
Employee() {
System.out.println(
"Creating Employee"
);
}
public
String getFirstName() {
return
firstName;
}
public
void
setFirstName(String firstName) {
System.out.println(
"Setting firstName : " +
firstName);
this
.firstName =
firstName;
}
public
String getLastName() {
return
lastName;
}
public
void
setLastName(String lastName) {
System.out.println(
"Setting lastName : " +
lastName);
this
.lastName =
lastName;
}
public
void
addOffice(Office office) {
System.out.println(
"Adding Office to this employee"
);
offices.add(office);
}
public
ArrayList getOffices() {
return
offices;
}
public
void
printName() {
System.out.println(
"My name is " + firstName + " " +
lastName);
}
}
现在写一个测试类Test01，它使用Digester类，并为其添加创建Employee对象和设置其属性的规则。
public
class
Test01 {
public
static
void
main(String[] args) {
InputStream inputStream
=
null
;
Digester digester
=
new
Digester();
//
add rules
digester.addObjectCreate("employee","ex15.pyrmont.digestertest.Employee"
);
digester.addSetProperties(
"employee"
);
digester.addCallMethod(
"employee", "printName"
);
try
{
inputStream
= Thread.currentThread().getContextClassLoader().getResourceAsStream("employee1.xml");
Employee employee =
(Employee) digester.parse(inputStream);
System.out.println(
"First name : " +
employee.getFirstName());
System.out.println(
"Last name : " +
employee.getLastName());
}
catch
(Exception e) {
e.printStackTrace();
}
finally
{
if
(inputStream !=
null
) {
try
{
inputStream.close();
}
catch
(IOException e) {
//
TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}
第二个示例演示如何利用Digester库创建两个对象，并建立他们之间的关系
employee2.xml 文件内容如下
<?
xml version="1.0" encoding="ISO-8859-1"
?>
<
employee
firstName
="Freddie"
lastName
="Mercury"
>
<
office
description
="Headquarters"
>
<
address
streetName
="Wellington Avenue"
streetNumber
="223"
/>
</
office
>
<
office
description
="Client site"
>
<
address
streetName
="Downing Street"
streetNumber
="10"
/>
</
office
>
</
employee
>
然后我们还需要创建Office类和Address类
Office类代码如下：
public
class
Office {
private
Address address;
private
String description;
public
Office() {
System.out.println(
"..Creating Office"
);
}
public
String getDescription() {
return
description;
}
public
void
setDescription(String description) {
System.out.println(
"..Setting office description : " +
description);
this
.description =
description;
}
public
Address getAddress() {
return
address;
}
public
void
setAddress(Address address) {
System.out.println(
"..Setting office address : " +
address);
this
.address =
address;
}
}
Address类代码如下：
public
class
Address {
private
String streetName;
private
String streetNumber;
public
Address() {
System.out.println(
"....Creating Address"
);
}
public
String getStreetName() {
return
streetName;
}
public
void
setStreetName(String streetName) {
System.out.println(
"....Setting streetName : " +
streetName);
this
.streetName =
streetName;
}
public
String getStreetNumber() {
return
streetNumber;
}
public
void
setStreetNumber(String streetNumber) {
System.out.println(
"....Setting streetNumber : " +
streetNumber);
this
.streetNumber =
streetNumber;
}
public
String toString() {
return
"...." + streetNumber + " " +
streetName;
}
}
下面是Test02类的定义，该类使用一个Digester对象，并为其添加规则
public
class
Test02 {
public
static
void
main(String[] args) {
InputStream inputStream =
null
;
Digester digester
=
new
Digester();
//
add rules
digester.addObjectCreate("employee"
,
"ex15.pyrmont.digestertest.Employee"
);
digester.addSetProperties(
"employee"
);
digester.addObjectCreate(
"employee/office"
,
"ex15.pyrmont.digestertest.Office"
);
digester.addSetProperties(
"employee/office"
);
digester.addSetNext(
"employee/office", "addOffice"
);
digester.addObjectCreate(
"employee/office/address"
,
"ex15.pyrmont.digestertest.Address"
);
digester.addSetProperties(
"employee/office/address"
);
digester.addSetNext(
"employee/office/address", "setAddress"
);
try
{
inputStream
=
Thread.currentThread().getContextClassLoader()
.getResourceAsStream(
"employee2.xml");
Employee employee =
(Employee) digester.parse(inputStream);
ArrayList offices
=
employee.getOffices();
Iterator iterator
=
offices.iterator();
System.out
.println(
"-------------------------------------------------"
);
while
(iterator.hasNext()) {
Office office
=
(Office) iterator.next();
Address address
=
office.getAddress();
System.out.println(office.getDescription());
System.out.println(
"Address : " +
address.getStreetNumber()
+ " " +
address.getStreetName());
System.out.println(
"--------------------------------"
);
}
}
catch
(Exception e) {
e.printStackTrace();
}
finally
{
if
(inputStream !=
null
) {
try
{
inputStream.close();
}
catch
(IOException e) {
//
TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}
Rule类包含了一些方法，其中最重要的两个方法是begin()方法和end()方法，当Digester实例遇到某个XML元素的开始标签时，它会调用它所包含的匹配Rule对象的begin()方法，方法签名如下：
public void begin( String namespace, String name, Attributes attributes ) throws Exception
当Digester实例遇到某个XML元素的结束标签时，它会调用它所包含的匹配Rule对象的end()方法，方法签名如下：
public void end( String namespace, String name ) throws Exception
Digester对象是如何完成这些工作的呢？当调用Digester对象的addObjectCreate()方法、addCallMethod()方法、addSetNext()方法或其他方法时，都会间接地调用Digester类的addRule()方法；该方法将一个Rule对象和它所匹配的模式添加到Digester对象的Rules集合中。
addRule()方法实现如下：
public
void
addRule( String pattern, Rule rule )
{
rule.setDigester(
this
);
getRules().add( pattern, rule );
}
查看Digester类的addObjectCreate()方法的重载实现如下：
public
void
addObjectCreate( String pattern, String className )
{
addRule( pattern,
new
ObjectCreateRule( className ) );
}
public
void
addObjectCreate( String pattern, Class<?>
clazz )
{
addRule( pattern,
new
ObjectCreateRule( clazz ) );
}
public
void
addObjectCreate( String pattern, String className, String attributeName )
{
addRule( pattern,
new
ObjectCreateRule( className, attributeName ) );
}
public
void
addObjectCreate( String pattern, String attributeName, Class<?>
clazz )
{
addRule( pattern,
new
ObjectCreateRule( attributeName, clazz ) );
}
这四个重载方法都调用了addRule()方法，ObjectCreateRule类是Rule类的子类，该类的实例可作为addRule()方法的第二个参数使用。
下面是ObjectCreateRule类的begin()方法和end()方法的实现
@Override
public
void
begin( String namespace, String name, Attributes attributes )
throws
Exception
{
Class
<?> clazz =
this
.clazz;
if
( clazz ==
null
)
{
//
Identify the name of the class to instantiate
String realClassName =
className;
if
( attributeName !=
null
)
{
String value
=
attributes.getValue( attributeName );
if
( value !=
null
)
{
realClassName
=
value;
}
}
if
( getDigester().getLogger().isDebugEnabled() )
{
getDigester().getLogger().debug( format(
"[ObjectCreateRule]{%s} New '%s'"
,
getDigester().getMatch(),
realClassName ) );
}
//
Instantiate the new object and push it on the context stack
clazz =
getDigester().getClassLoader().loadClass( realClassName );
}
Object instance;
if
( constructorArgumentTypes ==
null
|| constructorArgumentTypes.length == 0
)
{
if
( getDigester().getLogger().isDebugEnabled() )
{
getDigester()
.getLogger()
.debug( format(
"[ObjectCreateRule]{%s} New '%s' using default empty constructor"
,
getDigester().getMatch(),
clazz.getName() ) );
}
instance
=
clazz.newInstance();
}
else
{
if
( proxyManager ==
null
)
{
Constructor
<?> constructor =
getAccessibleConstructor( clazz, constructorArgumentTypes );
if
( constructor ==
null
)
{
throw
new
SAXException(
format(
"[ObjectCreateRule]{%s} Class '%s' does not have a construcor with types %s"
,
getDigester().getMatch(),
clazz.getName(),
Arrays.toString( constructorArgumentTypes ) ) );
}
proxyManager
=
new
ProxyManager( clazz, constructor, defaultConstructorArguments, getDigester() );
}
instance
=
proxyManager.createProxy();
}
getDigester().push( instance );
}
/**
* {
@inheritDoc
}
*/
@Override
public
void
end( String namespace, String name )
throws
Exception
{
Object top
=
getDigester().pop();
if
( proxyManager !=
null
)
{
proxyManager.finalize( top );
}
if
( getDigester().getLogger().isDebugEnabled() )
{
getDigester().getLogger().debug( format(
"[ObjectCreateRule]{%s} Pop '%s'"
,
getDigester().getMatch(),
top.getClass().getName() ) );
}
}
begin()方法用于创建一个对象实例，并将其压入到Digester对象的内部栈中；end()方法会将内部栈的栈顶元素弹出栈
要向Digester实例中添加Rule对象，还可以调用其addRuleSet()方法，方法实现如下：
public
void
addRuleSet( RuleSet ruleSet )
{
String oldNamespaceURI
=
getRuleNamespaceURI();
String newNamespaceURI
=
ruleSet.getNamespaceURI();
if
( log.isDebugEnabled() )
{
if
( newNamespaceURI ==
null
)
{
log.debug(
"addRuleSet() with no namespace URI"
);
}
else
{
log.debug(
"addRuleSet() with namespace URI " +
newNamespaceURI );
}
}
setRuleNamespaceURI( newNamespaceURI );
ruleSet.addRuleInstances(
this
);
setRuleNamespaceURI( oldNamespaceURI );
}
org.apache.commons.digester3.RuleSet接口表示Rule对象的集合，该接口定义了两个方法，分别为addRuleInstance()和getNamespaceURI()，addRuleInstance()方法签名如下：
public void addRuleInstance(Digester digester)
addRuleInstance()方法用于添加定义在当前RuleSet对象中的Rule对象集合到作为该方法参数传输的Digester实例中
getNamespaceUR()方法返回将要应用在所有Rule对象（在当前Ruleset中创建的）的命名空间的URI，该方法签名如下
public java.lang.String getNamespaceURI()
因此，在创建了Digester对象之后，可以创建一个RuleSet对象，并将其传输给Digester对象的addRuleSet()方法
为了便于使用，实现RuleSet接口有一个基类RuleSetBase，RuleSetBase类为抽象类，提供了getNamespaceURI()方法的实现，我们只需要提供addRuleInstances()方法的实现就可以了
下面是我们创建的EmployeeRuleSet类的源码（继承自RuleSetBase类）
public
class
EmployeeRuleSet
extends
RuleSetBase {
public
void
addRuleInstances(Digester digester) {
//
add rules
digester.addObjectCreate("employee", "ex15.pyrmont.digestertest.Employee"
);
digester.addSetProperties(
"employee"
);
digester.addObjectCreate(
"employee/office", "ex15.pyrmont.digestertest.Office"
);
digester.addSetProperties(
"employee/office"
);
digester.addSetNext(
"employee/office", "addOffice"
);
digester.addObjectCreate(
"employee/office/address"
,
"ex15.pyrmont.digestertest.Address"
);
digester.addSetProperties(
"employee/office/address"
);
digester.addSetNext(
"employee/office/address", "setAddress"
);
}
}
我们注意到，EmployeeRuleSet类中的addRuleInstances()方法的实现的功能类似Test02类，将相同的Rule对象添加到Digester对象中
下面是Test03的代码，里面会创建EmployeeRuleSet类的实例，然后将其添加到之前创建的Digester对象中
public
class
Test03 {
public
static
void
main(String[] args) {
InputStream inputStream =
null
;
Digester digester
=
new
Digester();
digester.addRuleSet(
new
EmployeeRuleSet());
try
{
inputStream
= Thread.currentThread().getContextClassLoader().getResourceAsStream("employee2.xml"
);
Employee employee
=
(Employee) digester.parse(inputStream);
ArrayList offices
=
employee.getOffices();
Iterator iterator
=
offices.iterator();
System.out.println(
"-------------------------------------------------"
);
while
(iterator.hasNext()) {
Office office
=
(Office) iterator.next();
Address address
=
office.getAddress();
System.out.println(office.getDescription());
System.out.println(
"Address : " +
address.getStreetNumber()
+ " " +
address.getStreetName());
System.out.println(
"--------------------------------"
);
}
}
catch
(Exception e) {
e.printStackTrace();
}
finally
{
if
(inputStream !=
null
) {
try
{
inputStream.close();
}
catch
(IOException e) {
//
TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}
与其他类型的容器不同，StandardContext实例必须有一个监听器，该监听器会负责配置StandardContext实例，设置成功后会将StandardContext实例的变量configued值设置为tue。
StandardContext类的标准监听器是org.apache.catalina.startup.ContextConfig类的实例，它会执行很对StandardContext实例来说必不可少的任务，例如安装验证器阀到StandardContext实例的管道对象中，此外还会添加许可器阀（类型为org.apache.catalina.valves.CertificateValve）到管道对象中。
但更重要的是，ContextConfig类的实例还会读取和解析默认的web.xml文件和应用程序自定义的web.xml文件，并将xml元素转换为java对象。
默认的web.xml文件位于CATALINE_HOME目录下的conf目录中，其中定义并映射了很多默认的servlet，配置了很多MIME类型文件的映射，定义了默认的session超时时间，以及定义了欢迎文件的列表。
应用程序的web.xml文件是应用程序自定义的配置文件，位于应用程序目录下的WEB-INF目录中。
ContextConfig实例会为每一个servlet元素创建StandardWrapper实例，因此，正如你在本章应用程序中看到的，配置变简单了，你不在需要实例化Wrapper实例了
因此，我们需要在Bootstrap类中实例化一个ContextConfig类，并调用org.apache.catalina.Lifecycle接口的addLifecycleListener()方法将其添加到StandardContext对象中
LifecycleListener listener =
new
ContextConfig();
((Lifecycle) context).addLifecycleListener(listener);
在启动和停止StandardContext实例时，会触发相应事件，ContextConfig类会对两种事件做出响应，分别为START_EVENT 和STOP_EVENT
每当StandardContext实例触发事件时，会调用ContextConfig实例的lifecycleEvent()方法
public
void
lifecycleEvent(LifecycleEvent event) {
//
Identify the context we are associated with
try
{
context
=
(Context) event.getLifecycle();
if
(context
instanceof
StandardContext) {
int
contextDebug =
((StandardContext) context).getDebug();
if
(contextDebug >
this
.debug)
this
.debug =
contextDebug;
}
}
catch
(ClassCastException e) {
log(sm.getString(
"contextConfig.cce"
, event.getLifecycle()), e);
return
;
}
//
Process the event that has occurred
if
(event.getType().equals(Lifecycle.START_EVENT))
start();
else
if
(event.getType().equals(Lifecycle.STOP_EVENT))
stop();
}
在上面方法中，会继续调用start()方法和stop()方法
private
synchronized
void
start() {
if
(debug > 0
)
log(sm.getString(
"contextConfig.start"
));
context.setConfigured(
false
);
ok
=
true
;
//
Set properties based on DefaultContext
Container container =
context.getParent();
if
( !
context.getOverride() ) {
if
( container
instanceof
Host ) {
((Host)container).importDefaultContext(context);
container
=
container.getParent();
}
if
( container
instanceof
Engine ) {
((Engine)container).importDefaultContext(context);
}
}
//
Process the default and application web.xml files
defaultConfig();
applicationConfig();
if
(ok) {
validateSecurityRoles();
}
//
Scan tag library descriptor files for additional listener classes
if
(ok) {
try
{
tldScan();
}
catch
(Exception e) {
log(e.getMessage(), e);
ok
=
false
;
}
}
//
Configure a certificates exposer valve, if required
if
(ok)
certificatesConfig();
//
Configure an authenticator if we need one
if
(ok)
authenticatorConfig();
//
Dump the contents of this pipeline if requested
if
((debug >= 1) && (context
instanceof
ContainerBase)) {
log(
"Pipline Configuration:"
);
Pipeline pipeline
=
((ContainerBase) context).getPipeline();
Valve valves[]
=
null
;
if
(pipeline !=
null
)
valves
=
pipeline.getValves();
if
(valves !=
null
) {
for
(
int
i = 0; i < valves.length; i++
) {
log(
" " +
valves[i].getInfo());
}
}
log(
"======================"
);
}
//
Make our application available if no problems were encountered
if
(ok)
context.setConfigured(
true
);
else
{
log(sm.getString(
"contextConfig.unavailable"
));
context.setConfigured(
false
);
}
}
start()方法会进一步调用defaultConfig()方法和applicationConfig()方法
defaultConfig()方法负责读取并解析位于%CATALINA_HOME%/conf目录下的默认的web.xml文件
private
void
defaultConfig() {
//
Open the default web.xml file, if it exists
File file =
new
File(Constants.DefaultWebXml);
if
(!
file.isAbsolute())
file
=
new
File(System.getProperty("catalina.base"
),
Constants.DefaultWebXml);
FileInputStream stream
=
null
;
try
{
stream
=
new
FileInputStream(file.getCanonicalPath());
stream.close();
stream
=
null
;
}
catch
(FileNotFoundException e) {
log(sm.getString(
"contextConfig.defaultMissing"
));
return
;
}
catch
(IOException e) {
log(sm.getString(
"contextConfig.defaultMissing"
), e);
return
;
}
//
Process the default web.xml file
synchronized
(webDigester) {
try
{
InputSource is
=
new
InputSource("file://" +
file.getAbsolutePath());
stream
=
new
FileInputStream(file);
is.setByteStream(stream);
webDigester.setDebug(getDebug());
if
(context
instanceof
StandardContext)
((StandardContext) context).setReplaceWelcomeFiles(
true
);
webDigester.clear();
webDigester.push(context);
webDigester.parse(is);
}
catch
(SAXParseException e) {
log(sm.getString(
"contextConfig.defaultParse"
), e);
log(sm.getString(
"contextConfig.defaultPosition"
,
"" +
e.getLineNumber(),
"" +
e.getColumnNumber()));
ok
=
false
;
}
catch
(Exception e) {
log(sm.getString(
"contextConfig.defaultParse"
), e);
ok
=
false
;
}
finally
{
try
{
if
(stream !=
null
) {
stream.close();
}
}
catch
(IOException e) {
log(sm.getString(
"contextConfig.defaultClose"
), e);
}
}
}
}
applicationConfig()方法与defaultConfig()方法类似，只不过它处理的是应用程序自定义的部署描述符，该部署描述符位于应用目录下的WEB-INF目录中
private
void
applicationConfig() {
//
Open the application web.xml file, if it exists
InputStream stream =
null
;
ServletContext servletContext
=
context.getServletContext();
if
(servletContext !=
null
)
stream
=
servletContext.getResourceAsStream
(Constants.ApplicationWebXml);
if
(stream ==
null
) {
log(sm.getString(
"contextConfig.applicationMissing"
));
return
;
}
//
Process the application web.xml file
synchronized
(webDigester) {
try
{
URL url
=
servletContext.getResource(Constants.ApplicationWebXml);
InputSource is
=
new
InputSource(url.toExternalForm());
is.setByteStream(stream);
webDigester.setDebug(getDebug());
if
(context
instanceof
StandardContext) {
((StandardContext) context).setReplaceWelcomeFiles(
true
);
}
webDigester.clear();
webDigester.push(context);
webDigester.parse(is);
}
catch
(SAXParseException e) {
log(sm.getString(
"contextConfig.applicationParse"
), e);
log(sm.getString(
"contextConfig.applicationPosition"
,
"" +
e.getLineNumber(),
"" +
e.getColumnNumber()));
ok
=
false
;
}
catch
(Exception e) {
log(sm.getString(
"contextConfig.applicationParse"
), e);
ok
=
false
;
}
finally
{
try
{
if
(stream !=
null
) {
stream.close();
}
}
catch
(IOException e) {
log(sm.getString(
"contextConfig.applicationClose"
), e);
}
}
}
}
在ContextConfig类中，使用变量webDigester来引用一个Digester类型的对象
private static Digester webDigester = createWebDigester();
该Digester对象用于解析默认的web.xml文件和应用程序自定义的web.xml文件，在调用createWebDigester()方法时会添加用来处理web.xml文件的规则
/**
* Create (if necessary) and return a Digester configured to process the
* web application deployment descriptor (web.xml).
*/
private
static
Digester createWebDigester() {
URL url
=
null
;
Digester webDigester
=
new
Digester();
webDigester.setValidating(
true
);
url
= ContextConfig.
class
.getResource(Constants.WebDtdResourcePath_22);
webDigester.register(Constants.WebDtdPublicId_22,
url.toString());
url
= ContextConfig.
class
.getResource(Constants.WebDtdResourcePath_23);
webDigester.register(Constants.WebDtdPublicId_23,
url.toString());
webDigester.addRuleSet(
new WebRuleSet());
return
(webDigester);
}
我们注意到，上面方法中调用了变量webDigester的addRuleSet()方法，传入一个org.apache.catalina.startup.WebRuleSet类型的对象作为参数；WebRuleSet类是org.apache.commons.digester.RuleSetBase的子类。
下面是WebRuleSet类的addRuleInstances()方法实现：
public
void
addRuleInstances(Digester digester) {
digester.addRule(prefix
+ "web-app"
,
new
SetPublicIdRule(digester, "setPublicId"
));
digester.addCallMethod(prefix
+ "web-app/context-param"
,
"addParameter", 2
);
digester.addCallParam(prefix
+ "web-app/context-param/param-name", 0
);
digester.addCallParam(prefix
+ "web-app/context-param/param-value", 1
);
digester.addCallMethod(prefix
+ "web-app/display-name"
,
"setDisplayName", 0
);
digester.addRule(prefix
+ "web-app/distributable"
,
new
SetDistributableRule(digester));
digester.addObjectCreate(prefix
+ "web-app/ejb-local-ref"
,
"org.apache.catalina.deploy.ContextLocalEjb"
);
digester.addSetNext(prefix
+ "web-app/ejb-local-ref"
,
"addLocalEjb"
,
"org.apache.catalina.deploy.ContextLocalEjb"
);
//
代码太长，后面部分略
}
---------------------------------------------------------------------------
本系列How Tomcat Works系本人原创
转载请注明出处 博客园 刺猬的温驯
本人邮箱： chenying998179 # 163.com （ #改为@ ）
