最屌网络编程解析

IP地址

 什么是IP地址：唯一标识网络上的每一台计算机

 IP地址组成：32位，由4个8位二进制数组成。如（127.0.0.1）

 网络地址：标识计算机或网络设备所在的网段

 主机地址：标识特定主机或者网络设备

 （127.0.0.1）红色为网络地址，蓝色为主机地址（0~255）

查看本机IP地址：cmd--->ipconfig

测试网络是否畅通：ping  目标IP

 网络通信协议

为了在网络中不同的计算机之间进行通信而建立的规则、标准或约定的集合

（仅展示了常用的五层）

TCP:（Transfer control protocol） 传输控制协议(构建可靠的传输)要求客户端与服务端必须建立连接

UDP:User Datagram protocol 用户数据报协议(不可靠的协议)客户端与服务端无需建立连接也可传输数据

三次握手的问题: 1、客户端向服务器发起连接请求   2、服务器接收请求向客户端响应回执   3、客户端真正的与服务端发起连接

Socket套接字

 通信链路的端点就被称为“套接字”（英文名Socket）

 废话不多说，接下来是基于TCP协议实现的编程

//服务器
//serverSocket:处理连接请求的Socket
//Socket才是真正负责数据传递的对象
public class SocketTest {
    public static void main(String[] args) {
        try {
              //1:实例化ServerSocket对象 port:指代端口的意思 当前程序在主机上的唯一标识
            ServerSocket server=new ServerSocket(5000);
              //2:等待客户端发起连接请求（特点:等待客户端请求 如果客户端始终没有发起请求 处于阻塞状态）
            Socket st=server.accept();//监听器
            //通过输入流读取数据
            InputStream is=st.getInputStream();
            BufferedReader br=new BufferedReader(new InputStreamReader(is));
            String info;
            while ((info=br.readLine())!=null) {
                System.out.println("客户端说:"+info);
                
            }
            
            //返回数据 输出流
            String str="你说得对";
            OutputStream os=st.getOutputStream();
            BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(os));
            bw.write(str);
            
                    
            //关闭流操作
            bw.close();
            os.close();
            br.close();
            is.close();
            st.close();
            server.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

//客户端
public class ScoketKh {
    public static void main(String[] args) {
        try {
            Socket se=new Socket("localhost",5000);//测试的本机地址localhost后面的是端口号
            String st="好好学习，天天向上";
            OutputStream os=se.getOutputStream();
            os.write(st.getBytes());
            
            se.shutdownOutput();
            InputStream is=se.getInputStream();
            BufferedReader br=new BufferedReader(new InputStreamReader(is));
            String info;
            while ((info=br.readLine())!=null) {
                System.out.println("服务器端说:"+info);
                
            }
            
            os.close();
            se.close();
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

 利用多线程的方式实现聊天对话

//服务器
public class Sever {
    public static void main(String[] args) {
        try {
            ServerSocket sever = new ServerSocket(10000);
                Socket socket=sever.accept();
                System.out.println("连接成功");
                
                final BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                final PrintWriter pw=new PrintWriter(socket.getOutputStream());
                final BufferedReader brs=new BufferedReader(new InputStreamReader(System.in));
                
                //使用了内部类方式创建线程
                new Thread(new Runnable() {
                    
                    @Override
                    public void run() {
                        try {
                            while (true) {
                                System.out.println("服务器说:"+br.readLine());
                                
                            }
                            
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                        
                    }
                }).start();
                new Thread(new Runnable() {
                    
                    @Override
                    public void run() {
                        try {
                            while (true) {
                                String readLine = brs.readLine();
                                pw.println(readLine);
                                pw.flush();
                            }
                            
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                        
                    }
                }).start();
            
        } catch (IOException e) {
            e.printStackTrace();
        }
    
    }

}

//客户端
public class User1 {
    public static void main(String[] args) {
        try {
            Socket socket=new Socket("127.0.0.1",10000);
            
            final BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            final PrintWriter pw=new PrintWriter(socket.getOutputStream());
            final BufferedReader brs=new BufferedReader(new InputStreamReader(System.in));
            
            
            
            new Thread(new Runnable() {
                
                @Override
                public void run() {
                    try {
                        while (true) {
                            System.out.println("客户端说:"+br.readLine());
                            
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                    
                }
            }).start();
            new Thread(new Runnable() {
                
                @Override
                public void run() {
                    try {
                        while (true) {
                            String readLine = brs.readLine();
                            pw.println(readLine);
                            pw.flush();
                        }
                        
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                    
                }
            }).start();
        } catch (UnknownHostException e) {
            e.printStackTrace();
        
        }catch (IOException e) {
            e.printStackTrace();
        }
    }

}

 利用多线程方式传输对象

//学生类实现Serializable接口表示可以序列化
public class Student implements Serializable{
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public Student() {
        super();
    }
    

}

//服务器
public class Server {
    public static void main(String[] args) {
        try {
            ServerSocket server = new ServerSocket(50000);
            while (true) {//每次来一个对象都要创建一个新的线程所以要一直开着服务器
                Socket socket=server.accept();
                new Thread(new MyThread(socket)).start();
                
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    
    }

}

//线程
public class MyThread implements Runnable{
    private Socket socket;//把Socket当做属性传入
    public MyThread(Socket socket) {
        super();
        this.socket = socket;
    }

    @Override
    public void run() {
        try {
            //读取传入的对象信息
            ObjectInputStream ois=new ObjectInputStream(socket.getInputStream());
            //返回给客户端的信息
            PrintWriter pw=new PrintWriter(socket.getOutputStream());
            Student stu = (Student)ois.readObject();
            if(stu!=null){
                System.out.println(stu.getName()+"	"+stu.getAge());
                pw.println("已添加一个学员信息");
                pw.flush();
            }else {
                System.out.println("没有传输学员信息");
                pw.println("添加失败");
                pw.flush();
            }
            
            pw.close();
            ois.close();
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        
    }

}

//客户端（传入一个有值的对象）
public class Client {
    public static void main(String[] args) throws Exception {
        Socket socket=new Socket("127.0.0.1",50000);
        
        Student stu=new Student("小明",18);
        ObjectOutputStream oos=new ObjectOutputStream(socket.getOutputStream());
        BufferedReader br=new BufferedReader(new InputStreamReader(socket.getInputStream()));
        
        oos.writeObject(stu);
        oos.flush();//强制清空缓存区
        System.out.println(br.readLine());
        
        br.close();
        oos.close();
        socket.close();
    }

}

//客户端2（传入一个无值的）
public class Client1 {
    public static void main(String[] args) throws Exception {
        Socket socket=new Socket("127.0.0.1",50000);
        
        Student stu=new Student("小明",18);
        ObjectOutputStream oos=new ObjectOutputStream(socket.getOutputStream());
        BufferedReader br=new BufferedReader(new InputStreamReader(socket.getInputStream()));
        
        oos.writeObject(null);
        oos.flush();
        System.out.println(br.readLine());
        
        br.close();
        oos.close();
        socket.close();
    }

}

 基于UDP实现的网络编程

//服务器
public class SocketUdpFwq {
    public static void main(String[] args) {
        byte[] bytes=new byte[1024];
        DatagramPacket dp=new DatagramPacket(bytes, bytes.length);
        try {
            DatagramSocket socket=new DatagramSocket(5000);
            socket.receive(dp);
            String str=new String(dp.getData(),0,dp.getData().length);
            System.out.println("客户端说:"+str);
            
            String str1="在的，您好";
            byte[] bytes1=str1.getBytes();
            SocketAddress sa=dp.getSocketAddress();
            DatagramPacket dp1=new DatagramPacket(bytes1, 0,bytes1.length,sa);
            socket.send(dp1);
            
            
            socket.close();
        } catch (SocketException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

//客户端
public class SocketUdp {
    public static void main(String[] args) {
        String str="你好,在吗";
        byte[] bytes=str.getBytes();
        try {
            //获取本机的地址
            InetAddress id=InetAddress.getByName("localhost");
             //指定包要发送的目的地
            DatagramPacket dp=new DatagramPacket(bytes, bytes.length,id,5000);
            DatagramSocket socket=new DatagramSocket() ;
            socket.send(dp);
            
            
            byte[] bytes1=new byte[1024];
            DatagramPacket dp1=new DatagramPacket(bytes1, bytes1.length);
            socket.receive(dp1);
            String str1=new String(dp1.getData(),0,dp1.getData().length);
            System.out.println("服务器说:"+str1);
            
            socket.close();
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (SocketException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        
    }

}