javanio網路編程

Ⅰ java網路編程中怎樣用管道流

一起學習，管道流滿搞的，用著比socket的stream麻煩
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.*;
import java.nio.channels.*;
import java.nio.*;
import java.util.*;
import java.nio.charset.*;
public class TCP extends Thread{
private SocketChannel channel;
private ServerSocket serverSocket;
private ServerSocketChannel serverSocketChannel;
private ByteBuffer readBuffer;
private ByteBuffer sendBuffer;
private Boolean isAccept=false;
private boolean isConnect=false;
private Thread accept;
private Thread connect;
/** Creates a new instance of TCP */
public TCP(int port,String addr) {
try {
readBuffer=ByteBuffer.allocate(1024);
serverSocketChannel=ServerSocketChannel.open();
serverSocket=serverSocketChannel.socket();
serverSocket.setReuseAddress(true);
serverSocket.bind(new InetSocketAddress(port));
channel=SocketChannel.open();
channel.connect(new InetSocketAddress(InetAddress.getByName(addr),port));
accept=new Thread(){
public void run(){
Selector selector;
try {
selector=Selector.open();
serverSocketChannel.configureBlocking(false);
serverSocketChannel.register(selector,SelectionKey.OP_ACCEPT);
isAccept=false;
selectors(selector);
} catch (ClosedChannelException ex) {
ex.printStackTrace();
} catch (IOException ex) {
ex.printStackTrace();
}
}
};
connect=new Thread(){
public void run(){
try{
Selector selector;
selector=Selector.open();
channel.configureBlocking(false);
channel.register(selector,SelectionKey.OP_WRITE|SelectionKey.OP_READ);
isConnect=false;
selectors(selector);
}catch (Exception ex){
ex.printStackTrace();
}
}
};
} catch (IOException ex) {
ex.printStackTrace();
System.out.println("d1");
}catch(Exception ex){
System.out.println("d2");
}
}
private void service(){
if(isConnect){
connect.start();
}
if(isAccept){
accept.start();
}
}
private void selectors(Selector selector){
try {
while (selector.select()>0){
Set readyKeys=selector.selectedKeys();
Iterator<SelectionKey> it=readyKeys.iterator();
while(it.hasNext()){
SelectionKey key=null;
key=it.next();
it.remove();
if(key.isAcceptable()){
//System.out.println("isAcceptable");
ServerSocketChannel ssc=(ServerSocketChannel)key.channel();
SocketChannel socketChannel=ssc.accept();
socketChannel.configureBlocking(false);
socketChannel.register(selector,SelectionKey.OP_READ|SelectionKey.OP_WRITE);
}
if(key.isReadable()){
synchronized(readBuffer){
// System.out.println("isReadable");
ByteBuffer buffer=ByteBuffer.allocate(1024);
SocketChannel socketChannel=(SocketChannel)key.channel();
socketChannel.read(buffer);
readBuffer=buffer;
}
}
if(key.isWritable()){
synchronized(sendBuffer){
// System.out.println("isWritable");
SocketChannel channel=(SocketChannel)key.channel();
if(sendBuffer!=null)
channel.write(sendBuffer);
}
}

}
try {
sleep(1);
} catch (InterruptedException ex) {
ex.printStackTrace();
}
}
} catch (ClosedChannelException ex) {
ex.printStackTrace();
} catch (IOException ex) {
ex.printStackTrace();
}
}

public void send(ByteBuffer buff){
this.sendBuffer=buff;
}
public ByteBuffer get(){
return readBuffer;
}
public void accpet(){
isAccept=true;
}
public void connect(){
isConnect=true;
}
public void run(){
while (true){
service();
}
}
}

Ⅱ 求java nio網路編程的小例子，要求客戶端一直與伺服器保持連接

import java.awt.*;
import java.awt.event.*;
import java.io.IOException;
import java.net.*;
import java.io.*;

public class chatClient extends Frame {

/**
* @param args
*/
TextField tfTxT=new TextField();
TextArea taContent=new TextArea();
Socket s=null;
DataOutputStream dos=null;
DataInputStream dis=null;
private boolean bConnected =false;

public static void main(String[] args) {
new chatClient().lunachFrame();
}

private class RecvThread implements Runnable{

public void run() {
try{
while(bConnected){
String str=dis.readUTF();
taContent.setText(taContent.getText()+str+'\n');
}
}catch(IOException e){
e.printStackTrace();
}
}

}

public void lunachFrame(){
this.setLocation(400, 300);
this.setSize(300,300);
//this.setLayout(new FlowLayout());
this.add(tfTxT,"South");
this.add(taContent,"North");
pack();
tfTxT.addActionListener(new TFListener());
this.addWindowListener(new WindowClose());
this.setVisible(true);
connect();
new Thread(new RecvThread()).start();
}

public void connect(){
try {
s= new Socket("127.0.0.1",8888);
dos =new DataOutputStream(s.getOutputStream());
dis =new DataInputStream(s.getInputStream());
System.out.println("connected!");
bConnected=true;
} catch (UnknownHostException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}

public void disconnect(){
try {
dos.close();
s.close();
} catch (Exception e) {
// TODO 自動生成 catch 塊
e.printStackTrace();
}
}

class WindowClose extends WindowAdapter{

@Override
public void windowClosing(WindowEvent e) {
// TODO 自動生成方法存根
System.exit(0);
disconnect();
}

}

private class TFListener implements ActionListener{

public void actionPerformed(ActionEvent e) {
String str=tfTxT.getText().trim();//trim去掉兩邊空格
//taContent.setText(str);
tfTxT.setText("");
try {
dos.writeUTF(str);
dos.flush();
//dos.close();

} catch (IOException e1) {
e1.printStackTrace();

}
}
}
}

======================================
import java.io.IOException;
import java.net.*;
import java.io.*;
import java.util.*;

public class ChatServer {
List<Client> clients=new ArrayList<Client>();
Client c=null;

public static void main(String[] args){
new ChatServer().start();
}

public void start(){
boolean started=false;
ServerSocket ss=null;
DataInputStream dis=null;
try{
ss=new ServerSocket(8888);
started =true;
}catch(Exception e)
{
e.printStackTrace();
}
try{
while(started){
Socket s=ss.accept();
c=new Client(s);//啟動線程,實行run()方法
System.out.println("a client connected!");
new Thread(c).start();//啟動start方法,循環.start是Thread中的方法與這上面的start無關
clients.add(c);
//dis.close();
}
} catch (Exception e) {

//e.printStackTrace();
}
finally{
try {
ss.close();
} catch (IOException e) {
// TODO 自動生成 catch 塊
e.printStackTrace();
}
}
}

class Client implements Runnable{

private Socket s;
private DataInputStream dis =null;
private boolean bConnected =false;
private DataOutputStream dos=null;

public Client(Socket s){
this.s=s;
try {
dis=new DataInputStream(s.getInputStream());
dos =new DataOutputStream(s.getOutputStream());
bConnected =true;
} catch (IOException e) {
// TODO 自動生成 catch 塊
e.printStackTrace();
}
}

public void send(String str)throws Exception{
dos.writeUTF(str);

}

public void run() {
try{
while(bConnected){
String str = dis.readUTF();
System.out.println(str);
for(int i=0;i<clients.size();i++){
c=clients.get(i);
c.send(str);
}
/*for(Iterator<Client> it=clients.iterator();it.hasNext();){
Client c=it.next();
c.send(str);
}*/
}
}catch(SocketException e){
clients.remove(this);
System.out.println("客戶下線了");
}
catch(EOFException e){
System.out.println("Client closed");
}
catch (Exception e){

//e.printStackTrace();
}
finally{
try {
if(dis !=null) dis.close();
if(dos !=null) dos.close();
if(s!=null) s.close();
} catch (Exception e1) {
// TODO 自動生成 catch 塊
//e1.printStackTrace();
}
}
}
}

}

第一個是客戶端,
第二個是server端

Ⅲ java Nio讀寫為什麼是雙向

作者：美團技術團隊
鏈接：https://zhuanlan.hu.com/p/23488863
來源：知乎
著作權歸作者所有。商業轉載請聯系作者獲得授權，非商業轉載請註明出處。

NIO（Non-blocking I/O，在Java領域，也稱為New I/O），是一種同步非阻塞的I/O模型，也是I/O多路復用的基礎，已經被越來越多地應用到大型應用伺服器，成為解決高並發與大量連接、I/O處理問題的有效方式。

那麼NIO的本質是什麼樣的呢？它是怎樣與事件模型結合來解放線程、提高系統吞吐的呢？

本文會從傳統的阻塞I/O和線程池模型面臨的問題講起，然後對比幾種常見I/O模型，一步步分析NIO怎麼利用事件模型處理I/O，解決線程池瓶頸處理海量連接，包括利用面向事件的方式編寫服務端/客戶端程序。最後延展到一些高級主題，如Reactor與Proactor模型的對比、Selector的喚醒、Buffer的選擇等。

註：本文的代碼都是偽代碼，主要是為了示意，不可用於生產環境。

傳統BIO模型分析

讓我們先回憶一下傳統的伺服器端同步阻塞I/O處理（也就是BIO，Blocking I/O）的經典編程模型：

{
ExecutorService executor = Excutors.newFixedThreadPollExecutor(100);//線程池

ServerSocket serverSocket = new ServerSocket();
serverSocket.bind(8088);
while(!Thread.currentThread.isInturrupted()){//主線程死循環等待新連接到來
Socket socket = serverSocket.accept();
executor.submit(new ConnectIOnHandler(socket));//為新的連接創建新的線程
}

class ConnectIOnHandler extends Thread{
private Socket socket;
public ConnectIOnHandler(Socket socket){
this.socket = socket;
}
public void run(){
while(!Thread.currentThread.isInturrupted()&&!socket.isClosed()){死循環處理讀寫事件
String someThing = socket.read()....//讀取數據
if(someThing!=null){
......//處理數據
socket.write()....//寫數據
}

}
}
}

這是一個經典的每連接每線程的模型，之所以使用多線程，主要原因在於socket.accept()、socket.read()、socket.write()三個主要函數都是同步阻塞的，當一個連接在處理I/O的時候，系統是阻塞的，如果是單線程的話必然就掛死在那裡；但CPU是被釋放出來的，開啟多線程，就可以讓CPU去處理更多的事情。其實這也是所有使用多線程的本質：

• 利用多核。

• 當I/O阻塞系統，但CPU空閑的時候，可以利用多線程使用CPU資源。

現在的多線程一般都使用線程池，可以讓線程的創建和回收成本相對較低。在活動連接數不是特別高（小於單機1000）的情況下，這種模型是比較不錯的，可以讓每一個連接專注於自己的I/O並且編程模型簡單，也不用過多考慮系統的過載、限流等問題。線程池本身就是一個天然的漏斗，可以緩沖一些系統處理不了的連接或請求。

不過，這個模型最本質的問題在於，嚴重依賴於線程。但線程是很"貴"的資源，主要表現在：

• 線程的創建和銷毀成本很高，在Linux這樣的操作系統中，線程本質上就是一個進程。創建和銷毀都是重量級的系統函數。

• 線程本身佔用較大內存，像Java的線程棧，一般至少分配512K～1M的空間，如果系統中的線程數過千，恐怕整個JVM的內存都會被吃掉一半。

• 線程的切換成本是很高的。操作系統發生線程切換的時候，需要保留線程的上下文，然後執行系統調用。如果線程數過高，可能執行線程切換的時間甚至會大於線程執行的時間，這時候帶來的表現往往是系統load偏高、CPU sy使用率特別高（超過20%以上)，導致系統幾乎陷入不可用的狀態。

• 容易造成鋸齒狀的系統負載。因為系統負載是用活動線程數或CPU核心數，一旦線程數量高但外部網路環境不是很穩定，就很容易造成大量請求的結果同時返回，激活大量阻塞線程從而使系統負載壓力過大。

所以，當面對十萬甚至百萬級連接的時候，傳統的BIO模型是無能為力的。隨著移動端應用的興起和各種網路游戲的盛行，百萬級長連接日趨普遍，此時，必然需要一種更高效的I/O處理模型。

NIO是怎麼工作的

很多剛接觸NIO的人，第一眼看到的就是Java相對晦澀的API，比如：Channel，Selector，Socket什麼的；然後就是一坨上百行的代碼來演示NIO的服務端Demo……瞬間頭大有沒有？

我們不管這些，拋開現象看本質，先分析下NIO是怎麼工作的。

常見I/O模型對比

所有的系統I/O都分為兩個階段：等待就緒和操作。舉例來說，讀函數，分為等待系統可讀和真正的讀；同理，寫函數分為等待網卡可以寫和真正的寫。

需要說明的是等待就緒的阻塞是不使用CPU的，是在「空等」；而真正的讀寫操作的阻塞是使用CPU的，真正在"幹活"，而且這個過程非常快，屬於memory ，帶寬通常在1GB/s級別以上，可以理解為基本不耗時。

下圖是幾種常見I/O模型的對比：



密碼：380p

以上都是小編收集了大神的靈葯，喜歡的拿走吧！喜歡小編就輕輕關注一下吧！

Ⅳ 針對Java 網路編程，有哪些比較好的書推薦

Java 網路編程，比較好的書：
ava TCPIP Socket編程(中文版) Java NIO (中文版) 中文的好理解

java 7 出了AIO 你有必要去網路了解下

Ⅳ java裡面的NIO是什麼，有什麼用

NIO即New IO，這個庫是在JDK1.4中才引入的。NIO和IO有相同的作用和目的，但實現方式不同，NIO主要用到的是塊，所以NIO的效率要比IO高很多。
在Java API中提供了兩套NIO，一套是針對標准輸入輸出NIO，另一套就是網路編程NIO。

Ⅵ JAVA開發工程師必須懂什麼

java Netty實戰課程java高性能分布式RPC教程課程 免費下載

鏈接:https://pan..com/s/1MpUM62h4nvHnUGMan-R6YA

提取碼:kvvv

Java是一門面向對象的編程語言，不僅吸收了C++語言的各種優點，還摒棄了C++里難以理解的多繼承、指針等概念，因此Java語言具有功能強大和簡單易用兩個特徵。Java語言作為靜態面向對象編程語言的代表，極好地實現了面向對象理論，允許程序員以優雅的思維方式進行復雜的編程



Ⅶ Java網路編程精解的目錄

第1章 Java網路編程入門 1
1.1 進程之間的通信 1
1.2 計算機網路的概念 3
1.3 OSI參考模型 5
1.4 TCP/IP參考模型和TCP/IP協議 8
1.4.1 IP協議 11
1.4.2 TCP協議及埠 14
1.4.3 RFC簡介 15
1.4.4 客戶/伺服器通信模式 16
1.5 用Java編寫客戶/伺服器程序 17
1.5.1 創建EchoServer 18
1.5.2 創建EchoClient 20
1.6 小結 22
1.7 練習題 23
第2章 Socket用法詳解 25
2.1 構造Socket 25
2.1.1 設定等待建立連接的超時時間 26
2.1.2 設定伺服器的地址 26
2.1.3 設定客戶端的地址 27
2.1.4 客戶連接伺服器時可能拋出的異常 27
2.2 獲取Socket的信息 30
2.3 關閉Socket 32
2.4 半關閉Socket 33
2.5 設置Socket的選項 38
2.5.1 TCP_NODELAY選項 38
2.5.2 SO_RESUSEADDR選項 38
2.5.3 SO_TIMEOUT選項 39
2.5.4 SO_LINGER選項 42
2.5.5 SO_RCVBUF選項 44
2.5.6 SO_SNDBUF選項 45
2.5.7 SO_KEEPALIVE選項 45
2.5.8 OOBINLINE選項 45
2.5.9 服務類型選項 45
2.5.10 設定連接時間、延遲和帶寬的相對重要性 46
2.6 發送郵件的SMTP客戶程序 47
2.7 小結 51
2.8 練習題 52
第3章 ServerSocket用法詳解 55
3.1 構造ServerSocket 55
3.1.1 綁定埠 55
3.1.2 設定客戶連接請求隊列的長度 56
3.1.3 設定綁定的IP地址 58
3.1.4 默認構造方法的作用 58
3.2 接收和關閉與客戶的連接 59
3.3 關閉ServerSocket 60
3.4 獲取ServerSocket的信息 60
3.5 ServerSocket選項 62
3.5.1 SO_TIMEOUT選項 62
3.5.2 SO_REUSEADDR選項 63
3.5.3 SO_RCVBUF選項 64
3.5.4 設定連接時間、延遲和帶寬的相對重要性 64
3.6 創建多線程的伺服器 65
3.6.1 為每個客戶分配一個線程 65
3.6.2 創建線程池 67
3.6.3 使用JDK類庫提供的線程池 72
3.6.4 使用線程池的注意事項 74
3.7 關閉伺服器 76
3.8 小結 80
3.9 練習題 81
第4章 非阻塞通信 83
4.1 線程阻塞的概念 83
4.1.1 線程阻塞的原因 83
4.1.2 伺服器程序用多線程處理阻塞通信的局限 84
4.1.3 非阻塞通信的基本思想 85
4.2 java.nio包中的主要類 87
4.2.1 緩沖區Buffer 88
4.2.2 字元編碼Charset 90
4.2.3 通道Channel 90
4.2.4 SelectableChannel類 92
4.2.5 ServerSocketChannel類 93
4.2.6 SocketChannel類 93
4.2.7 Selector類 96
4.2.8 SelectionKey類 97
4.3 伺服器編程範例 100
4.3.1 創建阻塞的EchoServer 100
4.3.2 創建非阻塞的EchoServer 103
4.3.3 在EchoServer中混合用阻塞模式與非阻塞模式 110
4.4 客戶端編程範例 114
4.4.1 創建阻塞的EchoClient 114
4.4.2 創建非阻塞的EchoClient 116
4.4.3 創建非阻塞的PingClient 120
4.5 小結 126
4.6 練習題 127
第5章 創建非阻塞的HTTP伺服器 129
5.1 HTTP協議簡介 129
5.1.1 HTTP請求格式 129
5.1.2 HTTP響應格式 132
5.1.3 測試HTTP請求 133
5.2 創建非阻塞的HTTP伺服器 137
5.2.1 伺服器主程序：
HttpServer類 137
5.2.2 具有自動增長的緩沖區的ChannelIO類 138
5.2.3 負責處理各種事件的
Handler介面 140
5.2.4 負責處理接收連接就緒
事件的AcceptHandler類 140
5.2.5 負責接收HTTP請求和發送HTTP響應的RequestHandler類 141
5.2.6 代表HTTP請求的Request類 143
5.2.7 代表HTTP響應的Response類 145
5.2.8 代表響應正文的Content介面及其實現類 147
5.2.9 運行HTTP伺服器 149
5.3 小結 150
5.4 練習題 151
第6章 客戶端協議處理框架 153
6.1 客戶端協議處理框架的主要類 153
6.2 在客戶程序中運用協議處理框架 154
6.2.1 URL類的用法 154
6.2.2 URLConnection類的用法 156
6.3 實現協議處理框架 160
6.3.1 創建EchoURLConnection類 161
6.3.2 創建EchoURLStreamHandler及工廠類 162
6.3.3 創建EchoContentHandler類及工廠類 163
6.3.4 在EchoClient類中運用ECHO協議處理框架 165
6.4 小結 166
6.5 練習題 167
第7章 用Swing組件展示HTML文檔 169
7.1 在按鈕等組件上展示HTML文檔 170
7.2 用JEditorPane組件創建簡單的瀏覽器 171
7.3 小結 179
7.4 練習題 179
第8章 基於UDP的
數據報和套接字 181
8.1 UDP協議簡介 181
8.2 DatagramPacket類 184
8.2.1 選擇數據報的大小 185
8.2.2 讀取和設置DatagramPacket的屬性 185
8.2.3 數據格式的轉換 186
8.2.4 重用DatagramPacket 187
8.3 DatagramSocket類 189
8.3.1 構造DatagramSocket 189
8.3.2 接收和發送數據報 190
8.3.3 管理連接 190
8.3.4 關閉DatagramSocket 191
8.3.5 DatagramSocket的選項 191
8.3.6 IP服務類型選項 193
8.4 DatagramChannel類 193
8.4.1 創建DatagramChannel 194
8.4.2 管理連接 194
8.4.3 用send()方法發送數據報 194
8.4.4 用receive()方法接收數據報 195
8.4.5 用write()方法發送數據報 198
8.4.6 用read()方法接收數據報 199
8.5 組播Socket 202
8.5.1 MulticastSocket類 205
8.5.2 組播Socket的範例 207
8.6 小結 209
8.7 練習題 210
第9章 對象的序列化與反序列化 213
9.1 JDK類庫中的序列化API 213
9.2 實現Serializable介面 218
9.2.1 序列化對象圖 220
9.2.2 控制序列化的行為 222
9.2.3 readResolve()方法在單例類中的運用 229
9.3 實現Externalizable介面 231
9.4 可序列化類的不同版本的序列化兼容性 233
9.5 小結 235
9.6 練習題 236
第10章 Java語言的反射機制 239
10.1 Java Reflection API簡介 239
10.2 在遠程方法調用中運用反射機制 244
10.3 代理模式 248
10.3.1 靜態代理類 248
10.3.2 動態代理類 250
10.3.3 在遠程方法調用中
運用代理類 253
10.4 小結 258
10.5 練習題 259
第11章 RMI框架 261
11.1 RMI的基本原理 262
11.2 創建第一個RMI應用 264
11.2.1 創建遠程介面 264
11.2.2 創建遠程類 265
11.2.3 創建伺服器程序 267
11.2.4 創建客戶程序 269
11.2.5 運行RMI應用 270
11.3 遠程對象工廠設計模式 272
11.4 遠程方法中的參數與返回值傳遞 277
11.5 回調客戶端的遠程對象 281
11.6 遠程對象的並發訪問 286
11.7 分布式垃圾收集 289
11.8 遠程對象的equals()、hashCode()和clone()方法 294
11.9 使用安全管理器 294
11.10 RMI應用的部署及類的動態載入 295
11.11 遠程激活 297
11.12 小結 303
11.13 練習題 304
第12章 通過JDBC API訪問資料庫 305
12.1 JDBC的實現原理 306
12.2 安裝和配置MySQL資料庫 308
12.3 JDBC API簡介 310
12.4 JDBC API的基本用法 314
12.4.1 處理字元編碼的轉換 317
12.4.2 把連接資料庫的各種屬性放在配置文件中 318
12.4.3 管理Connection、Statement和ResultSet對象的生命周期 321
12.4.4 執行SQL腳本文件 326
12.4.5 處理SQLException 328
12.4.6 輸出JDBC日誌 329
12.4.7 獲得新插入記錄的主鍵值 329
12.4.8 設置批量抓取屬性 330
12.4.9 檢測驅動器使用的JDBC版本 330
12.4.10 元數據 331
12.5 可滾動及可更新的結果集 333
12.6 行集 339
12.7 調用存儲過程 346
12.8 處理Blob和Clob類型數據 347
12.9 控制事務 351
12.9.1 事務的概念 351
12.9.2 聲明事務邊界的概念 353
12.9.3 在mysql.exe程序中聲明事務 354
12.9.4 通過JDBC API聲明事務邊界 356
12.9.5 保存點 357
12.9.6 批量更新 358
12.9.7 設置事務隔離級別 360
12.10 資料庫連接池 362
12.10.1 創建連接池 363
12.10.2 DataSource數據源 369
12.11 小結 371
12.12 練習題 372
第13章 基於MVC和RMI的分布式應用 375
13.1 MVC設計模式簡介 375
13.2 store應用簡介 377
13.3 創建視圖 381
13.4 創建控制器 389
13.5 創建模型 390
13.6 創建獨立應用 394
13.7 創建分布式應用 395
13.8 小結 398
13.9 練習題 398
第14章 通過JavaMail API收發郵件 401
14.1 E-mail協議簡介 401
14.1.1 SMTP簡單郵件傳輸協議 401
14.1.2 POP3郵局協議 402
14.1.3 接收郵件的新協議IMAP 402
14.1.4 MIME簡介 403
14.2 JavaMail API簡介 403
14.3 建立JavaMail應用程序的開發環境 405
14.3.1 獲得JavaMail API的類庫 405
14.3.2 安裝和配置郵件伺服器 406
14.4 創建JavaMail應用程序 408
14.5 身份驗證 412
14.6 URLName類 416
14.7 創建和讀取復雜電子郵件 418
14.7.1 郵件地址 419
14.7.2 郵件頭部 420
14.7.3 郵件標記 421
14.7.4 郵件正文 422
14.8 操縱郵件夾 427
14.9 小結 432
14.10 練習題 433
第15章 安全網路通信 435
15.1 SSL簡介 435
15.1.1 加密通信 436
15.1.2 安全證書 436
15.1.3 SSL握手 437
15.1.4 創建自我簽名的安全證書 438
15.2 JSSE簡介 439
15.2.1 KeyStore、KeyManager與TrustManager類 442
15.2.2 SSLContext類 443
15.2.3 SSLServerSocketFactory類 444
15.2.4 SSLSocketFactory類 444
15.2.5 SSLSocket類 444
15.2.6 SSLServerSocket類 447
15.2.7 SSLEngine類 448
15.3 創建基於SSL的安全伺服器和安全客戶 453
15.4 小結 457
15.5 練習題 457
第16章 CORBA簡介 459
16.1 創建IDL介面 460
16.2 創建IDL介面的實現類 460
16.3 創建伺服器程序 461
16.4 創建客戶程序 462
16.5 運行CORBA程序 463
16.6 小結 464
16.7 練習題 465
第17章 Web服務簡介 467
17.1 SOAP簡介 467
17.2 建立Apache AXIS環境 469
17.3 在Tomcat上發布
Apache-AXIS Web應用 470
17.4 創建SOAP服務 471
17.4.1 創建提供SOAP
服務的Java類 471
17.4.2 創建SOAP服務的
發布描述符文件 471
17.5 管理SOAP服務 472
17.5.1 發布SOAP服務 472
17.5.2 刪除SOAP服務 473
17.6 創建和運行SOAP
客戶程序 473
17.7 發布JWS服務 476
17.8 小結 476
17.9 練習題 477
附錄A 本書範例的運行方法 479
A.1 本書所用軟體的下載地址 479
A.2 部分軟體的安裝 479
A.2.1 安裝JDK 480
A.2.2 安裝ANT 480
A.2.3 安裝Tomcat 481
A.3 編譯源程序 481
A.4 運行客戶/伺服器程序 482



Ⅷ java常用api有哪些

Java常用API包括如下：
Java集合（位於java.util包下）
Java資料庫編程zhuan（位於java.sql和javax.sql包行下shu），
Java輸入輸出（位於java.io和java.nio包下），
Java圖形界面編程（位於java.awt包和javax.swing包下），
Java國際化和格式化（位於java.text包下），
Java多線程編程（位於java.concurrent包下），
Java網路編程編程（位於java.net包下）