网络编程，socket

1.网络编程

网络：
        TCP/IP      彼此之间遵守协议和规范！之间才能产生通信！
   
   
IP:  每个人都有自己的身份证号！
          用来标识我们网络中每一台计算机！   
          
IP地址= 网络地址 +主机地址   
    网络地址 ：标识我们计算机和所在网络的网段
    主机地址  ：标识我们的主机
        
          
          
 IPv4   : 纯数字  32位
      组成： 4个8位的2进制数组成
             每一个8位的2进制数 最大到255！
      
      00000000 00000000 00000000 00000000   
            因为2进制数不容易记忆
      192.168.30.247
      
      
      每个电脑中预留的一个ipv4地址：(127.0.0.1)
      
      
 IPv6   ：数字，字母和符号      128位   是ipv4的4倍
        每个电脑中预留的一个ipv6地址：  (::1)
 
 例子：
 
   小明和小红是好朋友，他们俩个需要通过微信进行聊天！
   
   01.两人家里都有电脑
   02.电脑必须都有TCP/IP协议，都有ip地址
   03.找到对方的ip地址
   04.找到微信对应的端口号
   05.进行通信
 
 端口号     0-65535
系统预留      0-1024 
 
 
 查询本机ip地址
 ipconfig
 
 测试网络是否畅通
 ping  ip地址
 
 
 域名
 DNS(Domain  Name System) 域名系统
  对应的就是一个ip地址
 
 www.baidu.com
 www.jd.com
 
 
 网络服务器
    能够提供用户服务的计算机！
    
     邮件服务器
   web服务器
   
网络通信协议：
     在不同的计算机之间进行通信而建立的一些约束和规范的集合！
 
 
TCP协议：（Transmission  Control  Protocol）传输控制协议
      面向连接的，可靠的，基于字节流的传输通信协议！ 安全！
 
 我们两个人在玩篮球，在我传球给你的时候，我需要考虑你知否能接住球！
 因为要考虑，所以传球的速度可能慢！
 
 
UDP协议： （User Datagram Protocol） 用户数据报协议
     没有连接协议。在我们传输数据之前，客户端和服务器没有建立连接！不安全！
  
 我们两个人在玩篮球，在我传球给你的时候，我不考虑你知否能接住球！直接扔给你！
 因为不需要考虑，所以传球的速度快！
 
 TCP协议中的Socket
 
  ServerSocket        服务器     指定端口号
  Socket              客户端     ip  +  端口号 
  
  
 UDP协议中的Socket
  
  DatagramSocket     接收  发送      指定端口号
  DatagramPacket     打包  拆包      ip  +  端口号 
  
  
  服务器的操作
  01.打开服务器  设置端口号
  02.开始接收客户端的信息DatagramSocket 
  03.拆包DatagramPacket
  04.需要给客户端响应
  05.打包DatagramPacket
  06.发送给客户端DatagramSocket 
  
  
  客户端的操作
  01.创建客户端  找到服务器的ip和端口号
  02.打包DatagramPacket
  03.发送给服务器DatagramSocket 
  04.接收服务器的响应DatagramSocket 
  05.拆包DatagramPacket
2.代码：
01.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * 超市   =====》服务器
 */
public class ServerSocketTest {

    public static void main(String[] args) {
        ServerSocket serverSocket = null; // 超市
        Socket socket = null; // 顾客
        InputStream inputStream = null; // 购物车
        BufferedReader br = null; // 收银员
        OutputStream outputStream = null; // 收银员的反馈信息
        try {
            // 创建一个指定位置的超市 （服务器）
            serverSocket = new ServerSocket(8800);
            // 超市开门 等待顾客购物
            socket = serverSocket.accept();
            // 顾客开始疯狂购物
            inputStream = socket.getInputStream();
            /**
             * 收银员会一个商品一个商品进行扫码
             * inputStream:顾客购买的商品
             */
            br = new BufferedReader(new InputStreamReader(inputStream));
            String line = null;
            while ((line = br.readLine()) != null) {
                System.out.println("您购买的商品是：" + line);
            }
            /**
             * 顾客买完商品  结了账  能不能转转？？ 没出超市
             *  结束购物  结账
             */
            socket.shutdownInput(); // 关闭了输入流
            // 打开输出流
            outputStream = socket.getOutputStream();
            outputStream.write("谢谢您的光临".getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 释放资源
            try {
                outputStream.close();
                socket.close();
                br.close();
                inputStream.close();
                serverSocket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }

    }

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;

/**
 * 顾客=====》客户端
 */
public class SocketTest {

    public static void main(String[] args) {
        Socket socket = null; // 顾客
        OutputStream outputStream = null; // 钱包
        InputStream inputStream = null; // 账单或者是收银员的回馈信息
        BufferedReader br = null;
        try {
            // 顾客去哪个地方的哪个超市购物
            socket = new Socket("localhost", 8800);
            // 消费 相当于 钱从钱包 出去了.......
            outputStream = socket.getOutputStream();
            outputStream.write("买了一艘航空母舰".getBytes());
            // 购物完毕
            socket.shutdownOutput();

            // 接收收银员的回馈信息
            inputStream = socket.getInputStream();
            // 循环获取收银员的回馈信息
            br = new BufferedReader(new InputStreamReader(inputStream));
            String line = null;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                br.close();
                inputStream.close();
                socket.close();
                outputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }

}

02.多用户登录

import java.net.ServerSocket;
import java.net.Socket;

/**
 * 服务器
 */
public class ServerTest {
    public static void main(String[] args) {

        ServerSocket serverSocket = null;
        Socket socket = null;

        try {
            // 创建服务器对象
            serverSocket = new ServerSocket(8800);
            // 一直监听 客户端是否有人登录
            while (true) {
                socket = serverSocket.accept();
                /**
                 * 这个socket是第几个用户？？？ 不知道
                 * 只知道一个socket就是一个线程
                 */
                LoginThread thread = new LoginThread(socket);
                thread.start();// 启动线程
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

}

import java.io.Serializable;

/**
 * 用户类
 */
public class User implements Serializable {

    private String name;
    private String password;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public User(String name, String password) {
        super();
        this.name = name;
        this.password = password;
    }

    public User() {
        super();
    }

    public String toString() {
        return "User [name=" + name + ", password=" + password + "]";
    }

}

import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.OutputStream;
import java.net.Socket;

public class LoginThread extends Thread {

    // 创建每个用户对应的socket
    Socket socket = null;

    public LoginThread(Socket socket) {
        this.socket = socket;
    }

    // 获取客户端的请求 给客户端响应
    public void run() {

        InputStream is = null;
        OutputStream os = null;
        // 反序列化
        ObjectInputStream ois = null;
        // 打开输入流和输出流
        try {
            is = socket.getInputStream();
            os = socket.getOutputStream();
            ois = new ObjectInputStream(is);
            User user = (User) ois.readObject();
            System.out.println("您的用户名是：" + user.getName());
            System.out.println("您的密码是：" + user.getPassword());
            socket.shutdownInput();

            // 给用户成功响应
            os.write("恭喜您登录成功！".getBytes());

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                os.close();
                socket.close();
                ois.close();
                is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }

    }

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.net.Socket;

/**
 * 用户登录 用户1
 */
public class ClientTest {

    public static void main(String[] args) {
        Socket socket = null;
        InputStream inputStream = null;
        OutputStream outputStream = null;
        BufferedReader br = null;
        // 序列化
        ObjectOutputStream oos = null;

        try {
            // 创建socket对象
            socket = new Socket("localhost", 8800);
            // 打开输入流和输出流
            inputStream = socket.getInputStream();
            outputStream = socket.getOutputStream();
            // 创建登录的对象
            User user = new User("admin1", "123456");
            // 序列化到服务器
            oos = new ObjectOutputStream(outputStream);
            oos.writeObject(user);
            socket.shutdownOutput();

            // 登录成功之后 服务器会给我们响应 需要接收
            br = new BufferedReader(new InputStreamReader(inputStream));
            String line = null;
            while ((line = br.readLine()) != null) {
                System.out.println("服务器给我们的回应=====》" + line);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                br.close();
                socket.close();
                oos.close();
                outputStream.close();
                inputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.net.Socket;

/**
 * 用户登录 用户2
 */
public class ClientTest2 {

    public static void main(String[] args) {
        Socket socket = null;
        InputStream inputStream = null;
        OutputStream outputStream = null;
        BufferedReader br = null;
        // 序列化
        ObjectOutputStream oos = null;

        try {
            // 创建socket对象
            socket = new Socket("localhost", 8800);
            // 打开输入流和输出流
            inputStream = socket.getInputStream();
            outputStream = socket.getOutputStream();
            // 创建登录的对象
            User user = new User("admin2", "654321");
            // 序列化到服务器
            oos = new ObjectOutputStream(outputStream);
            oos.writeObject(user);
            socket.shutdownOutput();

            // 登录成功之后 服务器会给我们响应 需要接收
            br = new BufferedReader(new InputStreamReader(inputStream));
            String line = null;
            while ((line = br.readLine()) != null) {
                System.out.println("服务器给我们的回应=====》" + line);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                br.close();
                socket.close();
                oos.close();
                outputStream.close();
                inputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.net.Socket;

/**
 * 用户登录 用户3
 */
public class ClientTest3 {

    public static void main(String[] args) {
        Socket socket = null;
        InputStream inputStream = null;
        OutputStream outputStream = null;
        BufferedReader br = null;
        // 序列化
        ObjectOutputStream oos = null;

        try {
            // 创建socket对象
            socket = new Socket("localhost", 8800);
            // 打开输入流和输出流
            inputStream = socket.getInputStream();
            outputStream = socket.getOutputStream();
            // 创建登录的对象
            User user = new User("admin3", "123456789");
            // 序列化到服务器
            oos = new ObjectOutputStream(outputStream);
            oos.writeObject(user);
            socket.shutdownOutput();

            // 登录成功之后 服务器会给我们响应 需要接收
            br = new BufferedReader(new InputStreamReader(inputStream));
            String line = null;
            while ((line = br.readLine()) != null) {
                System.out.println("服务器给我们的回应=====》" + line);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                br.close();
                socket.close();
                oos.close();
                outputStream.close();
                inputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }

}