Java基础---网络编程

第一讲     概述 

1、网络模型：OSI参考模型和TCP/IP参考模型

图示：

        一般来说开发处于传输层和网际层，应用层为：FTP和HTTP协议等，传输层为：UDP和TCP等，网际层为：IP。

        通常用户操作的是应用层，而编程人员需要做的是传输层和网际层，用户在应用层操作的数据，经过逐层封包，最后到物理层发送到另一个模型中，再进行逐层解包，图示为：

 

2、网络通信三要素：IP地址，端口号，传输协议

A、IP地址

        a、它是网络中的设备标识

        b、不易记忆，可用主机名表示，两者存在映射关系

        c、本机回环地址：127.0.0.1，主机名为：localhost。

IP地址：java中对应的是InetAddress类，存在于java.net包中。

InetAddress类：

     （一）无构造函数，可通过getLocalHost()方法获取InetAddress对象，此方法是静态的，返回本类对象。

                  InetAddress i = InetAddress.getLocalHost();

     （二）方法：

                1）static InetAddress getByName(String host)：获取指定主机的IP和主机名。（最好用ip地址去获取，主机名需要解析）

                2）static InetAddress[] getAllByName(String host)：在给定主机名的情况下，根据系统上配置的名称服务返回IP地址所组成的数组。返回对象不唯一时，用此方法。

                3）String getHostAddress()：返回IP地址字符串文本形式，以IP地址为主。

                4）String getHostName()：返回IP地址主机名。

     （三）如何获取任意一台主机的IP地址对象：

                1）功能：返回InetAddress对象

                2）对于任意主机，需要指定传入主机名的参数

注意：如果IP地址和对应的主机名，这种映射关系没有在网络上，就不会解析成功，返回的还是指定的IP。

示例：

[java] view plaincopy
  1. import java.net.*;  
  2. class IPDemo   
  3. {  
  4.     public static void main(String[] args)throws Exception   
  5.     {  
  6.         //获取本类对象  
  7.         InetAddress ia=InetAddress.getLocalHost();  
  8.           
  9.         //ip  
  10.         String address=ia.getHostAddress();  
  11.         //主机名  
  12.         String name=ia.getHostName();  
  13.         System.out.println("IP="+address+"\tname="+name);  
  14.   
  15.         //获取指定主机的ip信息  
  16.         InetAddress i=InetAddress.getByName("192.168.1.175");  
  17.   
  18.         String add=i.getHostAddress();  
  19.         String na=i.getHostName();  
  20.         System.out.println("addIP="+add+"\tiname="+na);  
  21.   
  22.         //获取指定主机名的ip信息  
  23.         InetAddress[] baidu=InetAddress.getAllByName("www.baidu.com");  
  24.         for (InetAddress b :baidu)  
  25.         {  
  26.             String baddress=b.getHostAddress();  
  27.             String bname=b.getHostName();  
  28.             System.out.println("baiduIP="+baddress+"\tbaiduname="+bname);  
  29.         }  
  30.     }  
  31. }  

B、端口号：

        a、用于标识进程的逻辑地址，不用进程的标识。

        b、有效端口：0 ~65535，系统使用或保留的端口是：0~ 1024。

C、传输协议：

        即通信规则，包含TCP和UDP协议

UDP

        是面向无连接，明确了对方的端口，无论在不在网上，只管传输，不在就会丢失数据。只求速度，应用于网络视频会议和聊天等应用程序中。

协议特点：

         a、面向无连接，即将数据及源和目的封装成数据包中，不建立链接的发送

         b、每个数据包的大小限制在64K之内

         c、因无连接，是不可靠的协议

         d、不建立连接，速度快。

TCP

        是面向连接的，必须连接成功才能传输数据，应用于下载等程序上

协议特点：

         a、面向连接，在建立连接后，形成传输数据的通道

         b、在连接中进行大数据量的传输

         c、通过三次握手完成连接，是可靠的协议

         d、必须建立连接，效率稍慢

三次握手：第一次本方发送请求，第二次对方确认连接，第三次本方再次确认连接成功。

3、通信的步骤：

        1）找到IP地址

        2）数据要发送到对象指定应用程序，为标识这些应用程序，所以给这些网络应用程序都用数字标识，为方便称呼这个数字，叫做端口，即逻辑端口。

        3）定义通信规则，称之为协议。国际组织定义了通用协议，即TCP/IP。

注意：必须要有数字标识才能将数据发送到应用程序上。

 

第二讲     传输协议

一、Socket

        1、它被称之为插座，相当于港口一样，是网络服务提供的一种机制。

        2、通信两端都要有Socket，才能建立服务。

        3、网络通信其实就是Socket间的通信，数据在两个Socket间通过IO传输。

 

二、UDP传输

1、通过类DatagramSocket，此类表示用发送和接收数据包的套接字，即Socket。

2、方法：

        1）创建 UDPSocket发送服务对象：

              DatagramSocket()，不指定端口。DatagramSocket(int port)，指定端口。

        2）发送：void send(DatagramPacket p)

        3）接收：void receive(DatagramPacket p)

       其中DatagramPacket：数据报包用来实现无连接包投递服务的，每条报文仅根据该包中包含的信息从一台机器路由到另一台机器中。凡是带地址（InetAddress）的都是用于发送包的。

3、步骤

        1）发送数据：

              a、建立UDPSocket服务，在此无需指定端口，也可以将端口加入。如果不指定的话，系统会随机分配一个端口，如第一次运行时端口为1093，那么第二次就会顺延为1094，再运行会一直顺延，因为之前的端口还没有得到释放，所以会顺延端口号值。

              b、提供数据，并将数据封装到数据包中

              c、通过socket服务的发送功能，将数据包发送出去

              d、关闭资源

        2）接收数据：

              a、定义UDPSocket服务。通常会监听一个端口，其实就是给这个接收网路应用程序定义数字标识，方便于明确哪些数据过来该应用程序可以处理。

              b、定义一个数据包，用来存储接收到的字节数据，因为数据包对象中有更多功能可以提取字节数据中的不同数据信息。

              c、通过socket服务的receive方法接收到的数据存入已定义好的数据包中伤感的句子

              d、通过数据包对象的特有功能，将这些不同的数据取出，打印在控制台上

              e、关闭资源

        在定义接收数据的方法中，仍会在DatagramSocket构造函数中传入DatagramPacket的参数，这是因为收到的数据太多，需要解析，通过将数据封装成对象，易于解析，所以需要传入参数。

注意：

        1、发送端与接收端是两个独立的运行程序。

        2、在发送端，要在数据包对象中明确目的地IP及端口。

        3、在接收端，要指定监听的端口。

示例：

[java] view plaincopy
  1. /* 
  2. udp发送端： 
  3. 需求：通过udp传输方式，将一段文字数据发送出去。 
  4. */  
  5.   
  6. import java.net.*;  
  7. class UdpSend   
  8. {  
  9.     public static void main(String[] args)throws Exception   
  10.     {  
  11.         //1、创建udp服务。通过DatagramSocket对象  
  12.         DatagramSocket ds=new DatagramSocket();  
  13.         //2、确定数据，并封装成数据包。DatagramPacket(byte[] buf, int length, InetAddress address, int port)   
  14.         byte[] buf="udp shi shen ma".getBytes();  
  15.         DatagramPacket dp=new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.175"),10000);  
  16.   
  17.         //3、通过Socket服务，将已有的数据包发送出去。通过send方法。  
  18.         ds.send(dp);  
  19.         //4、关闭资源  
  20.         ds.close();  
  21.     }  
  22. }  
  23.   
  24. /* 
  25. udp接收端 
  26. 需求：定义一个应用程序，用于接收udp协议传输的数据并处理。 
  27. */  
  28.   
  29. class UdpReceive  
  30. {  
  31.     public static void main(String[] args)throws Exception  
  32.     {  
  33.         //1、创建udp Socket服务，建立端点  
  34.         //DatagramSocket ds=new DatagramSocket(10000);  
  35.           
  36.         //一直处于接收状态  
  37.         while(true)  
  38.         {  
  39.             //1、创建udp Socket服务，建立端点  
  40.             DatagramSocket ds=new DatagramSocket(10000);  
  41.             //2、定义数据包。用于存储数据  
  42.             byte[] buf=new byte[1024];  
  43.             DatagramPacket dp=new DatagramPacket(buf,buf.length);  
  44.             //3、通过Socket服务的receive方法将接收到的数据存入数据包中  
  45.             ds.receive(dp);//阻塞式方法  
  46.             //4、通过数据包的方法获取其中的数据  
  47.             String ip=dp.getAddress().getHostName();  
  48.             String data=new String(dp.getData(),0,dp.getLength());  
  49.             int port=dp.getPort();  
  50.             System.out.println(ip+"::"+data+"::"+port);  
  51.             //5、关闭资源  
  52.             ds.close();  
  53.         }  
  54.         //5、关闭资源  
  55.         //ds.close();  
  56.     }  
  57. }  

练习一

[java] view plaincopy
  1. /* 
  2. 用键盘录入的方式，来发送数据 
  3. */  
  4.   
  5. import java.net.*;  
  6. import java.io.*;  
  7. //UDP 发送端  
  8. class UdpSend    
  9. {  
  10.     public static void main(String[] args)throws Exception  
  11.     {  
  12.         //1、创建udp Socket服务  
  13.         DatagramSocket ds=new DatagramSocket(9999);  
  14.         //2、确定数据，从键盘录入，并把键盘录入的数据封装成数据包  
  15.         DatagramPacket dp=null;  
  16.         BufferedReader br=new BufferedReader(new InputStreamReader(System.in));  
  17.         String line=null;  
  18.         while((line=br.readLine())!=null)  
  19.         {  
  20.             byte[] buf=line.getBytes();  
  21.             dp=new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.255"),10000);  
  22.             //3、通过Socket服务，将已有的数据包发送出去  
  23.             ds.send(dp);  
  24.             if ("886".equals(line))  
  25.             {  
  26.                 break;  
  27.             }  
  28.         }  
  29.         //4、关闭资源  
  30.         ds.close();  
  31.           
  32.     }  
  33. }  
  34.   
  35. //UDP 接收端  
  36. class UdpReceive  
  37. {  
  38.     public static void main(String[] args)throws Exception  
  39.     {  
  40.         //1、创建udp Socket服务  
  41.         DatagramSocket ds=new DatagramSocket(10000);  
  42.         //一直处于接收状态  
  43.         while (true)  
  44.         {  
  45.             //2、定义数据包，用于存储数据  
  46.             byte[] buf=new byte[1024];  
  47.             DatagramPacket dp=new DatagramPacket(buf,buf.length);  
  48.             //3、通过Socket服务，将数据接收并存储进数据包中  
  49.             ds.receive(dp);  
  50.             //4、通过数据包的方法获取其中的数据  
  51.             String ip=dp.getAddress().getHostAddress();  
  52.             String data=new String(dp.getData(),0,dp.getLength());  
  53.             int port=dp.getPort();  
  54.   
  55.             System.out.println("IP:"+ip+"=="+data);  
  56.         }  
  57.         //5、关闭资源  
  58.         //ds.close();  
  59.     }  
  60. }     

练习二

[java] view plaincopy
  1. /* 
  2. 编写一个聊天程序。 
  3. 有收数据的部分，和发数据的部分。 
  4. 这两部分需要同时执行。 
  5. 那就需要用到多线程技术。 
  6. 一个线程控制收，一个线程控制发。 
  7.  
  8. 因为收和发动作是不一致的，所以要定义两个run方法。 
  9. 而且这个两个方法要封装到不同的类中。 
  10.  
  11. */  
  12. //Udp发送线程  
  13.   
  14. import java.net.*;  
  15. import java.io.*;  
  16.   
  17. class UdpSend implements Runnable  
  18. {  
  19.     //定义Socket服务引用  
  20.     private DatagramSocket ds;  
  21.     UdpSend(DatagramSocket ds)  
  22.     {  
  23.         this.ds=ds;  
  24.     }  
  25.     //复写run方法  
  26.     public void run()  
  27.     {  
  28.         try  
  29.         {  
  30.             //2、确定数据，从键盘录入，并把键盘录入的数据封装成数据包  
  31.             DatagramPacket dp=null;  
  32.             BufferedReader br=new BufferedReader(new InputStreamReader(System.in));  
  33.             String line=null;  
  34.             while((line=br.readLine())!=null)  
  35.             {  
  36.                 byte[] buf=line.getBytes();  
  37.                 dp=new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.255"),10000);  
  38.                 //3、通过Socket服务，将已有的数据包发送出去  
  39.                 ds.send(dp);  
  40.                 if ("886".equals(line))  
  41.                 {  
  42.                     break;  
  43.                 }  
  44.             }  
  45.             //4、关闭资源  
  46.             ds.close();  
  47.         }  
  48.         catch (Exception e)  
  49.         {  
  50.             throw new RuntimeException("发送数据失败");  
  51.         }         
  52.     }  
  53. }  
  54.   
  55. //Udp接收线程  
  56. class UdpReceive implements Runnable  
  57. {  
  58.     //定义Socket服务引用  
  59.     private DatagramSocket ds;  
  60.     UdpReceive(DatagramSocket ds)  
  61.     {  
  62.         this.ds=ds;  
  63.     }  
  64.     //复写run方法  
  65.     public void run()  
  66.     {  
  67.         try  
  68.         {  
  69.             //一直处于接收状态  
  70.             while (true)  
  71.             {  
  72.                 //2、定义数据包，用于存储数据  
  73.                 byte[] buf=new byte[1024];  
  74.                 DatagramPacket dp=new DatagramPacket(buf,buf.length);  
  75.                 //3、通过Socket服务，将数据接收并存储进数据包中  
  76.                 ds.receive(dp);  
  77.                 //4、通过数据包的方法获取其中的数据  
  78.                 String ip=dp.getAddress().getHostAddress();  
  79.                 String data=new String(dp.getData(),0,dp.getLength());  
  80.                 int port=dp.getPort();  
  81.   
  82.                 System.out.println("IP:"+ip+"=="+data);  
  83.             }  
  84.             //5、关闭资源  
  85.             //ds.close();  
  86.         }  
  87.         catch (Exception e)  
  88.         {  
  89.             throw new RuntimeException("接收端接收数据失败");  
  90.         }  
  91.     }  
  92. }  
  93.   
  94. class UdpChatDemo  
  95. {  
  96.     public static void main(String[] args)throws Exception  
  97.     {  
  98.         new Thread(new UdpSend(new DatagramSocket())).start();  
  99.         new Thread(new UdpReceive(new DatagramSocket(10000))).start();  
  100.     }  
  101. }  

三、TCP传输

1、TCP分客户端和服务端。客户端对应的对象是Socket，服务端对应的对象是ServerSocket。

2、方法：

        1）创建客户端对象：

              Socket()：创建空参数的客户端对象，一般用于服务端接收数据

              Socket(String host,int port)，指定要接收的IP地址和端口号淘宝开店

        2）创建服务端对象：ServerSocket(int port)：指定接收的客户端的端口

        3）Socket accept()：监听并接受到此套接字的连接

        4）void shutdownInput()：此套接字的输入流至于“流的末尾”

        5）void shutdownOutput()：禁用此套接字的输出流

        6）InputStream getInputStream()：返回此套接字的输入流，Socket对象调用

        7）OutputStream getOutputStream()：返回套接字的输出流，Socket对象调用

3、基本思路

客户端：

        1）客户端需要明确服务器的ip地址以及端口，这样才可以去试着建立连接，如果连接失败，会出现异常。

        2）连接成功，说明客户端与服务端建立了通道，那么通过IO流就可以进行数据的传输，而Socket对象已经提供了输入流和输出流对象，通过getInputStream(),getOutputStream()获取即可。

        3）与服务端通讯结束后，关闭Socket。

服务端：

        1）服务端需要明确它要处理的数据是从哪个端口进入的。

        2）当有客户端访问时，要明确是哪个客户端，可通过accept()获取已连接的客户端对象，并通过该对象与客户端通过IO流进行数据传输。

        3）当该客户端访问结束，关闭该客户端。

4、步骤

客户端：

        通过查阅Socket对象的API文档，发现在该对象在建立时，就可去连接指定主机，因为TCP是面向连接的，所以在建立Socket服务时，就要有服务端存在，并连接成功，形成通路后，再通过该通道进行数据的传输。

         1）创建Socket服务，并指定要连接的主机端口。通路一建立，就会产生Socket流（包括输入流和输出流），通过方法获取

         2）为了发送数据，应获取Socket中的输出流，如果要接收服务端的反馈信息，还需要获取Socket的输入流

         3）通过输出流的write()方法将要发送的数据写入到流中

         4）关闭Socket流资源

服务端：

        服务器套接字等待请求通过网络传入。它基于该请求执行某些操作，然后可能向请求者返回结果。需监听一个端口。

         1）建立服务端的Socket服务，并监听一个端口。通过ServerSocet带端口参数的构造函数

         2）获取连接过来的客户对象，通过ServerSocket的accept()方法，此方法是阻塞式的，如果服务端没有连接到就会一直等待

         3）客户端如果发过来数据，则服务端要使用对应的客户端对象，并获取到该客户端对象的读取流读取发过来的数据，并输出到指定目的地。

         4）关闭服务端（可选）。一般服务端是常开的，因为在实际应用中，随时有客户端在请求连接和服务。但这里需要定时关闭客户端对象流，避免某一个客户端长时间占用服务器端。

示例：

[java] view plaincopy
  1. /* 
  2. 需求：客户端给服务端发送数据，服务端收到后，给客户端反馈信息。 
  3. */  
  4. //客户端  
  5. import java.net.*;  
  6. import java.io.*;  
  7. class  TcpClient  
  8. {  
  9.     public static void main(String[] args) throws Exception  
  10.     {  
  11.         //1、创建客户端的Socket服务。指定目的主机和端口  
  12.         Socket s=new Socket("127.0.0.1",10000);  
  13.         //2、获取Socket流中输出流，发送数据  
  14.         OutputStream out=s.getOutputStream();  
  15.         out.write("你好！".getBytes());  
  16.         //3、获取Socket流中的输入流，用来接收服务端的反馈信息并打印  
  17.         InputStream in=s.getInputStream();  
  18.           
  19.         byte[] buf=new byte[1024];  
  20.         int len=in.read(buf);//读取反馈的数据  
  21.   
  22.         //输出接收的数据  
  23.         System.out.println(new String(buf,0,len));  
  24.   
  25.         s.close();//关闭资源  
  26.     }  
  27. }  
  28.   
  29.   
  30. //服务端  
  31.   
  32. class TcpServer  
  33. {  
  34.     public static void main(String[] args)throws Exception  
  35.     {  
  36.         //1、创建服务端的Socket服务，并监听一个端口  
  37.         ServerSocket ss=new ServerSocket(10000);  
  38.         //2、通过accept方法获取连接过来的客户端对象。  
  39.         Socket s=ss.accept();  
  40.         //获取客户端ip  
  41.         String ip=s.getInetAddress().getHostName();  
  42.         System.out.println(ip+"connected....");  
  43.         //3、获取对应客户端对象的读取流读取发过来的数据，并打印  
  44.         InputStream in=s.getInputStream();  
  45.         byte[] buf=new byte[1024];  
  46.         int len=in.read(buf);  
  47.         System.out.println(new String(buf,0,len));  
  48.   
  49.         //4、调用对应的客户端的输出流写入返回数据  
  50.         OutputStream out=s.getOutputStream();  
  51.         out.write("哥们，收到！".getBytes());  
  52.   
  53.         //关闭资源  
  54.         s.close();  
  55.         ss.close();//可选操作  
  56.     }  
  57. }  

练习一

[java] view plaincopy
  1. /* 
  2. 练习 
  3. 需求：建立一个文本转换服务器 
  4. 客户端给服务端发送文本，服务端会将文本转成大写再返回给客户端。 
  5. 而且客户端可以不断的进行文本转换。当客户端输入over时，转换结束。 
  6.  
  7. 分析： 
  8. 客户端： 
  9. 既然是操作设备上的数据，那么就可以使用io技术，并按照io的操作规律来思考。 
  10. 源：键盘录入 
  11. 目的：网络设备，网络输出流。 
  12. 而且操作的是文本数据。可以选择字符流。 
  13.  
  14. 步骤： 
  15. 1、建立服务 
  16. 2、获取键盘录入 
  17. 3、将数据发给服务端 
  18. 4、获取服务端返回的大写数据 
  19. 5、结束，管资源。 
  20.  
  21. 都是文本数据，可以使用字符流进行操作，同时提高效率，加入缓冲。 
  22.  
  23.  
  24. 此练习出现的问题： 
  25. 现象：客户端和服务端都在莫名的等待。 
  26. 原因：因为客户端和服务端都有阻塞式方法。这些方法没有读到结束标记。那么就一直等。而导致两端都在等待。 
  27. 解决：需要用到刷新和换行的方式将写入和读取的数据从流中刷新到内存中 
  28.     方式一：可用高效缓冲区类的newLine()换行作为结束标记，并用flush()进行刷新。 
  29. 方式二：可用PrintWriter(s.getOutputStrean(),true)创建输出流对象，true作用是刷新，通过打印方法println()换行，“ln”表示换行。 
  30.  
  31. */  
  32.   
  33. import java.io.*;  
  34. import java.net.*;  
  35. class  TcpClient  
  36. {  
  37.     public static void main(String[] args) throws Exception  
  38.     {  
  39.         //创建Socket服务  
  40.         Socket s=new Socket("127.0.0.1",10000);  
  41.           
  42.         //定义读取键盘数据的流对象  
  43.         BufferedReader br=new BufferedReader(new InputStreamReader(System.in));  
  44.           
  45.         //定义目的，将数据写入到Socket输出流。发给服务端  
  46.         //BufferedWriter bwout=new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));  
  47.         PrintWriter pw=new PrintWriter(s.getOutputStream(),true);  
  48.           
  49.         //定义一个Socket读取流，读取服务端返回的大写信息。  
  50.         BufferedReader brin=new BufferedReader(new InputStreamReader(s.getInputStream()));  
  51.   
  52.         String line=null;  
  53.         while ((line=br.readLine())!=null)  
  54.         {  
  55.               
  56.             if("over".equals(line))  
  57.                 break;  
  58.   
  59.             //bwout.write(line);//写入输出流  
  60.             //bwout.newLine();//换行  
  61.             //bwout.flush();//刷新  
  62.             pw.println(line);//将数据写入流中  
  63.   
  64.             String data=brin.readLine();//读取返回的信息  
  65.             System.out.println(data);  
  66.   
  67.         }  
  68.         br.close();//关流  
  69.         s.close();  
  70.     }  
  71. }  
  72. /* 
  73. 服务端： 
  74. 源：Socket读取流 
  75. 目的：Socket输出流 
  76. 都是文本，装饰 
  77. */  
  78.   
  79. class TcpServer  
  80. {  
  81.     public static void main(String[] args)throws Exception  
  82.     {  
  83.         //创建服务端的ServerSocket服务,并指定监听端口  
  84.         ServerSocket ss =new ServerSocket(10000);  
  85.           
  86.         //获取客户端连接  
  87.         Socket s=ss.accept();  
  88.   
  89.         //获取客户端ip  
  90.         System.out.println(s.getInetAddress().getHostName()+" connected.......");  
  91.   
  92.         //读取Socket读取流中的数据  
  93.         BufferedReader brin=new BufferedReader(new InputStreamReader(s.getInputStream()));  
  94.   
  95.         //将大写数据写入到Socket输出流，并发送给客户端。  
  96.         //BufferedWriter bwout=new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));  
  97.         PrintWriter pw=new PrintWriter(s.getOutputStream(),true);  
  98.   
  99.         String line=null;  
  100.         while ((line=brin.readLine())!=null)  
  101.         {  
  102.             System.out.println(line);  
  103.   
  104.             //bwout.write(line.toUpperCase());//将读到数据转换为大写后返回  
  105.             //bwout.newLine();//换行  
  106.             //bwout.flush();//刷新  
  107.   
  108.             pw.println(line.toUpperCase());//将读到数据转换为大写后返回  
  109.         }  
  110.         s.close();//关流  
  111.         ss.close();关闭资源（可选）  
  112.     }  
  113. }  

练习二

[java] view plaincopy
  1. /* 
  2. 需求：向服务器上传一个文件，服务返回一条信息 
  3. 1、客户端： 
  4. 源：硬盘上的文件；目的：网络设备，即网络输出流。 
  5. 若操作的是文本数据，可选字符流，并加入高效缓冲区。若是媒体文件，用字节流。 
  6.  
  7. 2、服务端： 
  8. 源：socket读取流；目的：socket输出流。 
  9.  
  10. 3、出现的问题：  
  11. 现象： 
  12. a、文件已经上传成功了，但是没有得到服务端的反馈信息。 
  13. b、即使得到反馈信息，但得到的是null，而不是“上传成功”的信息 
  14.  
  15. 原因： 
  16. a、因为客户端将数据发送完毕后，服务端仍然在等待这读取数据，并没有收到结束标记，就会一直等待读取。 
  17. b、上个问题解决后，收到的不是指定信息而是null，是因为服务端写入数据后，需要刷新，才能将信息反馈给客服端。 
  18.  
  19. 解决： 
  20. 方法一：定义结束标记，先将结束标记发送给服务端，让服务端接收到结束标记，然后再发送上传的数据。但是这样定义可能会发生定义的标记和文件中的数据重复，而导致提前结束。 
  21.    方法二：定义时间戳，由于时间是唯一的，在发送数据前，先获取时间，发送完后在结尾处写上相同的时间戳，在服务端，接收数据前先接收一个时间戳，然后在循环中判断时间戳以结束标记。 
  22.   方法三：通过socket方法中的shutdownOutput()，关闭输入流资源，从而结束传输流，以给定结束标记。通常用这个方法。 
  23. */  
  24.   
  25. import java.io.*;  
  26. import java.net.*;  
  27.   
  28.   
  29. //客户端  
  30. class  TcpClient  
  31. {  
  32.     public static void main(String[] args) throws Exception  
  33.     {  
  34.         //创建Socket服务  
  35.         Socket s=new Socket("127.0.0.1",10000);  
  36.           
  37.         //定义读取流读取文件数据  
  38.         BufferedReader br=new BufferedReader(new FileReader("TcpDemo.java"));  
  39.   
  40.         //定义目的，将数据写入到Socket输出流。发给服务端  
  41.         //BufferedWriter bwout=new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));  
  42.         PrintWriter pw=new PrintWriter(s.getOutputStream(),true);  
  43.   
  44.         //定义一个Socket读取流，读取服务端返回信息。  
  45.         BufferedReader brin=new BufferedReader(new InputStreamReader(s.getInputStream()));  
  46.   
  47.         String line=null;  
  48.         while ((line=br.readLine())!=null)  
  49.         {  
  50.             pw.println(line);  
  51.         }  
  52.           
  53.         s.shutdownOutput();//关闭客户端的输出流。相当于给流中加入一个结束标记-1.  
  54.   
  55.         System.out.println(brin.readLine());//接收返回信息  
  56.           
  57.         br.close();  
  58.         s.close();  
  59.     }  
  60. }  
  61.   
  62. //服务端  
  63. class TcpServer  
  64. {  
  65.     public static void main(String[] args)throws Exception  
  66.     {  
  67.         //创建服务端的ServerSocket服务,并指定监听端口  
  68.         ServerSocket ss =new ServerSocket(10000);  
  69.           
  70.         //获取客户端连接  
  71.         Socket s=ss.accept();  
  72.   
  73.         //获取客户端ip  
  74.         System.out.println(s.getInetAddress().getHostName()+" connected.......");  
  75.   
  76.         //读取Socket读取流中的数据  
  77.         BufferedReader brin=new BufferedReader(new InputStreamReader(s.getInputStream()));  
  78.   
  79.         //将接收到的数据写入文件中  
  80.         PrintWriter out=new PrintWriter(new FileWriter("TcpDemo.txt"),true);  
  81.           
  82.         //将返回信息写入Socket流的写入流中  
  83.         BufferedWriter bwout=new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));  
  84.   
  85.         String line=null;  
  86.         while ((line=brin.readLine())!=null)  
  87.         {  
  88.             out.println(line);  
  89.         }  
  90.   
  91.         //PrintWriter pw = new PrintWriter(s.getOutputStream(),true);  
  92.         //pw.println("上传成功");  
  93.           
  94.         bwout.write("上传成功!");  
  95.         bwout.newLine();//换行  
  96.         bwout.flush();//刷新  
  97.   
  98.         out.close();//关流  
  99.         s.close();  
  100.         ss.close();  
  101.     }  
  102. }  

 

第三讲     应用

一、用TCP客户端并发上传图片

1、一对一（单线程）上传的思路：

客户端

        a、服务端点。

        b、读取客户端已有的图片数据

        c、通过Socket输出流将数据发给服务端

        d、读取服务端反馈信息。

        e、关闭

服务端

        a、服务端服务，并监听窗口

        b、获取客户端对象，并获取客户ip

        c、读取客户端输入流数据

        d、写入文件

        e、用客户端输出流反馈信息

        f、关流

2、单线程的服务端有个局限性。当A客户端连接上以后，被服务端获取到。服务端执行具体流程。这时B客户端连接，只能等待。因为服务端还没有处理完A客户端的请求。还没有循环回来执行下一次accept方法。所以，暂时获取不到B客户端对象。

        那么为了可以让多个客户端同时并发访问服务端。服务端最好就是将每个客户端封装到一个单独的线程中，这样，就可以同时处理多个客户端请求。

如何定义线程呢？

        只要明确了每一个客户端要在服务端执行的代码，将该代码存入run方法即可。

代码：

[java] view plaincopy
  1. /* 
  2. 需求：并发上传图片 
  3. */  
  4.   
  5. import java.io.*;  
  6. import java.net.*;  
  7. //客户端  
  8. class  PicClient  
  9. {  
  10.     public static void main(String[] args) throws Exception  
  11.     {  
  12.         //对传入的值进行判断  
  13.         if (args.length!=1)  
  14.         {  
  15.             System.out.println("请指定一个图片文件！");  
  16.             return;  
  17.         }  
  18.   
  19.         File file=new File(args[0]);  
  20.   
  21.         //对文件路径进行判断  
  22.         if (!(file.exists()&&file.isFile()))  
  23.         {  
  24.             System.out.println("你上传的文件有问题，非文件或者不存在！");  
  25.             return;  
  26.         }  
  27.   
  28.         //判断是否是图片文件  
  29.         if (!file.getName().endsWith(".jpg"))  
  30.         {  
  31.             System.out.println("图片格式错误，请重新选择！");  
  32.             return;  
  33.         }  
  34.   
  35.         //对文件大小进行判断  
  36.         if (file.length()>1024*1024*5)  
  37.         {  
  38.             System.out.println("你上传的文件过大,居心叵测！");  
  39.             return;  
  40.         }  
  41.   
  42.         //创建服务  
  43.         Socket s=new Socket("localhost",10000);  
  44.         //读取图片数据  
  45.         FileInputStream fis=new FileInputStream(file);  
  46.           
  47.         //用Socket服务输出流写入数据  
  48.         OutputStream out =s.getOutputStream();  
  49.   
  50.         BufferedReader in=new BufferedReader(new InputStreamReader(s.getInputStream()));  
  51.   
  52.         byte[] buf=new byte[1024];  
  53.   
  54.         int len=0;  
  55.   
  56.         while ((len=fis.read(buf))!=-1)  
  57.         {  
  58.             out.write(buf,0,len);  
  59.         }  
  60.   
  61.         //结束标记，表示文件数据已经上传完了  
  62.         s.shutdownOutput();  
  63.   
  64.         String info=in.readLine();//读取返回信息  
  65.         System.out.println(info);  
  66.   
  67.         fis.close();//关流  
  68.         s.close();  
  69.   
  70.     }  
  71. }  
  72.   
  73. //服务端  
  74. class PicServer  
  75. {  
  76.     public static void main(String[] args)throws Exception  
  77.     {  
  78.         //创建服务，监听端口  
  79.         ServerSocket ss=new ServerSocket(10000);  
  80.           
  81.         while (true)  
  82.         {  
  83.             //获取客户端对象  
  84.             Socket s=ss.accept();  
  85.             //客户端执行线程  
  86.             new Thread(new PicThread(s)).start();  
  87.         }  
  88.           
  89.         //ss.close();  
  90.     }  
  91. }  
  92.   
  93. //利用多线程实现并发上传  
  94. class PicThread implements Runnable  
  95. {  
  96.     private Socket s;  
  97.     PicThread(Socket s)  
  98.     {  
  99.         this.s=s;  
  100.     }  
  101.     public void run()  
  102.     {  
  103.         int count=1;  
  104.         //获取客户端ip  
  105.         String ip=s.getInetAddress().getHostAddress();  
  106.         try  
  107.         {         
  108.             System.out.println(ip+"  connected.....");  
  109.   
  110.             //通过客户端的读取流读取数据  
  111.             InputStream in=s.getInputStream();  
  112.             //文件保存路径  
  113.             File dir =new File("C:\\Users\\asus\\Desktop");  
  114.             //文件名  
  115.             File file=new File(dir,ip+".jpg");  
  116.             //判断文件是否存在  
  117.             while(file.exists())  
  118.             {  
  119.                 file=new File(dir,ip+"("+(count++)+").jpg");  
  120.             }  
  121.   
  122.             //将数据写入到指定文件中  
  123.             FileOutputStream fos=new FileOutputStream(file);  
  124.   
  125.             byte[] buf=new byte[1024];  
  126.             int len=0;  
  127.             while ((len=in.read(buf))!=-1)  
  128.             {  
  129.                 fos.write(buf,0,len);  
  130.             }  
  131.   
  132.             //将收到图片数据的信息返回给客户端  
  133.             OutputStream out=s.getOutputStream();  
  134.               
  135.             out.write("上传成功！".getBytes());  
  136.   
  137.             fos.close();//关流  
  138.             s.close();  
  139.         }  
  140.         catch (Exception e)  
  141.         {  
  142.             throw new RuntimeException(ip+"图片上传失败");  
  143.         }  
  144.     }  
  145. }  


二、客户端并发登录

        客户端通过键盘录入用户名，服务端对这个用户名进行校验。

        如果该用户存在，在服务端显示xxx，已登陆；并在客户端显示xxx，欢迎光临。

        如果用户不存在，在服务端显示xxx，尝试登陆；并在客户端显示xxx，该用户不存在。

        最多就登录三次。

代码： 

[java] view plaincopy
  1. import java.io.*;  
  2. import java.net.*;  
  3. //客户端  
  4. class  LoginClient  
  5. {  
  6.     public static void main(String[] args) throws Exception  
  7.     {  
  8.         //创建服务  
  9.         Socket s=new Socket("localhost",10000);  
  10.         //键盘录入  
  11.         BufferedReader br=new BufferedReader(new InputStreamReader(System.in));  
  12.   
  13.           
  14.         //用Socket服务输出流写入数据  
  15.         PrintWriter out =new PrintWriter(s.getOutputStream(),true );  
  16.   
  17.         //接收服务器返回的信息  
  18.         BufferedReader in=new BufferedReader(new InputStreamReader(s.getInputStream()));  
  19.   
  20.         String line=null;  
  21.   
  22.         for(int x=0;x<3;x++)  
  23.         {  
  24.             line=br.readLine();//读取键盘录入  
  25.             if (line==null)  
  26.             {  
  27.                 break;//如果键盘没有输入，则直接结束  
  28.             }  
  29.   
  30.             out.println(line);//将数据写入流中  
  31.   
  32.             String info=in.readLine();//读取返回信息  
  33.   
  34.             System.out.println(info);  
  35.   
  36.             if (info.contains("欢迎"))//---------------  
  37.             {  
  38.                 break;//如果登录成功，就跳出循环  
  39.             }  
  40.         }  
  41.   
  42.         br.close();//关流  
  43.         s.close();  
  44.     }  
  45. }  
  46.   
  47. //服务端  
  48. class LoginServer  
  49. {  
  50.     public static void main(String [] args)throws Exception  
  51.     {  
  52.         //创建服务，监听端口  
  53.         ServerSocket ss=new ServerSocket(10000);  
  54.           
  55.         while (true)  
  56.         {  
  57.             //获取客户端对象  
  58.             Socket s=ss.accept();  
  59.           
  60.             //客户端执行线程  
  61.             new Thread(new LoginThread(s)).start();  
  62.         }  
  63.           
  64.         //ss.close();  
  65.     }  
  66. }  
  67.   
  68. //利用多线程实现并发登录  
  69. class LoginThread implements Runnable  
  70. {  
  71.     private Socket s;  
  72.     LoginThread(Socket s)  
  73.     {  
  74.         this.s=s;  
  75.     }  
  76.     public void run()  
  77.     {  
  78.         //获取客户端ip  
  79.         String ip=s.getInetAddress().getHostAddress();  
  80.         System.out.println(ip+"  connected.....");  
  81.         try  
  82.         {         
  83.             for (int x=0;x<3 ;x++ )  
  84.             {     
  85.                 //通过客户端的读取流读取数据  
  86.                 BufferedReader in=new BufferedReader(new InputStreamReader(s.getInputStream()));  
  87.                   
  88.                 //读取数据库中的数据，这里用文件来表示数据库  
  89.                 BufferedReader br=new BufferedReader(new FileReader("users.txt"));  
  90.   
  91.                 String line=in.readLine();//读取客户端数据  
  92.                 if (line==null)//--------------  
  93.                 {  
  94.                     break;//如果客户端没有发送数据，则跳出循环  
  95.                 }  
  96.                 String data=null;  
  97.                 boolean flag=false;//设置标记  
  98.                 //读取数据库中的用户数据  
  99.                 while ((data=br.readLine())!=null)  
  100.                 {  
  101.                     if (line.equals(data))  
  102.                     {  
  103.                         flag=true;//如果用户存在，则将标记设为true  
  104.                         break;  
  105.                     }  
  106.                 }  
  107.   
  108.                 //将数据写入到指定文件中  
  109.                 PrintWriter out=new PrintWriter(s.getOutputStream(),true);  
  110.   
  111.                 if (flag)  
  112.                 {  
  113.                     System.out.println(line+",已登陆！");  
  114.                       
  115.                     out.println(line+"，欢迎光临！");  
  116.   
  117.                     break;//-----------  
  118.                 }  
  119.                 else  
  120.                 {  
  121.                     System.out.println(line+",尝试登陆！");  
  122.                     out.println(line+"，用户名不存在！");  
  123.                 }     
  124.             }  
  125.             s.close();//关流  
  126.         }  
  127.         catch (Exception e)  
  128.         {  
  129.             throw new RuntimeException("用户登陆失败");  
  130.         }     
  131.     }  
  132. }  


三、客户端和服务的浏览器演示

        浏览器是一个标准的客户端，它可以对服务端传送过来的数据消息进行解析，把符合应用层协议的消息部分解析后，将头信息拆包掉，传送到应用层，只保留了正确的正文主题部分显示在主体部分上。

        而由于使用java编译是在传输层和网际层处理的，所以，会接受到全部的消息，包含了头消息。而浏览器处于应用层，已将发送来的头消息去除，只留下了主体信息。

示例：

        自定义服务器，用浏览器访问：

[java] view plaincopy
  1. import java.io.*;  
  2. import java.net.*;  
  3.   
  4. //服务器  
  5. class  ServerDemo  
  6. {  
  7.     public static void main(String[] args)throws Exception   
  8.     {  
  9.         //创建服务，监听端口  
  10.         ServerSocket ss=new ServerSocket(10000);  
  11.         //获取客户端  
  12.         Socket s=ss.accept();  
  13.         //显示ip  
  14.         String ip=s.getInetAddress().getHostAddress();  
  15.   
  16.         System.out.println(ip);  
  17.         //读取客户端读取流数据  
  18.         InputStream in=s.getInputStream();  
  19.   
  20.         byte[] buf=new byte[1024];  
  21.         int len=in.read(buf);  
  22.         //显示数据  
  23.         System.out.println(new String(buf,0,len));  
  24.         //返回信息写入客户端输出流  
  25.         PrintWriter out=new PrintWriter(s.getOutputStream(),true);///true一定要记得写  
  26.   
  27.         out.println("<font color='red' size='7'>客户端你好!</font>");  
  28.   
  29.         s.close();//关流  
  30.         ss.close();  
  31.     }  
  32. }  

 

四、URL和URLConnection

1、URL：

        URI：范围更大，条形码也包含于此范围

        URL：范围较小，即域名

方法：

        1）构造函数：URL(String protocol,String host,int port,String file);//根据指定 protocol、host、port号和 file 创建 URL对象。

        2）String getProtocol();//获取协议名称

        3）String getHost();//获取主机名

        4）int getPort();//获取端口号

        5）String getFile();//获取URL文件名

        6）String getPath();//获取此URL的路径部分

        7）String getQuery();//获取此URL的查询部，客户端传输的特定信息

注：一般输入网址，是不带端口号的，此时可进行获取，通过获取网址返回的port，若port为-1，则分配一个默认的80端口，如

        int port = getPort();

        if(port == -1)

              port = 80;

2、URLConnection

方法：

        1）URLConnection openConnection();//用URL调用此方法，返回一个 URLConnection 对象，它表示到 URL 所引用的远程对象的连接。

        2）InputStream getInputStream();//获取输入流

        3）OutputStream getOutputStream();//获取输出流

示例：

[java] view plaincopy
  1. /* 
  2. 自定义浏览器，显示网页信息 
  3. */  
  4.   
  5. import java.io.*;  
  6. import java.awt.*;  
  7. import java.awt.event.*;  
  8. import java.net.*;  
  9.   
  10. class MyIEGUIDemo  
  11. {  
  12.     //定义所需组件引用  
  13.     private Frame f;  
  14.     private Button but,bok;  
  15.     private TextField tf;  
  16.     private TextArea ta;  
  17.   
  18.     //构造函数  
  19.     MyIEGUIDemo()  
  20.     {  
  21.         init();  
  22.     }  
  23.   
  24.     //窗体基本设置于功能实现  
  25.     public void init()  
  26.     {  
  27.         //组件实例化  
  28.         f=new Frame("我的Window");  
  29.         but=new Button("跳转");  
  30.         tf=new TextField(50);  
  31.         ta=new TextArea(25,60);  
  32.   
  33.         //基本设置  
  34.         f.setBounds(300,150,500,500);  
  35.         f.setLayout(new FlowLayout());  
  36.   
  37.         //添加组件  
  38.         f.add(tf);  
  39.         f.add(but);  
  40.         f.add(ta);  
  41.   
  42.         //窗体事件  
  43.         myEvent();  
  44.   
  45.         //窗体显示  
  46.         f.setVisible(true);  
  47.     }  
  48.   
  49.     //注册事件  
  50.     public void myEvent()  
  51.     {  
  52.         //窗体关闭功能  
  53.         f.addWindowListener(new WindowAdapter()  
  54.         {  
  55.             public void windowClosing(WindowEvent e)  
  56.             {  
  57.                 System.exit(0);  
  58.             }  
  59.         });  
  60.   
  61.         //“跳转”按钮事件  
  62.         but.addActionListener(new ActionListener()  
  63.         {  
  64.             public void actionPerformed(ActionEvent e)  
  65.             {  
  66.                 showFile();//显示网页内容在文本区中  
  67.             }  
  68.         });  
  69.   
  70.           
  71.   
  72.         //文本框键盘事件  
  73.         tf.addKeyListener(new KeyAdapter()  
  74.         {  
  75.             public void keyPressed(KeyEvent e)  
  76.             {  
  77.                 //如果键盘按下Enter键，就将网页内容显示在文本区中  
  78.                 if(e.getKeyCode()==KeyEvent.VK_ENTER)  
  79.                     showFile();  
  80.             }  
  81.         });  
  82.     }  
  83.   
  84.     //显示网页内容  
  85.         private void showFile()  
  86.         {  
  87.             ta.setText("");  
  88.             String path=tf.getText();//获取输入的路径  
  89.             try  
  90.             {  
  91.                 //封装地址对象  
  92. URL url =new URL(path);  
  93. 连接网页服务器  
  94.                 URLConnection conn=url.openConnection();  
  95.                 //读取流，用于读取服务器返回数据  
  96.                 InputStream in=conn.getInputStream();  
  97.   
  98.                 byte[] buf=new byte[1024*1024];  
  99.   
  100.                 int len=in.read(buf);  
  101.                 //将数据显示在文本区中  
  102.                 ta.append(new String(buf,0,len));  
  103.             }  
  104.             catch (Exception e)  
  105.             {  
  106.                 throw new RuntimeException("连接"+path+"网站失败");  
  107.             }  
  108.         }  
  109.   
  110.     public static void main(String[] args)   
  111.     {  
  112.         //运行窗体  
  113.         new MyIEGUIDemo();  
  114.     }  
  115. }  

 

小知识点

1、Socket类的构造函数中，有一个空参数的构造函数：

        Socket()//通过系统默认类型的 SocketImpl创建未连接套接字对象

       可以通过connect(SocketAddress endpoint)方法来连接服务器。而SocketAddress是一个抽象类，它的子类InetSocketAddress实现了IP套接字地址（IP地址+端口号）。所以就可以连接到服务器了。

2、ServerSocket对象中的构造函数：

        ServerSocket(int port,int backlog)，其中的backlog表示队列的最大长度，即最多连入客户端的个数，即最大连接数。

3、在浏览器输入网址访问一台主机所做的操作：

       如输入http://61.135.169.125，可以直接连接此ip的主机，而我们一般是输入主机名：http:/www.baidu.ocm（百度主机对应的ip地址就是：61.135.169.125），那么此时浏览器做了神马操作呢？

       也就是说如何通过主机名获取IP地址，从而连接到这台主机呢？这就需要将主机名翻译成IP地址，即域名解析：DNS

        在进行访问的时候，会先在本地的hosts文件（c:\windows\system32\drivers\ext\host）中找对应的映射。若有，则直接返回请求；若无，则到公网的映射列表即DNS中找对应的映射，找到后，将主机名对应的IP地址返回给本机，本机通过这个IP地址找到对应的服务器。

示意图：

 host应用：可屏蔽一些恶意网址，即将对应的映射关系写入hosts中，将IP地址改为本机的回环地址，那么会直接找到hosts，就不会将请求发送出去了。

 

转载于:https://www.cnblogs.com/tiankong101/p/4227355.html

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/273446.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

AND、OR运算符的组合使用

AND、OR运算符的组合使用

6.2.3 AND、OR运算符的组合使用 在WHERE子句中&#xff0c;通过AND、OR运算符可以同时连接多个条件&#xff0c;当然AND、OR运算符也可以同时使用。但是当AND、OR运算符同时存在时&#xff0c;其优先级如何确定呢&#xff1f;与大多数语言一样&#xff0c;SQL语言认为AND运算…
阅读更多...
IN运算符的使用

IN运算符的使用

6.3 IN运算符 在查询中&#xff0c;有时只要满足多个条件中的一个条件即可&#xff0c;如查询地址在北京、上海或者重庆的学生信息&#xff0c;这时候可以使用IN运算符。 6.3.1 IN运算符的使用 IN运算符允许根据一行记录中&#xff0c;是否有一列包括在一系列值之中&#…
阅读更多...
NOT运算符与运算符

NOT运算符与运算符

6.4.2 NOT运算符与<>运算符 对于简单的条件查询&#xff0c;NOT运算符与<>运算符的功能几乎没有什么区别&#xff0c;那么NOT运算符的优势体现在哪里呢&#xff1f;答案是它可以与其他运算符组合使用&#xff0c;这一点是<>运算符所不能实现的。在6.4.1节已…
阅读更多...
“%”通配符

“%”通配符

6.5.2 “%”通配符 在SQL语言中最常用的通配符可能就是“%”了&#xff0c;它表示任意字符的匹配&#xff0c;且不计字符的多少。下面通过几个典型实例来说明“%”通配符的使用。 1&#xff0e;开头&#xff0f;结尾匹配 从COURSE表中查询所有以“计算机”开头的所有课程的…
阅读更多...
Wireshark基本介绍和学习TCP三次握手

Wireshark基本介绍和学习TCP三次握手

Wireshark基本介绍和学习TCP三次握手 原文&#xff1a;http://www.cnblogs.com/TankXiao/archive/2012/10/10/2711777.html wireshark介绍 wireshark的官方下载网站&#xff1a; http://www.wireshark.org/ wireshark是非常流行的网络封包分析软件&#xff0c;功能十分强大。可…
阅读更多...
“_”通配符

“_”通配符

6.5.3 “_”通配符 “_”通配符的功能与“%”通配符基本相同&#xff0c;只是它只表示任意一个字符的匹配。当然&#xff0c;要表示两个字符的匹配&#xff0c;就需要使用两个“_”通配符&#xff0c;即写成“__”。 只有在用户确定所要查询的字符串的个数&#xff0c;只是不…
阅读更多...
“[]”通配符

“[]”通配符

6.5.4 “[]”通配符 “[]”通配符用于指定一系列的字符&#xff0c;只要满足这些字符其中之一&#xff0c;且位置出现在“[]”通配符的位置的字符串就满足查询条件。 当然&#xff0c;各种通配符也可以组合使用。组合使用各种通配符时&#xff0c;一定要弄清其表示的匹配条…
阅读更多...
QT分页控件，开源，供大家使用

QT分页控件，开源，供大家使用

下载地址&#xff1a;http://files.cnblogs.com/dragonsuc/qt5.rar 转载于:https://www.cnblogs.com/dragonsuc/p/4242342.html
阅读更多...
STL学习小结

STL学习小结

STL就是Standard Template Library&#xff0c;标准模板库。这可能是一个历史上最令人兴奋的工具的最无聊的术语。从根本上说&#xff0c;STL是一些“容器”的集合&#xff0c;这些“容器”有list, vector,set,map等&#xff0c;STL也是算法和其它一些组件的集合。这里的“容器…
阅读更多...
内连接（INNER JOIN）

内连接（INNER JOIN）

9.3.3 内连接&#xff08;INNER JOIN&#xff09; 内连接也称为等同连接&#xff0c;返回的结果集是两个表中所有相匹配的数据&#xff0c;而舍弃不匹配的数据。也就是说&#xff0c;在这种查询中&#xff0c;DBMS只返回来自源表中的相关的行&#xff0c;即查询的结果表包含的…
阅读更多...
外连接（OUTER JOIN）

外连接（OUTER JOIN）

9.3.4 外连接&#xff08;OUTER JOIN&#xff09; 不管是内连接还是带WHERE子句的多表查询&#xff0c;都组合自多个表&#xff0c;并生成结果表。换句话说&#xff0c;如果任何一个源表中的行在另一个源表中没有匹配&#xff0c;DBMS将不把该行放在最后的结果表中。 而外连…
阅读更多...
Android应用切换皮肤功能实现

Android应用切换皮肤功能实现

原文地址&#xff1a;http://www.eoeandroid.com/thread-318159-1-1.html 现在大多数android应用都支持切换皮肤的功能。比如千千静听&#xff0c;墨迹天气等等。本文介绍两种切换皮肤的方法。1.第一种是通过安装皮肤apk的方式。当安装了皮肤apk包之后&#xff0c;主程序只需要…
阅读更多...
交叉连接（CROSS JOIN）

交叉连接（CROSS JOIN）

9.3.5 交叉连接&#xff08;CROSS JOIN&#xff09; 除了在FROM子句中使用逗号间隔连接的表外&#xff0c;SQL还支持另一种被称为交叉连接的操作&#xff0c;它们都返回被连接的两个表所有数据行的笛卡尔积&#xff0c;返回到的数据行数等于第一个表中符合查询条件的数据行数…
阅读更多...
UNION运算符

UNION运算符

9.4.2 UNION运算符 在SQL中&#xff0c;UNION运算符用于执行集合并的运算。关于UNION运算符的使用&#xff0c;这里通过实例来说明。 实例16 使用UNION运算符执行集合并的运算 在STUDENT表中&#xff0c;查询选修了1号或者10号课程的学生的学号、姓名、所在系信息。实例代…
阅读更多...
「OC」类的深入研究、description方法和sel

「OC」类的深入研究、description方法和sel

一、类的深入研究 &#xff08;一&#xff09;类的本质 类本身也是一个对象&#xff0c;是class类型的对象&#xff0c;简称“类对象”。 Class类型的定义&#xff1a; Typedef struct obj class *class; 类名就代表着类对象&#xff0c;每个类只有一个类对象。 利用class 创建…
阅读更多...
UNION JOIN 连接表

UNION JOIN 连接表

9.4.5 UNION JOIN 连接表 使用UNION JOIN进行多表连接&#xff0c;与9.3节介绍的各种表的连接类型不同&#xff0c;它并不对表中的数据进行任何匹配处理&#xff0c;而只是把来自一个源表中的行与另一个源表中的行联合起来&#xff0c;生成的结果表中包括第一个表中的所有行和…
阅读更多...
获取网址中参数的方式

获取网址中参数的方式

1&#xff1a; $c$_GET[c]; 获取这种形式的参数http://127.0.0.1/?c1 2&#xff1a; example.com/class/function/ID。 id是function函数的参数&#xff0c;这样function函数可以获取到ID的值当作函数的参数传递进自己。3&#xff1a;$_GET数组是超全局变量数组&#xff0c;…
阅读更多...
[原创]html5游戏_五线谱打音符

[原创]html5游戏_五线谱打音符

html5手机游戏—五线谱打音符 1.[用五线谱打唱名] 2.[用唱名打五线谱] 3.[无限练习模式] 用来熟悉五线谱上音符的位置 代码不难&#xff0c;这回注释还是有认真写的[只是废代码没有全部删除。。。] 效果图&#xff1a; --- 在线地址: http://wangxinsheng.herokuapp.com/staffg…
阅读更多...
Mysql数据库正则表达式

Mysql数据库正则表达式

1.基本字符的匹配 SELECT * FROM a1 WHERE name regexp 1000 #匹配名称含有1000的所有行 SELECT * FROM a1 WHERE name regexp .000 #匹配以000结尾的所有行&#xff0c;(.正则中表示&#xff1a;匹配任意一个字符) 从中可以看到正则表达式能够模拟LIKE使用通配符&#xff0c…
阅读更多...
android项目 之 记事本（6）----- 加入手写

android项目 之 记事本（6）----- 加入手写

想必大家都用过QQ的白板功能&#xff0c;里面主要有两项&#xff0c;一个是涂鸦功能&#xff0c;事实上类似于上节的画板功能&#xff0c;而还有一个就是手写&#xff0c;那记事本怎么能没有这个功能呢&#xff0c;今天就来为我们的记事本加入手写功能。 先上图&#xff0c;看看…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023