端到端J2ME开发——介绍Smart Ticket

package com.sun.j2me.blueprints.smartticket.client.midp.model;
public class ModelFacade {
  private SynchronizationAgent syncAgent;
  private RemoteModelProxy remoteModel;
  private LocalModel localModel;
  // Action methods ...
  public Reservation reserveSeats(String theaterKey,
                         String movieKey,
                         int[] showTime, Seat[] seats)
                         throws ApplicationException {
    try {
      return remoteModel.reserveSeats(theaterKey, 
          movieKey, showTime, seats);
    } catch (ModelException me) {
      // ...
    } 
  } 
  public void purchaseTickets(Reservation reservation) 
                          throws ApplicationException {
    try {
      remoteModel.purchaseTickets(reservation.getId());
      localModel.addMovieRating(
        new MovieRating(remoteModel.getMovie(reservation.getMovieId()), 
                        reservation.getShowTime()));
    } catch (ModelException me) {
      // ...
    }
    return;
  }
  public void synchronizeMovieRatings(int 
     conflictResolutionStrategyId) 
         throws ApplicationException {
    try {
      syncAgent.synchronizeMovieRatings(conflictResolutionStrategyId);
      return;
    } catch (ModelException me) {
      // ...
    }
  }
  // ...
} 

package com.sun.j2me.blueprints.smartticket.server.web.midp;
public class SmartTicketServlet extends HttpServlet {
  public static final String SESSION_ATTRIBUTE_SMART_TICKET_BD =
    "com.sun.j2me.blueprints.smartticket.server.web.midp.SmartTicketBD";
  protected void doPost(HttpServletRequest request,
                        HttpServletResponse response)
                        throws ServletException, IOException {
    HttpSession session = request.getSession(true);
    SmartTicketBD smartTicketBD = (SmartTicketBD)
      session.getAttribute(SESSION_ATTRIBUTE_SMART_TICKET_BD);
    // Calls handleCall() method and encodes the URL for
    // session tracking
  }
  public int handleCall(SmartTicketBD smartTicketBD, 
     InputStream in, OutputStream out)
         throws IOException, ApplicationException {
    // Identifies the requested action method
    // Executes the method, as selected in a switch statement
    switch (method) {
    // cases ...
    case MessageConstants.OPERATION_GET_MOVIE: {
      getMovie(smartTicketBD, call, successfulResult);
      break;
    }
    // more cases ...
    }
  }
}
package com.sun.j2me.blueprints.smartticket.server.web.midp;
public class SmartTicketBD implements RemoteModel {
  public static final String EJB_REF_FACADE = 
      "ejb/SmartTicketFacade";
  private SmartTicketFacadeLocal facade;
  private ServletContext servletContext = null;
  public SmartTicketBD(ServletContext servletContext) 
                       throws ApplicationException {
    this.servletContext = servletContext;
    try {
      Context context = (Context)
        new InitialContext().lookup("java:comp/env");
      facade = ((SmartTicketFacadeLocalHome)
        context.lookup(EJB_REF_FACADE)).create();
      return;
    } catch (Exception e) {
      throw new ApplicationException(e);
    } 
  }
  public Movie getMovie(String movieKey) 
      throws ModelException, ApplicationException {
    try {
      MovieLocal movieLocal = facade.getMovie(movieKey);
      Movie movie = new Movie(movieLocal.getId(), 
                              movieLocal.getTitle(), 
                              movieLocal.getSummary(), 
                              movieLocal.getRating());
      return movie;
    } catch (SmartTicketFacadeException stfe) {
      throw new 
          ModelException(ModelException.CAUSE_MOVIE_NOT_FOUND);
    } catch (Exception e) {
      throw new ApplicationException(e);
    } 
  }
  // Other action methods in RemoteModel interface ...
}
package com.sun.j2me.blueprints.smartticket.server.ejb;
public class SmartTicketFacadeBean implements SessionBean {
  // ...
  public MovieLocal getMovie(String movieId) 
                    throws SmartTicketFacadeException {
    try {
      return movieHome.findByPrimaryKey(movieId);
    } catch (FinderException fe) {
      throw new 
          SmartTicketFacadeException("No matching movie.");
    } 
  }
  // ...
}
下图展示了整体 MVC 和界面的体系结构：

实现模式
MVC 和界面模式定义了应用程序的整体结构。另外，Smart Ticket 也列出了一些重要的行为模式，

这些模式能帮助开发人员提高效率。
处理程序链
The RemoteModelProxy 类把每一个请求动作都委托给 handler 类链，以便透明地解决 RMS 串行化

和 HTTP 连接的异常管道。 链接的处理程序体系结构基于实现它的 RequestHandler接口和 

RemoteModelRequestHandler 抽象类：





public interface RequestHandler {
    RequestHandler getNextHandler();
    void init() throws ApplicationException;
    void destroy() throws ApplicationException;
}
abstract public class RemoteModelRequestHandler 
  implements RequestHandler, RemoteModel {
  private RemoteModelRequestHandler nextHandler;
  private Preferences preferences;
  protected static ProgressObserver progressObserver;
  public RemoteModelRequestHandler(
      RemoteModelRequestHandler nextHandler) {
    this.nextHandler = nextHandler;
  }
  public RequestHandler getNextHandler() {
    return nextHandler;
  }
  public void init() throws ApplicationException {
    if (nextHandler != null) {
      nextHandler.init();
    }
    return;
  }
  public void destroy() throws ApplicationException {
    if (nextHandler != null) {
      nextHandler.destroy();
    }
    return;
  }
  public void login(String userName, String password) 
      throws ModelException, ApplicationException {
    getRemoteModelRequestHandler().login(userName, password);
    return;
  } 
  public void createAccount(AccountInfo accountInfo) 
                            throws ModelException, 
                            ApplicationException {
    getRemoteModelRequestHandler().createAccount(accountInfo);
    return;
  }
  // Other action methods declared in RemoteModel
  // ...
} 
 


具体的 handler 类扩展了 RemoteModelRequestHandler 类。嵌套的构造

函数建立一个处理程序链。Smart Ticket 启用了两个处理程序类：RMSCacheHandler 和 

HTTPCommunicationHandler。因此链接装配方法如下：





public class RemoteModelProxy extends ModelObjectLoader 
                              implements RemoteModel {
  private RemoteModelRequestHandler requestHandlerChain;
  private Preferences preferences = null;
  private Hashtable movies = new Hashtable();
  public RemoteModelProxy(String serviceURL) 
                          throws ApplicationException {
    requestHandlerChain =
      new RMSCacheHandler(
        new HTTPCommunicationHandler(null, serviceURL));
    return;
  }
  // ...
  public Movie getMovie(String movieKey) 
                        throws ModelException, 
                        ApplicationException {
    Movie movie = (Movie) movies.get(movieKey);
    if (movie == null) {
      movie = requestHandlerChain.getMovie(movieKey);
      movies.put(movieKey, movie);
    } 
    return movie;
  } 
  // Other methods ...
}

public class UIController {
  // Action methods ...
  public void chooseMovieRequested() {
    runWithProgress(
      new EventDispatcher(
        EventIds.EVENT_ID_CHOOSEMOVIEREQUESTED, 
            mainMenuUI), 
                getString(UIConstants.PROCESSING), false);
  }
  // Action methods ...
  public void runWithProgress(Thread thread, String title, 
                              boolean stoppable) {
    progressObserverUI.init(title, stoppable);
    getDisplay().setCurrent(progressObserverUI);
    thread.start();
  }
  class EventDispatcher extends Thread {
    // ...
    public void run() {
      // Switch -- case statements to delegate
      // actions to the model layer
    }
  }
}
public class ProgressObserverUI extends Form 
            implements ProgressObserver,
            CommandListener {
  private UIController uiController;
  private static final int GAUGE_MAX = 8;
  private static final int GAUGE_LEVELS = 4;
  int current = 0;
  Gauge gauge;
  Command stopCommand;
  boolean stoppable;
  boolean stopped;
  public ProgressObserverUI(UIController uiController) {
    super("");
    gauge = new Gauge("", false, GAUGE_MAX, 0);
    stopCommand = new 
        Command(uiController.getString(UIConstants.STOP), 
            Command.STOP, 10);
    append(gauge);
    setCommandListener(this);
  }
  public void init(String note, boolean stoppable) {
    gauge.setValue(0);
    setNote(note);
    setStoppable(stoppable);
    stopped = false;
  }
  public void setNote(String note) {
    setTitle(note);
  }
  public boolean isStoppable() {
    return stoppable;
  }
  public void setStoppable(boolean stoppable) {
    this.stoppable = stoppable;
    if (stoppable) {
      addCommand(stopCommand);
    } else {
      removeCommand(stopCommand);
    }
  }
  /**
   * Indicates whether the user has stopped the progress.
   * This message should be called before calling update.
   */
  public boolean isStopped() {
    return stopped;
  }
  public void updateProgress() {
    current = (current + 1) % GAUGE_LEVELS;
    gauge.setValue(current * GAUGE_MAX / GAUGE_LEVELS);
  }
  public void commandAction(Command c, Displayable d) {
    if (c == stopCommand) {
      stopped = true;
    }
  }
}