企业级Java编程思想英文版解读

需积分: 10 132 浏览量更新于2024-07-24 收藏 811KB PDF 举报

"Thinking in Enterprise Java 是由 Bruce Eckel 编写的英文版企业级 Java 开发指南，尽管这本书相对较老，但仍然具有一定的参考价值。本书涵盖了网络编程、远程方法调用（RMI）和数据库连接等核心企业级 Java 开发主题。" 在《Thinking in Enterprise Java》中，作者首先介绍了企业编程的基础知识，为读者铺垫了必要的前提条件。这部分可能包括对 Java 平台的理解、企业级应用的基本架构和设计模式等内容，旨在让读者具备进行企业级开发的背景知识。在网络编程部分，书中讲解了使用 Sockets 和 Channels 进行通信的基本概念。识别机器、服务器与客户端的角色划分是这一章节的关键。书中通过实例展示了如何创建简单的服务器和客户端，以及如何处理多个客户端的并发连接。此外，还涉及了 Datagrams（数据报）的使用，这是一种无连接、不可靠的通信方式。对于在 Applet 中使用 URLs 访问网络资源以及利用 Selector 基于的多路复用技术（在 JDK 1.4 中引入）也有所讨论，这些都是实现高效网络通信的重要工具。远程方法调用（RMI）是 Java 在分布式系统中的重要特性。书中详细阐述了 RMI 的工作原理，包括定义远程接口、实现该接口、设置注册表、生成 stubs 和 skeletons 以及如何使用远程对象。这一部分的练习可以帮助读者巩固 RMI 的实际应用。最后，书中提到了与数据库的连接，这是任何企业级应用中不可或缺的部分。这部分可能会涵盖 JDBC API 的使用，如何建立数据库连接，执行 SQL 查询，以及如何处理结果集。这些技能对于开发需要持久化数据的 Java 应用至关重要。《Thinking in Enterprise Java》虽然年代稍久，但它提供的基础知识和实践案例对于理解企业级 Java 开发仍然具有很高的学习价值。书中的练习题可以进一步加深读者对这些关键概念的理解和应用。

// Guard everything in a try-finally to make

// sure that the socket is closed:

try {

System.out.println("socket = " + socket);

BufferedReader in =

new BufferedReader(

new InputStreamReader(

socket.getInputStream()));

// Output is automatically flushed

// by PrintWriter:

PrintWriter out =

new PrintWriter(

new BufferedWriter(

new OutputStreamWriter(

socket.getOutputStream())),true);

for(int i = 0; i < 10; i ++) {

out.println("howdy " + i);

String str = in.readLine();

System.out.println(str);

}

out.println("END");

} finally {

System.out.println("closing...");

socket.close();

}

} ///:~

In main( ) you can see all three ways to produce the InetAddress of the local loopback

IP address: using null, localhost, or the explicit reserved address 127.0.0.1. Of course,

if you want to connect to a machine across a network you substitute that machine’s

IP address. When the InetAddress addr is printed (via the automatic call to its

toString( ) method) the result is:

localhost/127.0.0.1

By handing getByName( ) a null, it defaulted to finding the localhost, and that

produced the special address 127.0.0.1.

Note that the Socket called socket is created with both the InetAddress and the port

number. To understand what it means when you print one of these Socket objects,

remember that an Internet connection is determined uniquely by these four pieces of

data: clientHost, clientPortNumber, serverHost, and serverPortNumber. When the

server comes up, it takes up its assigned port (8080) on the localhost (127.0.0.1).

When the client comes up, it is allocated to the next available port on its machine,

1077 in this case, which also happens to be on the same machine (127.0.0.1) as the

server. Now, in order for data to move between the client and server, each side has to

know where to send it. Therefore, during the process of connecting to the “known”

server, the client sends a “return address” so the server knows where to send its data.

This is what you see in the example output for the server side:

Socket[addr=127.0.0.1,port=1077,localport=8080]

This means that the server just accepted a connection from 127.0.0.1 on port 1077

while listening on its local port (8080). On the client side:

Socket[addr=localhost/127.0.0.1,PORT=8080,localport=1077]

which means that the client made a connection to 127.0.0.1 on port 8080 using the

local port 1077.

You’ll notice that every time you start up the client anew, the local port number is

incremented. It starts at 1025 (one past the reserved block of ports) and keeps going

up until you reboot the machine, at which point it starts at 1025 again. (On UNIX

machines, once the upper limit of the socket range is reached, the numbers will wrap

around to the lowest available number again.)

Once the Socket object has been created, the process of turning it into a

BufferedReader and PrintWriter is the same as in the server (again, in both cases you

start with a Socket). Here, the client initiates the conversation by sending the string

“howdy” followed by a number. Note that the buffer must again be flushed (which

happens automatically via the second argument to the PrintWriter constructor). If

the buffer isn’t flushed, the whole conversation will hang because the initial “howdy”

will never get sent (the buffer isn’t full enough to cause the send to happen

automatically). Each line that is sent back from the server is written to System.out to

verify that everything is working correctly. To terminate the conversation, the

agreed-upon “END” is sent. If the client simply hangs up, then the server throws an

exception.

You can see that the same care is taken here to ensure that the network resources

represented by the Socket are properly cleaned up, using a try-finally block.

Sockets produce a “dedicated” connection that persists until it is explicitly

disconnected. (The dedicated connection can still be disconnected unexplicitly if one

side, or an intermediary link, of the connection crashes.) This means the two parties

are locked in communication and the connection is constantly open. This seems like

a logical approach to networking, but it puts an extra load on the network. Later in

this chapter you’ll see a different approach to networking, in which the connections

are only temporary.

Serving multiple clients

The JabberServer works, but it can handle only one client at a time. In a typical

server, you’ll want to be able to deal with many clients at once. The answer is

multithreading, and in languages that don’t directly support multithreading this

means all sorts of complications. In Chapter 14 you saw that multithreading in Java

is about as simple as possible, considering that multithreading is a rather complex

topic. Because threading in Java is reasonably straightforward, making a server that

handles multiple clients is relatively easy.

剩余223页未读，继续阅读

honchy

粉丝: 2
资源: 3

企业级Java编程思想英文版解读

Thinking in Enterprise Java

thinking in Enterprise java

thinking in enterprise java

Thinking In Enterprise Java v1.1

Thinking in Enterprise Java.rar

Thinking in Enterprise Java（良好排版）

Thinking in Enterprise Java(Revision 1.1)

英文版J2EE开发实践指南：Thinking In Enterprise Java

企业级Java编程：Thinking in Enterprise Java探索

Thinking_In_Enterprise_Java.rar_英文 java_英文 书

最新资源

Thinking_In_Enterprise_Java.rar_英文 java_英文书