How Tomcat Works（十八）-CSDN博客

在前面的文章中，如果我们要启动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");

        //代码太长，后面部分略

    }