EJB 倡导者: 在面向服务的体系结构中，使用无 facade 的 EJB 组件是最佳选择吗？

try {
    // Assume a routine to get the id exists on the superclass servlet
    int cID = getCustomerId(req);
    // The five lines of code to invoke a remote session method
    InitialContext initCtx = new InitialContext();
    Object obj = initCtx.lookup("java:comp/env/ejb/OrderEntry");       
    OrderEntryHome home = (OrderEntryHome)PortableObjectRemote(
	obj, OrderEntryHome.class
    );       
    OrderEntry ref = home.create();
    CustomerData data = ref.getOpenOrderForCustomer(cID);
    // Assume an include JSP method exists on the superclass servlet
    include("CustomerWithOpenOrder", data, req, res);
}
catch (ParseException e) {
    // Occurs if parse routine fails to get a valid positive integer
    include("ParseException", e, req, res);
}
catch (NamingException e) {
    // Occurs if JNDI context cannot be initialized or name not found
    include("NamingException", e, req, res);		
}
catch (RemoteException e) {
    // Occurs if the object cannot be narrowed, created or executed
    include("RemoteException", e, req, res);		
}
catch (CustomerNotFoundException e) {
    // Occurs if the customer ID is valid integer but not found
    include("CustomerNotFoundException", e, req, res);
}
catch (OrderNotOpenException e) {
    // Occurs if the customer has no open order
    include("OrderNotOpenException", e, req, res);
}

try {
    // Assume a routine to get the id exists on the superclass servlet
    int cID = getCustomerId(req);
    // The four lines of code to invoke a local session method
    InitialContext initCtx = new InitialContext();
    OrderEntryHome home = (OrderEntryHome)initCtx.lookup(   
        "java:comp/env/OrderEntry"
    );       
    OrderEntry ref = home.create();
    CustomerData data = ref.getOpenOrderForCustomer(cID);
    // Assume an include JSP method exists on the superclass servlet
    include("CustomerWithOpenOrder", data, req, res);
}
catch (ParseException e) {
    // Occurs if parse routine fails to get a valid positive integer
    include("ParseException", e, req, res);
}
catch (NamingException e) {
    // Occurs if JNDI context cannot be initialized or name not found
    include("NamingException", e, req, res);		
}
catch (ClassCastException e) {
    // Occurs if the object cannot be cast to the home class
    include("ClassCastException", e, req, res);		
}
catch (CustomerNotFoundException e) {
    // Occurs if the customer ID is valid integer but not found
    include("CustomerNotFoundException", e, req, res);
}
catch (OrderNotOpenException e) {
    // Occurs if the customer ID has no open order
    include("OrderNotOpenException", e, req, res);
}

try {
    // Assume a routine to get the id exists on the superclass servlet
    int cID = getCustomerId(req);
    // The five lines of code to invoke a local entity method
    InitialContext initCtx = new InitialContext();
    CustomerHome home = (CustomerHome)initCtx.lookup(   
        "java:comp/env/Customer"
    );
    CustomerKey key = new CustomerKey(cID);
    Customer ref = home.findByPrimaryKey(key);
    CustomerData data = ref.getOpenOrder();
    // Assume an include JSP method exists on the superclass servlet
    include("CustomerWithOpenOrder", data, req, res);
}
catch (ParseException e) {
    // Occurs if parse routine fails to get a valid positive integer
    include("ParseException", e, req, res);
}
catch (NamingException e) {
    // Occurs if JNDI context cannot be initialized or name not found
    include("NamingException", e, req, res);		
}
catch (ClassCastException e) {
    // Occurs if the object cannot be cast to the home class
    include("ClassCastException", e, req, res);		
}
catch (FinderException e) {
    // Occurs if the customer is not found
    include("FinderException", e, req, res);	
}
catch (OrderNotOpenException e) {
    // Occurs if the customer ID is invalid
    include("OrderNotOpenException", e, req, res);
}

try {
    // Assume a routine to get the id exists on the superclass servlet
    int cID = getCustomerId(req);
    // The two lines of code to invoke the service
    OrderEntryDelegate ref = new OrderEntryDelegate();
    CustomerData data = ref.getOpenOrderForCustomer(cID);
    // Assume an include JSP method exists on the superclass servlet
    include("CustomerWithOpenOrder", data, req, res);
}
catch (ParseException e) {
    // Occurs if parse routine fails to get a valid positive integer
    include("ParseException", e, req, res);
}
catch (ServiceException e) {
    // Occurs if the service is not able to be invoked 
    include("CustomerNotFoundException", e, req, res);
}
catch (CustomerNotFoundException e) {
    // Occurs if the customer ID is valid integer but not found
    include("CustomerNotFoundException", e, req, res);
}
catch (OrderNotOpenException e) {
    // Occurs if the customer ID has no open order
    include("OrderNotOpenException", e, req, res);
}

public class OrderEntryDelegate {
    private static OrderEntryDelegate instance = 
        new OrderEntryDelegate();
    public static singleton() { return instance; }
    // Insert rest of the delegate code here including cached variables
}

public interface OrderEntryDelegate {
    // Insert service signatures here
}
public class OrderEntryDelegateImpl
implements OrderEntryDelegate {
    // Insert delegate implementations here
}
public class OrderEntryFactory {
    private OrderEntryDelegate instance = 
        new OrderEntryDelegateImpl();
    public static OrderEntryDelegate getDelegate() {
        return instance;        
    }
}

public interface OrderEntry 
extends OrderEntryDelegate, EJBLocalObject {
}
public class OrderEntryBean 
implements OrderEntryDelegate, SessionBean {
   // Insert service implementations here
}

public interface Factory {
}
public interface OrderEntryFactory extends Factory {
    public OrderEntryDelegate getDelegate();
}
public class OrderEntryFactoryImpl implements OrderEntryFactory {
    private OrderEntryDelegate instance = 
        new OrderEntryDelegateImpl();
    public OrderEntryDelegate getDelegate() {
        return instance;        
    }
}
public class FactoryFinder {
    private HashMap factories = new HashMap();
    public FactoryFinder() {
       // Bind the implementations, possibly using environment vars
    }
    public Factory getFactory(String name) {
        return (Factory)factories.get(name);
    }
}

public class OrderEntryHelper
implements OrderEntryDelegate {
    // Insert service implementations here
}

public class OrderEntryBean 
implements OrderEntryDelegate, SessionBean {
   private OrderEntryHelper helper = null;
   public void ejbCreate() {
       helper = new OrderEntryHelper();
   }
   // Insert service implementations here
   public CustomerData getOpenOrderForCustomer(int cID) {
       return helper.getOpenOrderForCustomer(cID);
   }
}

public class GetOpenOrderServlet extends CustomerServlet
{
    public void doGet(
        OrderEntryDelegate ref,
        HttpServletRequest req,
        HttpServletResponse res
    ){
        try {
    	    // The ref is passed in from the template superclass    
    	    CustomerData data = ref.getOpenOrder();
	    // Assume an include JSP method exists on the superclass
	    include("CustomerWithOpenOrder", data, req, res);
        }
        catch (OrderNotOpenException e) {
            // Occurs if the customer ID has no open order
            include("OrderNotOpenException", e, req, res);
        }
    }
}

    public CustomerData  ejbHomeGetOpenOrderForCustomer(int id) 
    throws OrderNotOpenException
    {
	// Get the Customer DTO	
	CustomerKey key = CustomerKey new(id)
	Customer ref = findByPrimaryKey(key);
	return ref.getDataWithOpenOrder();
    }

    InitialContext initCtx = new InitialContext();
    CustomerHome home = (CustomerHome)initCtx.lookup(   
        "java:comp/env/Customer"
    );
    CustomerData data = home.getOpenOrderForCustomer(cID);