Java网络编程新经典：超越Web应用的潜力

需积分: 0 199 浏览量更新于2024-07-26 收藏 1.89MB PDF 举报

"Addison Wesley 的《Advanced Java Networking - 2002》是一本经典的Java网络编程指南，该书在当时被誉为Java领域的权威之作。作者深入探讨了Java在网络技术中的应用潜力，旨在打破人们对Java的传统认知，将其从仅仅局限于Web页面开发的印象中解放出来。书中强调，尽管C++或C语言在构建复杂应用时仍然广泛使用，但Java凭借其强大的设计灵活性和高效性，提供了全新的编程体验。相比于过去的编程范式，Java减少了繁琐的调试时间，使得开发者能够更快地将创意转化为实际的软件产品。它的优势在于能够让开发者在软件设计的初期阶段更多地思考如何利用互联网的知识库和全球用户的互动，而非陷入底层细节的困扰。通过Java，开发者可以更加专注于概念层面的设计，探索创新的方式来整合互联网资源并将其融入桌面应用程序中。在《Advanced Java Networking》中，读者不仅能学习到如何使用Java进行网络编程，包括Socket编程、网络通信协议、并发处理等核心概念，还能了解到如何构建功能强大且用户友好的网络应用程序。随着信息时代的飞速发展，通过Java与互联网无缝对接，已经成为一种必不可少的技术能力。这本书不仅适合经验丰富的Java开发者提升技能，也对初次接触Java网络编程的人员提供了深入学习的基石，引领他们进入一个全新的编程世界。" 这本著作不仅详细讲解了Java网络编程的基础原理和技术实践，还展示了Java在互联网时代下如何改变传统软件开发模式，以及如何通过其特性实现更高效、更灵活的软件开发。它不仅是一本技术手册，更是启发创新思维的工具书，对于推动Java在网络领域的发展起到了关键作用。

input end of a pipe in one application is directly connected to the output end of the

same pipe on another application. If you write to the input of the pipe, you will read

the same exact data at the pipe's output end. As you can see in Figure 1-3 this is a

pretty nifty way to promote interapplication communication.

Figure 1-3. Pipes enable interaction between two or more applications.

Last, you will eventually want to fiddle with files on your local file system. The

FileInputStream and FileOutputStream enable you to open, read, and write files as we

will show you in a moment. Remember that Java has strict restrictions on applet

security, so most file streams can be manipulated only by applications. For more

information, consult Chapter 13, "Java and Security."

The Java Core System

In Java, applications are allowed to write to the standard output devices on a machine.

If you use a Web browser such as Netscape, the standard output to which Java writes

is the "Java Console" mentioned in one of Navigator's windows. If you write a Java

application (i.e., a stand-alone applet), the standard output device is the command line

from which you execute the program.

The System Class

One of the classes Java includes in every applet or application, whether you specify

that it do so or not, is the System class. The System class provides support for

input/output (I/O) using the Java console; you are to provide the ability to write to the

console, read from the console, and write errors to the user. The Java console is

provided in two ways, one for browsers and one for applications. In the browser

environment the console is a separate browser window that has controls for scrolling

and clearing. For applications run from the operating system (OS) command line, the

console is the text interface you see and suffers the same problems as the text base OS

environment (lack of scrolling backwards). The Java console is really intended to

provide the same level of user interactivity as the C++ cin, cout, and cerr objects. The

names of the standard Java streams are in, out, and err; these names can be changed

using the System classes setIn, setOut, and setErr methods. Changing the names of

these streams can only be done by the SecurityManager.

Input Using the System Class

Input in the System class is actually handled by the InputStream class contained in the

Java I/O routines. System.in is an object of type InputStream that is created,

maintained, and initialized by the System class. In other words, it's yours for the

taking; you don't have to do a thing to use it.

The InputStream class assumes that you will be reading from the standard input

stream (the keyboard you are sitting at). A stream is a sequence of characters retrieved

from somewhere. The standard input stream is the location that your operating system

uses to get data from you. Because streams are defined as characters from a source, it

is entirely conceivable that a stream could be a file, a modem, a microphone, or even a

connection to another process running on your computer or another computer. As a

matter of fact, Java treats files and other peripherals as streams. This abstraction of a

stream simplifies I/O programming by reducing all I/O to a stream.

So, how do you get input from the user? Simply use the System class's input stream to

get the information you require. The input stream is an object with several methods to

facilitate data input. For example, there are primitive, yet useful, routines to get

characters and strings, to read integers and other numbers, and even to get a stream of

unfiltered and untranslated bytes. Deciding which routine to use is simply a matter of

which kind of data you wish to read. In our example, we will read and write strings:

public class InputOutputTest()

{

String str; //private data

public void getInput(){

// read a string from the Java console keyboard (sysin)

str = System.in.getln();

}

Output Using the System Class

As with input, output is handled through streams. How can output be a stream if a

stream is a sequence of characters from a source? Well, the source is your application,

and the stream is routed to a device known as the standard output. The standard output

is usually your monitor, but it could be other things as well. Most notably, the

standard output is set to be the Java console when an applet runs within Netscape

Navigator. When you run the following example from within an applet, watch your

Java console for the output. If you run it from within an application, the output should

show up on the command line.

public class InputOutputTest(){

String str; // classdata

public void getInput(){

// read a string from the keyboard

str = System.in.getln();

}

public void drawOutput(){

// write a string to the console screen

System.out.println(str);

}

Files

The stream classes would be pretty useless if you couldn't manipulate files as well.

There are several security mechanisms defined in the security model used by Java-

capable browsers for running applets. These mechanisms prevent unguarded file

access and will be discussed in more depth in Chapter 13, "Java and Security." But for

now, simply assume that as long as you are not writing an applet, you will be able to

manipulate files. In the purest sense, standard input and output are files. As such, they

are sometimes subject to the same applet security restrictions, so be forewarned.

The Basics

When reading and writing to and from files, there are three steps that must be

followed:

1. Open the file for reading or writing.

2. Read or write from the file.

3. Close the file.

It is important to do each step. Failing to open a file will, obviously, prevent you from

reading. But perhaps not as intuitively, you must still close the file or you may wreck

your file system. Every application is allowed a certain number of file descriptors

(handles) that maintain the status of a file. If you run out of available file descriptors,

you will no longer be able to open any other files. The following snippet uses the

FileReader class to read the contents of a file specified on the command line and the

PrintWriter class to write it to the Java console:

import java. io.*;

public class ShowFile{

public static void main (Stringargs[]){

try{

FileReader fin = new FileReader(args[0]);

PrintWriter consoleOut = new PrintWriter(System.out, true);

char c[] = new char[512];

int count = 0;

while ((count=fin.read(c))!=-1)

consoleOut.write(c,0,count);

consoleOut.flush();

consoleOut.close();

fin.close();

}

catch(FileNotFoundException e){

System.out.println(e.toString());

}

catch(IOException e) {

System.out.println(e.toString());

The AWT is a half-baked attempt to create a user interface toolbox for programmers.

Because all the various classes, containers, and widgets in the toolkit are capable of

being used both in the applets embedded in Web pages and in the stand-alone

applications on your desktop, it is a powerfully extensible tool. At the heart of this

kind of flexibility is the idea that the toolkit is an abstraction—in other words, a layer

on top of your current windowing system. This abstraction is more understandable if

you know the background behind it. When Sun was courting its early customers,

Netscape insisted that the Java Virtual Machine (JVM) included in its browser must

create widgets that had the exact look and feel of the host operating system's widgets.

Since "Swing" wasn't yet a gleam in its father's eye, the only way to accomplish this

was to use the peer components of the host operating system. Thus we can truly say

that the AWT is an abstraction of the windowing system of the operating system.

Your current windowing system may be anything from X11/Motif to Windows 95's

own window system. In any event, the AWT ensures that native calls are made to

these windowing systems in order to allow applications to run on top of the desktop.

For applets within a Web page, the browser manufacturer essentially creates a

windowing system that renders the AWT's widgets within itself.

The end result of all this is that eventually a native call is made for each action taken

by the AWT. Your applications need not be aware of this, for Java's platform

independence ensures that, no matter the platform on which you execute bytecodes,

the results will be identical.

One of the problems with this approach to user interface (UI) implementation is that

when making a UI that must be rendered the same way on all the platforms it is to be

targeted to, small differences in the way that components are rendered on each of the

targeted systems may cause the overall effect to have problems. For instance, a UI

having several closely aligned text fields may look good on Windows platforms but

appear overlayed on UNIX machines.

One of the major complaints about the AWT by people used to building user

interfaces for enterprise applications was that it had a relatively small set of widgets

and low functionality. AWT provided only slightly more functionality than the

widgets provided in HTML's forms controls. In early 1997 the work on JDK 1.1

incorporated a number of new pieces including Netscape Corporation's Internet

Foundation Classes (IFC), components from IBM's Taligent Division, and Lighthouse

Design. The first release of Swing 1.0 in early 1998 contained almost 250 classes and

80 interfaces. The art of user interface creation had been raised to a new level and was

now able to go head to head with platform-specific development tools.

The Java 1.2 platform provides a set of components (Swing) that eliminate this

problem by eliminating the use of peer components. The Swing components are pure

Java and will render reliably on all host platforms. With Swing the native look and

feel of Windows, Motif, or Mac widgets are options from a predefined list of look and

feels that are extensible by the user.

Input Alternatives

剩余362页未读，继续阅读

洛神夫

粉丝: 125
资源: 10

Java网络编程新经典：超越Web应用的潜力

Addison Wesley - Advanced Programming in the UNIX Environment - 2nd Edition

Addison Wesley - The Java Tutorial, 3rd Edition - A Short Course on the Basics

Addison Wesley - 2001 - Knuth - The Art of Computer Programming Vol I II III IV.part5.rar of 6

Addison Wesley - Advanced Windows Debugging 2007.pdf

Addison Wesley - Java Native Interface

Addison Wesley - Java and JMX (2002).chm

Addison Wesley -- LDAP programming with Java.pdf

Addison-Wesley - Advanced Windows Debugging (Nov 2007)

Addison Wesley - Java Network Programming and Distributed Computing

Addison Wesley - Java Design Objects, UML, and Process

最新资源