端到端J2ME应用开发实例——介绍Smart Ticket

J2EE_HOME/bin/cloudscape -start
J2EE_HOME/bin/j2ee -verbose

setup deploy

public class ChooseMovieUI extends Form implements
CommandListener, ItemStateListener,
ItemCommandListener {

private UIController uiController;

// ...

public void commandAction(Command command, Displayable
displayable) { uiController.commandAction(command,
displayable);
}

public void commandAction(Command command, Item item) {
if (command == selectSeatsCommand) {
if (numOfTickets.getString().length() == 0
|| Integer.parseInt(numOfTickets.getString())
< 1) {
uiController.showErrorAlert(
uiController.getString(
UIConstants.NUM_OF_TICKET_ERR));
} else {
uiController.selectSeatsSelected(
movieSchedules[movieList.getSelectedIndex()],
getShowTimes());
}
}
}
}

package com.sun.j2me.blueprints.smartticket.client.midp.ui;

public class UIController {

// references to all UI classes
// ...

public UIController(MIDlet midlet, ModelFacade model) {
this.display = Display.getDisplay(midlet);
this.model = model;
}

// ...

public void selectSeatsSelected(TheaterSchedule.MovieSchedule
movieSchedule, int[] showTime) {
selectedShowTime = showTime;
selectedMovie = movieSchedule.getMovie();
selectedMovieSchedule = movieSchedule;

runWithProgress(
new EventDispatcher(EventIds.EVENT_ID_SELECTSEATSSELECTED,
mainMenuUI),
getString(UIConstants.PROCESSING), false);
}

class EventDispatcher extends Thread {
private int taskId;
private Displayable fallbackUI;

EventDispatcher(int taskId, Displayable fallbackUI) {
this.taskId = taskId;
this.fallbackUI = fallbackUI;
return;
}

public void run() {
try {
switch (taskId) {

// cases ...

case EventIds.EVENT_ID_SELECTSEATSSELECTED: {
SeatingPlan seatingPlan =
selectedMovieSchedule.getSeatingPlan(selectedShowTime);
String movieName = selectedMovie.getTitle();

seatingPlanUI.init(selectedTheater.getName(), movieName,
seatingPlan, selectedShowTime);
display.setCurrent(seatingPlanUI);

break;
}

case EventIds.EVENT_ID_SEATSSELECTED: {
reservation =
model.reserveSeats(selectedTheater.getPrimaryKey(),
selectedMovie.getPrimaryKey(),
selectedShowTime, selectedSeats);

purchaseTicketsUI.init(model.getAccountInfo());
display.setCurrent(purchaseTicketsUI);

break;
}

case EventIds.EVENT_ID_PURCHASEREQUESTED: {
model.purchaseTickets(reservation);
purchaseCompleteUI.init(reservation.getId(),
selectedTheater.getName(),
selectedMovie.getTitle(),
selectedShowTime);
display.setCurrent(purchaseCompleteUI);

break;
}

// Other cases ...

}
} catch (Exception exception) {
// handle exceptions
}
} // end of run() method
} // end of EventDispatcher class
}

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.");
}
}

// ...

}

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
// ...
}

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 RMSCacheHandler extends RemoteModelRequestHandler {

// ...

public Movie getMovie(String movieKey)
throws ModelException,
ApplicationException {
IndexEntry indexEntry =
rmsAdapter.getIndexEntry(movieKey,
IndexEntry.TYPE_MOVIE, IndexEntry.MODE_ANY);

if (indexEntry != null) {
return rmsAdapter.loadMovie(indexEntry.getRecordId());
}
return super.getMovie(movieKey);
}

// ...

}

package com.sun.j2me.blueprints.smartticket.shared.midp;

public final class MessageConstants {

public static final byte OPERATION_LOGIN_USER = 0;
public static final byte OPERATION_CREATE_ACCOUNT = 1;
public static final byte OPERATION_UPDATE_ACCOUNT = 2;
public static final byte OPERATION_GET_THEATERS = 3;
public static final byte OPERATION_GET_THEATER_SCHEDULE = 4;
public static final byte OPERATION_GET_MOVIE = 5;
public static final byte OPERATION_GET_MOVIE_POSTER = 6;
public static final byte OPERATION_GET_MOVIE_SHOWTIMES = 7;
public static final byte OPERATION_GET_SEATING_PLAN = 8;
public static final byte OPERATION_RESERVE_SEATS = 9;
public static final byte OPERATION_PURCHASE_TICKETS = 10;
public static final byte OPERATION_CANCEL_SEAT_RESERVATION = 11;
public static final byte OPERATION_GET_LOCALES = 12;
public static final byte OPERATION_GET_RESOURCE_BUNDLE = 13;
public static final byte OPERATION_INITIATE_SYNCHRONIZATION = 14;
public static final byte OPERATION_SYNCHRONIZE_MOVIE_RATINGS = 15;
public static final byte OPERATION_COMMIT_MOVIE_RATINGS = 16;
public static final byte ERROR_NONE = 0;
public static final byte ERROR_UNKNOWN_OPERATION = 1;
public static final byte ERROR_SERVER_ERROR = 2;
public static final byte ERROR_MODEL_EXCEPTION = 3;
public static final byte ERROR_REQUEST_FORMAT = 4;

private MessageConstants() {}
}

package com.sun.j2me.blueprints.smartticket.client.midp.model;

public class HTTPCommunicationHandler
extends RemoteModelRequestHandler {

// ...

public Movie getMovie(String movieKey)
throws ModelException,
ApplicationException {
HttpConnection connection = null;
DataOutputStream outputStream = null;
DataInputStream inputStream = null;

try {
connection = openConnection();
updateProgress();
outputStream = openConnectionOutputStream(connection);

// The RPC request
outputStream.writeByte(MessageConstants.OPERATION_GET_MOVIE);
outputStream.writeUTF(movieKey);
outputStream.close();
updateProgress();

// unmarshal the return values
inputStream = openConnectionInputStream(connection);
Movie movie = Movie.deserialize(inputStream);
updateProgress();

return movie;
} catch (IOException ioe) {
throw new
ApplicationException(ErrorMessageCodes.ERROR_CANNOT_CONNECT);
} finally {
closeConnection(connection, outputStream, inputStream);
}
}

// Other action methods ...

}

package com.sun.j2me.blueprints.smartticket.shared.midp.model;

public class Movie {
private String primaryKey;
private String title;
private String summary;
private String rating;
private boolean alreadySeen = false;
transient private byte[] poster = null;

public static Movie deserialize(DataInputStream
dataStream) throws ApplicationException {
try {
Movie movie = new Movie();

// Read the RPC response stream
movie.primaryKey = dataStream.readUTF();
movie.title = dataStream.readUTF();
movie.summary = dataStream.readUTF();
movie.rating = dataStream.readUTF();
try {
movie.alreadySeen = dataStream.readBoolean();
} catch (IOException ioe) {
movie.alreadySeen = false;
}

try {
return
ModelObjectLoader.getInstance().getMovie(movie);
} catch (ModelException me) {
throw new ApplicationException();
}
} catch (IOException ioe) {
throw new ApplicationException(ioe);
}
}

// 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;
}
}
}