JAVA自學筆記26

時間  2019-11-11
標籤 java 自學 筆記 欄目 Java 简体版
原文   原文鏈接

JAVA自學筆記26

一、網絡編程
1）用來實現網絡互聯的不一樣計算機上運行的程序能夠進行數據交換
2）網絡模型通常泛指
OSI：（Open System Interconnection）開放系統互聯參考模型
TCP/IP參考模型
這裏寫圖片描述javascript

這裏寫圖片描述

3）網絡編程三要素
IP地址、端口、協議
①IP地址：在TCP/IP協議中網絡通訊中的計算機的惟一標識號
java提供類InetAddress供使用。
爲了方便用4個十進制數表示
網絡號段+主機號段
IP分類：
見書
ipconfig–查看本機IP地址
ping ip地址–測試本機與指定的ip地址間的通訊是否有問題
特殊的Ip地址：
127.0.0.1–迴環地址，表示本機
x.x.x.255–廣播地址
x.x.x.0–網絡地址java

4）InetAddress
無構造方法：{
成員都是靜態的
單例設計模式（Runtime)
類中有靜態方法返回該類的對象
}
屬上述狀況中的最後一種web

public static InetAddress getByName(String host):
根據主機名或者ip地址表示獲得的IP地址對象編程

InetAdress address=InetAddress.getByName("cc");

String name=address.getHostName();//獲取主機名
String ip=address.getHostName();//獲取ip地址

5）端口號
每一個網絡程序都會至少有一個邏輯端口，用於標識進程的邏輯地址，不一樣 進程的標識
有效端口0~65535，其中0~1024系統使用或保留設計模式

6）協議
UDP：將數據源和目的封裝成數據包中，不須要創建鏈接；每一個數據包的大小限制在64k;因無鏈接，是不可靠的協議；不須要創建鏈接，速度快
TCP：創建鏈接，造成傳輸數據的通道：在鏈接進行大數據量的傳輸；經過3次握手完成鏈接，是可靠協議；必須創建鏈接，效率稍低。
7）socket通訊原理
socket–網絡套接字
網絡上具備惟一標識的IP地址和端口組合在一塊兒才能構成惟一能識別的標識符套接字。
原理機制：
通訊的兩端都有socket，網絡通訊實際上是Socket之間的通訊，數據在兩個Socket之間經過IO傳輸
DatagramPacket (byte[] buf,int length,InetAddress address,int port)
構造包含數據，其長度，遠程主機的Ip地址和遠程主機的端口號服務器

public void send(DatagramPacket p);
今後套接字發送數據報包。DatagramPacket含將要發送的數據，其長度，遠程主機的Ip地址和遠程主機的端口號網絡

//UDP協議發送數據
--建立發送端Socket對象
--建立數據，並把數據打包
--調用Socket對象的放鬆方法發送數據包
--釋放資源

//建立發送端Socket對象
DatagramSocket ds=new DatagramSocket();

//建立數據，並把數據打包
byte[] bys="good morning!你好";
int length=bys.length();
InetAddress address=InetAddress.getByName("222,241.111,1");
int port=10086;
DatagramPacket (bys,length,address,port)
//調用Socket對象的發送方法發送數據包
ds.send(dp);
//釋放資源
ds.close();

DatagramSocket(int port);//建立數據報套接字並將其綁定到本地主機上的指定端口多線程

public void receive(DatagramPacket p)今後套接字接收數據報包。socket

//UDP協議接收數據
--建立接受端Socket對象
--建立一個數據包（接收容器）
--調用Socket對象的接收方法接收數據
--解析數據包，並顯示在控制檯
--釋放資源

//建立接受對象
DatagramSocket ds=new DatagramSocket(10086);

 //建立一個數據包
 byte[] bys=new byte[1024];
 int length=bys.length;
 DatagramPacket dp=new DatagramPacket(bys,length);

//調用Socket對象的接收方法接收數據
ds。receive(dp);

//解析數據包，並輸出到控制檯
//public byte[] getData():獲取數據緩衝區
//public int getLength();//獲取數據的實際長度
byte[] bys2=dp.getData();
int len=dp.getLength();
String s=new String(by2,0,len);
System.out.println(s);

ds.close();
//

圖解：
這裏寫圖片描述svg

//代碼優化
public class ReceiveDemo{
public static void main(String args[]){
//建立接收端的Socket對象
DatagramSocket ds=new DatagramSocket(10086);

DatagramPacket dp=new DatagramPacket(bys,bys.length);

//接收數據
ds.receive(dp);

//解析數據，鏈式編程
String ip=dp.getAddress().getHostAddress();
String s=new String (dp.getData(),0,dp.getLength());
System.out.println(s);
ds.close();
}
}


public class SendDemo{
public static void main(String args[]){
byte[] bys="hello".getBytes();
DataPacket dp=new DatagramPacket(bys,bys.length.InetAddress.getByName("192.12.36.8"),10086);
ds.send(dp);
ds.close();
}
}

屢次啓動接收端將提示該端口已被佔用

//發送端的數據來自鍵盤錄入
public class ReceiveDemo{
public static void main(String args[]){
//建立接收端的Socket對象
DatagramSocket ds=new DatagramSocket(10086);
while(true){
byte[] bys=new byte[1024];
DatagramPacket dp=new DatagramPacket(bys,bys.length);
//接收數據
ds.receive(dp);

//解析數據，鏈式編程
String ip=dp.getAddress().getHostAddress();
String s=new String (dp.getData(),0,dp.getLength());
System.out.println(s);
}
}
}


public class SendDemo{
public static void main(String args[]){

DatagramSocket ds=new DatagramSocket();
//封裝鍵盤錄入數據
BufferedReader ds=new DatagramSocket();

BUfferedReader br=new BufferedReader(new InputStreamReader(System.in));
String line=null;
while((line=br.readLine())!=null){
byte[] bys=line.getBytes();
DataPacket dp=new DatagramPacket(bys,bys.length.InetAddress.getByName("192.12.36.255"),10086);//廣播地址
ds.send(dp);}
ds.close();
}
}
//多線程實現聊天室

public class ChatRoom{
public static void main(String args[]){
DatagramSocket ds=new DatagramSocket();
DatagramSocket dsReceive=new DatagramSocket(12300);

SendThread st=new SendThread(dsSend);
ReceiveThread(dsReceive);

Thread t1=new Thread(st);
Thread t2=new Thread(rt);

t1.start();
t2.start();
}
}

public class SendThread implements Runnable{
private DatagramSocket ds;

public SendThread(DatagramSocket ds){
this.ds=ds;
}
public void run(){
BUfferedReader br=new BufferedReader(new InputStreamReader(System.in));
String line=null;
while((line=br.readLine())!=null){
byte[] bys=line.getBytes();
DataPacket dp=new DatagramPacket(bys,bys.length.InetAddress.getByName("192.12.36.255"),12300);//廣播地址
ds.send(dp);}
ds.close();

}

}

public class ReceiveThread implements Runnable{
private DatagramSocket ds;
public ReceiveThread(DatagramSocket ds){
this.ds=ds;
}
public void run(){
while(true){
byte[] bys=new byte[1024];
DatagramPacket dp=new DatagramPacket(bys,bys.length);
//接收數據
ds.receive(dp);

//解析數據，鏈式編程
String ip=dp.getAddress().getHostAddress();
String s=new String (dp.getData(),0,dp.getLength());
System.out.println(s);
}
}
}

二、TCP

//TCP發送數據
--建立發送端的Socket對象
--獲取輸出流寫數據
--釋放資源

public class ClientDemo{
public static void main(String args[]){
Socket s=new Socket(InetAddress.getByName("193.36.14.2"),6811);
//Socket s=new Socket("193.36.14.2",6811);也行

//獲取輸出流，寫數據
public OutputStream getOutputStream()

OutputStream os=s.getOutputStream();
os,write("hell0!".getBytes());
s.close();
}
}
//TCP協議接收數據
--建立接收端Socket對象
--監聽客戶端接收，返回一個對應的Socket對象
--獲取輸入流，讀取數據顯示在控制檯
--釋放資源

ServerSocket ss=new ServerSocket(6811);

//監聽客戶端鏈接，返回一個對應的Socket對象 Socket s=ss.accept();
//獲取輸入流顯示在控制檯
InputStream is=s.getInputStream();

byte[]bys=new byte[1024];
int len=is.read(bys);
String str=new  String(bys,0,len);
String ip=s.getInetAddress().getHostAddress();
System.out,println(str);

//釋放資源
s.close();

圖解:
這裏寫圖片描述

//有反饋的案例

public class ServerDemo{
public static void main(String[] aargs){
//建立服務器Socket對象
ServerSocket ss=new SeverSocket(9999);

//監聽客戶端的鏈接
Socket s=ss.accept();

//獲取輸入流
InputStream is=s.getInputStream();
byte[] bs=new byte[1024];
int len=is.read(bys);
String server=new String(bys,0,len);
System.out.println(server);

//獲取輸出值
OutputStream os=s.getOutpitStream();
os.write("數據已收取"。getByte());

//關閉
s.close();
}
}

public class ClientDemo{
public static void main(String[] args){
//建立客戶端Socket對象
Socket s=new Socket("111.111.1.1",9999);

//獲取輸出流
OutputStream os=s.getOutputStream();
Os.write("今每天氣還行".getBytes());

//獲取輸入流
InputStream is=s.getInputStream();
byte[] bys=new byte[1024];
int len=is.read(bys);
String client=new String(bys,0,len);
System.out.println(client);

//釋放資源
s.close();
}
}
//客戶端鍵盤錄入服務器控制檯輸出

public class ClientDemo{
public static void main(Stirng[] args){
Socket s=new Socket("192.168.2.92",22222);

//鍵盤錄入數據
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
String line=null;
while((line=br.readLine())!=null){
//把通道內的流包裝一下
BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));//字節流
String line=null;
while(if("886".equals(line)){
break;
}
(line=br.readLine())!=null){
bw.write(line);
bw.newLine();
bw.flush();
}
//釋放資源
s.close();
}
}
}

//服務器
public class ServerDemo{
pubic static void main(String[] args){
//建立服務器Socket對象
ServerSocket ss=new ServerSocket(22222);

//監聽客戶端鏈接
Socket s=ss..accept();

//包裝通道內的流
BufferedReader br=new BufferedReader(new InputStreamReader(s.getInputStream()));
String line=null;
while((line=br.readLine())!=null){
System.out.println(line);
}

s.close();

}
}
//客戶端鍵盤錄入服務器寫到文本文件
public class ClientDemo{
pubic static void main(String args[]){
Socket s=new Socket("192.168.12.92",23456);

//封裝鍵盤錄入
Buffered br=new BufferedReader(new InputStreamReader(System.in));

//封裝通道內的數據
BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(
s.getOutputStream()));
String line=null;
While((line=br.readLine())!=null)
if("over".equals(line)){
break;
}
s.close();
}
}

public class ServerDemo{
public static void main(String[] args){
//建立服務器Socket對象
ServerSocket ss=new ServerSocket(23456);

//監聽客戶端鏈接
Socket s=ss.accept();

//封裝通道內的數據
BufferedReader br=new BufferedReader(new InputStreamReader(s.getInputStream()));

//封裝文本文件
BufferedWriter bw=new BufferedWriter(new FileWriter("a.txt"));

String line=null;
while((line=br.readLine())!=null){
bw.write(line);
bw.newLine();
bw.flush();
}
bw,close();
s.close();
}
}
//客戶端讀取文本文件服務器控制檯輸出
public  static ClientDemo{
public static void main(String[] args){
//建立Socket對象
Socket s=new Socket("198.168.12.92",34567);

//封裝文本文件
BufferedReader br=new BufferedReader(new FileReader("InetAddressDemo.java"));

//封裝通道內的流
BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
String line=null;
while((line=br.readLine())!=bull){
bw.write(line);
bw.newLine();
bw.flush();


}

br.close();
s.close();}
}

public class ServerDemo{
public static void main(String[] args){
//建立服務器Socket對象
ServerSocket ss=new ServerSocket(34567);

//監聽客戶端鏈接
Socket s=ss.accept();

//封裝通道內的流
BufferedReader br=new BufferedReader(new InputStreamReader{s.getInputStream()));

String line=null;
while((line=br.readLine())!=null){
System.out.println(line);
}
}
s.close();
}
//客戶端文本文件，服務器輸出文本文件

public class UploadClient{
public static void main(String args[]){
//建立客戶端Socket對象
Socket s=new Socket("192.188.12.92",11111);
//封裝文本文件
BufferedReader br=new BufferedReader(new FileReader("InetAddressDemo.java"));

//封裝通道內流
BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));

String line=null;
while((line=br.readLine())!=null){
br.close();
s.close();

}
}

public class Uploadserver{
public static void main(String args[]){
//建立服務器的Socket對象
ServerSocket ss=new ServerSocket(11111);

//監聽客戶端鏈接
Socket s=ss.accept();

//封裝通道內的流
BufferedReader br=new BufferedReader(new InputStramReader(s.getInputStream()));

//封裝文本文件
BufferedWriter bw=new BufferedWriter(new FileWriter("Copy.java"));

String line=null;
while((line=br.readLine())!=bull){
bw.write(line);
bw.newLine();
bw.flush();

bw.close();
s.close();

}
}
//TCP上傳文本文件並給出反饋
注意：讀取文本文件是能夠以null做爲結束信息的，可是通道內是不能這樣結束信息的。因此服務器根本就不知道結束了，而客戶端還在等服務器給反饋，所以就相互等待了。
a.自定義結束標記
b.shutdownInput()--禁用此套接字的輸出流，對於TCP套接字，任何之前寫入的數據都將被髮送，而且後跟TCP的正常終止序列。

以此爲準
public class UploadClient {
    public static void main(String[] args) throws IOException {
        // 建立客戶端Socket對象
        Socket s = new Socket("192.168.12.92", 11111);

        // 封裝文本文件
        BufferedReader br = new BufferedReader(new FileReader(
                "InetAddressDemo.java"));
        // 封裝通道內流
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(
                s.getOutputStream()));

        String line = null;
        while ((line = br.readLine()) != null) { // 阻塞
            bw.write(line);
            bw.newLine();
            bw.flush();
        }

        //自定義一個結束標記
// bw.write("over");
// bw.newLine();
// bw.flush();

        //Socket提供了一個終止，它會通知服務器你別等了，我沒有數據過來了
        s.shutdownOutput();

        // 接收反饋
        BufferedReader brClient = new BufferedReader(new InputStreamReader(
                s.getInputStream()));
        String client = brClient.readLine(); // 阻塞
        System.out.println(client);

        // 釋放資源
        br.close();
        s.close();
    }
}

public class UploadServer {
    public static void main(String[] args) throws IOException {
        // 建立服務器端的Socket對象
        ServerSocket ss = new ServerSocket(11111);

        // 監聽客戶端鏈接
        Socket s = ss.accept();// 阻塞

        // 封裝通道內的流
        BufferedReader br = new BufferedReader(new InputStreamReader(
                s.getInputStream()));
        // 封裝文本文件
        BufferedWriter bw = new BufferedWriter(new FileWriter("Copy.java"));

        String line = null;
        while ((line = br.readLine()) != null) { // 阻塞
        // if("over".equals(line)){
        // break;
        // }
            bw.write(line);
            bw.newLine();
            bw.flush();
        }

        // 給出反饋
        BufferedWriter bwServer = new BufferedWriter(new OutputStreamWriter(
                s.getOutputStream()));
        bwServer.write("文件上傳成功");
        bwServer.newLine();
        bwServer.flush();

        // 釋放資源
        bw.close();
        s.close();
    }
}
//TCP協議上傳圖片，使用字節流

public class UploadServer{
public static void main(String args){
//建立服務器Socket對象
ServerSocket ss=new ServerSocket(19191)；
//監聽客戶端鏈接
Socket s=ss.accept();
//封裝通道內流
BufferedInputStream bis=new BufferedInputStream(s.getInputStream());
//封裝圖片文件
BufferedOutoutStream bos=new BufferedOutputStream{
new FileOutpuutStream("mn.jpg");

byte[] bys=new byte[1024];
int len=0;
while((len=bis.read(bys))!=-1){
bos.write(bys,0,len);
}
//給一個反饋
OutputStream os=s.getOurStream();
os.write("success".getBytes());

bos.close();
s.close();
}
}
}


public class UploadClient{
public static void main(String args){
//建立客戶端Socket對象
Socket s=new Socket("192.168.12.92"),19191);

//封裝圖片文件
BufferedInputStream bis=new BufferedInputStream(new FileInputStrean(a.jpg));
//封裝通道內的流
BufferedOutputStream bos=new BufferedOutputStream(s.getOutputStream());

int len=0;
while((len=bis.read(bys))!=-1){
bos.write(bys,0,len);
bos.flush();//必定要刷新
}

s.shutdownOutput();

//讀取反饋
InputStream is=s.getInputStream();
byte[] bys2=new byte[1024];
int len2=is.read(bys2);
String client=new String(by2,0,len2);
System.out.println(client);

//釋放資源
bis.close();
s.close();


}

}

多個客戶端上傳至一個服務器

it.cast-15
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程