10.3. Chat Server
The daytime server example from the last section demonstrated the
nuts and bolts of using each of the three communication techniques
for applet-servlet communication. It
didn't take advantage, though, of the persistence gains when
using socket communication. Nor did it show off the simplicity of RMI
communication or the elegance of RMI callbacks (where the servlet can
invoke methods of the applet). It also didn't provide a
compelling reason for why one servlet should support all the
communication techniques--there was no state to maintain or
complicated code base to collect in one location. So, before we end
our discussion of applet-servlet communication, let's look at a
more sophisticated
example: a chat server, implemented as a servlet, that supports
clients connecting via HTTP, non-HTTP sockets, and RMI.
We'll build this chat server using all three communication
techniques so that it can take advantage of the best, most efficient
solution for each client. For example, when the client supports RMI,
the servlet can be treated as a remote object, and (where possible)
it can treat the applet as a remote object, too. When the client
doesn't support RMI but can support direct socket
communication, the chat server can utilize socket persistence and
communicate with the client using a non-HTTP socket protocol. And, of
course, when all else fails, the chat server can fall back to using
HTTP. It would rather not fall back because HTTP, being stateless,
requires that the client poll for updates. But for many clients, HTTP
is the only choice.
The chat server is implemented as a single class with a single
instantiation because it has a large amount of associated state and a
fair amount of code that would otherwise have to be repeated. To
separate it into three classes, one for each protocol, would demand
excessive interserver communication and replicate the core chat
server code three times. Implementing the chat server as a servlet
provides a simple way for one object to make itself available via all
three communication techniques. By being an HTTP servlet, it has
built-in HTTP support. And by extending the
RemoteDaemonHttpServlet
class, it can also easily gain support for non-HTTP socket and RMI
communication.
Note that although you'll see the code in its entirety, we
won't be fully explaining each and every line. To do so would
extend this chapter beyond a reasonable length, assuming we
aren't there already. Therefore, we'll explain the issues
as they concern applet-servlet communication and rely on you to
examine the code to understand all the details.
10.3.1. The Design
Figure 10-3 shows the chat applet in action. Notice
that it uses a large TextArea component to display
the running conversation, with a small TextInput
component underneath where the user can post a new single-line
message. As each contributor composes a message, it's sent to
the chat server and distributed to the other chat clients in various
ways.
Figure 10-3. The chat applet in action
HTTP chat clients post their messages to the server using the HTTP
POST method. The applet takes the new
message from the TextInput component when the user
hits Enter, URL-encodes the message,
and posts it to the servlet as a message
parameter. It's all very straightforward. What is a bit more
complicated is how an HTTP chat client manages to get the other
clients' messages. It uses the HTTP GET method to receive each message,
but it has a problem: it doesn't know when exactly
there's a new message to get. This is the problem with a
unidirectional request/response communication paradigm. The client
has to either periodically poll for updates or simulate bidirectional
communication by making a series of blocking GET requests. By that we
mean the chat client initiates a GET request that blocks until the
server decides it's time to return something. For our example,
we implement this simulated bidirectional communication.
Socket chat clients, for the sake of convenience, post their messages
to the server the same way HTTP chat clients do, with the HTTP POST
method. They could post their messages using
raw socket connections, but only
with a marginal gain in efficiency that, at least in this case,
doesn't outweigh the increased complexity. These socket
clients, however, do use raw sockets to get messages from the other
clients, replacing the simulated bidirectional communication with
actual bidirectional communication. As each new message comes in to
the servlet, it's sent right away from the servlet to the
socket chat clients across plain-text socket connections.
RMI chat clients perform their POSTs and their GETs using method
invocations. To post each new message, the applet simply calls the
remote servlet's broadcastMessage(String)
method. To get new messages, it has two options. It can call the
servlet's blocking getNextMessage() method
or, through the use of callbacks, it can ask the servlet to
call its own setNextMessage(String) method every
time there's a new message broadcast. We've chosen to use
the callback option in our example.
In front of all these applets is a dispatch servlet. It lets the user
choose the applet-servlet communication technique (HTTP, socket, or
RMI) he wants to use and, based on his choice, generates a page that
contains the appropriate applet. It's true that a single applet
could be written to support all three techniques and auto-select
between them based on its runtime environment, but to do that here
would unnecessarily complicate our example. The dispatch servlet also
tells the applet the name of its user, but more on that later.
10.3.2. The Servlet
The full listings for the ChatServer interface and
the ChatServlet class that implements it are given
in Example 10-15 and Example 10-16.
Example 10-15. The ChatServer interface, implemented by ChatServlet
import java.rmi.Remote;
import java.rmi.RemoteException;
public interface ChatServer extends Remote {
public String getNextMessage() throws RemoteException;
public void broadcastMessage(String message) throws RemoteException;
public void addClient(ChatClient client) throws RemoteException;
public void deleteClient(ChatClient client) throws RemoteException;
}
Example 10-16. A full-service chat server/servlet
import java.io.*;
import java.net.*;
import java.rmi.*;
import java.util.*;
import javax.servlet.*;
import javax.servlet.http.*;
import com.oreilly.servlet.RemoteDaemonHttpServlet;
public class ChatServlet extends RemoteDaemonHttpServlet
implements ChatServer {
// source acts as the distributor of new messages
MessageSource source = new MessageSource();
// socketClients holds references to all the socket-connected clients
Vector socketClients = new Vector();
// rmiClients holds references to all the RMI clients
Vector rmiClients = new Vector();
// doGet() returns the next message. It blocks until there is one.
public void doGet(HttpServletRequest req, HttpServletResponse res)
throws ServletException, IOException {
res.setContentType("text/plain");
PrintWriter out = res.getWriter();
// Return the next message (blocking)
out.println(getNextMessage());
}
// doPost() accepts a new message and broadcasts it to all
// the currently listening HTTP and socket clients.
public void doPost(HttpServletRequest req, HttpServletResponse res)
throws ServletException, IOException {
// Accept the new message as the "message" parameter
String message = req.getParameter("message");
// Broadcast it to all listening clients
if (message != null) broadcastMessage(message);
// Set the status code to indicate there will be no response
res.setStatus(res.SC_NO_CONTENT);
}
// getNextMessage() returns the next new message.
// It blocks until there is one.
public String getNextMessage() {
// Create a message sink to wait for a new message from the
// message source.
return new MessageSink().getNextMessage(source);
}
// broadcastMessage() informs all currently listening clients that there
// is a new message. Causes all calls to getNextMessage() to unblock.
public void broadcastMessage(String message) {
// Send the message to all the HTTP-connected clients by giving the
// message to the message source
source.sendMessage(message);
// Directly send the message to all the socket-connected clients
Enumeration enum = socketClients.elements();
while (enum.hasMoreElements()) {
Socket client = null;
try {
client = (Socket)enum.nextElement();
PrintStream out = new PrintStream(client.getOutputStream());
out.println(message);
}
catch (IOException e) {
// Problem with a client, close and remote it
try {
if (client != null) client.close();
}
catch (IOException ignored) { }
socketClients.removeElement(client);
}
}
// Directly send the message to all RMI clients
enum = rmiClients.elements();
while (enum.hasMoreElements()) {
ChatClient chatClient = null;
try {
chatClient = (ChatClient)enum.nextElement();
chatClient.setNextMessage(message);
}
catch (RemoteException e) {
// Problem communicating with a client, remove it
deleteClient(chatClient);
}
}
}
protected int getSocketPort() {
// We listen on port 2428 (look at a phone to see why)
return 2428;
}
public void handleClient(Socket client) {
// We have a new socket client. Add it to our list.
socketClients.addElement(client);
}
public void addClient(ChatClient client) {
// We have a new RMI client. Add it to our list.
rmiClients.addElement(client);
}
public void deleteClient(ChatClient client) {
// Remote the specified client from our list.
rmiClients.removeElement(client);
}
}
// MessageSource acts as the source for new messages.
// Clients interested in receiving new messages can
// observe this object.
class MessageSource extends Observable {
public void sendMessage(String message) {
setChanged();
notifyObservers(message);
}
}
// MessageSink acts as the receiver of new messages.
// It listens to the source.
class MessageSink implements Observer {
String message = null; // set by update() and read by getNextMessage()
// Called by the message source when it gets a new message
synchronized public void update(Observable o, Object arg) {
// Get the new message
message = (String)arg;
// Wake up our waiting thread
notify();
}
// Gets the next message sent out from the message source
synchronized public String getNextMessage(MessageSource source) {
// Tell source we want to be told about new messages
source.addObserver(this);
// Wait until our update() method receives a message
while (message == null) {
try { wait(); } catch (Exception ignored) { }
}
// Tell source to stop telling us about new messages
source.deleteObserver(this);
// Now return the message we received
// But first set the message instance variable to null
// so update() and getNextMessage() can be called again.
String messageCopy = message;
message = null;
return messageCopy;
}
}
The getNextMessage() and
broadcastMessage(String message) methods are most
interesting portions of ChatServlet. The
getNextMessage() method returns the next new
message as it comes in, blocking until there is one. To enable this
blocking, it uses the MessageSource and
MessageSink classes. Without getting too deep into
the details of these two classes, we'll just say this: the
servlet constructs a new MessageSink and asks this
sink to get the next message from the source. To accomplish this, the
sink registers itself as an observer of source and calls
wait() to block. When the source receives a new
message, the sink (being an observer) is notified of the change with
a call to its update() method. The sink's
update() method saves the source's latest
message in its message variable and then calls
notify(). This causes its
getNextMessage() method to unblock and return the
message.
The broadcastMessage() method tells all listening
clients when there's a new message. It notifies HTTP clients by
sending the message to the MessageSource; other
clients it notifies directly by looping through its client list. For
each of its socket-connected clients, it prints the message to the
client's socket. For each of its RMI clients, it calls the
client's setNextMessage(String) method. This
is the callback we've been talking about. If, at any point,
there's a problem with a socket or RMI client, it removes that
client from its list.
The two lists, socketClients and
rmiClients, are populated as the servlet hears
from clients. When a socket client connects, the servlet's
handleClient(Socket) method is called and the new
client is added to the socketClientsVector. RMI clients have to add themselves to the
list by invoking the servlet's
addClient(ChatClient) method.
The doGet()
and doPost()
methods of ChatServlet are essentially thin
wrappers around the getNextMessage() and
broadcastMessage() methods. The
doGet() wrapper is so thin you can almost see
through it: doGet() sends as its response whatever
String is returned by
getNextMessage(). The doPost()
wrapper is a bit less transparent. It extracts the posted message
from the POST form data's
"message" parameter, broadcasts the message by
passing it to the broadcastMessage() method, and
sets its response's status code to
SC_NO_CONTENT to indicate there is no content in
the response. In a sense, making a GET request is equivalent to
calling getNextMessage(), and making a POST
request is equivalent to calling
broadcastMessage().
Did you notice which socket port ChatServlet
listens on? It's 2428. Overriding the
getSocketPort() method as
ChatServlet does is an easy way to set the socket
port when you don't want to use an init parameter.
10.3.3. The HTTP Applet
The code for our first applet, the
HTTP chat applet, is shown in Example 10-17.
Example 10-17. A chat client using HTTP communication
import java.applet.*;
import java.awt.*;
import java.io.*;
import java.net.*;
import java.util.*;
import com.oreilly.servlet.HttpMessage;
public class HttpChatApplet extends Applet implements Runnable {
TextArea text;
Label label;
TextField input;
Thread thread;
String user;
public void init() {
// Check if this applet was loaded directly from the filesystem.
// If so, explain to the user that this applet needs to be loaded
// from a server in order to communicate with that server's servlets.
URL codebase = getCodeBase();
if (!"http".equals(codebase.getProtocol())) {
System.out.println();
System.out.println("*** Whoops! ***");
System.out.println("This applet must be loaded from a web server.");
System.out.println("Please try again, this time fetching the HTML");
System.out.println("file containing this servlet as");
System.out.println("\"http://server:port/file.html\".");
System.out.println();
System.exit(1); // Works only from appletviewer
// Browsers throw an exception and muddle on
}
// Get this user's name from an applet parameter set by the servlet
// We could just ask the user, but this demonstrates a
// form of servlet->applet communication.
user = getParameter("user");
if (user == null) user = "anonymous";
// Set up the user interface...
// On top, a large TextArea showing what everyone's saying.
// Underneath, a labeled TextField to accept this user's input.
text = new TextArea();
text.setEditable(false);
label = new Label("Say something: ");
input = new TextField();
input.setEditable(true);
setLayout(new BorderLayout());
Panel panel = new Panel();
panel.setLayout(new BorderLayout());
add("Center", text);
add("South", panel);
panel.add("West", label);
panel.add("Center", input);
}
public void start() {
thread = new Thread(this);
thread.start();
}
String getNextMessage() {
String nextMessage = null;
while (nextMessage == null) {
try {
URL url = new URL(getCodeBase(), "/servlet/ChatServlet");
HttpMessage msg = new HttpMessage(url);
InputStream in = msg.sendGetMessage();
DataInputStream data = new DataInputStream(
new BufferedInputStream(in));
nextMessage = data.readLine();
}
catch (SocketException e) {
// Can't connect to host, report it and wait before trying again
System.out.println("Can't connect to host: " + e.getMessage());
try { Thread.sleep(5000); } catch (InterruptedException ignored) { }
}
catch (FileNotFoundException e) {
// Servlet doesn't exist, report it and wait before trying again
System.out.println("Resource not found: " + e.getMessage());
try { Thread.sleep(5000); } catch (InterruptedException ignored) { }
}
catch (Exception e) {
// Some other problem, report it and wait before trying again
System.out.println("General exception: " +
e.getClass().getName() + ": " + e.getMessage());
try { Thread.sleep(1000); } catch (InterruptedException ignored) { }
}
}
return nextMessage + "\n";
}
public void run() {
while (true) {
text.appendText(getNextMessage());
}
}
public void stop() {
thread.stop();
thread = null;
}
void broadcastMessage(String message) {
message = user + ": " + message; // Pre-pend the speaker's name
try {
URL url = new URL(getCodeBase(), "/servlet/ChatServlet");
HttpMessage msg = new HttpMessage(url);
Properties props = new Properties();
props.put("message", message);
msg.sendPostMessage(props);
}
catch (SocketException e) {
// Can't connect to host, report it and abandon the broadcast
System.out.println("Can't connect to host: " + e.getMessage());
}
catch (FileNotFoundException e) {
// Servlet doesn't exist, report it and abandon the broadcast
System.out.println("Resource not found: " + e.getMessage());
}
catch (Exception e) {
// Some other problem, report it and abandon the broadcast
System.out.println("General exception: " +
e.getClass().getName() + ": " + e.getMessage());
}
}
public boolean handleEvent(Event event) {
switch (event.id) {
case Event.ACTION_EVENT:
if (event.target == input) {
broadcastMessage(input.getText());
input.setText("");
return true;
}
}
return false;
}
}
This applet has the same two workhorse methods as
ChatServlet: getNextMessage()
and broadcastMessage(). Its
getNextMessage() method gets the next message from
the servlet. It's called repeatedly to update the
TextArea. It operates using an
HttpMessage to make a GET request to the servlet,
then interprets the first line of the response as the next new
message. Its broadcastMessage() method sends a
message to the servlet for distribution to the other clients. This
method is called in the applet's
handleEvent() method every time the user hits
Enter in the
TextInput component. It works similarly to
getNextMessage(). It uses an
HttpMessage to perform a POST request, passing the
TextInput's text as the
"message" parameter, and it doesn't bother
to read the response.
10.3.4. The Socket-Connecting Applet
The only difference between the socket-based
SocketChatApplet and the HTTP-based
HttpChatApplet is a redesigned
getNextMessage() method. This method is shown in
Example 10-18.
Example 10-18. A chat client using a raw socket connection
static final int PORT = 2428;
DataInputStream serverStream;
String getNextMessage() {
String nextMessage = null;
while (nextMessage == null) {
try {
// Connect to the server if we haven't before
if (serverStream == null) {
Socket s = new Socket(getCodeBase().getHost(), PORT);
serverStream = new DataInputStream(
new BufferedInputStream(
s.getInputStream()));
}
// Read a line
nextMessage = serverStream.readLine();
}
catch (SocketException e) {
// Can't connect to host, report it and wait before trying again
System.out.println("Can't connect to host: " + e.getMessage());
serverStream = null;
try { Thread.sleep(5000); } catch (InterruptedException ignored) { }
}
catch (Exception e) {
// Some other problem, report it and wait before trying again
System.out.println("General exception: " +
e.getClass().getName() + ": " + e.getMessage());
try { Thread.sleep(1000); } catch (InterruptedException ignored) { }
}
}
return nextMessage + "\n";
}
This method reads broadcast messages from a socket that's
connected to the chat servlet. It uses a simple socket protocol: all
content is plain text, one message per line. The first time this
method is called, it establishes the socket connection and then uses
the connection to get a DataInputStream, where it
can read from the socket one line at a time. It reads the first line
from this stream and returns the text as the next message. For each
subsequent invocation, it reuses the same stream and simply returns
the next line it reads. If there's ever a
SocketException, it reestablishes the connection.
10.3.5. The RMI Applet
The code for the ChatClient interface is shown in
Example 10-19; the RMI-based chat applet that
implements it is shown in Example 10-20.
Example 10-19. The ChatClient interface, implemented by RMIChatApplet
import java.rmi.Remote;
import java.rmi.RemoteException;
public interface ChatClient extends Remote {
public void setNextMessage(String message) throws RemoteException;
}
Example 10-20. A chat client using RMI communication
import java.applet.*;
import java.awt.*;
import java.io.*;
import java.net.*;
import java.rmi.*;
import java.rmi.registry.*;
import java.rmi.server.*;
import java.util.*;
public class RMIChatApplet extends Applet implements ChatClient {
TextArea text;
Label label;
TextField input;
Thread thread;
String user;
ChatServer chatServer;
private int getRegistryPort() {
try { return Integer.parseInt(getParameter("port")); }
catch (NumberFormatException ignored) { return Registry.REGISTRY_PORT; }
}
private String getRegistryName() {
String name = getParameter("name");
return (name == null ? "ChatServlet" : name);
}
// Returns a reference to the remote chat server/servlet
// Tries to exit if there's a problem.
private ChatServer getChatServer() {
try {
Registry registry =
LocateRegistry.getRegistry(getCodeBase().getHost(), getRegistryPort());
Object obj = registry.lookup(getRegistryName());
return (ChatServer)obj;
}
catch (java.rmi.UnknownHostException e) {
// Don't know the registry host, try to exit
System.out.println("Host unknown in url: " + e.getMessage());
System.exit(1);
}
catch (NotBoundException e) {
// Can't find our object, try to exit
System.out.println("Name not bound: " + e.getMessage());
System.exit(1);
}
catch (ClassCastException e) {
// The object wasn't a ChatServer, try to exit
System.out.println(getRegistryName() + " was not a ChatServer:" +
e.getMessage());
System.exit(1);
}
catch (RemoteException e) {
// General RMI problem, try to exit
System.out.println("Remote exception: " + e.getMessage());
System.exit(1);
}
catch (Exception e) {
// Some other problem, try to exit
System.out.println("General exception: " +
e.getClass().getName() + ": " + e.getMessage());
System.exit(1);
}
return null; // return null if the exit() doesn't work
}
// Add ourselves as a client of the chat server
// Notice there's no need for an RMI registry
private void registerWithChatServer(ChatServer server) {
try {
UnicastRemoteObject.exportObject(this);
server.addClient(this);
}
catch (RemoteException e) {
// General RMI problem, try to exit
System.out.println("Remote exception: " + e.getMessage());
System.exit(1);
}
catch (Exception e) {
// Some other problem, try to exit
System.out.println("General exception: " +
e.getClass().getName() + ": " + e.getMessage());
System.exit(1);
}
}
public void init() {
// Check if this applet was loaded directly from the filesystem.
// If so, explain to the user that this applet needs to be loaded
// from a server in order to communicate with that server's servlets.
URL codebase = getCodeBase();
if (!"http".equals(codebase.getProtocol())) {
System.out.println();
System.out.println("*** Whoops! ***");
System.out.println("This applet must be loaded from a web server.");
System.out.println("Please try again, this time fetching the HTML");
System.out.println("file containing this servlet as");
System.out.println("\"http://server:port/file.html\".");
System.out.println();
System.exit(1); // Works only from appletviewer
// Browsers throw an exception and muddle on
}
// Get the remote chat server
chatServer = getChatServer();
// Register ourselves as one of its clients
registerWithChatServer(chatServer);
// Get this user's name from an applet parameter set by the dispatch servlet
// We could just ask the user, but this demonstrates a
// form of servlet->applet communication.
user = getParameter("user");
if (user == null) user = "anonymous";
// Set up the user interface...
// On top, a large TextArea showing what everyone's saying.
// Underneath, a labeled TextField to accept this user's input.
text = new TextArea();
text.setEditable(false);
label = new Label("Say something: ");
input = new TextField();
input.setEditable(true);
setLayout(new BorderLayout());
Panel panel = new Panel();
panel.setLayout(new BorderLayout());
add("Center", text);
add("South", panel);
panel.add("West", label);
panel.add("Center", input);
}
String getNextMessage() {
String nextMessage = null;
while (nextMessage == null) {
try {
nextMessage = chatServer.getNextMessage();
}
catch (RemoteException e) {
// Remote exception, report and wait before trying again
System.out.println("Remote Exception:" + e.getMessage());
try { Thread.sleep(1000); } catch (InterruptedException ignored) { }
}
}
return nextMessage + "\n";
}
public void setNextMessage(String message) {
text.appendText(message + "\n");
}
void broadcastMessage(String message) {
message = user + ": " + message; // Pre-pend the speaker's name
try {
chatServer.broadcastMessage(message);
}
catch (RemoteException e) {
// Remote exception, report it and abandon the broadcast
System.out.println("Remote exception: " + e.getMessage());
}
catch (Exception e) {
// Some other exception, report it and abandon the broadcast
System.out.println("General exception: " +
e.getClass().getName() + ": " + e.getMessage());
}
}
public boolean handleEvent(Event event) {
switch (event.id) {
case Event.ACTION_EVENT:
if (event.target == input) {
broadcastMessage(input.getText());
input.setText("");
return true;
}
}
return false;
}
}
This applet's getNextMessage() and
broadcastMessage() implementations are as simple
as any we've seen. They need only call the remote
servlet's methods of the same name. But their simplicity comes
with a cost: more complicated set-up code. Specifically, the
init() method now has to call the lengthy (but by
now understandable) getChatServer() method to
obtain a reference to the remote chat servlet.
If you look closely at RMIChatApplet, you'll
notice that it doesn't actually use its
getNextMessage() method. Instead, it asks the
servlet to call its setNextMessage() method each
time there's a new message being broadcast. It makes this
request in its init() method when it calls
registerWithChatSer-ver(ChatServer). This method
exports the applet as a remote object, then invokes the
servlet's addClient() method passing a
reference to itself. After this, the servlet's
broadcastMessage() method sends a callback to the
applet each time there's a new message.
If you try using callbacks on your own, don't
forget the basics we covered earlier. You need to run the
rmic RMI compiler on
your remote applet to generate its stub and skeleton classes. And you
need to be sure your server has the
RMIChatApplet_Stub.class and
ChatClient.class files somewhere in its
classpath.
10.3.6. The Dispatcher
Now, for this chapter's last code example, the
ChatDispatch servlet is shown in Example 10-21. This servlet performs two duties. First, when
this servlet is accessed without any request parameters, it prints a
friendly welcome page asking the user which applet version he is
interested in using, as shown in Figure 10-4.
Second, when it's accessed with a request parameter, it prints
a page that contains the appropriate applet, as you saw in Figure 10-3. Be aware that the URL used to access this
dispatch servlet should contain the server's true name, not
localhost, so as to avoid RMI security problems.
Figure 10-4. The chat dispatch welcome page
Example 10-21. The front door dispatch servlet
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class ChatDispatch extends HttpServlet {
public void doGet(HttpServletRequest req, HttpServletResponse res)
throws IOException, ServletException {
res.setContentType("text/html");
if (!req.getParameterNames().hasMoreElements()) {
// There were no request parameters. Print a welcome page.
printWelcomePage(req, res);
}
else {
// There was at least one request parameter.
// Print a page containing the applet.
printAppletPage(req, res);
}
}
// The welcome page greets the reader and has a form where the user
// can choose an applet-servlet communication method.
private void printWelcomePage(HttpServletRequest req,
HttpServletResponse res)
throws IOException {
PrintWriter out = res.getWriter();
String me = req.getServletPath();
out.println("<HTML>");
out.println("<HEAD><TITLE>");
out.println("Welcome to an Absurdly Simple Chat");
out.println("</TITLE></HEAD>");
out.println();
out.println("<BODY>");
out.println("<H1>Welcome to an Absurdly Simple Chat</H1>");
out.println();
out.println("Would you like to communicate via:");
out.println("<UL>");
out.println(" <LI><A HREF=\"" + me + "?method=http\">http</A>");
out.println(" <LI><A HREF=\"" + me + "?method=socket\">socket</A>");
out.println(" <LI><A HREF=\"" + me + "?method=rmi\">rmi</A>");
out.println("</UL>");
out.println("</BODY></HTML>");
}
// The applet page displays the chat applet.
private void printAppletPage(HttpServletRequest req,
HttpServletResponse res)
throws IOException {
PrintWriter out = res.getWriter();
out.println("<HTML>");
out.println("<HEAD><TITLE>An Absurdly Simple Chat</TITLE></HEAD>");
out.println("<BODY>");
out.println("<H1>An Absurdly Simple Chat</H1>");
String method = req.getParameter("method");
String user = req.getRemoteUser();
String applet = null;
if ("http".equals(method)) {
applet = "HttpChatApplet";
}
else if ("socket".equals(method)) {
applet = "SocketChatApplet";
}
else if ("rmi".equals(method)) {
applet = "RMIChatApplet";
}
else {
// No method given, or an invalid method given.
// Explain to the user what we expect.
out.println("Sorry, this servlet requires a <TT>method</TT> " +
"parameter with one of these values: " +
"http, socket, rmi");
return;
}
// Print the HTML code to generate the applet.
// Choose the applet code based on the method parameter.
// Provide a user parameter if we know the remote user.
out.println("<APPLET CODE=" + applet + " CODEBASE=/ " +
"WIDTH=500 HEIGHT=170>");
if (user != null)
out.println("<PARAM NAME=user VALUE=\"" + user + "\">");
out.println("</APPLET>");
out.println("</BODY></HTML>");
}
}
Nothing here should surprise you. In fact, we expect this code to
appear refreshingly simple after the ChatServlet
example. Still, this example does demonstrate one last form of
applet-servlet communication: servlet-generated applet
parameters. Using this technique, a servlet generates a page that
contains an applet and passes information to the applet by
manipulating the applet's <PARAM>
tags. Any information the servlet wants to send to a new applet can be
sent this way. In this example, the servlet sends the name returned by
req.getRemoteUser(). In another example, a servlet
could tell the applet its browser type by sending it the string
returned by req.getHeader("User-Agent"). Or, to be
more helpful, the servlet could use a database to determine the
capabilities of the browser and tell the applet exactly what it needs
to know. It could even tell the applet whether the browser supports
RMI communication.
refer:
http://www.unix.com.ua/orelly/java-ent/servlet/ch10_03.htm#ch10-34482
สร้างรายได้ 100 บาท/โฆษณา/เดือน
เนื่องจากต้นทุนที่ต่ำและปัจจัยหลาย ๆ อย่างของชีวิตประจำวัน โดยการลงโฆษณาเราควรเลือกลงโฆษณากับเว็บไซต์ที่ได้รับการยอมรับทางบุคคลทั่วไป ในเว็บไซต์ที่เราจะแนะนำคือ Google.com ซึ่งมีจำนวนผู้ใช้ มากกว่า 57% ของคนใช้อินเตอร์เน็ต
Promotion ส่งท้ายปี 2008
โดยเป็นรูปแบบ Pay Per Click (PPC) คือคุณจะจ่ายค่าโฆษณาก็ต่อเมื่อมีคนคลิกที่ Ad โฆษณาของคุณ และ Ad โฆษณาของคุณจะปรากฏให้ผู้ชมเห็นตามคีย์เวิร์ด (Keyword) หรือกลุ่มคำที่คุณเลือกไว้และเป็นคำที่เกี่ยวข้องกับธุรกิจของคุณ เมื่อคุณทำการลงโฆษณากับ Google Adwords แล้ว Ad โฆษณาของคุณจะไปปรากฏอยู่ใน Search Engine และเว็บไซต์ชั้นนำของโลก เช่น 
ฉลองครบรอบ 
รายละเอียด : 
ดาวน์โหลด : 
