黑马程序员--java基础--网络编程(UDP和TCP)

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

网络编程



网络参考模型图解






各层的用处

开发主要在传输层和网际层。

传输层为：UDP和TCP等，网际层为：IP。

用户在应用层操作的数据，经过逐层封包，最后到物理层发送到另一个模型中，再进行逐层解包

原理图



网络通信三要素：IP地址，端口号，传输协议



UDP特点：

1、面向无连接，即将数据及源和目的封装成数据包中，不建立链接的发送

2、每个数据包的大小限制在64K之内

3、因无连接，是不可靠的协议

4、不建立连接，速度快。

TCP特点：

1、面向连接，在建立连接后，形成传输数据的通道

2、在连接中进行大数据量的传输

3、通过三次握手完成连接，是可靠的协议

4、必须建立连接，效率稍慢

通信步骤

1、找到IP地址国，际组织定义了通用协议，即TCP/IP。

2、数据要发送到对象指定应用程序，即逻辑端口（port）。



Socket机制



UDP传输

DatagramSocket：发送和接收数据包的套接字，即Socket。

步骤

1、发送数据：

a、建立UDPSocket服务，在此无需指定端口，也可以将端口加入。

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

c、通过socket服务的发送功能，将数据包发送出去

d、关闭资源

应用事例

public class UDPSendDemo {

<span style="white-space:pre">	</span>public static void main(String[] args) throws IOException {

<span style="white-space:pre">		</span>System.out.println("发送端启动......");
<span style="white-space:pre">	</span>
<span style="white-space:pre">		</span>//1,udpsocket服务。使用DatagramSocket对象。
<span style="white-space:pre">		</span>DatagramSocket ds = new DatagramSocket(8888);
<span style="white-space:pre">		</span>
<span style="white-space:pre">		</span>//2,将要发送的数据封装到数据包中。
<span style="white-space:pre">		</span>String str = "udp传输演示：哥们来了！";
<span style="white-space:pre">			</span>//使用DatagramPacket将数据封装到的该对象包中。
<span style="white-space:pre">		</span>byte[] buf = str.getBytes();
<span style="white-space:pre">		</span>
<span style="white-space:pre">		</span>DatagramPacket dp = 
<span style="white-space:pre">				</span>new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.100"),10000);
<span style="white-space:pre">				</span>
<span style="white-space:pre">		</span>//3，通过udp的socket服务将数据包发送出去。使用send方法。
<span style="white-space:pre">		</span>ds.send(dp);
<span style="white-space:pre">		</span>
<span style="white-space:pre">		</span>//4，关闭资源。
<span style="white-space:pre">		</span>ds.close();
<span style="white-space:pre">		</span>
<span style="white-space:pre">		</span>
<span style="white-space:pre">	</span>}

}

2、接收数据：

a、定义UDPSocket服务。通常会监听一个端口，其实就是给这个接收网路应用程序定义数字标识，方便于明确哪些数据过来该应用程序可以处理。

b、定义一个数据包，用来存储接收到的字节数据，因为数据包对象中有更多功能可以提取字节数据中的不同数据信息。

c、通过socket服务的receive方法接收到的数据存入已定义好的数据包中

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

e、关闭资源

应用事例

public class UDPReceDemo {
public static void main(String[] args) throws IOException {

System.out.println("接收端启动......");

//1,建立udp socket服务。
DatagramSocket ds = new DatagramSocket(10000);

//2,创建数据包。
byte[] buf = new byte[1024];
DatagramPacket dp = new DatagramPacket(buf,buf.length);

//3,使用接收方法将数据存储到数据包中。
ds.receive(dp);//阻塞式的。

//4，通过数据包对象的方法，解析其中的数据,比如，地址，端口，数据内容。
String ip = dp.getAddress().getHostAddress();
int port = dp.getPort();
String text = new String(dp.getData(),0,dp.getLength());

System.out.println(ip+":"+port+":"+text);

//5,关闭资源。
ds.close();
}
}

TCP传输

TCP分客户端和服务端。

客户端用Socket，服务端用ServerSocket。

原理图



客户端创建

1，创建tcp客户端socket服务。使用的是Socket对象。

建议该对象一创建就明确目的地。要连接的主机。

2，如果连接建立成功，说明数据传输通道已建立。

该通道就是socket流 ,是底层建立好的。 既然是流，说明这里既有输入，又有输出。

想要输入或者输出流对象，可以找Socket来获取。

可以通过getOutputStream(),和getInputStream()来获取两个字节流。

3，使用输出流，将数据写出。

4，关闭资源。

应用事例

public class ClientDemo {

public static void main(String[] args) throws UnknownHostException, IOException {

//创建客户端socket服务。
Socket socket = new Socket("192.168.1.100",10002);

//获取socket流中的输出流。
OutputStream out = socket.getOutputStream();

//使用输出流将指定的数据写出去。
out.write("tcp演示：哥们又来了!".getBytes());

//关闭资源。
socket.close();

}

}

服务端创建

1，创建服务端socket服务。通过ServerSocket对象。

2，服务端必须对外提供一个端口，否则客户端无法连接。

3，获取连接过来的客户端对象。

4，通过客户端对象获取socket流读取客户端发来的数据

并打印在控制台上。

5，关闭资源。关客户端，关服务端。

应用事例

public class ServerDemo {

public static void main(String[] args) throws IOException {
//		服务端接收客户端发送过来的数据，并打印在控制台上。
//1创建服务端对象。
ServerSocket ss = new ServerSocket(10002);

//2,获取连接过来的客户端对象。
Socket s = ss.accept();//阻塞式.

String ip = s.getInetAddress().getHostAddress();

//3，通过socket对象获取输入流，要读取客户端发来的数据
InputStream in = s.getInputStream();

byte[] buf = new byte[1024];

int len = in.read(buf);
String text = new String(buf,0,len);
System.out.println(ip+":"+text);

s.close();
ss.close();

}

}

小练习

客户端输入字母数据，发送给服务端，服务端收到后显示在控制台，并将该数据转成大写返回给客户端，直到客户端输入over.转换结束. 创建一个英文大写转换服务器.

客户端

public class TransClient {

public static void main(String[] args) throws UnknownHostException, IOException {

/*
* 思路：
* 客户端：
* 1，需要先有socket端点。
* 2，客户端的数据源：键盘。
* 3，客户端的目的：socket.
* 4，接收服务端的数据，源：socket。
* 5，将数据显示在打印出来：目的：控制台.
* 6，在这些流中操作的数据，都是文本数据。
*
*
* 转换客户端:
* 1,创建socket客户端对象。
* 2,获取键盘录入。
* 3，将录入的信息发送给socket输出流。
*/

//1,创建socket客户端对象。
Socket s = new Socket("192.168.1.100",10004);

//2，获取键盘录入。
BufferedReader bufr  =
new BufferedReader(new InputStreamReader(System.in));

//3,socket输出流。

PrintWriter out = new PrintWriter(s.getOutputStream(),true);

//4,socket输入流，读取服务端返回的大写数据
BufferedReader bufIn  = new BufferedReader(new InputStreamReader(s.getInputStream()));

String line = null;

while((line=bufr.readLine())!=null){

if("over".equals(line))
break;

out.println(line);

//读取服务端发回的一行大写数。
String upperStr = bufIn.readLine();
System.out.println(upperStr);
}

s.close();

}

}

服务端

<span style="font-family:SimSun;">public class TransServer {

public static void main(String[] args) throws IOException {

/*
*
* 转换服务端。
* 分析：
* 1，serversocket服务。
* 2，获取socket对象。
* 3，源：socket，读取客户端发过来的需要转换的数据。
* 4，目的：显示在控制台上。
* 5，将数据转成大写发给客户端。
*/

//1,
ServerSocket ss = new ServerSocket(10004);

//2,获取socket对象。
Socket s = ss.accept();

//获取ip.
String ip = s.getInetAddress().getHostAddress();
System.out.println(ip+"......connected");

//3,获取socket读取流，并装饰。
BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));

//4,获取socket的输出流，并装饰。
PrintWriter out = new PrintWriter(s.getOutputStream(),true);

String line = null;
while((line=bufIn.readLine())!=null){

System.out.println(line);
out.println(line.toUpperCase());
}

s.close();
ss.close();

}

}</span>

单线程的服务端局限性：当A客户端连接上以后，被服务端获取到。服务端执行具体流程。这时B客户端连接，只能等待，这时获取不到B客户端对象。

那么为了可以让多个客户端同时并发访问服务端。服务端最好就是将每个客户端封装到一个单独的线程中，这样，就可以同时处理多个客户端请求。

解决方法 ：只要明确了每一个客户端要在服务端执行的代码，将该代码存入run方法即可。

小练习2

客户端上传图片到服务端

客户端创建

public class UploadPicClient {

public static void main(String[] args) throws UnknownHostException, IOException {

//1,创建客户端socket。
Socket s = new Socket("192.168.1.100",10006);

//2,读取客户端要上传的图片文件。
FileInputStream fis = new FileInputStream("c:\\0.bmp");

//3,获取socket输出流，将读到图片数据发送给服务端。
OutputStream out = s.getOutputStream();

byte[] buf = new byte[1024];

int len = 0;

while((len=fis.read(buf))!=-1){
out.write(buf,0,len);
}

//告诉服务端说：这边的数据发送完毕。让服务端停止读取。
s.shutdownOutput();

//读取服务端发回的内容。
InputStream in  = s.getInputStream();
byte[] bufIn = new byte[1024];

int lenIn = in.read(buf);
String text = new String(buf,0,lenIn);
System.out.println(text);

fis.close();
s.close();

}

}

服务端创建之前先创建一个UploadTask方法类

public class UploadTask implements Runnable {

private static final int SIZE = 1024*1024*2;
private Socket s;

public  UploadTask(Socket s) {
this.s = s;
}

public void run() {

int count = 0;
String ip = s.getInetAddress().getHostAddress();
System.out.println(ip + ".....connected");

try{

// 读取客户端发来的数据。
InputStream in = s.getInputStream();

// 将读取到数据存储到一个文件中。
File dir = new File("c:\\pic");
if (!dir.exists()) {
dir.mkdirs();
}
File file = new File(dir, ip + ".jpg");
//如果文件已经存在于服务端
while(file.exists()){
file = new File(dir,ip+"("+(++count)+").jpg");
}

FileOutputStream fos = new FileOutputStream(file);

byte[] buf = new byte[1024];

int len = 0;

while ((len = in.read(buf)) != -1) {

fos.write(buf, 0, len);

if(file.length()>SIZE){
System.out.println(ip+"文件体积过大");

fos.close();
s.close();

System.out.println(ip+"...."+file.delete());

return ;
}
}

// 获取socket输出流，将上传成功字样发给客户端。
OutputStream out = s.getOutputStream();
out.write("上传成功".getBytes());

fos.close();
s.close();
}catch(IOException e){

}

}

}

客户端创建

public class UploadPicServer {

public static void main(String[] args) throws IOException {

//创建tcp的socket服务端。
ServerSocket ss = new ServerSocket(10006);

while(true){
Socket s = ss.accept();

new Thread(new UploadTask(s)).start();

}

}

}