-----------android培训、java培训、java学习型技术博客、期待与您交流！------------
（一）概述
1、网络模型：OSI参考模型和TCP/IP参考模型
图示：
一般来说开发处于传输层和网际层，应用层为：FTP和HTTP协议等，传输层为：UDP和TCP等，网际层为：IP。
通常用户操作的是应用层，而编程人员需要做的是传输层和网际层，用户在应用层操作的数据，经过逐层封包，最后到物理层发送到另一个模型中，再进行逐层解包，图示为：
2、网络通信三要素：IP地址，端口号，传输协议
A、IP地址
a、它是网络中的设备标识
b、不易记忆，可用主机名表示，两者存在映射关系
c、本机回环地址：127.0.0.1，主机名为：localhost。
IP地址：java中对应的是InetAddress类，存在于java.net包中。
InetAddress类：
（一）无构造函数，可通过getLocalHost()方法获取InetAddress对象，此方法是静态的，返回本类对象。
InetAddress i = InetAddress.getLocalHost();
（二）方法：
1）static InetAddress getByName(String host)：获取指定主机的IP和主机名。（最好用ip地址去获取，主机名需要解析）
2）static InetAddress[] getAllByName(String host)：在给定主机名的情况下，根据系统上配置的名称服务返回IP地址所组成的数组。返回对象不唯一时，用此方法。
3）String getHostAddress()：返回IP地址字符串文本形式，以IP地址为主。
4）String getHostName()：返回IP地址主机名。
（三）如何获取任意一台主机的IP地址对象：
1）功能：返回InetAddress对象
2）对于任意主机，需要指定传入主机名的参数
注意：如果IP地址和对应的主机名，这种映射关系没有在网络上，就不会解析成功，返回的还是指定的IP。
B、端口号：
a、用于标识进程的逻辑地址，不用进程的标识。
b、有效端口：0 ~65535，系统使用或保留的端口是：0~ 1024。
C、传输协议：
即通信规则，包含TCP和UDP协议
UDP
是面向无连接，明确了对方的端口，无论在不在网上，只管传输，不在就会丢失数据。只求速度，应用于网络视频会议和聊天等应用程序中。
协议特点：
a、面向无连接，即将数据及源和目的封装成数据包中，不建立链接的发送
b、每个数据包的大小限制在64K之内
c、因无连接，是不可靠的协议
d、不建立连接，速度快。
TCP
是面向连接的，必须连接成功才能传输数据，应用于下载等程序上
协议特点：
a、面向连接，在建立连接后，形成传输数据的通道
b、在连接中进行大数据量的传输
c、通过三次握手完成连接，是可靠的协议
d、必须建立连接，效率稍慢
三次握手：第一次本方发送请求，第二次对方确认连接，第三次本方再次确认连接成功。
3、通信的步骤：
1）找到IP地址
2）数据要发送到对象指定应用程序，为标识这些应用程序，所以给这些网络应用程序都用数字标识，为方便称呼这个数字，叫做端口，即逻辑端口。
3）定义通信规则，称之为协议。国际组织定义了通用协议，即TCP/IP。
注意：必须要有数字标识才能将数据发送到应用程序上。
（二）传输协议
一、Socket
1、它被称之为插座，相当于港口一样，是网络服务提供的一种机制。
2、通信两端都要有Socket，才能建立服务。
3、网络通信其实就是Socket间的通信，数据在两个Socket间通过IO传输。
二、UDP传输
1、通过类DatagramSocket，此类表示用发送和接收数据包的套接字，即Socket。
2、方法：
1）创建 UDPSocket发送服务对象：
DatagramSocket()，不指定端口。DatagramSocket(int port)，指定端口。
2）发送：void send(DatagramPacket p)
3）接收：void receive(DatagramPacket p)
其中DatagramPacket：数据报包用来实现无连接包投递服务的，每条报文仅根据该包中包含的信息从一台机器路由到另一台机器中。凡是带地址（InetAddress）的都是用于发送包的。
3、步骤
1）发送数据：
a、建立UDPSocket服务，在此无需指定端口，也可以将端口加入。如果不指定的话，系统会随机分配一个端口，如第一次运行时端口为1093，那么第二次就会顺延为1094，再运行会一直顺延，因为之前的端口还没有得到释放，所以会顺延端口号值。
b、提供数据，并将数据封装到数据包中
c、通过socket服务的发送功能，将数据包发送出去
d、关闭资源
2）接收数据：
a、定义UDPSocket服务。通常会监听一个端口，其实就是给这个接收网路应用程序定义数字标识，方便于明确哪些数据过来该应用程序可以处理。
b、定义一个数据包，用来存储接收到的字节数据，因为数据包对象中有更多功能可以提取字节数据中的不同数据信息。
c、通过socket服务的receive方法接收到的数据存入已定义好的数据包中
d、通过数据包对象的特有功能，将这些不同的数据取出，打印在控制台上
e、关闭资源
在定义接收数据的方法中，仍会在DatagramSocket构造函数中传入DatagramPacket的参数，这是因为收到的数据太多，需要解析，通过将数据封装成对象，易于解析，所以需要传入参数。
注意：
1、发送端与接收端是两个独立的运行程序。
2、在发送端，要在数据包对象中明确目的地IP及端口。
3、在接收端，要指定监听的端口。
练习：
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
public class UdpDategramPacket {
public static void main(String[] args) throws Exception {
//創建发送端socket对象
DatagramSocket ds= new DatagramSocket();
//数据打包
String s1="jiayou";
byte[] ch=s1.getBytes();
//
InetAddress i=InetAddress.getByName("127.0.0.1");
int Port=12306;
DatagramPacket dp=new DatagramPacket(ch,ch.length,i, Port);
//发送数据包
ds.send(dp);
ds.close();
}
}
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
public class UdpDategramSocket {
public static void main(String[] args)throws Exception{
//创建接受包对象
DatagramSocket ds=new DatagramSocket(12306);
BufferedOutputStream bs=new BufferedOutputStream(new FileOutputStream("f:\\c.txt"));//创建输出流对象
//创建数据接收器（包）
byte[] b=new byte[1024];
DatagramPacket dp=new DatagramPacket(b,b.length);
//调用接受方法
ds.receive(dp);
//解析数据包
InetAddress ia=dp.getAddress();
int i=dp.getPort();
String s=ia.getHostAddress();
System.out.println(s+" "+i);
//存数据
byte[] by=dp.getData();
int in=dp.getLength();
bs.write(by, 0, in);
bs.flush();
String ss=new String(by,0,in);
System.out.println(ss);
//释放资源
ds.close();
}
}
三、TCP传输
1、TCP分客户端和服务端。客户端对应的对象是Socket，服务端对应的对象是ServerSocket。
2、方法：
1）创建客户端对象：
Socket()：创建空参数的客户端对象，一般用于服务端接收数据
Socket(String host,int port)，指定要接收的IP地址和端口号
2）创建服务端对象：ServerSocket(int port)：指定接收的客户端的端口
3）Socket accept()：监听并接受到此套接字的连接
4）void shutdownInput()：此套接字的输入流至于“流的末尾”
5）void shutdownOutput()：禁用此套接字的输出流
6）InputStream getInputStream()：返回此套接字的输入流，Socket对象调用
7）OutputStream getOutputStream()：返回套接字的输出流，Socket对象调用
3、基本思路
客户端：
1）客户端需要明确服务器的ip地址以及端口，这样才可以去试着建立连接，如果连接失败，会出现异常。
2）连接成功，说明客户端与服务端建立了通道，那么通过IO流就可以进行数据的传输，而Socket对象已经提供了输入流和输出流对象，通过getInputStream(),getOutputStream()获取即可。
3）与服务端通讯结束后，关闭Socket。
服务端：
1）服务端需要明确它要处理的数据是从哪个端口进入的。
2）当有客户端访问时，要明确是哪个客户端，可通过accept()获取已连接的客户端对象，并通过该对象与客户端通过IO流进行数据传输。
3）当该客户端访问结束，关闭该客户端。
4、步骤
客户端：
通过查阅Socket对象的API文档，发现在该对象在建立时，就可去连接指定主机，因为TCP是面向连接的，所以在建立Socket服务时，就要有服务端存在，并连接成功，形成通路后，再通过该通道进行数据的传输。
1）创建Socket服务，并指定要连接的主机端口。通路一建立，就会产生Socket流（包括输入流和输出流），通过方法获取
2）为了发送数据，应获取Socket中的输出流，如果要接收服务端的反馈信息，还需要获取Socket的输入流
3）通过输出流的write()方法将要发送的数据写入到流中
4）关闭Socket流资源
服务端：
服务器套接字等待请求通过网络传入。它基于该请求执行某些操作，然后可能向请求者返回结果。需监听一个端口。
1）建立服务端的Socket服务，并监听一个端口。通过ServerSocet带端口参数的构造函数
2）获取连接过来的客户对象，通过ServerSocket的accept()方法，此方法是阻塞式的，如果服务端没有连接到就会一直等待
3）客户端如果发过来数据，则服务端要使用对应的客户端对象，并获取到该客户端对象的读取流读取发过来的数据，并输出到指定目的地。
4）关闭服务端（可选）。一般服务端是常开的，因为在实际应用中，随时有客户端在请求连接和服务。但这里需要定时关闭客户端对象流，避免某一个客户端长时间占用服务器端。
练习：
import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.Socket;
public class TcpSocket {
public static void main(String[] args) throws Exception{
//創建客戶端對象
Socket s=new Socket("127.0.0.1",12306);
//獲取輸出字節流
OutputStream os=s.getOutputStream();
//BufferedReader br=new BufferedReader(new FileReader(""));//讀取的是文件 、、字符類型
BufferedInputStream bis=new BufferedInputStream(new FileInputStream("f:\\tu.mp4")); //讀取的是文件 、、字節類型 囊括所有的文件 一般用他
//高效的方法
byte[] byt=new byte[1024];
int len=0;
while((len=bis.read(byt))!=-1){
os.write(byt, 0, len);
os.flush();
}
s.shutdownOutput();
//获取反馈
//InputStream is=s.getInputStream();
BufferedReader br=new BufferedReader(new InputStreamReader(s.getInputStream()));
String ss=br.readLine();
System.out.println(ss);
bis.close();
s.close();
}
}import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedWriter;
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;
import java.net.ServerSocket;
import java.net.Socket;
public class TcpServerSocket {
public static void main(String[] args) throws Exception {
//创建服务器对象
ServerSocket ss=new ServerSocket(12306); //接受端口
while(true){
//监听客户端
Socket s=ss.accept();
//获取輸入字节流
//InputStream is=s.getInputStream(); //读的是传来的字节流
BufferedInputStream bis=new BufferedInputStream(s.getInputStream());
BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("f:\\c.mp4"));
byte[] byt=new byte[1024];
int len=0;
while((len=bis.read(byt))!=-1){
bos.write(byt, 0, len);
bos.flush();
}
//反馈信息给客户端
//OutputStream os=s.getOutputStream(); //以输出字节流的方式
BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));//输出字符流
String s1="我已经接收到了";
bw.write(s1);
bw.flush();
//bos.close();
s.close();
}
}
}（三）应用
一、用TCP客户端并发上传图片
1、一对一（单线程）上传的思路：
客户端
a、服务端点。
b、读取客户端已有的图片数据
c、通过Socket输出流将数据发给服务端
d、读取服务端反馈信息。
e、关闭
服务端
a、服务端服务，并监听窗口
b、获取客户端对象，并获取客户ip
c、读取客户端输入流数据
d、写入文件
e、用客户端输出流反馈信息
f、关流
2、单线程的服务端有个局限性。当A客户端连接上以后，被服务端获取到。服务端执行具体流程。这时B客户端连接，只能等待。因为服务端还没有处理完A客户端的请求。还没有循环回来执行下一次accept方法。所以，暂时获取不到B客户端对象。
那么为了可以让多个客户端同时并发访问服务端。服务端最好就是将每个客户端封装到一个单独的线程中，这样，就可以同时处理多个客户端请求。
如何定义线程呢？
只要明确了每一个客户端要在服务端执行的代码，将该代码存入run方法即可。
二、客户端并发登录
客户端通过键盘录入用户名，服务端对这个用户名进行校验。
如果该用户存在，在服务端显示xxx，已登陆；并在客户端显示xxx，欢迎光临。
如果用户不存在，在服务端显示xxx，尝试登陆；并在客户端显示xxx，该用户不存在。
最多就登录三次。
三、客户端和服务的浏览器演示
浏览器是一个标准的客户端，它可以对服务端传送过来的数据消息进行解析，把符合应用层协议的消息部分解析后，将头信息拆包掉，传送到应用层，只保留了正确的正文主题部分显示在主体部分上。
而由于使用java编译是在传输层和网际层处理的，所以，会接受到全部的消息，包含了头消息。而浏览器处于应用层，已将发送来的头消息去除，只留下了主体信息。
下面是小练习：传递文件
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.Socket;
public class Socket2复制文件 {
public static void main(String[] args) throws IOException {
//创建客户端的对象
Socket s=new Socket("192.168.1.10",12306);
//获取输入对象
//OutputStream os =s.getOutputStream();
BufferedInputStream bs=new BufferedInputStream(new FileInputStream("E:\\电影\\韵动中国3.mp4"));
BufferedOutputStream bo=new BufferedOutputStream(s.getOutputStream());
byte[] b=new byte[1024];
int i=0;
while((i=bs.read(b))!=-1){
bo.write(b,0,i);
bo.flush();
}
s.shutdownOutput();
//获取服务器的反馈
//InputStream is=s.getInputStream();
BufferedReader br=new BufferedReader(new InputStreamReader(s.getInputStream()));//读取反馈
String server = br.readLine();//阻塞
System.out.println("server:" + server);
br.close();
bs.close();
s.close();
}
}import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class Server2服务器接收文件 {
public static void main(String[] args) throws IOException {
//创建服务器对象
ServerSocket ss=new ServerSocket(12306);
//监听客户端
while(true){
Socket s=ss.accept(); //堵塞
//获取输入流
InputStream bs =s.getInputStream(); //字节流
//BufferedInputStream bs=new BufferedInputStream(s.getInputStream()); //和上面的代码是一样的
//封装输出流
BufferedOutputStream bo=new BufferedOutputStream(new FileOutputStream("f:\\tu.mp4"));
byte[] ch=new byte[1024];
int i=0;
while((i=bs.read(ch))!=-1){
bo.write(ch,0,i);
bo.flush();
}
//PrintWriter pw=new PrintWriter(new FileWriter("a.txt"));
//反馈
//OutputStream os=s.getOutputStream();
PrintWriter pw=new PrintWriter(s.getOutputStream(),true);
pw.println("加油");
bo.close();
s.close();
}
}
}（四）小知识点
1、Socket类的构造函数中，有一个空参数的构造函数：
Socket()//通过系统默认类型的 SocketImpl创建未连接套接字对象
可以通过connect(SocketAddress endpoint)方法来连接服务器。而SocketAddress是一个抽象类，它的子类InetSocketAddress实现了IP套接字地址（IP地址+端口号）。所以就可以连接到服务器了。
2、ServerSocket对象中的构造函数：
ServerSocket(int port,int backlog)，其中的backlog表示队列的最大长度，即最多连入客户端的个数，即最大连接数。
3、在浏览器输入网址访问一台主机所做的操作：
如输入http://61.135.169.125，可以直接连接此ip的主机，而我们一般是输入主机名：http:/www.baidu.ocm（百度主机对应的ip地址就是：61.135.169.125），那么此时浏览器做了神马操作呢？
也就是说如何通过主机名获取IP地址，从而连接到这台主机呢？这就需要将主机名翻译成IP地址，即域名解析：DNS
在进行访问的时候，会先在本地的hosts文件（c:\windows\system32\drivers\ext\host）中找对应的映射。若有，则直接返回请求；若无，则到公网的映射列表即DNS中找对应的映射，找到后，将主机名对应的IP地址返回给本机，本机通过这个IP地址找到对应的服务器。
示意图：
363
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
