brett mclaughlin 在这篇 ejb 最佳实践专栏文章中研究了 jndi 查找，它是几乎所有的 ejb 交互中不可或缺并且常见的部分。遗憾的是，jndi 操作几乎总是需要性能开销。在本技巧文章中，brett 向您展示了 home 接口工厂是如何降低您 ejb 应用程序中 jndi 查找开销的。
每种 ejb 组件（会话、实体和消息驱动的）都有 home 接口。home 接口是 bean 的操作基础；一旦您找到它，就可以使用该 bean 的功能。ejb 应用程序依靠 jndi 查找来访问其 bean 的 home 接口。因为 ejb 应用程序往往运行多个 bean，并且因为许多组件中经常使用 jndi 查找，所以应用程序大部分性能开销都花费在这些查找上。

在这篇技巧文章中，我们将研究一些最常用的 jndi 优化。特别地，我们将向您展示如何将高速缓存和通用助手类组合使用，以创建针对 jndi 开销的工厂风格的解决方案。

减少上下文实例

清单 1 显示了一段典型的 ejb 代码，它需要多次 jndi 查找。请花一点时间研究代码，然后我们将对它进行优化以获得更佳性能。


清单 1. 典型的 ejb 查找

public boolean buyitems(paymentinfo paymentinfo, string storename,
list items) {
      // load up the initial context
      context ctx = new initialcontext();

      // look up a bean's home interface
      object obj = ctx.lookup("java:comp/env/ejb/purchasehome");
      purchasehome purchasehome =
       (purchasehome)portableremoteobject.narrow(obj, purchasehome.class);
      purchase purchase = purchasehome.create(paymentinfo);

      // work on the bean
      for (iterator i = items.iterator(); i.hasnext(); ) {
          purchase.additem((item)i.next());
      }

      // look up another bean
      object obj = ctx.lookup("java:comp/env/ejb/inventoryhome");
      inventoryhome inventoryhome =
       (inventoryhome)portableremoteobject.narrow(obj, inventoryhome.class);
      inventory inventory = inventoryhome.findbystorename(storename);

      // work on the bean
      for (iterator i = items.iterator(); i.hasnext(); )
          inventory.markassold((item)i.next());
      }

      // do some other stuff
}
 


尽管这个示例多少有点刻意，但它确实揭示了使用 jndi 时的一些最明显的问题。对于初学者，您应该问问自己，新建 initialcontext 对象是否必需。很可能在应用程序代码的其它地方已经装入了这个上下文，而我们又在这里创建了一个新的。高速缓存 initialcontext 实例会立即促使性能提高，如清单 2 所示： 


清单 2. 高速缓存 initialcontext 实例

public static context getinitialcontext() {
      if (initialcontext == null) {
          initialcontext = new initialcontext();
      }

      return initialcontext;
}
 


通过对 getinitialcontext() 使用助手类，而不是为每个操作都实例化一个新的 initialcontext ，我们将遍布在应用程序中的上下文数量减少为一个。 

 哦 ? 线程化会怎么样？

如果您对此处提出的解决方案的线程化感到担心，那大可不必。两个线程同时进行 getinitialcontext() 是绝对有可能的（从而一次创建两个上下文），但只有首次调用该方法时才会发生此类错误。因为问题至多只会发生一次，所以同步是不必要的，实际上，同步引入的复杂性比它所解决的复杂性更多。

优化查找

高速缓存上下文实例这个步骤的方向是正确的，但仅这样做，还不足以完成优化。我们每次调用 lookup() 方法时都会执行一次新查找，并返回 bean 的 home 接口的新实例。至少，jndi 查找通常是这样编码的。但如果每个 bean 都只有一个 home 接口，并在多个组件上共享这个接口，这样不是更好吗？ 

我们可以高速缓存每个单独的 bean 引用，而不是反复查找 purchasehome 或 inventoryhome 的 home 接口；这是一种解决方案。但我们真正想要的是一种更通用的机制：在 ejb 应用程序中高速缓存 home 接口。 

答案是创建通用助手类，它既可以为应用程序中的每个 bean 获取初始上下文，又可以为它们查找 home 接口。此外，这个类还应该能够为各种应用程序组件管理每个 bean 的上下文。清单 3 中所示的通用助手类将充当 ejb home 接口的工厂：


清单 3. ejb home 接口工厂

package com.ibm.ejb;

import java.util.map;
import javax.ejb.ejbhome;
import javax.naming.context;
import javax.naming.initialcontext;
import javax.naming.namingexception;

public class ejbhomefactory {

      private static ejbhomefactory;

      private map homeinterfaces;
      private context context;

      // this is private, and can't be instantiated directly
      private ejbhomefactory() throws namingexception {
          homeinterfaces = new hashmap();

          // get the context for caching purposes
          context = new initialcontext();

          /**
           * in non-j2ee applications, you might need to load up
           *   a properties file and get this context manually. i've
           *   kept this simple for demonstration purposes.
           */
      }

      public static ejbhomefactory getinstance() throws namingexception {
          // not completely thread-safe, but good enough 
          // (see note in article)
          if (instance == null) {
              instance = new ejbhomefactory();
          }
          return instance;
      }

      public ejbhome lookup(string jndiname, class homeinterfaceclass) 
            throws namingexception {

          // see if we already have this interface cached
          ejbhome homeinterface = (ejbhome)homeinterfaces.get(homeclass);

          // if not, look up with the supplied jndi name
          if (homeinterface == null) {
              object obj = context.lookup(jndiname);
              homeinterface =
               (ejbhome)portableremoteobject.narrow(obj, homeinterfaceclass);

              // if this is a new ref, save for caching purposes
              homeinterfaces.put(homeinterfaceclass, homeinterface);
          }
          return homeinterface;
      }
}
 
ejbhomefactory 类内幕

home 接口工厂的关键在 homeinterfaces 映射中。该映射存储了供使用的每个 bean 的 home 接口；这样，home 接口实例可以反复使用。您还应注意，映射中的关键并 不是传递到 lookup() 方法的 jndi 名称。将同一 home 接口绑定到不同 jndi 名称是很常见的，但这样做会在您的映射中产生副本。通过依靠类本身，您就可以确保最终不会为同一个 bean 创建多个 home 接口。 

将新的 home 接口工厂类插入清单 1 的原始代码，这样将会产生优化的 ejb 查找，如清单 4 所示：


清单 4. 改进的 ejb 查找

public boolean buyitems(paymentinfo paymentinfo, string storename,
list items) {

      ejbhomefactory f = ejbhomefactory.getinstance();

      purchasehome purchasehome =
          (purchasehome)f.lookup("java:comp/env/ejb/purchasehome", 
          purchasehome.class);
      purchase purchase = purchasehome.create(paymentinfo);

      // work on the bean
      for (iterator i = items.iterator(); i.hasnext(); ) {
          purchase.additem((item)i.next());
      }

      inventoryhome inventoryhome =
          (inventoryhome)f.lookup("java:comp/env/ejb/inventoryhome", 
          inventoryhome.class);
      inventory inventory = inventoryhome.findbystorename(storename);

      // work on the bean
      for (iterator i = items.iterator(); i.hasnext(); ) {
          inventory.markassold((item)i.next());
      }

      // do some other stuff
}
 


随着时间的推进，除了更清晰之外（至少按我的观点），以上工厂优化的 ejb 查找将执行得更快。您第一次使用这个新类时，将花费所有正常查找开销（假定应用程序的其它部分没有付出过这种开销），但将来的所有 jndi 查找都将继续使用原先的查找结果。还有必要指出，home 接口工厂 不会干扰您容器的bean 管理。容器管理的是 bean 实例，而不是这些 bean 实例的 home 接口。您的容器还将管理实例交换，以及其它您希望它执行的任何优化。