黑马程序员_网络编程

乔小杰

于 2012-09-08 16:30:36 发布

阅读量398

点赞数 1

分类专栏：黑马学习日记

本文链接：https://blog.csdn.net/qiaoyuji/article/details/7731149

版权

黑马学习日记专栏收录该内容

3 篇文章 0 订阅

订阅专栏

网络模型

层次的划分（谁谁谁是干什么的，走哪层）

OSI参考模型---应用层，表示层，会话层，传输层（TCP,UDP），网络层(ip地址)，数据链路层，物理层（光纤，网线，蓝牙，红外）
TCP/IP参考模型---应用层，传输层，网际层，主机至网络层

数据封包：按照每一层的不同加入每一层特有的信息。

网络通信要素

ip地址

网络中设备的标识
不易记忆，可用主机名
本地回环地址：127.0.0.1，主机名：localhost

端口号

用于标识自称的逻辑地址，不同进程的标识
有效端口：0~65535，其中0~1024系统使用或保留端口

mySQL 3306 http 80 tomcat 8080

传输协议

通信的规则
常见协议：TCP,UDP

java.net包

类 InetAddress

String getHostAddress()
返回 IP 地址字符串（以文本表现形式）。

`String`	`getLocalHost()` 返回 IP 地址字符串（以文本表现形式）。
`String`	`getHostName()` 获取此 IP 地址的主机名。
`static InetAddress`	`getLocalHost()` 返回本地主机。

static InetAddress getByName(String host)
在给定主机名的情况下确定主机的 IP 地址。

static InetAddress[] getAllByName(String host)
在给定主机名的情况下，根据系统上配置的名称服务返回其 IP 地址所组成的数组。

异常：UnknownHostException

package cn.itcast.day4;

import java.net.InetAddress;
import java.net.UnknownHostException;

public class InetAddressDemo {

	public static void main(String[] args) throws UnknownHostException{
		//获取本地主机地址对象
		InetAddress i = InetAddress.getLocalHost();
		System.out.println(i.toString());
		//分别获取主机名和主机地址
		System.out.println(i.getHostName()+"："+i.getHostAddress());
		
		//获取任意一台主机地址
		InetAddress ia = InetAddress.getByName("www.baidu.com");
		System.out.println(i.getHostName()+"："+i.getHostAddress());
		
		//获取主机名对应的多个主机地址对象，一个域名对应多个IP
		InetAddress[] iarr = InetAddress.getAllByName("www.baidu.com");
		for(InetAddress id:iarr){
			System.out.println(id.getHostName()+"："+id.getHostAddress());
		}
		
	}

}

TCP和UDP

UDP

将数据及源和目的封装成数据包中，不需要建立连接
每个数据包的大小限制在64k内
因无连接，是不可靠协议
不需要建立连接，速度快

TCP

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

Socket

Socket就是为网络服务提供的一种机制。
通信的两端都有Socket
网络通信其实就是socket见的通信。
数据在两个socket间通过IO流传输。
插座的概念。也可以理解为港口，码头，想要船输（数据传输）就要有港口（Socket）。

UDP传输

DatagramSocket与DatagramPacket
建立发送端，接收端。
建立数据包。
调用Socket的发送接收方法。
关闭Socket
发送端与接收端是两个独立的运行程序。

UDP的Socket服务建立：

类 DatagramPacket此类表示数据报包。数据报包用来实现无连接包投递服务。

构造方法：

DatagramPacket(byte[] buf, int length)
构造 DatagramPacket，用来接收长度为 length 的数据包。

DatagramPacket(byte[] buf, int length, InetAddress address, int port)
构造数据报包，用来将长度为 length 的包发送到指定主机上的指定端口号。

类 DatagramSocket 此类表示用来发送和接收数据报包的套接字。

方法：

`void`	`receive(DatagramPacket p)` 从此套接字接收数据报包。
`void`	`send(DatagramPacket p)` 从此套接字发送数据报包。

UDP发送端

需求：通过udp传输方式，将一段文字数据发送出去。
思路：
1，建立udpsocket服务。
2，提供数据，并将数据封装到数据包中。
3，通过socket服务的发送功能，将数据包发出去。
4，关闭资源。

package cn.itcast.day4;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

public class UdpSend {


	public static void main(String[] args) throws Exception{
		// 1，创建udp服务，通过DatagramSocket对象
		DatagramSocket ds = new DatagramSocket();
		//2，确认数据，并封装成数据包，通过DatagramPacket
		byte[] buf = "ni hao heima".getBytes();
		DatagramPacket dp = new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.0.2"),10000);
		//3,通过socket服务将已有的数据包发送出去
		ds.send(dp);
		//关闭资源
		ds.close();
		
	}

}

UDP接收端

需求：定义一个应用程序，用于接收udp协议传输数据并处理。

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

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

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

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

3，关闭资源。

package cn.itcast.day4;

import java.net.DatagramPacket;
import java.net.DatagramSocket;

public class UdpRece {

	
	public static void main(String[] args)throws Exception {
		//1，创建udp socket，建立端口
		DatagramSocket ds = new DatagramSocket(10000);
		
		//2，定义数据包，用于存储数据。
		byte[] buf = new byte[1024];
		DatagramPacket dp = new DatagramPacket(buf,buf.length);
		
		//3，通过服务的receive方法将收到的数据存入数据包中。
		ds.receive(dp);
		
		//关闭资源
		ds.close();
		
		//4，通过数据包的方法获取其中的数据。
		String ip = dp.getAddress().getHostAddress();
		
		String data = new String(dp.getData(),0,dp.getLength());
		
		int port = dp.getPort();
		
		System.out.println(ip+":"+data+":"+port);
		
		//关闭资源
		ds.close();
		
	}

}

注意：服务只能建立一次，不能放在while(true)中，会出现绑定异常 BindException,因为端口已经被占用

网络聊天-Upd聊天

code.....

TCP传输

Socket和ServerSoke

TCP分客户端和服务端。

客户端对应的对象是Socket。服务端对应的对象是ServerSocket

TCP传输原理图：

需求：给服务端发送一个文本数据

客户端：

该对象建立时，就可以去连接指定主机。

因为tcp是面向连接的，所以在建立socket服务时，就要有服务端存在，并连接成功。形成通路后，在该通道进行数据的传输。

步骤：

1，创建socket服务，并指定要连接的主机和端口。

2，获取socket流中的输出流，通过getOutpuutStream

3，通过输出流的write方法把要写的数据写进流中

4，关闭socket服务

import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
public class TcpDemo {

	public static void main(String[] args)throws IOException{
		//创建客户端的socket服务，指定目的主机和端口。
		Socket s = new Socket("192.168.1.113",11000);
		
		//为了发送数据，应该获取socket流中的输出流		
		OutputStream out = s.getOutputStream();
		
		out.write("你好啊，表妹".getBytes());
		
		s.close();		
	}
}

需求：定义端点接收数据并打印在控制台上。

服务端：

1，建立服务端的socket服务，ServerSocket()；并监听一个端口。

2，获取连接过来的客户端对象。通过ServerSocket的 accept方法。没有连接就会等，所以这个方法阻塞式的。

3，客户端如果发过来数据，那么服务端要使用对应的客户端对象，并获取到该客户端对象的读取流来读取发过来的数据。

并打印在控制台上。

4，关闭获取到的客户端对象，因为一直连着会占用资源，

5，关闭服务端。（可选）服务端可以一直开着，不能只服务一次就关掉

class ServerSocketDemo{
	public void main(String[] args)throws IOException{
		//创建服务端的ServerSocket服务
		ServerSocket ss = new ServerSocket(11000);
		
		//获取连接过来的客户端对象，通过accept方法
		Socket socket = ss.accept();
		
		String ip = socket.getInetAddress().getHostAddress();
		System.out.println(ip+".....connected");
		//获取客户端发送过来的数据,那么要使用客户端对象的读取流来读取数据。
		InputStream in = socket.getInputStream();
		
		byte[] buf = new byte[024];
		int len = in.read(buf);
		
		System.out.println(new String(buf,0,len));
		
		socket.close();
//		ss.close();
		
	}
}

需求：建立一个文本转换服务器。

客户端给服务器发送文本，服务端会将文本装换成大写在返回给客户端。

而且客户端可以不断的进行文本转换。当客户端输入over时，转换结束。

分析：

客户端：

既然是操作设备上的数据，那么久可以使用io技术，并按照io操作规则来思考。

源：键盘录入。

目的：网络设备，网络输出流。

而且操作的是文本数据，可以选择字符流。这就用到了字符缓冲流。

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;

public class TcpDemo3 {

	public static void main(String[] args) throws Exception{
		Socket socket = new Socket("192.168.1.102",10001);
		//键盘读取流
		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));	
		//网络输出流,别忘了加true ，自动刷新
		PrintWriter out	= new PrintWriter(socket.getOutputStream(),true);
		//网络读取流
		BufferedReader bufIn = new BufferedReader(new InputStreamReader(socket.getInputStream()));
		String line = null;
		while((line=in.readLine())!=null){

			out.println(line);
			if("over".equals(line))
				break;
			System.out.println(bufIn.readLine());
		}
		in.close();
		socket.close();
	}
}

public class TransServer {

	public static void main(String[] args) throws Exception{
		ServerSocket ss = new ServerSocket(10001);
		Socket socket = ss.accept();
		System.out.println(socket.getInetAddress().getHostAddress()+"连接成功");
		BufferedReader bufIn = new BufferedReader(new InputStreamReader(socket.getInputStream()));
		PrintWriter out = new PrintWriter(socket.getOutputStream(),true);
		String line	= null;
		while((line=bufIn.readLine())!=null){

			if("over".equals(line))
				break;
			out.println(line.toUpperCase());
		}
		socket.close();
		ss.close();
	}
}

该例子出现的问题。

现象：客户端和服务端都是在莫名的等待。

为什么呢？

因为客户端和服务端都有阻塞式方法。这些方法没有读到结束标记。那么就一直等

而导致两端都在等待。

需求：TCP上传文件练习。（不涉及多线程）

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;

public class UploadClient {

	public static void main(String[] args) throws Exception{
		Socket socket = new Socket("192.168.1.108",10000);

		BufferedReader bufr = new BufferedReader(new InputStreamReader(new FileInputStream("D:\\workspace\\javaenhance\\src\\cn\\itcast\\day4\\ChatDemo.java"),"utf-8"));
	
		BufferedWriter bufOut = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
		PrintWriter out = new PrintWriter(bufOut,true);
		BufferedReader bufIn = new BufferedReader(new InputStreamReader(socket.getInputStream()));		
		String line = null;
		while((line = bufr.readLine())!=null){
			out.println(line);
		}
		socket.shutdownOutput();
		
		String info = bufIn.readLine();
		System.out.println(info);			
		bufr.close();		
		socket.close();	
	}
}



class TextServer {


	public static void main(String[] args) throws Exception{
		ServerSocket ss = new ServerSocket(10000);
		Socket socket = ss.accept();
		String ip =socket.getInetAddress().getHostAddress();
		System.out.println(ip+"...连接成功");
		
		BufferedReader bufIn = new BufferedReader(new InputStreamReader(socket.getInputStream()));
		
		PrintWriter out = new PrintWriter(new FileWriter("E:\\Chat.java"),true);
		PrintWriter bufOut = new PrintWriter(socket.getOutputStream(),true);
		String line = null;
		while((line=bufIn.readLine())!=null){
			out.println(line);
		}
		
		bufOut.println("上传成功");
		
		out.close();
		socket.close();
		
		ss.close();
	}
}

解决网络编程中客户端和服务端等待没响应的问题：

IO流在读写数据的时候会出现等待的现象。这时因为流在读取和写入的时候有阻塞式方法，read和write、print、println等

解决一:
总结：只有读硬盘上的文件时候才会自动返回结束标记，读键盘或者内存，都要手动给定结束标记。在使用TCP协议给服务器上传网络资源的时候最容易出现这种等待现象，解决办法就是在客户端写入输出流之后再写入一个结束标记，这个结束标记可以通过socket对象调用shutdownOutput()方法，这个方法内部就是返回了一个结束标记。

解决二:
1、还有一种方法就是在写入输出流之前，先写入一段结束标记，通常写入时间戳，long l = System.currentTimeMillis获取时间,通过调用基本数据读取流DataOutputStream的writeLong方法，把l写进输出流。
2，然后服务器读取这个时间戳并记下。
3，客户端发送完数据之后，再次写入这个时间戳，服务端判断到时间戳即结束读取。

TCP客户端并发上传图片

乔小杰

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
黑马程序员_网络编程

网络模型层次的划分（谁谁谁是干什么的，走哪层）OSI参考模型---应用层，表示层，会话层，传输层（TCP,UDP），网络层(ip地址)，数据链路层，物理层（光纤，网线，蓝牙，红外）TCP/IP参考模型---应用层，传输层，网际层，主机至网络层数据封包：按照每一层的不同加入每一层特有的信息。网络通信要素ip地址网络中设备的标识不易记忆，可用主机名本地回环地址：
复制链接

扫一扫