Not to state the obvious, but because applets are used on the Internet, they have the ability to perform a few types of telecommunications tasks. One of these tasks, connecting to other Web sites, is a snap to implement. Other tasks, such as accessing data in files, are difficult to implement because you constantly stumble over the security restrictions built into applets. Dealing with the intricacies of Internet security is beyond the scope of this book. If you're interested in this topic, you should pick up an advanced Java book. In this chapter, though, you'll get a chance to use Java to communicate over the Internet by connecting to URLs that the user supplies.
In the previous chapter, you got a quick introduction to URL objects when you obtained the location of graphics and sound files by calling the getDocumentBase() and getCodeBase() methods. You used the URL objects returned by these methods in order to display images and play sounds that were stored on your computer. In that case, the locations of the files were on your own system. What you didn't know then is that you can create an URL object directly by calling its constructor. Using this technique, you can create URL objects that represent other sites on the World Wide Web.
Although the URL class's constructor has several forms, the easiest to use requires a string argument holding the URL from which you want to create the object. Using this constructor, you create the URL object like this:
URL url = new URL(str);
This constructor's single argument is the complete URL of the location to which you want to connect. This URL string must be properly constructed or the URL constructor will throw an exception (generate an error). You'll soon see what to do about such errors.
Suppose you want to create an URL object for the URL http://www.sun.com, which is where you can find lots of information about Java. You'd create the URL object like this:
URL url = new URL("http://www.sun.com");
If the URL construction goes okay, you can then use the URL object however you need to in your applet.
As I mentioned previously, if the argument for the URL constructor is in error (meaning that it doesn't use valid URL syntax), the URL class throws an exception. Because the URL class is designed to throw an exception when necessary, Java gives you no choice except to handle that exception properly. This prevents the applet from accidentally attempting to use a defective URL object. You'll learn all the details about handling exceptions in Chapter 30, "Exceptions." For now, though, you need to know how to handle the URL exception because your applets will not compile properly until you add the exception-handling code.
Basically, when you need to watch out for an exception, you enclose the code that may generate the error in a try program block. If the code in the block generates an exception, you handle that exception in a catch program block. (It's no coincidence that when code "throws" an exception, Java expects the program to "catch" that exception.) When you create an URL object from a string, you must watch out for the MalformedURLException exception, which is one of the many exceptions defined by Java. To do this, use the try and catch program blocks, as shown in Listing 28.1.
Listing 28.1 LST28_1.TXT: Handling URL Exceptions.
try
{
URL url = new URL(str);
}
catch (MalformedURLException e)
{
DisplayErrorMessage();
}
Once you have the URL object created, you need a way to pass it on to the browser in which the applet is running. It is the browser, after all, that will make the Web connection for you. But, how do you refer to the browser from within your applet? You call the getAppletContext() method, which returns an AppletContext object. This AppletContext object represents the browser in which the applet is running. You call getAppletContext() like this:
AppletContext context = getAppletContext();
Once you have the context, you can link to the URL represented by the URL object you already created. You do this by calling the AppletContext object's showDocument() method, like this:
context.showDocument(url);
If all goes well, the above line will connect you to the requested URL.
Suppose that you want to enable the user to enter an URL string in your applet and then use URL and AppletContext objects to link to that URL. Listing 28.2 shows how you might accomplish this feat of Internet prestidigitation:
Listing 28.2 LST28_2.TXT: Linking to an URL.
String str = GetURLStringFromUser();
try
{
URL url = new URL(str);
AppletContext context = getAppletContext();
context.showDocument(url);
}
catch (MalformedURLException e)
{
DisplayErrorMessage();
}
In Listing 28.2, the program first calls a method that retrieves a text string from the user. This text string is the URL to which the user wants to connect. Then, the try program block starts. The first line inside the try block attempts to create an URL object from the string the user entered. Of course, because user's often make mistakes when typing in long strings of characters, the string the user entered may not be a syntactically valid URL. In that case, program execution automatically jumps to the catch program block, where your applet displays an appropriate error message. If the URL object gets created okay, though, the program finishes the code in the try block, getting the AppletContext object and making the link to the URL. In this case, Java completely ignores the catch block.
Ready for a full-fledged example? Listing 28.3 is a complete applet that enables the user to link to an URL. Listing 28.4 is the HTML document that loads the applet. Because this applet actually interacts with a browser and the Internet, you must have made your Internet connection before running the applet. Then, to run the applet, load its HTML document into a Java-compatible browser such as Netscape Navigator 2.0. When you do, you'll see a window similar to that shown in Figure 28.1. In this figure, the user has already entered the URL he wishes to visit. In Figure 28.2, the browser has made the requested connection. Figure 28.3 shows the browser when the user enters an invalid URL string.
Figure 28.1 : Here, the user is ready to make a connection.
Figure 28.2 : If the URL is OK, the browser connects.
Figure 28.3 : If the URL is constructed improperly, the applet displays an error message.
| NOTE |
You can load ConnectApplet's HTML file using Appletviewer, if you like. However, you will be unable to make a connection to the requested URL. You can, however, see what happens when you enter a badly constructed URL string. |
Listing 28.3 ConnectApplet.java: An Applet That Connects to User-Requested URLs.
import java.awt.*;
import java.applet.*;
import java.net.*;
public class ConnectApplet extends Applet
{
TextField textField;
boolean badURL;
public void init()
{
textField = new TextField("", 40);
Button button = new Button("Connect");
add(textField);
add(button);
badURL = false;
}
public void paint(Graphics g)
{
Font font = new Font("TimesRoman", Font.PLAIN, 24);
g.setFont(font);
int height = font.getSize();
if (badURL)
g.drawString("Bad URL!", 60, 130);
else
{
g.drawString("Type the URL to which", 25, 130);
g.drawString("you want to connect,",
25, 130+height);
g.drawString("and then click the Connect",
25, 130+height*2);
g.drawString("button.", 25, 130 + height*3);
}
}
public boolean action(Event evt, Object arg)
{
String str = textField.getText();
try
{
URL url = new URL(str);
AppletContext context = getAppletContext();
context.showDocument(url);
}
catch (MalformedURLException e)
{
badURL = true;
repaint();
}
return true;
}
}
Tell Java that the applet uses the classes in the awt package.
Tell Java that the applet uses the classes in the applet package.
Tell Java that the applet uses the classes in the net package.
Derive the ConnectApplet class from Java's Applet class.
Declare the class's data fields.
Override the init() method.
Create the TextField and Button controls.
Add the controls to the applet's layout.
Initialize the bad URL flag.
Override the paint() method.
Create and set the Graphics object's font.
Get the font's height.
If the applet has a bad URL string...
Display an error message.
Or, of the URL is OK...
Draw the applet's instructions.
Override the action() method.
Get the URL string the user entered.
Start the try block.
Attempt to create an URL object from the string.
Get the AppletContext object.
Make the connection.
Start the catch block.
Set the bad URL flag to true.
Repaint the applet in order to display the error message.
Tell Java that the applet handled the event message.
Listing 28.4 CONNECTAPPLET.htmL: ConnectApplet's HTML Document.
<title>Applet Test Page</title>
<h1>Applet Test Page</h1>
<applet
code="ConnectApplet.class"
width=300
height=250
name="ConnectApplet">
</applet>
Nothing, of course, says that the string from which you create an URL object must be typed in by the user at runtime. You can hard-code the URLs you want to use right in the applet's source code, which not only ensures that the URLs will always be correct (unless the associated server changes), but also makes it quick and easy to jump to whatever URL you want. Using this idea, you can put together an applet that gives you pushbutton control over your connections, selecting your URLs as easily as you'd select a radio station.
The ConnectApplet2 applet, shown in Listing 28.5, is just such an applet. In its current version, it provides four buttons that give you instant connection to the Web sites represented by the buttons. Want to jump to Microsoft's Web page? Give the Microsoft button a click. Want to check out the latest news at Macmillan Computer Publishing? Click the Macmillan button. Of course, just as with the original ConnectApplet, you must have your Internet connection established before you run the applet. And, you must run the applet from a Java-compatible browser.
When you run the applet from Netscape Navigator 2.0, you see the window shown in Figure 28.4. As you can see, the applet currently displays four buttons, one each for the Sun, Netscape, Microsoft, and Macmillan Web sites. Just click a button to jump to the associated site. (Figure 28.5 shows the browser after the user has clicked the Macmillan button.) When you're through with that site, use the browser's Back button to return to the ConnectApplet2 applet. Then, choose another site.
Figure 28.4 : ConnectApplet2 running under Netscape Navigator 2.0.
Figure 28.5 : After clicking the Macmillan button.
Sure, you can do the same sort of thing with an HTML document using Web links. But, let's face it, applets are way cooler.
Listing 28.5 ConnectApplet2.java: A "Favorite URLs" Applet.
import java.awt.*;
import java.applet.*;
import java.net.*;
public class ConnectApplet2 extends Applet
{
boolean badURL;
public void init()
{
GridLayout layout = new GridLayout(2, 2, 10, 10);
setLayout(layout);
Font font = new Font("TimesRoman", Font.PLAIN, 24);
setFont(font);
Button button = new Button("Sun");
add(button);
button = new Button("Netscape");
add(button);
button = new Button("Microsoft");
add(button);
button = new Button("Macmillan");
add(button);
badURL = false;
}
public void paint(Graphics g)
{
if (badURL)
g.drawString("Bad URL!", 60, 130);
}
public boolean action(Event evt, Object arg)
{
String str;
if (arg == "Sun")
str = "http://www.sun.com";
else if (arg == "Netscape")
str = "http://www.netscape.com";
else if (arg == "Microsoft")
str = "http://www.microsoft.com";
else
str = "http://www.mcp.com";
try
{
URL url = new URL(str);
AppletContext context = getAppletContext();
context.showDocument(url);
}
catch (MalformedURLException e)
{
badURL = true;
repaint();
}
return true;
}
}
Tell Java that the applet uses the classes in the awt package.
Tell Java that the applet uses the classes in the applet package.
Tell Java that the applet uses the classes in the net package.
Derive the ConnectApplet2 class from Java's Applet class.
Declare the class's data field.
Override the init() method.
Create and set the applet's layout manager.
Create and set the applet's font.
Add four button controls to the layout.
Initialize the bad URL flag.
Override the paint() method.
If the applet has a bad URL string...
Display an error message.
Override the action() method.
Declare a local string variable.
Get the URL string the user requested.
Start the try block.
Create an URL object from the string.
Get the AppletContext object.
Make the connection.
Start the catch block.
Set the bad URL flag to true.
Repaint the applet in order to display the error message.
Tell Java that the applet handled the event message.
In Listing 28.5, notice how, even though the URLs are hard-coded into the program, the action() method still surrounds the call to the URL constructor with the try and catch program blocks. This is because Java insists that the applet handle the exception should the URL class throw it. If you remove the exception handling, the applet won't compile. Anyway, having a little extra protection never hurts. Handling the exception is a good way to test whether your hard-coded URLs are valid. I've never known a programmer yet who didn't need to be protected from himself!
Although a running applet has to deal with many security considerations, it can usually connect to other Web sites. To do this, the applet creates an URL object representing the site to which the applet should connect. The applet then instructs the browser containing the applet to make the connection, by calling the AppletContext object's showDocument() method. In spite of the telecommunications limitations inherent in applets, you can easily create Internet-aware applets.
