网络编程（续）

UDP的基本使用方法

需求：通过udp传输方式，将一段文字数据发送出去。，

定义一个udp发送端。

 

class  UdpSend

{

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

       {

              //1，创建udp服务。通过DatagramSocket对象。

              DatagramSocket ds = new DatagramSocket(8888);

 

              //2，确定数据，并封装成数据包。DatagramPacket(byte[] buf, int length, InetAddress address, int port)

 

              byte[] buf = "heima I am coming !".getBytes();

              DatagramPacket dp =

                     new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.254"),10000);

 

              //3，通过socket服务，将已有的数据包发送出去。通过send方法。

              ds.send(dp);

 

              //4，关闭资源。

ds.close();

       }

}

 

需求：

定义一个应用程序，用于接收udp协议传输的数据并处理的。

 

定义udp的接收端。

 

class  UdpRece

{

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

       {

              //1,创建udp socket，建立端点。

              DatagramSocket ds = new DatagramSocket(10000);

              while(true)

              {

              //2,定义数据包。用于存储数据。

              byte[] buf = new byte[1024];

              DatagramPacket dp = new DatagramPacket(buf,buf.length);

 

              //3，通过服务的receive方法将收到数据存入数据包中。

              ds.receive(dp);//阻塞式方法。

             

 

              //4，通过数据包的方法获取其中的数据。

              String ip = dp.getAddress().getHostAddress();

 

              String data = new String(dp.getData(),0,dp.getLength());

 

              int port = dp.getPort();

 

              System.out.println(ip+"::"+data+"::"+port);

 

              }

              //5，关闭资源

              //ds.close();

 

       }

}

tcp传输。

1,tcp分客户端和服务端。

2，客户端对应的对象是Socket。

       服务端对应的对象是ServerSocket。

客户端，

通过查阅socket对象，发现在该对象建立时，就可以去连接指定主机。

因为tcp是面向连接的。所以在建立socket服务时，

就要有服务端存在，并连接成功。形成通路后，在该通道进行数据的传输。

 

需求：给服务端发送给一个文本数据。

 

class  TcpClient

{

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

       {

              //创建客户端的socket服务。指定目的主机和端口

              Socket s = new Socket("192.168.1.254",10003);

             

              //为了发送数据，应该获取socket流中的输出流。

              OutputStream out = s.getOutputStream();

 

              out.write("tcp heima I am coming ! ".getBytes());

 

 

              s.close();

       }

}

 

 

需求：定义端点接收数据并打印在控制台上。

 

服务端:

 

class  TcpServer

{

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

       {

              //建立服务端socket服务。并监听一个端口。

              ServerSocket ss = new ServerSocket(10003);

 

              //通过accept方法获取连接过来的客户端对象。

              while(true)

              {

              Socket s = ss.accept();//阻塞式的方法所以不会形成无限循环

 

              String ip = s.getInetAddress().getHostAddress();

              System.out.println(ip+".....connected");

 

              //获取客户端发送过来的数据，那么要使用客户端对象的读取流来读取数据。

              InputStream in = s.getInputStream();

             

              byte[] buf = new byte[1024];

              int len = in.read(buf);

 

              System.out.println(new String(buf,0,len));

 

              s.close();//关闭客户端.

              }

              //ss.close();可选，因为服务端一般是不会关闭的

       }

}

 

 

tcp的传输的客户端和服务端的互访。

 

需求：客户端给服务端发送数据，服务端收到后，给客户端反馈信息。

 

客户端：

class TcpClient2

{

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

       {

              Socket s = new Socket("192.168.1.254",10004);

             

              OutputStream out = s.getOutputStream();

 

              out.write("服务端，你好".getBytes());

 

             

              InputStream in = s.getInputStream();

 

              byte[] buf = new byte[1024];

 

              int len = in.read(buf);

 

              System.out.println(new String(buf,0,len));

 

              s.close();

       }

}

 

服务端：

class TcpServer2

{

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

       {

              ServerSocket ss = new ServerSocket(10004);

 

              Socket s = ss.accept();

 

              String ip = s.getInetAddress().getHostAddress();

              System.out.println(ip+"....connected");

              InputStream in = s.getInputStream();

 

              byte[] buf = new byte[1024];

 

              int len = in.read(buf);

 

              System.out.println(new String(buf,0,len));

 

 

              OutputStream out = s.getOutputStream();

 

 

              Thread.sleep(10000);

              out.write("哥们收到,你也好".getBytes());

 

              s.close();

 

              ss.close();

       }

}

 

建立一个文本转换服务器

客户端给服务端发送文本，服务端将文本转成大写在返回给客户端。

而且客户端可以不断的进行文本转换。当客户端输入over时，转换结束。

 

客户端：

class  TransClient

{

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

       {

              Socket s = new Socket("192.168.1.254",10005);

 

 

              //定义读取键盘数据的流对象。

              BufferedReader bufr =

                     new BufferedReader(new InputStreamReader(System.in));

 

 

              //定义目的，将数据写入到socket输出流。发给服务端。

              //BufferedWriter bufOut =

                     //new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));

              PrintWriter out = new PrintWriter(s.getOutputStream(),true);

 

 

              //定义一个socket读取流，读取服务端返回的大写信息。

              BufferedReader bufIn =

                     new BufferedReader(new InputStreamReader(s.getInputStream()));

 

              String line = null;

             

              while((line=bufr.readLine())!=null)

              {

                     if("over".equals(line))

                            break;

                    

                     out.println(line);

//                   bufOut.write(line);

//                   bufOut.newLine();

//                   bufOut.flush();

 

                     String str =bufIn.readLine();

                     System.out.println("server:"+str);

                    

              }

 

              bufr.close();

              s.close();//在socket流中加-1标记

 

 

       }

}

/*

 

服务端：

class  TransServer

{

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

       {

              ServerSocket ss = new ServerSocket(10005);

 

              Socket s = ss.accept();

              String ip = s.getInetAddress().getHostAddress();

              System.out.println(ip+"....connected");

 

              //读取socket读取流中的数据。

              BufferedReader bufIn =

                     new BufferedReader(new InputStreamReader(s.getInputStream()));

 

              //目的。socket输出流。将大写数据写入到socket输出流，并发送给客户端。

              //BufferedWriter bufOut =

                     //new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));

 

              PrintWriter out = new PrintWriter(s.getOutputStream(),true);

         //目地流，可以接收字节流也可接收字符流，还可以自动刷新

              String line = null;

              while((line=bufIn.readLine())!=null)//读到回车换行才返回

              {

 

                     System.out.println(line);

 

                     out.println(line.toUpperCase());

//                   bufOut.write(line.toUpperCase());

//                   bufOut.newLine();结束标记

//                   bufOut.flush();

              }

 

              s.close();

              ss.close();

 

       }

}

上传图片

客户端。

class  PicClient

{

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

       {

              Socket s = new Socket("192.168.1.254",10007);

 

              FileInputStream fis = new FileInputStream("c:\\1.bmp");

 

              OutputStream out = s.getOutputStream();

 

              byte[] buf = new byte[1024];

 

              int len = 0;

 

              while((len=fis.read(buf))!=-1)

              {

                     out.write(buf,0,len);

              }

 

//告诉服务端数据已写完

              s.shutdownOutput();

 

              InputStream in = s.getInputStream();

 

              byte[] bufIn = new byte[1024];

 

              int num = in.read(bufIn);

              System.out.println(new String(bufIn,0,num));

 

              fis.close();

              s.close();

       }

}

 

 

服务端

 

class  PicServer

{

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

       {

              ServerSocket ss = new ServerSocket(10007);

 

              Socket s = ss.accept();

 

              InputStream in = s.getInputStream();

 

              FileOutputStream fos = new FileOutputStream("server.bmp");

 

              byte[] buf = new byte[1024];

 

              int len = 0;

              while((len=in.read(buf))!=-1)

              {

                     fos.write(buf,0,len);

              }

 

              OutputStream out = s.getOutputStream();

 

              out.write("上传成功".getBytes());

 

              fos.close();

 

              s.close();

 

              ss.close();

       }

}

 

URLConnection建立网络连接

class  URLConnectionDemo

{

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

       {

              URL url = new URL("http://192.168.1.254:8080/myweb/demo.html");

 

              URLConnection conn = url.openConnection();

              System.out.println(conn);

             

              InputStream in = conn.getInputStream();

 

              byte[] buf = new byte[1024];

 

              int len = in.read(buf);

 

              System.out.println(new String(buf,0,len));

 

 

       }

}