Java Socket编程题库

一、    填空题

1. ___ IP地址____用来标志网络中的一个通信实体的地址。通信实体可以是计算机，路由器等。
2. 统一资源定位符URL是指向互联网“资源”的指针,由4部分组成：协议、存放资源的主机域名、__端口___和资源路径和文件名。
3. URL  是统一资源定位器的简称，它表示Internet上某一资源的地址。
4. 在Socket编程中，IP地址用来标志一台计算机，但是一台计算机上可能提供多种应用程序，使用  端口    来区分这些应用程序。
5. 在Java Socket网络编程中，开发基于TCP协议的服务器端程序使用的套接字是     ServerSocket  。
6. 在Java Socket网络编程中，开发基于UDP协议的程序使用的套接字是   DatagramSocket  。

二、    选择题

1.	以下协议都属于TCP/IP协议栈，其中位于传输层的协议是（  AD  ）。（选择二项）
	A	TCP
	B.	HTTP
	C.	SMTP
	D.	UDP

2.	以下协议中属于TCP/IP协议栈中应用层协议的是（  A  ）。（选择一项）
	A	HTTP
	B.	TCP
	C.	UDP
	D.	IP

 

3.	以下说法中关于UDP协议的说法正确的是（  AD  ）。（选择二项）
	A.	发送不管对方是否准备好，接收方收到也不确认
	B.	面向连接
	C.	占用系统资源多、效率低
	D.	非常简单的协议，可以广播发送

 

4.	在基于TCP网络通信模式中，客户与服务器程序的主要任务是（  BC  ）。（选择二项）
	A	客户程序在网络上找到一条到达服务器的路由
	B.	客户程序发送请求，并接收服务器的响应
	C.	服务器程序接收并处理客户请求，然后向客户发送响应结果
	D.	如果客户程序和服务器都会保证发送的数据不会在传输途中丢失

 

 

5.	在Java网络编程中，使用客户端套接字Socket创建对象时，需要指定（  A  ）。（选择一项）
	A	服务器主机名称和端口
	B.	服务器端口和文件
	C.	服务器名称和文件
	D.	服务器地址和文件

 

6.	ServerSocket的监听方法accept( )方法的返回值类型是（  A   ）。（选择一项）
	A.	Socket
	B.	Void
	C.	Object
	D.	DatagramSocket

 

7.	Java UDP Socket编程主要用到的两个类是（  BD  ）。（选择二项）
	A	UDPSocket
	B.	DatagramSocket
	C.	UDPPacket
	D.	DatagramPacket

 

8.	在使用UDP套接字通信时，常用（  D  ）类把要发送的信息打包。（选择一项）
	A	String
	B.	DatagramSocket
	C.	MulticastSocket
	D.	DatagramPacket

三、    判断题

1. Socket是传输层供给应用层的编程接口，是应用层与传输层之间的桥梁 。(  T  )
2. TCP/IP传输控制协议是Internet的主要协议，定义了计算机和外设进行通信的规则。TCP/IP网络参考模型包括七个层次：应用层、会话层、表示层、传输层、网络层、链路层和物理层。（  F  ）
3. TCP协议一种面向连接的、可靠的、基于字节流的通信协议 。HTTP、FTP、TELNET、SMTP 都是基于TCP协议的应用层协议。（  T  ）
4. UDP协议是一种面向无连接的、可靠的、基于字节流的传输层通信协议，该协议占用系统资源多、效率较低。（  F  ）

四、    简答题

1. TCP/IP协议栈中，TCP协议和UDP协议的联系和区别？
2. 简述基于TCP的Socket编程的主要步骤。

提示：分别说明服务器端和客户端的编程步骤。

1. 简述基于UDP的Socket编程的主要步骤。

提示：分别说明服务器端和客户端的编程步骤。

五、    编码题

1. 使用基于TCP的Java Socket编程，完成如下功能：

1)   要求从客户端录入几个字符，发送到服务器端。

2)   由服务器端将接收到的字符进行输出。

3)   服务器端向客户端发出“您的信息已收到”作为响应。

4)   客户端接收服务器端的响应信息。

提示：

服务器端:PrintWriter out =new PrintWriter(socket.getOutputStream(),true);

客户端:BufferedReader line=new BufferedReader(new InputStreamReader(System.in));

服务器端：

 public class Server
 { // 服务器端类
     private ServerSocket ss; // 声明ServerSocket对象
     private Socket socket; // 声明Socket对象
     private BufferedReader in; // 声明输入流对象BufferedReader
     private PrintWriter out; // 声明输出流对象
     public Server()
     {
         try
         {
             // 创建一个ServerSocket，指定等待端口
             ss = new ServerSocket(10000);
             while (true)
             {
                 // 使用ServerSocket接收用户请求（处于监听状态）
                 socket = ss.accept(); // 获得客户端的socket对象
                 // 创建输入流并读取信息
                 in = new BufferedReader(new InputStreamReader(socket
                         .getInputStream()));
                 String line = in.readLine();
                 System.out.println("客户端说:" + line);
                 // 创建输出流并输出信息
                 out = new PrintWriter(socket.getOutputStream(), true);
                 out.print("您的信息已接收!");
                 // 关闭流和socket
                 out.close();
                 in.close();
                 socket.close();
             }
         } catch (IOException e)
         {
             e.printStackTrace();
             out.println("出错了!");
         } // 创建ServerSocket对象
     }
     public static void main(String[] args)
     {// 程序主入口
         // 创建对象
         new Server();
     }
 }

客户端：（3分）

 public class Client
 { // 声明客户端类
     Socket socket; // 声明Socket对象
     BufferedReader in; // 声明输入流对象
     PrintWriter out; // 声明输出流对象
     public Client()
     { // 构造方法
         try
         {
             // 创建Socket对象，用来发送请求
             socket = new Socket(InetAddress.getLocalHost(), 10000);
             // 创建字符缓冲区对象
             BufferedReader line = new BufferedReader(new InputStreamReader(
                     System.in));
             // 创建输出流对象并输出
             out = new PrintWriter(socket.getOutputStream(), true);
             out.println(line.readLine());
             // 创建输入流对象
             in = new BufferedReader(new InputStreamReader(socket
                     .getInputStream()));
             System.out.println(in.readLine());
             // 关闭流对象
             out.close();
             in.close();
         } catch (Exception e)
         {
             e.printStackTrace();
             System.out.println("出错了!");
         }
     }
     public static void main(String[] args)
     {
         // 创建对象
         new Client();
     }
 }

2. 使用基于UDP的Java Socket编程，完成在线咨询功能：

1)   客户向咨询人员咨询。

2)   咨询人员给出回答。

3)   客户和咨询人员可以一直沟通，直到客户发送bye给咨询人员。

 /**
  *
  * 在线客服咨询人员
  *
  */
 public class AskServer
 {
     public static void main(String[] args)
     {
         //创建DatagramSocket，发送接收数据都依赖他
         DatagramSocket socket = null;
         try
         {
             socket = new DatagramSocket(8888);
             Scanner input = new Scanner(System.in);
             while (true)
             {
                 //准备一个空的数据包，用来接收数据
                 byte[] buf = new byte[1024];
                 DatagramPacket packet = new DatagramPacket(buf, buf.length);
                 //接收数据使用空的数据包
                 socket.receive(packet);
                 //输出信息
                 String info = new String(packet.getData(), 0, packet.getLength());
                 System.out.println("客户端请求：" + info);
                 //判断是否退出
                 if ("bye".equals(info))
                 {
                     break;
                 }
                 //发送数据
                 String result = input.nextLine();
                 byte[] buf2 = result.getBytes();
                 DatagramPacket packet2 = new DatagramPacket(buf2, buf2.length,
                         packet.getAddress(), packet.getPort());
                 socket.send(packet2);
             }
         } catch (SocketException e)
         {
             e.printStackTrace();
         } catch (IOException e)
         {
             e.printStackTrace();
         } finally
         {
             //关闭socket
             socket.close();
         }
     }
 }

 /**
  *
  * 在线客服客户
  *
  */
 public class AskClient
 {
     public static void main(String[] args)
     {
         //创建DatagramSocket，发送接收数据都依赖他
         DatagramSocket socket = null;
         try
         {
             socket = new DatagramSocket(9999);
             Scanner input = new Scanner(System.in);
             while (true)
             {
                 //准备要发送的数据
                 String str = input.nextLine();//bye
                 //使用数据包把数据封装起来
                 byte[] buf = str.getBytes();
                 DatagramPacket packet = new DatagramPacket(buf, buf.length,
                         InetAddress.getByName("192.168.1.252"), 8888);
                 //发送数据包
                 socket.send(packet);
                 //判断是否退出
                 if ("bye".equals(str))
                 {
                     break;
                 }
                 //接收数据
                 byte[] buf2 = new byte[1024];
                 DatagramPacket packet2 = new DatagramPacket(buf2, buf2.length);
                 socket.receive(packet2);
                 System.out.println("服务器端反馈："
                         + new String(packet2.getData(), 0, packet2.getLength()));
             }
         } catch (SocketException e)
         {
             e.printStackTrace();
         } catch (IOException e)
         {
             e.printStackTrace();
         } finally
         {
             //关闭socket
             socket.close();
         }
     }
 } 

六、    可选题

1. 使用TCP网络编程完成用户登录功能：客户端输入用户名和密码，向服务器发出登录请求；服务器接收数据并进行判断，如果用户名和密码均是bjsxt，则登录成功，否则登录失败，返回相应响应信息；客户端接收响应信息并输出登录结果。

1)   用户User类已提供构造方法 public User(String username,String password)。

2)   客户端采用ObjectOutputStream发送封装了用户名和密码的User对象。

3)   服务器端和客户端的类名和方法声明如下所示。

public class LoginServer {

public static void main(String[] args) throws Exception {}

}

public class LoginClient {

public static void main(String[] args) throws Exception {}

}

 public class LoginServer
 {
     public static void main(String[] args) throws Exception
     {
         // 1.创建一个ServerSocket，指定等待端口（1分）
         ServerSocket serverSocket = new ServerSocket(8888);
         // 2.使用ServerSocket接收用户请求（处于监听状态）（1分）
         Socket socket = serverSocket.accept();
         // 3.创建输入流和输出流（0.5分）
         ObjectInputStream ois
                 = new ObjectInputStream(socket.getInputStream());
         DataOutputStream dos
                 = new DataOutputStream(socket.getOutputStream());
         // 4.接收用户数据并输出（0.5分）
         User user = (User) ois.readObject();
         System.out.println("我是服务器，收到的信息是：" + user);
         // 5.发送反馈信息（0.5分）
         boolean flag = false;
         if ("bjsxt".equals(user.getUsername())
                 && "bjsxt".equals(user.getPassword()))
         {
             flag = true;
         }
         dos.writeBoolean(flag);
         // 6.关闭流和socket（0.5分）
         ois.close();
         dos.close();
         socket.close();
     }
 }

 public class LoginClient
 {
     public static void main(String[] args) throws Exception
     {
         // 1.创建Socket，用来发送请求（0.5分）
         Socket socket
                 = new Socket(InetAddress.getByName("127.0.0.1"), 8888);
         // 2.创建输入流和输出流（0.5分）
         DataInputStream dis
                 = new DataInputStream(socket.getInputStream());
         ObjectOutputStream oos
                 = new ObjectOutputStream(socket.getOutputStream());
         // 3.发送数据（1分）
         Scanner input = new Scanner(System.in);
         System.out.println("请输入用户名");
         String username = input.nextLine();
         System.out.println("请输入密码");
         String password = input.nextLine();
         User user = new User(username, password);
         oos.writeObject(user);
         // 4.接收反馈信息并输出（0.5分）
         boolean flag = dis.readBoolean();
         if (flag)
         {
             System.out.println("登录成功");
         } else
         {
             System.out.println("登录失败");
         }
         // 5.关闭流和socket（0.5分）
         dis.close();
         oos.close();
         socket.close();
     }
 }