Java学习笔记(Javase毕向东版视频)十

 1 import java.net.InetAddress;
 2 import java.net.UnknownHostException;
 3 
 4 public class IpClassDemo
 5 {
 6     public static void main(String[] args) throws UnknownHostException{
 7         demo();
 8     }
 9 
10     public static void demo() throws UnknownHostException{
11         //InetAddress没有构造方法,不能直接创建对象
12         //获取本机
13         InetAddress ip=InetAddress.getLocalHost();
14         //获取其他主机
15         ip=InetAddress.getByName("k01");
16         System.out.println(ip.getHostAddress());
17         System.out.println(ip.getHostName());
18     }
19 
20 }

 1 import java.io.IOException;
 2 import java.net.DatagramPacket;
 3 import java.net.DatagramSocket;
 4 import java.net.InetAddress;
 5 
 6 public class UDPSendDemo {
 7     public static void main(String[] args) throws IOException{
 8         System.out.println("发送端启动...");
 9         sendemo();
10     }
11 
12     public static void sendemo() throws IOException {
13         /*使用UDP发送数据需要四步,
14          * 1、建立发送端的socket服务,对于UDP协议来说就是创建DatagramSocket对象
15          * 2、将数据封包,对于UDP协议来说使用的是DatagramPacket对象。！！！该对象还可以用于拆包数据
16          * 3、使用socket服务发送:这里需要使用通讯协议的另外两个点-->1、接收端的ip，2、端口
17          * 注意:传输的信息会被接收端的对应端口接收
18          * 4、关闭socket服务
19          */
20         DatagramSocket ds=new DatagramSocket();
21         
22         String context="UDP发送演示";
23         byte[] buf=context.getBytes();
24         
25         DatagramPacket dp=new DatagramPacket(buf, buf.length, InetAddress.getByName("192.16.25.16"), 10000);
26         
27         ds.send(dp);
28         
29         ds.close();
30     }
31 }

 1 import java.io.IOException;
 2 import java.net.DatagramPacket;
 3 import java.net.DatagramSocket;
 4 
 5 public class UDPReceiveDemo {
 6 
 7     public static void main(String[] args) throws IOException {
 8         System.out.println("接收端启动...");
 9         receivedemo();
10     }
11 
12     public static void receivedemo() throws IOException {
13         /*使用UDP接收数据和发送过程类似
14          * 1、建立发送端的socket服务,！！！需要明确端口号
15          * 2、创建数据包,准备存储和解析数据
16          * 3、使用socket的receive()接收数据存入准备好的解析对象中
17          * 4、使用数据包的解析方法解析数据,即拆包.可以解析出发送端地址,端口,数据内容等信息
18          * 5、关闭socket服务
19          */
20         DatagramSocket ds=new DatagramSocket(10000);
21         
22         byte[] buf=new byte[1024];
23         DatagramPacket dp=new DatagramPacket(buf, buf.length);
24         
25         ds.receive(dp);            //阻塞式,在接收到信息之前一直阻塞
26         String ip=dp.getAddress().getHostAddress();
27         int port=dp.getPort();
28         String context=new String(dp.getData(),0,dp.getLength());
29         System.out.println("ip是"+ip+",端口是"+port+",内容是\""+context+"\"");
30         
31         ds.close();
32     }
33 
34 }

 1 import java.io.IOException;
 2 import java.net.DatagramSocket;
 3 
 4 public class UDPTest {
 5     /*这是UDP协议的聊天室,使用UDPSendTest2和UDPReceiveTest2,
 6      * 其实就是添加了多线程
 7      */
 8     public static void main(String[] args) throws IOException {
 9         DatagramSocket send=new DatagramSocket();
10         DatagramSocket rece=new DatagramSocket(13419);
11         UDPSendTest2 usend=new UDPSendTest2(send);
12         UDPReceiveTest2 urece=new UDPReceiveTest2(rece);
13         Thread t1=new Thread(usend);
14         Thread t2=new Thread(urece);
15         t1.start();
16         t2.start();
17     }
18 
19 }

 1 import java.io.BufferedReader;
 2 import java.io.InputStreamReader;
 3 import java.net.DatagramPacket;
 4 import java.net.DatagramSocket;
 5 import java.net.InetAddress;
 6 
 7 public class UDPSendTest2 implements Runnable{
 8     private DatagramSocket ds;
 9     public UDPSendTest2(DatagramSocket ds){
10         this.ds=ds;
11     }
12     public void run(){
13         try{
14             BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
15             String line=null;
16             while((line=br.readLine())!=null){
17                 byte[] buf=line.getBytes();
18                 DatagramPacket dp=new DatagramPacket(buf, buf.length, InetAddress.getByName("172.25.14.5"), 13419);
19                 ds.send(dp);
20                 if(line.equals("886")){
21                     break;
22                 }
23             }
24             ds.close();
25         }catch(Exception e){
26         }
27     }
28 }

 1 import java.net.DatagramPacket;
 2 import java.net.DatagramSocket;
 3 
 4 public class UDPReceiveTest2 implements Runnable{
 5     private DatagramSocket ds;
 6     public UDPReceiveTest2(DatagramSocket ds){
 7         this.ds=ds;
 8     }
 9     public void run(){
10         try{
11             while(true){
12                 byte[] buf=new byte[1024];
13                 DatagramPacket dp=new DatagramPacket(buf, buf.length);
14                     
15                 ds.receive(dp);
16                 String context=new String(dp.getData(),0,dp.getLength());
17                 System.out.println("内容是:"+context);
18                 if(context.equals("886")){
19                     System.out.println("对方退出聊天");
20                 }
21             }
22         }catch(Exception e){
23         }
24     }
25 
26 }

 1 import java.io.IOException;
 2 import java.io.OutputStream;
 3 import java.net.Socket;
 4 import java.net.UnknownHostException;
 5 
 6 public class TCPClientDemo {
 7 
 8     public static void main(String[] args) throws UnknownHostException, IOException {
 9         demo();
10     }
11 
12     public static void demo() throws UnknownHostException, IOException {
13         /*TCP传输客户端的建立过程:
14          * 1、创建客户端socket服务,使用Socket对象
15          *         建议:一旦创建该对象,就明确要连接的主机地址
16          * 2、如果连接成功,会生成一个通道。在Java中表现为socket流,
17          *   有输入流和输出流,对应的对象可以通过Socket对象获取
18          *   getOutputStream()    --》获取输出流
19          *      getInputStream()    --》获取输入流
20          * 3、使用输出流发送数据,还可以接受服务器端反馈的数据
21          * 4、关闭资源
22          */
23         Socket s=new Socket("172.25.14.9", 10002);
24         OutputStream os=s.getOutputStream();
25         os.write("TCP演示".getBytes());
26         s.close();
27     }
28 
29 }

 1 import java.io.BufferedReader;
 2 import java.io.IOException;
 3 import java.io.InputStream;
 4 import java.io.InputStreamReader;
 5 import java.net.ServerSocket;
 6 import java.net.Socket;
 7 
 8 public class TCPServerDemo {
 9 
10     public static void main(String[] args) throws IOException {
11         /*TCP和UDP的一个不同是:TCP是面向连接的,
12          * 就是说要先开启服务器端,在开启客户端,两端相连接才能通讯
13          * 而UDP只要两端开启就可以通讯
14          */
15         demo();
16     }
17 
18     public static void demo() throws IOException {
19         /*
20          * 建立TCP服务器端的过程
21          * 1、建立服务器端的socket服务,使用ServerSocket对象
22          *       ！！！ 注意：服务器端必须提供一个端口给客户端使用,否则无法连接
23          * 2、获取正在连接的客户端socket对象,并使用该对象对应的通道,即socket流进行数据发送
24          *      ！！！注意:这是因为  服务器端需要和多个客户端进行数据交换,这样可以保证数据不会传错
25          * 3、关闭资源,包括客户端和服务器端。
26          */
27         ServerSocket ss=new ServerSocket(10002);
28         
29         //accept()是阻塞式,在服务器端开启后会一直阻塞,直到有传输数据进入才会执行下一步操作
30         Socket s=ss.accept();    
31         InputStream is=s.getInputStream();
32         
33         BufferedReader br=new BufferedReader(new InputStreamReader(is));
34         System.out.println(br.readLine());
35         
36         s.close();
37         ss.close();
38     }
39 
40 }

 1 import java.io.BufferedReader;
 2 import java.io.IOException;
 3 import java.io.InputStreamReader;
 4 import java.io.OutputStream;
 5 import java.io.PrintStream;
 6 import java.net.Socket;
 7 import java.net.UnknownHostException;
 8 
 9 public class TCPClientTest {
10 
11     public static void main(String[] args) throws UnknownHostException, IOException {
12         //TCPTest是用TCP协议建立一个服务器端,对客户端传来的数据进行大小写转换,使用键盘录入
13         demo();
14     }
15 
16     public static void demo() throws UnknownHostException, IOException {
17         Socket s=new Socket("172.25.14.9", 7999);
18         OutputStream os=s.getOutputStream();
19         PrintStream out=new PrintStream(os);
20         
21         BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
22         BufferedReader brIn=new BufferedReader(new InputStreamReader(s.getInputStream()));
23         String str=null;
24         while((str=br.readLine())!=null){
25             if(str.equals("over")){
26                 break;
27             }
28             out.println(str);
29             //上面一句相当于下面一句
30             //out.print(str+"\r\n");
31             //out.flush();
32             String upperStr=brIn.readLine();
33             System.out.println(upperStr);
34         }
35 
36         s.close();
37     }
38 }

 1 import java.io.BufferedReader;
 2 import java.io.IOException;
 3 import java.io.InputStream;
 4 import java.io.InputStreamReader;
 5 import java.io.OutputStream;
 6 import java.io.PrintStream;
 7 import java.net.ServerSocket;
 8 import java.net.Socket;
 9 
10 public class TCPServerTest {
11 
12     public static void main(String[] args) throws IOException {
13         demo();
14     }
15 
16     public static void demo() throws IOException {
17         ServerSocket ss=new ServerSocket(7999);
18         
19         Socket s=ss.accept();
20         InputStream is=s.getInputStream();
21         
22         BufferedReader br=new BufferedReader(new InputStreamReader(is));
23         OutputStream os=s.getOutputStream();
24         PrintStream out=new PrintStream(os,true);
25         String str=null;
26         while((str=br.readLine())!=null){
27             out.println(str.toUpperCase());
28         }
29         s.close();
30         ss.close();
31     }
32 
33 }

 1 import java.io.BufferedReader;
 2 import java.io.IOException;
 3 import java.io.InputStreamReader;
 4 import java.io.OutputStream;
 5 import java.io.FileReader;
 6 import java.io.PrintStream;
 7 import java.net.Socket;
 8 import java.net.UnknownHostException;
 9 
10 public class TCPUploadClient {
11 
12     public static void main(String[] args) throws UnknownHostException, IOException {
13         demo();
14     }
15 
16     public static void demo() throws UnknownHostException, IOException {
17         Socket s=new Socket("172.25.14.4", 7999);
18         OutputStream os=s.getOutputStream();
19         PrintStream out=new PrintStream(os);
20         
21         BufferedReader br=new BufferedReader(new FileReader("D:\\2.txt"));
22         String str=null;
23         while((str=br.readLine())!=null){
24             out.println(str);
25         }
26         
27         //因为TCP两端都有阻塞式方法,为了结束通讯过程,Java的socket对象提供了TCP通讯结束标记,
28         s.shutdownOutput();
29         
30         BufferedReader brIn=new BufferedReader(new InputStreamReader(s.getInputStream()));
31         String context=brIn.readLine();
32         System.out.println(context);
33         br.close();
34         s.close();
35     }
36 }

 1 import java.io.BufferedReader;
 2 import java.io.BufferedWriter;
 3 import java.io.IOException;
 4 import java.io.InputStream;
 5 import java.io.InputStreamReader;
 6 import java.io.OutputStream;
 7 import java.net.ServerSocket;
 8 import java.net.Socket;
 9 import java.io.FileWriter;
10 import java.io.PrintStream;
11 
12 public class TCPUploadServer {
13 
14     public static void main(String[] args) throws IOException {
15         demo();
16     }
17 
18     public static void demo() throws IOException {
19         ServerSocket ss=new ServerSocket(7999);
20         
21         
22         Socket s=ss.accept();
23         String ip=s.getInetAddress().getHostAddress();
24         System.out.println(ip+"....connect");
25         InputStream is=s.getInputStream();
26         
27         BufferedReader br=new BufferedReader(new InputStreamReader(is));
28         BufferedWriter bw=new BufferedWriter(new FileWriter("D:\\1.txt"));
29         OutputStream os=s.getOutputStream();
30         PrintStream out=new PrintStream(os,true);
31         String str=null;
32         while((str=br.readLine())!=null){
33             if(str.equals("over")){
34                 break;
35             }
36             bw.write(str);
37             bw.newLine();
38             bw.flush();
39         }
40         out.println("get");
41         bw.close();
42         s.close();
43         ss.close();
44     }
45 
46 }