网络编程

网络概述

　　

IP地址

　IP地址组成

　　

　　

　IP命令

　　

　DNS

　　

网络服务器

　　

网络通信协议

　　

基于TCP协议的Socket编程

　　

　　

　　

import java.io.Serializable;

public class User implements Serializable {
    private String name;
    private String pwd;

    public User() {
    }

    public String getName() {
        return name;
    }

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

    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }

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

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

public class ServerLogin {

    public static void main(String[] args) {
        // 1、创建一个ServerSocket对象，指定端口号
        try {
            ServerSocket serverSocket = new ServerSocket(8000);
            // 2、监听者客户端请求
            Socket socket = serverSocket.accept();
            // 3、打开流，处理用户请求
            InputStream is = socket.getInputStream();
            OutputStream os = socket.getOutputStream();
            ObjectInputStream ois = new ObjectInputStream(is);
            User user;
            try {
                user = (User) ois.readObject();
                System.out.println("我是服务器，客户端信息为：" + user.getName() + "，密码"
                        + user.getPwd());
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
            socket.shutdownInput();
            // 服务器给客户端一个响应
            String info = "欢迎您，登录成功！";
            os.write(info.getBytes());
            // 4、关闭资源
            ois.close();
            os.close();
            is.close();
            socket.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.ObjectOutputStream;
import java.io.OutputStream;
import java.net.Socket;

public class ClientLogin {

    public static void main(String[] args) {
        // 1、创建一个socket对象（指定服务器IP，端口号）
        try {
            Socket socket = new Socket("localhost", 8000);
            // 2、打开流，发送请求
            OutputStream os = socket.getOutputStream();
            InputStream is = socket.getInputStream();
            User user = new User("TOM", "1234"); // 创建用来发送的对象
            ObjectOutputStream oos = new ObjectOutputStream(os);
            oos.writeObject(user);
            socket.shutdownOutput();
            // 接收服务器反馈
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            String info = "";
            while ((info = br.readLine()) != null) {
                System.out.println("我是客户端，服务器的响应是：" + info);
            }
            // 3、关闭资源
            oos.close();
            is.close();
            os.close();
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

　多线程处理多请求

　　

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

import cn.bdqn.xhd.socket2.LoginThread;

public class ServerLogin {

    public static void main(String[] args) {
        // 1、创建一个ServerSocket对象，指定端口号
        ServerSocket serverSocket = null;
        try {
            serverSocket = new ServerSocket(8000);
            // 持续监听
            while (true) {
                Socket socket = serverSocket.accept();
                LoginThread loginThread = new LoginThread(socket);
                loginThread.start(); // 启动线程，处理客户端请求
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

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

import cn.bdqn.xhd.socket.User;

public class LoginThread extends Thread {
    Socket socket = null;

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

    // 处理用户请求
    public void run() {
        try {
            // 3、打开流，处理用户请求
            InputStream is = socket.getInputStream();
            OutputStream os = socket.getOutputStream();
            ObjectInputStream ois = new ObjectInputStream(is);
            User user;
            try {
                user = (User) ois.readObject();
                System.out.println("我是服务器，客户端信息为：" + user.getName() + "，密码"
                        + user.getPwd());
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
            socket.shutdownInput();
            // 服务器给客户端一个响应
            String info = "欢迎您，登录成功！";
            os.write(info.getBytes());
            // 4、关闭资源
            ois.close();
            os.close();
            is.close();
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

基于UDP协议的网络编程

　　

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.net.UnknownHostException;

public class Send {

    public static void main(String[] args) {
        InetAddress ia = null;
        DatagramSocket ds = null;

        try {
            String mess = "你好，我想咨询一个问题。";
            // 显示与本地对话框
            System.out.println("我说：" + mess);
            // 获取本地主机地址
            ia = InetAddress.getByName("localhost");
            // 创建DatagramPacket对象，封装数据
            DatagramPacket dp = new DatagramPacket(mess.getBytes(),
                    mess.getBytes().length, ia, 8800);
            // 创建DatagramSocket对象，向服务器发送数据
            ds = new DatagramSocket();
            ds.send(dp);

            byte[] buf = new byte[1024];
            DatagramPacket dpre = new DatagramPacket(buf, buf.length);
            ds.receive(dpre);
            // 显示接收到的信息
            String reply = new String(dpre.getData(), 0, dpre.getLength());
            System.out.println(dpre.getAddress().getHostAddress() + "说："
                    + reply);

        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (SocketException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 关闭DatagramSocket对象
            ds.close();
        }
    }

}

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketAddress;
import java.net.SocketException;

public class Receive {

    public static void main(String[] args) {
        DatagramPacket dp = null;
        DatagramSocket ds = null;
        DatagramPacket dpto = null;
        try {
            // 创建DatagramPacket对象，用来准备接收数据包
            byte[] buf = new byte[1024];
            dp = new DatagramPacket(buf, buf.length);
            // 创建DatagramSocket对象，接收数据
            ds = new DatagramSocket(8800);
            ds.receive(dp);
            // 显示接收到的信息
            String mess = new String(dp.getData(), 0, dp.getLength());
            System.out.println(dp.getAddress().getHostAddress() + "说：" + mess);

            String reply = "你好，我在，请咨询！";
            // 显示与本地对话框
            System.out.println("我说：" + reply);

            // 创建DatagramPacket对象，封装数据
            SocketAddress sa = dp.getSocketAddress();
            dpto = new DatagramPacket(reply.getBytes(),
                    reply.getBytes().length, sa);
            ds.send(dpto);
        } catch (SocketException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 关闭DatagramSocket对象
            ds.close();
        }
    }

}