Socket网络编程

1.通过 URL对象的OpenStream()方法可以得到指定资源的输入流,通过输入流可以读取、访问网络上的数据。

 1 public class URLTest02 {
 2 
 3     public static void main(String[] args) {
 4         
 5         try {
 6             //创建一个URL实例
 7             URL url = new URL("http://www.baidu.com");
 8             //通过URL的openStream方法获取URL的字节输入流
 9             InputStream is = url.openStream();
10             //将字节输入流转换为字符输入流
11             InputStreamReader isr = new  InputStreamReader(is,"UTF-8");
12             //为字符输入流添加缓冲
13             BufferedReader br = new BufferedReader(isr);
14             String data = br.readLine();//读取数据
15             while(data!=null){//循环读取数据
16                 System.out.print(data);
17                 data = br.readLine();
18             }
19             br.close();
20             isr.close();
21             is.close();
22         } catch (MalformedURLException e) {
23             e.printStackTrace();
24         } catch (IOException e) {
25             e.printStackTrace();
26         }
27 
28     }
29 
30 }

2. 基于TCP的网络编程

   TCP协议是面向连接的、可靠的、有序的,以字节流的方式发送数据。

    基于TCP协议实现网络通信的类:客户端的Socket类,服务器端的SeverSocket类

   基本步骤:

  (1) 服务器端建立服务端监听Socket

     (2)服务器端等待并接受请求

     (3) 客户端创建连接Socket,向服务器端发送请求

     (4) 服务器端接收请求,并创建连接Socket

     (5) 传送与接收数据

     (6) 关闭Socket及相关资源 

 

   应用多线程来实现服务器与客户端之间的通信

   基本步骤:

    (1)服务器端创建ServerSocket,循环调用accept()等待客户端连接

    (2)客户端创建一个Socket并请求和服务器端连接

    (3)服务器端接受客户端请求,创建Socket与该客户建立连接

    (4)建立连接的两个Socket在一个单独的线程上对话

    (5)服务器端继续等待新的连接

 1 /*
 2  * 基于TCP协议的Socket通信,实现用户登录
 3  * 服务器端
 4  */
 5 public class SocketServer {
 6 
 7     public static void main(String[] args) {
 8 
 9         Socket socket = null;
10         ServerSocket serverSocket = null;
11         int count = 0;
12         try {
13             // 1. 创建一个服务器端的Socket,即ServerSocket,指定绑定的端口,并监听此端口
14             serverSocket = new ServerSocket(8888);
15             System.out.println("服务器即将启动,等待客户连接。。。");
16             // 循环监听等待客户端的连接
17             while (true) {
18                 // 2. 调用accept()方法开始监听,等待客户端的连接
19                 socket = serverSocket.accept(); // 此时会堵塞
20                 // 创建一个新的线程
21                 ServerThread serverThread = new ServerThread(socket);
22                 // 启动线程
23                 serverThread.start();
24                 count++;
25                 System.out.println("客户端的数量为:"+count);
26                 InetAddress address = socket.getInetAddress();
27                 System.out.println("客户端IP:"+address.getHostAddress());
28                 
29             }
30 
31         } catch (IOException e) {
32             e.printStackTrace();
33         }
34     }
35 }   
 1 /*
 2  * 基于TCP协议的Socket通信,实现用户登录
 3  * 客户端
 4  */
 5 public class SocketClient {
 6    
 7     public static void main(String[] args) {
 8       
 9         try {
10             //1. 创建客户端Socket,指定服务器地址和端口
11             Socket socket = new Socket("localhost",8888);
12             //2. 获取输出流,向服务器发送信息
13             OutputStream os = socket.getOutputStream();//字节输出流
14             PrintWriter pw = new PrintWriter(os);
15             
16             pw.write("用户名:lah;密码:123456");
17             System.out.println();
18             pw.flush();
19             socket.shutdownOutput();//关闭输出流
20             
21             //获取输入流,读取服务器端的响应信息
22             InputStream is = socket.getInputStream();
23             BufferedReader br = new BufferedReader(new InputStreamReader(is));
24             String info = null;
25             while((info = br.readLine())!=null){//循环读取客户端信息
26                 System.out.println("我是客户端,服务器说:"+info);
27             }
28              
29             //4. 关闭资源
30             br.close();
31             is.close();
32             pw.close();
33             os.close();
34             socket.close();
35             
36         } catch (UnknownHostException e) {
37             e.printStackTrace();
38         } catch (IOException e) {
39             e.printStackTrace();
40         }
41  
42    }
43 }
 1 /*
 2  * 服务器线程处理类
 3  */
 4 public class ServerThread extends Thread {
 5     // 和本线程相关的Socket
 6     Socket socket = null;
 7 
 8     public ServerThread(Socket socket) {
 9         this.socket = socket;
10     }
11 
12     // 线程执行的操作,响应客户端的请求
13     @Override
14     public void run() {
15         
16         InputStream is = null;
17         InputStreamReader isr = null;
18         BufferedReader br = null;
19 
20         OutputStream os = null;
21         PrintWriter pw = null;
22         String info = null;
23         
24         try {
25             // 3. 获取输入流,用来读取客户端所发送的信息
26             is = socket.getInputStream();
27             isr = new InputStreamReader(is);
28             br = new BufferedReader(isr);
29             
30             while ((info = br.readLine()) != null) {// 循环读取客户端信息
31                 System.out.print("我是服务器,客户端说:" + info);
32             }
33             socket.shutdownInput();// 关闭输入流
34             // 获取输出流,响应客户端的请求
35             os = socket.getOutputStream();
36             pw = new PrintWriter(os);
37             pw.write("欢迎您!");
38             pw.flush();
39         } catch (IOException e) {
40             e.printStackTrace();
41         } finally {
42 
43             try {
44                 // 5. 关闭相关的资源
45                 if (pw != null)
46                     pw.close();
47                 if (os != null)
48                     os.close();
49                 if (br != null)
50                     br.close();
51                 if (isr != null)
52                     isr.close();
53                 if (is != null)
54                     is.close();
55                 if (socket != null)
56                     socket.close();
57             } catch (IOException e) {
58                 e.printStackTrace();
59             }
60         }
61 
62     }
63 
64 }

3. UDP编程

   进行数据传输时,首先需要将传输的数据定义成数据报,在数据报中指定数据要到达的Socket(主机地址和端口号),然后再将数据报发送出去。

   DatagramPacket: 表示数据包

   DatagramSocket: 进行端到端通信的类

   服务器端实现步骤:

   (1)创建DatagramSocket,指定端口号

   (2)创建DatagramPacket

   (3)接收客户端发送的数据信息

   (4)读取数据

 1 /*
 2  * 基于UDP的用户登录
 3  */
 4 public class UDPServer {
 5 
 6     public static void main(String[] args) throws IOException {
 7         //1. 创建服务器端DatagramSocket,指定端口 
 8         DatagramSocket socket = new DatagramSocket(8800);
 9         //2. 创建数据报,用于接收客户端发送的数据
10         byte[] data = new byte[1024];//创建字节数组,指定接收数据报的大小
11         DatagramPacket packet = new DatagramPacket(data, data.length);
12         //3. 接收客户端发送的数据
13         System.out.println("服务器端已经启动,等待客户端发送数据****");
14         socket.receive(packet);//此方法在接收到数据报之前会一直阻塞
15         //4. 读取数据
16         String info = new String(data, 0, packet.getLength());
17         System.out.println("我是服务器,客户端说:"+info);
18         
19         /*
20          * 向客户端响应数据
21          */
22         //1. 定义客户端的地址、端口号、数据
23         InetAddress address = packet.getAddress();
24         int port = packet.getPort();
25         byte[] dataTo = new byte[1024];
26         dataTo="欢迎您!".getBytes();
27         DatagramPacket packetTo = new DatagramPacket(dataTo,dataTo.length, address, port);
28         socket.send(packetTo);
29         
30         socket.close();
31     }
32 
33 }

 

  客户端实现步骤:

  (1)定义发送的信息

  (2)创建DatagramPacket,包含要发送的信息

  (3)创建DatagramSocke

  (4)发送数据

 1 /*
 2  * 客户端,基于UDP的用户登录
 3  */
 4 public class UDPClient {
 5 
 6     public static void main(String[] args) throws IOException {
 7         // 1. 定义服务器的地址,端口号、数据
 8         InetAddress address = InetAddress.getByName("localhost");
 9         int port = 8800;
10         byte[] data = "用户名:admin;密码:123".getBytes();
11         //2. 创建数据报,包含发送的数据信息
12         DatagramPacket packet = new DatagramPacket(data, data.length, address, port);
13         //3. 创建DatagramSocket对象
14         DatagramSocket socket = new DatagramSocket();
15         //4. 向服务器端发送数据报
16         socket.send(packet);
17         
18         /*
19          * 接收服务器端响应的数据
20          */
21         //
22         byte[] data2 = new byte[1024];
23         DatagramPacket packet2 = new DatagramPacket(data2, data2.length);
24         socket.receive(packet2);
25         String reply = new String(data2, 0, packet2.getLength());
26         System.out.println("我是客户端,服务器说:"+reply);
27         socket.close();
28     }
29 
30 }

 

posted @ 2015-03-19 10:35  N_ll  阅读(194)  评论(0编辑  收藏  举报