一、网络参考模型
OSI（Open System Interconnection 开放系统互连）参考模型
TCP/IP 参考模型
OSI七层描述
1. 物理层：主要定义物理设备标准，如网线的接口类型、光纤的接口类型、各种
传输介质的传输速率等。它的主要作用是传输比特流
（就是由1、0转化为电流强弱来进行传输，到达目的地后再转化为1、0，也就
是我们常说的数模转换与模数转换）。这一层的数据叫做比特。
2. 数据链路层：主要将从物理层接收的数据进行MAC地址（网卡的地址）的封装与解封装。常把这一层的数据叫做帧。在这一层工作的设备是交换机，数据通过交换机来传输。
3. 网络层：主要将下层接收到的数据进行IP地址（例，192.168.0.1）的封装与解封装。
在这一层工作的设备是路由器，常把这一层的数据叫做数据包。
4. 传输层：定义了一些传输数据的协议和端口号（WWW端口号80等），如：TCP
（传输控制协议，传输效率低，可靠性强，用于传输可靠性要求高，数据量大的数据），
UDP（用户数据报协议，与TCP特性恰恰相反，用于传输可靠性要求不高，数据量
小的数据，如QQ聊天数据就是通过这种方式传输的）。主要是将从下层接收的数据
进行分段和传输，到达目的地址后再进行重组。常常把这一层叫做段。
5. 会话层：通过传输层（端口号：传输端口与接收端口）建立数据传输的通路。主要
在你的系统之间发起会话或者接收会话请求（设备之间需要互相认识可以是IP也可以
是MAC或者是主机名）。
6. 表示层：主要是进行对接收的数据进行解释，加密与解密、压缩与解压缩等
（也就是把计算机能够识别的东西转换成人能够识别的东西（如图片、声音等）。
7. 应用层：主要是一些终端的应用，比如说FTP（各种文件下载）、WEB（IE浏览）、
QQ之类的（可以把它理解成我们在电脑屏幕上可以看到的东西，就是终端应用）。
TCP/IP 参考模型
1.应用层
2.传输层
3.网际层
4.主机至网络层
一般来说开发处于传输层和网际层，应用层为：FTP和HTTP协议等，
传输层为：UDP和TCP等，网际层为：IP。
通常用户操作的是应用层，而编程人员需要做的是传输层和网际层，用户在
应用层操作的数据，经过逐层封包，最后到物理层发送到另一个模型中，再进行逐层解包
二、网络通信三要素：IP地址，端口号，传输协议
A、IP地址
a、它是网络中的设备标识
b、不易记忆，可用主机名表示，两者存在映射关系
c、本机回环地址：127.0.0.1，主机名为：localhost。
IP地址：java中对应的是InetAddress类，存在于java.net包中。
tL
InetAddress类：
（一）无构造函数，可通过getLocalHost()方法获取InetAddress对象，此方法是静态的，返回本类对象。
InetAddress i = InetAddress.geocalHost();
（二）方法：
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、必须建立连接，效率稍慢
三次握手：第一次本方发送请求，第二次对方确认连接，第三次本方再次确认连接成功。
----------------------------------------------------------------------------------------
传输协议
一、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、在接收端，要指定监听的端口。
三、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）关闭服务端（可选）。一般服务端是常开的，因为在实际应用中，随时有客户
端在请求连接和服务。
但这里需要定时关闭客户端对象流，避免某一个客户端长时间占用服务器端。
* Caso I: chat robot inteligente, combinado con múltiples hilos abiertos varios clientes, pantalla de interfaz GUI
/*
* 智能聊天机器人 客户端，设置了GUI 界面，能让数据显示在其文本区域内，
* 开启方法：同样先开启服务端，然后再开启此GUI客户端
*/
public class ChatClientGUI {
//定义GUI的一些组件
private JFrame jf ;
private JTextArea area;
private JPanel jp;
private JTextField msgField;
private JButton sendBtn;
//定义客户端流对象
private Socket socket;
private OutputStream out;
private InputStream in;
public ChatClientGUI(){
//具体定义GUI界面的一些组件信息
jf = new JFrame("智能聊天机器人");
area = new JTextArea();
jf.add(area,BorderLayout.CENTER);
jf.pack();
msgField = new JTextField(18);
sendBtn = new JButton("发送");
//事件鉴定机制,监听某个组件触发的时间，并作出相应的处理
sendBtn.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent ae) {//发送按钮单击监听,要实现的一些效果
// 先拿到输入框中的 消息内容
String msg = msgField.getText();
//用户输入的内容也同样添加至文本区域area中
area.append("用户："+msg+"\r\n");
msgField.setText("");//用户输入完发送后，清空发送框
// socket 服务已经存在，流对象也已经存在,实现与服务端的信息交互
try {
//在发送框，写入要发送的数据
out.write(msg.getBytes());
byte[] buf = new byte[1024];
//读取到服务端返回的信息
int len = in.read(buf);
//添加到文本区域，area,并换行
//Thread.sleep(1000)//这样的话是对发送那个按钮 停止了1秒，感觉像是卡顿，这不是我想要的,待续8/19
area.append("机器人："+new String(buf,0,len)+"\r\n");
} catch (IOException e) {
e.printStackTrace();
}
}
});
//把组件添加至某组件内
jp = new JPanel();
jp.add(msgField);
jp.add(sendBtn);
jf.add(jp,BorderLayout.SOUTH);
//设置大小
jf.setSize(320, 200);
jf.setLocation(400, 400);
jf.setVisible(true);
jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//在开启一个GUI界面初始化时，就调用连接获取到流对象，对其使用
newSocket();
}
//定义一个连接，并初始化就获取到读写流
public void newSocket(){
try {
socket = new Socket(InetAddress.getLocalHost(),10005);
out = socket.getOutputStream();
in = socket.getInputStream();
} catch (UnknownHostException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) throws Exception {
new ChatClientGUI();
}
}
/*
* 我们使用多线程的实现，通过Server客户端重复获取多个客户端，同时和服务器端进行聊天
* 启动：1,先开启能够获取到多个客户端的Server服务器
* 2,再多次开启客户端
* */
//自定义一个线程类，目的为了能够使服务器获取到多个客户端线程
class UserThread implements Runnable{
Map<String,String> data = new HashMap<String,String>();
public Socket socket;
//初始化，开启一个线程，需传入一个Socket客户端参数
public UserThread(Socket socket){
this.socket=socket;
//初始化时，需要获取到到一些机器人会的的数据信息，
data.put("你好", "您好，我叫小智!");
data.put("hey","hey,最近在干嘛");
data.put("想你了","想我了就找我聊天吧！");
data.put("拜拜", "好的，下次找我聊天喔！");
data.put("886", "好的，下次找我聊天喔！");
data.put("woxiangni", "想我了就找我聊天吧！！");
}
//复写的run方法需要执行的是服务器端的读取交互
public void run() {
//因为传入的参数已经获取到了一个Socket客户端对象，所以直接获取到读写流对象即可
try {
OutputStream out = socket.getOutputStream();
InputStream in = socket.getInputStream();
byte[] buf = new byte[1024];
int len =0;//in读取流往buf容器装
while((len=in.read(buf))!=-1){
//获取到客户端发送过来的消息
String msg = new String(buf,0,len);
//在Map集合中找有没有相对应的key与之相对应，如果有，把相对应的value值 回写给 客户端；
if(data.containsKey(msg)){
String replyMsg = data.get(msg);//查找到到返回的数据
out.write(replyMsg.getBytes());//写出给客户端
}else{
out.write("嘿嘿".getBytes());//没有找打相对应的就返回嘿嘿
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
public class ChatServerThread {
public static void main(String[] args) throws Exception{
ServerSocket ss = new ServerSocket(10005);
//重复获取连接客户端
while(true){
Socket socket = ss.accept();//阻塞式的等待获取 客户端1 客户端2,每次进来的客户端 往下执行都会开启一个线程
//启动一个线程,负责和连接进来的客户端，进行交互
new Thread(new UserThread(socket)).start();
}
}
}Caso II: Continuará ing
