java17-网络编程

------- android培训、java培训、期待与您交流！
----------

概念

网络通讯要素有

IP地址：InetAddress对象

网络中设备的标识

IP不易记忆，可用主机名

127.0.0.1:本地回环地址

端口

标识进程的逻辑地址，区分不同进程

有效端口：0到65535，0到1024系统使用或保留

传输协议

通讯规则

常用TCP和UDP

TCP面向无连接，将数据及源和目的封装成数据包中，包大小限定６４K，速度快，会丢包，不可靠协议

UDP

UDP

建立连接，形成传输数据通道，在连接通道中进行大数据量传输，通过三次握手完成连接，可靠协议，要建立连接，效率稍低。

Socket（DatagramSocket）

为网络服务提供的一种机制，两端都有Socket。数据在两个Socket间通过IO传输

网络参考模型

OSI参考模型

应用层，

表示层，

会话层。

传输层。

网络层。

数据链路层，

物理层。

TCP/IP参考模型

应用层。

传输层。

网络层。

主机至网络层

通过UDP传输方式，将文件发送出去。

1，建立UdpSocket服务

2，提供数据，并将数据封装到数据包中

3，通过socket服务的发送功能，把数据发送出去

4，关闭资源

 UDP接收

1，定义UDPSocket服务，监听一个端口，相当于给程序添加个标识，确定接收哪些数据

2，定义一个数据包，因为要存储接收到的字节数据。

数据包对象中有更多功能可以提取字节数据中的不同数据信息 

3，通过Socket服务的receive方法将收到的数据存入已经定义好的数据包中

4，通过数据包对象的特有功能，将这些不同的数据取出，打印到控制台上

5，关闭资源

TCP服务器客户端

Socket和ServerSocket

建立客户端Socket和服务端ServerSocket，

建立连接后，通过Socket中的IO流传递数据

关闭Socket

TCP

客户端和服务端都在等待机，是因为Socket中的流都是阻塞式的方法。这些方法没有读到结束标记时，就会一直等待。而导致两边都在等待。

传送文件时，文件结束需要标记。

s.shutdownOutput();结束标记

 服务端

 1.建立服务端的socket，ServerSocket（）并监听一个端口

　2，获取连接过来的客户端，通过ServerSocket的accept方法，没有连接时会等待，方法是阻塞式的

 3，客户端如果发来数据，服务端要使用对应的客户端对象，

 并获取客户端对象的读取流来读取发来的数据，打印在控制台上

 4.关闭服务端（可选操作）

客户端

 1,开启Socket服务，指定要连接的主机和端口

 2，获取Socket中的输出流，数据写入流中，发送数据

 3，获取socket中的输入流，接收数据，打印

 4，关闭客户端资源 

/*

IP地址获取

InetAddress类中没有构造函数，静态方法获取本类对象

*/

import java.net.InetAddress;

class IaDemo
{
public static void main(String[] args)throws Exception
{
//返回本机
InetAddress id = InetAddress.getLocalHost();
//指定主机名
InetAddress i = InetAddress.getByName("www.baidu.com");
//获取IP，主机名
System.out.println("address:"+i.getHostAddress());
System.out.println("name"+i.getHostName());

}
}
/*
多线程UDP发送接收
*/

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.io.InputStreamReader;
import java.io.BufferedReader;

class Send implements Runnable
{
private DatagramSocket ds;

public Send(DatagramSocket ds)
{
this.ds = ds;
}
public void run()
{
try
{

//建立缓冲，存储键盘输入数据
BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));

String line = null;

while((line=bufr.readLine())!=null)
{
//打到88结束
if("88".equals(line))
break;
byte[] buf = line.getBytes();
//确定数据，并封装成数据包DatagramPacket
DatagramPacket dp = new DatagramPacket(buf,buf.length,InetAddress.getByName("127.0.0.1"),10000);
//通过socket服务，将已有数据包发送出去，通过send方法
ds.send(dp);
}
}
catch(Exception e)
{
throw new RuntimeException("发送端失败");

}

//关闭资源
ds.close();
}
}
class Rece implements Runnable
{
private DatagramSocket ds;
public Rece(DatagramSocket ds)
{
this.ds = ds;
}

public void run()
{
try
{

while(true)
{
byte[] buf = new byte[1024];
//定义数据包，用于存储数据
DatagramPacket dp = new DatagramPacket(buf,buf.length);
//接受数据
ds.receive(dp);
//IP转字符
String ip = dp.getAddress().getHostAddress();
//数据转字符
String data = new String(dp.getData(),0,dp.getLength());
//打印数据
System.out.println(ip+"::"+data);

}
}
catch(Exception e)
{
throw new RuntimeException("接收失败");

}

}
}

/**
* 1,开启Socket服务，指定要连接的主机和端口
* 2，获取Socket中的输出流，数据写入流中，发送数据
* 3，获取socket中的输入流，接收数据，打印
* 4，关闭客户端资源
*
* */
class Tcpk
{
public static void main(String[] args)throws Exception
{
//创建客户端的socket服务，指定目的主机和端口
Socket s = new Socket("127.0.0.1",10002);
//要发送数据，应该获取socket流中的输出流
OutputStream out = s.getOutputStream();
//数据转成字节数组传递
out.write("tcp,gemeilaile".getBytes());
//获取socket中的输入流，接收数据，打印
InputStream in = s.getInputStream();
byte[] buf = new byte[1024];
int len = in.read(buf);

System.out.println(new String(buf,0,len));

//关闭Socket，同时关闭了Socket中的流
s.close();

}
}
/**
* 服务端
* 1.建立服务端的socket，ServerSocket（）并监听一个端口
* 2，获取连接过来的客户端，通过ServerSocket的accept方法，没有连接时会等待，方法是阻塞式的
* 3，客户端如果发来数据，服务端要使用对应的客户端对象，
* 并获取客户端对象的读取流来读取发来的数据，打印在控制台上
* 4.关闭服务端（可选操作）
*
* */

class TcpF
{
public static void main(String[] args)throws Exception
{
//建立服务端socket服务，并且监听一个端口
ServerSocket ss = new ServerSocket(10002);
//通过accept方法获取连接过来的客户端对象

Socket s = ss.accept();
//客户端ip
String ip = s.getInetAddress().getHostAddress();

//获取客户端发送过来的数据，
//要使用客户端对象的读取流来读取数据
InputStream in = s.getInputStream();

byte[] buf = new byte[1024];
//字节数据转成字符打印
int len = in.read(buf);

System.out.println(new String(buf,0,len));
OutputStream out = s.getOutputStream();
out.write("你也好".getBytes());

//关闭客户端
s.close();
}
}

TCP

import java.io.*;
import java.net.*;

/**
* 需求：建立一个文本转换服务器，把客户端发来的文本转成大写返回
* 可以不断进行转换，over时，结束
*
* 操作设备上的数据，可以使用IO流，
* 源自键盘录入
* 目的：服务器，网络设备，网络输出流
* 操作的是文本数据，可以用字符流
*
* 1，建立Socket服务
* 2，获取键盘录入
* 3，将数据
4000
发给服务端
* 4，接收服务端返回的数据
* 5.结束，关闭
* 文本数据，可用字符流，加入缓冲，提高效率
*
*
*
* */

class Transk
{
public static void main(String[] args)throws Exception
{
Socket s = new Socket("127.0.0.1",10005);
//定义读取键盘录入的流对象
BufferedReader bufr =
new BufferedReader(new InputStreamReader(System.in));
//定义目的，将数据写入Socket输出流，发送
BufferedWriter bufwOut =
new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
//定义Socket读取流，读取服务端返回的数据
BufferedReader bufIn =
new BufferedReader(new InputStreamReader(s.getInputStream()));
String line = null;

while((line=bufr.readLine())!=null)
{
if("over".equals(line))
break;
bufwOut.write(line);
//加入换行，并刷新
bufwOut.newLine();
bufwOut.flush();
//读取大写
String str = bufIn.readLine();

System.out.println("D:"+str);

}
}
}

import java.io.*;
import java.net.*;

/**
* 服务端
* 源：Socket读取流
* 目的：Socket输出流
* 文本，装饰
*
*
* */

class Transf
{
public static void main(String[] args) throws Exception
{
ServerSocket ss = new ServerSocket(10005);

Socket s = ss.accept();
//读取socket读取流中的数据
String ip = s.getInetAddress().getHostAddress();

System.out.println(ip+"...IP");
BufferedReader bufIn =
new BufferedReader(new InputStreamReader(s.getInputStream()));
//目的，Socket输出流，将大写数据写入到Socket输出流，并发送
BufferedWriter bufOut =
new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
//输入流中数据转成大写写入输出流
String line = null;
while((line=bufIn.readLine())!=null)
{
bufOut.write(line.toUpperCase());

bufOut.newLine();
bufOut.flush();

}
//关闭资源
s.close();
ss.close();
}
}



------- android培训、java培训、期待与您交流！
----------