一、概述

1、概述：

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

2、网络通信要素：IP地址，端口号、传输协议。
1）IP地址：
A、它是网络中的设备标识
B、不易记忆，可用主机名表示，两者存在映射关系
C、本机回环地址：127.0.0.1，主机名为：localhost

2）端口号：
A、用于标识进程的逻辑地址，不用进程的标识。
B、有效端口：0 ~ 65535，系统使用或保留的端口是：0 ~ 1024.

3）传输协议：
A、即通信规则，包含TCP和UDP协议
B、UDP是面向无连接，无论在不在网上，只管传输，不在就会丢失数据。只求速度，应用于网络视频会议和聊天等应用程序中
》协议特点：
》》a、面向无连接，即将数据及源和目的封装成数据包中，不建立链接的发送
》》b、每个数据报的大小限制在64K之内
》》c、因无连接，是不可靠的协议
》》d、不建立连接，速度快。
C、TCP是面向连接的，必须连接成功才能传输数据，应用于下载等程序上
协议特点：
》》a、面向连接，在建立连接后，形成传输数据的通道
》》b、在连接中进行大数据量的传输
》》c、通过三次握手完成连接，是可靠的协议
》》d、必须建立连接，效率稍慢

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

3、通信的步骤：
1）找到IP地址
2）数据要发送到对象指定应用程序，为标识这些应用程序，所以给这些网络应用程序都用数字标识，为方便称呼这个数字，叫做端口，即逻辑端口。
3）定义通信规则，称之为协议。国际组织定义了通用协议，即TCP/IP。
注意：
必须要有数字标识才能将数据发送到应用程序上。

示意图

2、网络模型：

1、对于TCP/IP协议，开发处于传输层和网际层
应用层：FTP和HTTP协议等
传输层：UDP和TCP等
网际层：IP

3、网络通信要素：

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

InetAddress类：
1、无构造函数，可通过getLocalHost()方法获取InetAddress对象，此方法是静态的，返回此对象。
InetAddress i = InetAddress.getLocalHost();

2、方法：
1）static InetAddress getByName(String host)：在给定主机名的情况下获取主机的IP地址
2）static InetAddress[] getAllByName(String host)：在给定主机名的情况下，根据系统上配置的名称服务返回IP地址所组成的数组。返回对象不唯一时，用此方法。
3）String getHostAddress()：返回IP地址字符串文本形式，以这个为主，即以IP地址为主。
4）String getHostName()：返回IP地址主机名。

3、如何获取任意一台主机的IP地址对象：
1）功能：返回InetAddress对象
2）对于任意主机，需要指定传入主机名的参数
注意：
如果IP地址和主机名无映射关系，或者没有在网络上，就不会解析成功

/* 
获取IP地址和IP地址主机名 
*/  
  
import java.net.*;  
class InetDemo  
{  
    public static void main(String[] args) throws Exception  
    {  
        //获取本机IP地址  
        InetAddress ia = InetAddress.getLocalHost();  
        System.out.println(ia.toString());  
  
        //通过百度主机名获取其IP地址  
        InetAddress i = InetAddress.getByName("www.baidu.com");  
        System.out.println("name:" + i.getHostName());  
        System.out.println("address:" + i.getHostAddress());  
    }  
}

二、网络编译

1、概述：

1、Socket：
1）它被称之为插座，相当于港口一样，是网络服务提供的一种机制。
2）通信两端都要有Socket，才能建立服务。
3）网络通信其实就是Socket间的通信，数据在两个Socket间通过IO传输。

2、UDP传输：

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

2、方法：
1）创建 UDPSocket发送服务对象：DatagramSocket()，可不指定端口
2）创建 UDPSocket接收服务对象：DatagramSocket(int port)
3）发送：void send(DatagramPacket p)
4）接收：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的参数，这是因为收到的数据太多，需要解析，通过将数据封装成对象，易于解析，所以需要传入参数。

示例：

/* 
键盘录入 
*/  
  
import java.net.*;  
import java.io.*;  
  
//发送端：通过UDP传输方式，将一段文字发送出去  
class UDPSend  
{  
    public static void main(String[] args) throws Exception  
    {  
        //1、创建udp服务，通过DatagramSocket对象  
        DatagramSocket ds = new DatagramSocket();  
        //2、确定要发送的数据，并封装成数据包  
        BufferedReader bufr =  
            new BufferedReader(new InputStreamReader(System.in));  
  
        String line = null;  
        while((line=bufr.readLine())!=null)  
        {  
            if("886".equals(line))  
                break;  
            byte[] bt = line.getBytes();  
            //3、通过socket服务的发送请求，将数据发送出去  
            DatagramPacket dp =  
                new DatagramPacket(bt,bt.length,InetAddress.getByName("192.168.1.101"),10001);  
            ds.send(dp);  
        }  
        //4、关闭资源  
        ds.close();  
    }  
}

import java.net.*;  
import java.io.*;  
  
//接收端：定义一个应用程序，用于接收udp协议传输数据并处理  
class UDPRece  
{  
    public static void main(String[] args) throws Exception  
    {  
        //1、创建udpsocket，建立端点  
        DatagramSocket ds = new DatagramSocket(10001);  
        //连续读取收到的数据  
        while(true)  
        {  
            //2、定义数据包，用于存储数据  
            byte[] by = new byte[1024];  
            //3、通过服务的receive方法将接收到的数据存入数据包中  
            DatagramPacket dp = new DatagramPacket(by,by.length);  
            ds.receive(dp);  
            //4、通过数据包的方法获取其中的数据  
            String ip = dp.getAddress().getHostAddress();  
            String data = new String(dp.getData(),0,dp.getLength());  
            System.out.println(ip+":"+data);  
        }  
    }  
}

练习：编写一个简单的聊天程序：
分析：
有收数据的部分，有发数据的部分，这两部分需要同时执行，那就需要多线程技术，一个线程控制接收，一个线程控制发。

因为收和发的动作不一致，所以要定义两个run方法，而且这个两个方法要封装到不同的类中。

import java.io.*;  
import java.net.*;  
//发送数据  
class SendSocket implements Runnable  
{  
    //定义全局变量  
    private DatagramSocket ds;  
    //初始化发送类对象的参数  
    public SendSocket(DatagramSocket ds)  
    {  
        this.ds = ds;  
    }  
    //覆写run方法，此线程发送键盘录入的数据  
    public void run()  
    {  
        try  
        {  
            //创建读取流，读取键盘数据  
            BufferedReader bufr =  
                new BufferedReader(new InputStreamReader(System.in));  
            String line = null;  
            while((line=bufr.readLine())!=null)  
            {  
                if("886".equals(line))  
                    break;  
                byte[] b = line.getBytes();  
                //创建发送服务对象，将数据发送出去  
                DatagramPacket dp =  
                new DatagramPacket(b,b.length,InetAddress.getByName("192.168.1.255"),10001);  
                ds.send(dp);  
            }  
            //关闭资源  
            ds.close();  
        }  
        catch (Exception e)  
        {  
            throw new RuntimeException("发送失败");  
        }  
    }  
}  
  
//接收数据  
class ReceSocket implements Runnable  
{  
    //定义全局变量  
    private DatagramSocket ds;  
    //初始化接收类对象的参数  
    public ReceSocket(DatagramSocket ds)  
    {  
        this.ds = ds;  
    }  
    //覆写run方法，此线程接收数据  
    public void run()  
    {  
        try  
        {  
            //循环读取接收到的数据  
            while(true)  
            {  
                //创建字节数组存储数据  
                byte[] by = new byte[1024];  
                //创建接收数据的对象，接收数据  
                DatagramPacket dp = new DatagramPacket(by,by.length);  
                ds.receive(dp);  
                //获取发送方的ip地址  
                String ip = dp.getAddress().getHostAddress();  
                //getData获取byte数组中的数据  
                String data = new String(dp.getData(),0,dp.getLength());  
                System.out.println(ip+":"+data);  
            }  
        }  
        catch (Exception e)  
        {  
            throw new RuntimeException("接收失败");  
        }  
    }  
}  
//测试  
class SocketDemo   
{  
    public static void main(String[] args) throws Exception  
    {  
        //创建发送和接收服务的对象  
        DatagramSocket sendSocket = new DatagramSocket();  
        DatagramSocket receSocket = new DatagramSocket(10001);  
        //创建两个线程，同时执行  
        new Thread(new SendSocket(sendSocket)).start();  
        new Thread(new ReceSocket(receSocket)).start();  
    }  
}

3、TCP传输

1、包括客户端和服务端，即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() ：返回此套接字的输入流
7）OutputStream getOutputStream() ：返回套接字的输出流

3、流程：
1）建立客户端和服务器端。
2）建立连接后，通过Socket中的IO流进行数据的传输。
3）关闭socket

同样的，客户端与服务端是两个独立的应用程序。

4、客户端：在该对象建立时就可去连接指定主机，因为TCP是面向俩接的，所以在建立Socket服务时，就要有服务端存在，并连接成功，形成通路后，再通过该通道进行数据的传输。

步骤：
1）创建Socket服务，并指定要连接的主机端口。通路一建立，就会产生Socket流（包括输入流和输出流），通过方法获取
2）为了发送数据，应获取Socket中的输出流，如果要接收服务端的反馈信息，需要获取Socket的输入流
3）通过write()方法将信息写入到流中。
4）关闭Socket流资源
5、服务端：定义端连接数据，并存放指定地方，需监听一个端口。

步骤：
1）建立服务端的Socket服务，通过ServerSocet带端口参数的构造函数
2）获取连接过来的客户对象，通过ServerSocket的accept()方法，此方法是阻塞式的，如果服务端没有连接到就会等待。
3）客户端若发来数据，则服务端要使用对应的客户端对象，并获取到该客户端对象的读取流发来的数据，并输出到指定目的地。
4）关闭服务端。一般服务端是常开的，因为在实际应用中，随时有客户端在请求连接和服务，所有这里需要定时关闭客户端对象流，避免某一个客户端长时间占用服务器端。

/* 
需求：客户端发信，服务端收信，再反馈信息 
*/  
  
import java.io.*;  
import java.net.*;  
//客户端  
class TcpSocketDemo  
{  
    public static void main(String[] args) throws Exception  
    {  
        //创建socket服务，指定连接的主机端口  
        Socket s = new Socket("192.168.1.101",10003);  
        //获取socket的输出流，并将数据写入流中  
        OutputStream out = s.getOutputStream();  
        out.write("socket is coming...".getBytes());  
        //获取socket的输入流，读取服务端的反馈信息  
        InputStream in = s.getInputStream();  
        byte[] b = new byte[1024];  
        int len = in.read(b);  
        System.out.println(new String(b,0,len));  
        //关闭流资源  
        s.close();  
    }  
}

import java.io.*;  
import java.net.*;  
  
//服务端  
class TcpServerDemo  
{  
    public static void main(String[] args) throws Exception  
    {  
        //创建ServerSocket服务，并指定接收的端口  
        ServerSocket ss = new ServerSocket(10003);  
        //通过accept方法获取链接过来的客户端对象  
        Socket s = ss.accept();  
        //获取连接的客户端的IP地址  
        String ip = s.getInetAddress().getHostAddress();  
        System.out.println(ip+".....connected");  
        //通过客户端对象，获取输入流，读取接收的信息  
        InputStream in = s.getInputStream();  
        byte[] b = new byte[1024];  
        int len = in.read(b);  
        System.out.println(new String(b,0,len));  
        //通过客户端对象，获取输出流，将信息反馈给客户端  
        OutputStream out = s.getOutputStream();  
        out.write("嘿嘿，收到了".getBytes());  
        //关闭流资源  
        s.close();  
        ss.close();//服务端流资源可不用关  
    }  
}

示例一：文本转换器，客户端通过键盘发送信息，服务端将信息以大写形式返回到控制台上，形成客户端和服务端的互访。
分析：既然是设备上的数据，则可用IO技术，并依IO操作规律操作。

1、客户端：
源：键盘录入；目的：网络设备，即网络输出流。
-->操作的是文本数据，可选字符流，并加入高效缓冲区。

步骤：
1）建立服务。
2）获取键盘录入
3）将数据发给服务端
4）之后去服务端返回数据
5）结束，关闭资源

2、服务端：
源：socket读取流；目的：socket输出流。

注：socket的close()方法中加入了结束标记-1，所以客户端结束了，服务端也结束了。

3、该例可能出现的问题：
现象：客户端和服务端都在莫名的等待，似乎数据都没有传输过去。

原因：因为客户端和服务端都有阻塞方法，这些方法没有读到结束标记，就会一直等待，而导致两端都在等待。

解决：需要用到刷新和换行的方式将写入和读取的数据从流中刷新到内存中
方式一：可用高效缓冲区类的newLine()换行作为结束标记，并用flush()进行刷新。
方式二：可用PrintWriter(s.getOutputStrean(),true)创建输出流对象，true作用是刷新，通过打印方法println()换行，“ln”表示换行。

import java.io.*;  
import java.net.*;  
  
//客户端  
class TransClient  
{  
    public static void main(String[] args) throws Exception  
    {  
        //创建Socket服务  
        Socket s = new Socket("192.168.1.101",10003);  
        //定义读取键盘数据的流对象  
        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();  
    }  
}

import java.io.*;  
import java.net.*;  
  
//服务端  
class TransSever  
{  
    public static void main(String[] args) throws Exception  
    {  
        ServerSocket ss = new ServerSocket(10003);  
        Socket s = ss.accept();  
          
        String ip = s.getInetAddress().getHostAddress();  
        System.out.println(ip+"....connected");  
  
        BufferedReader bufIn =  
            new BufferedReader(new InputStreamReader(s.getInputStream()));  
        //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();  
    }  
}

示例二：TCP复制文件
1、客户端：
源：硬盘上的文件；目的：网络设备，即网络输出流。
-->若操作的是文本数据，可选字符流，并加入高效缓冲区。若是媒体文件，用字节流。

2、服务端：
源：socket读取流；目的：socket输出流。

3、出现的问题：
现象：
a.文件已经上传成功了，但是没有得到服务端的反馈信息。
b.即使得到反馈信息，但得到的是null，而不是“上传成功”的信息

原因：
a.因为客户端将数据发送完毕后，服务端仍然在等待这读取数据，并没有收到结束标记，就会一直等待读取。
b.上个问题解决后，收到的不是指定信息而是null，是因为服务端写入数据后，也需要刷新，才能将信息反馈给客服端。

解决：
方法一：
定义结束标记，先将结束标记发送给服务端，让服务端接收到结束标记，然后再发送上传的数据。但是这样定义可能会发生定义的标记和文件中的数据重复而导致提前结束。
方法二：
定义时间戳，由于时间是唯一的，在发送数据前，先获取时间，发送完后在结尾处写上相同的时间戳，在服务端，接收数据前先接收一个时间戳，然后在循环中判断时间戳以结束标记。
方法三：
通过socket方法中的shutdownOutput()，关闭输入流资源，从而结束传输流，以给定结束标记。这里主要用这个方法。

import java.io.*;  
import java.net.*;  
  
//客户端  
class CopyClient  
{  
    public static void main(String[] args)   
    {  
        //定义全局变量  
        Socket s = null;  
        try  
        {  
            s = new Socket("192.168.1.101",10003);  
        }  
        catch (IOException e)  
        {  
            throw new RuntimeException("创建连接失败");  
        }  
        BufferedReader bufr = null;  
        try  
        {  
            //创建读取流，读取指定文件  
            bufr = new BufferedReader(new FileReader("D:\\File\\udp.java"));  
            //创建写入缓冲区，写入网络输出流中  
            BufferedWriter bufOut =   
                new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));  
              
            //读取文本，并写入流中  
            String line = null;  
            while((line=bufr.readLine())!=null)  
            {  
                bufOut.write(line);  
                bufOut.newLine();  
                bufOut.flush();  
            }  
            //关闭客户端的输出流。  
            s.shutdownOutput();  
            //创建读取流，读取网络输入流  
            BufferedReader bufIn =  
                new BufferedReader(new InputStreamReader(s.getInputStream()));  
            //读取反馈信息  
            String str = bufIn.readLine();  
            System.out.println(str);  
        }  
        catch (IOException e)  
        {  
            throw new RuntimeException("发送失败");  
        }  
        //关闭流资源  
        finally  
        {  
            try  
            {  
                if(bufr!=null)  
                    bufr.close();  
                s.close();  
            }  
            catch (IOException e)  
            {  
                throw new RuntimeException("资源关闭失败");  
            }  
        }  
    }  
}

import java.io.*;  
import java.net.*;  
  
//服务端  
class CopyServer  
{  
    public static void main(String[] args)   
    {  
        //定义全局变量  
        ServerSocket ss = null;  
        Socket s= null;  
        try  
        {  
            //创建服务，接收客户端数据  
            ss = new ServerSocket(10003);  
            s= ss.accept();  
            String ip = s.getInetAddress().getHostAddress();  
            System.out.println(ip+"....connected");  
        }  
        catch (IOException e)  
        {  
            throw new RuntimeException("连接失败");  
        }  
        BufferedWriter bufw = null;  
        try  
        {  
            //创建写入流  
            bufw = new BufferedWriter(new FileWriter("server.txt"));  
            //创建读取流  
            BufferedReader bufIn =  
                new BufferedReader(new InputStreamReader(s.getInputStream()));  
            String line = null;  
            //读取网络输入流数据  
            while((line=bufIn.readLine())!=null)  
            {  
                bufw.write(line);  
                bufw.newLine();  
                bufw.flush();  
            }  
            //创建写入流，反馈给客户端信息  
            BufferedWriter bufOut =   
                new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));  
            bufOut.write("上传成功");  
            bufOut.flush();  
  
        }  
        catch (IOException e)  
        {  
            throw new RuntimeException("发送失败");  
        }  
        //关闭流资源  
        finally   
        {  
            try  
            {  
                if(bufw!=null)  
                    bufw.close();  
                s.close();  
                ss.close();  
            }  
            catch (IOException e)  
            {  
                throw new RuntimeException("资源关闭失败");  
            }  
        }  
    }  
}

三、应用

1、TCP并发执行请求

一）图片上传：

第一、客户端：
1、创建服务端点
2、读取客户端以后图片数据
3、通过Socket输出流将数据发给服务端
4、读取服务端反馈信息
5、关闭客户端

第二、服务端
对于客户端并发上传图片，服务端如果单纯的使用while(true)循环式有局限性的，当A客户端连接上以后，被服务端获取到，服务端执行具体的流程，这时B客户端连接就只有等待了，因为服务端还未处理完A客户端的请求，还有循环来回执行下须accept方法，所以暂时获取不到B客户端对象，那么为了可让多个客户端同时并发访问服务端，那么服务端最好就是将每个客户端封装到一个单独的线程，这样就可以同时处理多个客户端的请求。
如何定义线程呢？只要明确每个客户端要在服务端执行的代码即可，将改代码存入到run方法中。

import java.io.*;  
import java.net.*;  
  
  
//客户端  
class UploadClient   
{  
    public static void main(String[] args)   
    {  
        //判断上传的文件是否符合要求  
        if(args.length!=1)  
        {  
            System.out.println("请选择一个jpg格式的图片");  
            return ;  
        }  
        File file = null;  
        try{  
            file = new File(args[0]);  
            if(!(file.exists() && file.isFile()))  
            {  
                System.out.println("该文件有问题，要么补存在，要么不是文件");  
                return ;  
            }  
  
            if(!file.getName().endsWith(".jpg"))  
            {  
                System.out.println("图片格式错误,请重新选择");  
                return ;  
            }  
            if(file.length()>1024*1024*5)  
            {  
                System.out.println("文件过大，没安好心");  
                return ;  
            }  
        }catch (Exception e){  
            throw new RuntimeException("获取文件失败");  
        }  
        //创建客户端，接收客户端流对象  
        Socket s = null;  
        FileInputStream fis = null;  
        try{  
            s = new Socket("192.168.1.101",10003);  
            fis = new FileInputStream(file);  
            OutputStream out = s.getOutputStream();  
            //将数据写入到读取流中，传送给服务端  
            byte[] b = new byte[1024];  
            int len = 0;  
            while((len=fis.read(b))!=-1)  
            {  
                out.write(b,0,len);  
            }  
            s.shutdownOutput();  
            //获取服务端反馈的信息  
            InputStream in = s.getInputStream();  
            byte[] by = new byte[1024];  
            int n = in.read(by);  
            System.out.println(new String(by,0,n));  
  
        }catch (IOException e){  
            throw new RuntimeException("服务创建或读取流失败");  
        }  
        finally{  
            try{  
                if(fis!=null)  
                    fis.close();  
            }catch (IOException e){  
                throw new RuntimeException("读取流关闭失败");  
            }  
            try{  
                if(s!=null)  
                    s.close();  
            }catch (IOException e){  
                throw new RuntimeException("资源关闭失败");  
            }  
        }  
    }  
}  
  
//服务端  
//创建服务端多线程  
class ServerThread implements Runnable  
{  
    private Socket s;  
    ServerThread(Socket s)  
    {  
        this.s = s;  
    }  
    public void run()  
    {  
        //获取客户端的ip  
        int count = 1;  
        String ip = s.getInetAddress().getHostAddress();  
        System.out.println(ip+"...connected");  
        FileOutputStream fos = null;  
        try{  
            //获取客户端数据，判断文件是否重名  
            InputStream in = s.getInputStream();  
            File dir = new File("D:\\File\\pics");  
            File file = new File(dir,ip+".jpg");  
            while(file.exists())  
                file = new File(dir,ip+"("+(count++)+").jpg");  
            //将数据写入到指定文件中  
            fos = new FileOutputStream(file);  
            byte[] b = new byte[1024];  
            int len = 0;  
            while((len=in.read(b))!=-1)  
            {  
                fos.write(b,0,len);  
            }  
            //将信息反馈给客户端  
            OutputStream out = s.getOutputStream();  
            out.write("上传成功".getBytes());  
        }catch (Exception e){  
            throw new RuntimeException(ip+"上传失败");  
        }  
        finally{  
            try{  
                if(fos!=null)  
                    fos.close();  
            }catch (IOException e){  
                throw new RuntimeException("写入流关闭失败");  
            }  
            try{  
                if(s!=null)  
                    s.close();  
            }catch (IOException e){  
                throw new RuntimeException("资源关闭失败");  
            }  
        }  
    }  
}  
  
//服务端  
class UploadServer  
{  
    public static void main(String[] args)   
    {  
        ServerSocket ss = null;  
        Socket s = null;  
        try{  
            //创建服务端，并接受多个客户端并发访问  
            ss = new ServerSocket(10003);  
            while(true)  
            {  
                s = ss.accept();  
                new Thread(new ServerThread(s)).start();  
            }  
        }catch (IOException e){  
            throw new RuntimeException("上传失败");  
        }  
          
        finally{  
            try{  
                if(s!=null)  
                    s.close();  
            }catch (IOException e){  
                throw new RuntimeException("资源关闭失败");  
            }  
        }  
    }  
}

二）客户端并发登陆：
客户端通过键盘录入用户名。服务端对这个用户名进行校验。如果该用户存在，在服务端显示xxx，已登陆。并在客户端显示 xxx，欢迎光临。如果该用户存在，在服务端显示xxx，尝试登陆。并在客户端显示 xxx，该用户不存在。最多就登录三次。

import java.io.*;  
import java.net.*;  
  
class LoginClient   
{  
    public static void main(String[] args) throws Exception  
    {  
        //创建服务  
        Socket s = new Socket("192.168.1.101",10003);  
        //读取键盘录入  
        BufferedReader bufr =   
            new BufferedReader(new InputStreamReader(System.in));  
        PrintWriter out = new PrintWriter(s.getOutputStream(),true);  
        BufferedReader in =  
            new BufferedReader(new InputStreamReader(s.getInputStream()));  
        //最多三次登陆  
        for(int i=0;i<3;i++)  
        {  
            String line = bufr.readLine();  
            if(line==null)  
                break;  
            out.println(line);  
            String info = in.readLine();  
            System.out.println(info);  
            if(info.contains("欢迎"))  
                break;  
        }  
        //关闭流资源  
        bufr.close();  
        s.close();  
    }  
}  
//服务端的多线程，使服务端共享  
class UserThread implements Runnable  
{  
    private Socket s;  
    UserThread(Socket s)  
    {  
        this.s = s;  
    }  
    public void run()  
    {  
        String ip = s.getInetAddress().getHostAddress();  
        System.out.println(ip+"........connected");  
        try{  
            //最多登陆三次  
            for(int i=0;i<3;i++)  
            {  
                BufferedReader in =  
                    new BufferedReader(new InputStreamReader(s.getInputStream()));  
                String name = in.readLine();  
                if(name==null)  
                    break;  
                  
                BufferedReader bufr =  
                    new BufferedReader(new FileReader("user.txt"));  
                PrintWriter out = new PrintWriter(s.getOutputStream(),true);  
                String line = null;  
                boolean flag = false;  
  
                while((line=bufr.readLine())!=null)  
                {  
                    if(line.equals(name)){  
                        flag = true;  
                        break;  
                    }  
                }  
                //对用户进行判断  
                if(flag){  
                    System.out.println(name+",已登录");  
                    out.println(name+"欢迎光临");  
                    break;  
                }else{  
                    System.out.println(name+",尝试登陆");  
                    out.println(name+",用户名不存在");  
                }  
            }  
            s.close();  
        }catch (Exception e){  
            throw new RuntimeException(ip+"校验失败");  
        }  
    }  
}  
//创建服务端  
class LoginServer  
{  
    public static void main(String[] args) throws Exception  
    {  
        ServerSocket ss = new ServerSocket(10003);  
        //客户端并发访问  
        while(true)  
        {  
            Socket s = ss.accept();  
            new Thread(new UserThread(s)).start();  
        }  
    }  
}

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

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

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

3、URL和URLConnection

一）URL：
URI：范围更大，条形码也包含于此范围
URL：范围较小，即域名

1、方法：
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的查询部，客户端传输的特定信息

2、一般输入网址，是不带端口号的，此时可进行设置，在URL中写port，若port为-1，则分配一个默认的80端口，否则用自己定义的，如

int port = getPort();
if(port == -1)
  port = 80;

二）URLConnection：
1、方法：
1）URLConnection openConnection() ---> 表示到URL所引用的远程对象的链接
2）InputStream getInputStream() ：获取输入流
3）OutputStream getOutputStream() ：获取输出流

示例：

import java.awt.*;  
import java.awt.event.*;  
import java.net.*;  
import java.io.*;  
  
class MyIEGUI  
{  
    //创建全局变量  
    private Frame f;  
    private Button but;  
    private TextField tf;  
    private TextArea ta;  
  
    private Dialog d;  
    private Label lab;  
    private Button okBut;  
  
    //构造函数，初始化窗体  
    MyIEGUI()  
    {  
        init();  
    }  
    //创建窗体和组件，并将事件添加进来  
    public void init()  
    {  
        //设置窗体  
        f = new Frame("my window");  
        f.setBounds(300,200,600,500);  
        f.setLayout(new FlowLayout());  
        //创建组件  
        but = new Button("转到");  
        tf = new TextField(60);  
        ta = new TextArea(25,75);  
  
        d = new Dialog(f,"提示信息-self",true);  
        d.setBounds(300,100,300,150);  
        d.setLayout(new FlowLayout());  
        lab = new Label();  
        okBut = new Button("确定");  
  
        //将组件添加到窗体  
        f.add(tf);  
        f.add(but);  
        f.add(ta);  
          
        d.add(lab);  
        d.add(okBut);  
  
        //添加事件  
        myEvent();  
        //设置窗体可见  
        f.setVisible(true);  
    }  
    //常见引发的时间  
    private void myEvent()  
    {  
        //给but添加一个活动监听器  
        but.addActionListener(new ActionListener()  
        {  
            public void actionPerformed(ActionEvent e)  
            {  
                try{  
                    showInfo();  
                }catch (Exception ex){  
                    throw new RuntimeException("客户端登陆失败");  
                }  
        }});  
        okBut.addActionListener(new ActionListener()  
        {  
            public void actionPerformed(ActionEvent e)  
            {  
                d.setVisible(false);  
            }  
        });  
        //给文本框添加键盘事件  
        tf.addKeyListener(new KeyAdapter()  
        {  
            public void keyPressed(KeyEvent e)  
            {  
                try{  
                    if(e.getKeyCode()==KeyEvent.VK_ENTER)  
                        showInfo();  
                }catch (Exception ex){  
                    throw new RuntimeException("客户端登陆失败");  
                }  
            }  
        });  
        //关闭窗体事件  
        f.addWindowListener(new WindowAdapter()  
        {  
            public void windowClosing(WindowEvent e)  
            {  
                System.exit(0);  
            }  
        });  
        d.addWindowListener(new WindowAdapter()  
        {  
            public void windowClosing(WindowEvent e)  
            {  
                d.setVisible(false);  
            }  
        });  
    }  
    private void showInfo()throws Exception  
    {  
  
        ta.setText("");  
        //获取路径  
        String urlPath = tf.getText();//http://192.168.1.101:8080/myweb/myIE.html  
        //创建URL对象，解析路径  
        URL url = new URL(urlPath);  
        //获取连接  
        URLConnection conn = url.openConnection();  
        //获取输入流，读取获得的数据，并显示在文本框中  
        InputStream in = conn.getInputStream();  
        byte[] buf = new byte[1024];  
        int len=in.read();  
        ta.setText(new String(buf,0,len));  
    }  
    public static void main(String[] args)   
    {  
        new MyIEGUI();  
    }  
}

小知识点

1、InetSocketAddress对象（IP+端口）

2、ServerSocket对象中的构造函数：
ServerSocket(int port,int backlog)，其中的backlog表示队列的最大长度，即最多连入客户端的个数，即最大连接数。

3、在进行浏览器输入网址访问一台主机所做的操作：
如http://192.168.1.100:8080/myweb/myIE.html ，一般直接输入主机名：http://baidu.com.cn 等

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

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

示意图

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