网络编程

TCP

UDP

Socket

域名解析

1、网络编程

1，网络模型

a)        OSI参考模型

b)       TCP/IP参考模型

2，网络通讯要素

a)        IP地址

b)       端口号

c)        传输协议

数据通讯原理是数据传输。

ping 127.0.0.1（本地回环地址），回执测试 可以测试网卡。

Internet协议（TCP/IP）既可以用于广域网也可用于局域网。

数据传输图例：

网络参考模型

网络通讯要素

1，IP 地址：InetAddress

a)      网络中设备的标识

b)      不易记忆，可用主机名

c)      本地回环地址：127.0.0.1主机名localhost----- ping localhost  ping 127.0.0.1

2，端口号

a)      用于标识进程的逻辑地址，不同进程的标识

b)      有效端口：0-65535，其中0-1024系统使用或保留端口

3，传输协议

a)      通讯的规则

b)      常见协议：TCP，UDP

import java.net.*;
public class IpDemo {
	/**
	 * @param args
	 */
	public static void main(String[] args) throws Exception
	{
	InetAddress i=	InetAddress.getLocalHost();
	System.out.println("address"+i.getHostAddress());
         System.out.println(i.toString());
         System.out.println("name:"+i.getHostName());
          //获取任意主机IP地址对象 返回值类型，IP地址对象，
          InetAddress a=InetAddress.getByName("192.168.1.254"/*"www.baidu.com"*/);
         System.out.println("address"+ia.getHostAddress());
         System.out.println(i.toString());
         System.out.println("name:"+ia.getHostName());
	}
}

static InetAddress getAllByName(String host)在给定主机名的情况下，根据系统上配置的名称服务返回其IP地址所组成的数组。

unknownhostException 未知主机异常

BindException绑定异常。

2、TCP和UDP

TCP和UDP    数据封包-数据拆包。

UDP：面向无连接。发送数据前不需要建立连接。UDP把数据打成数据包，数据会被封包。对方的端口和地址要明确出来。面向无连接不需要连接，它发送的包是有限制的，分成多包发送。不可靠，数据丢失。速度快。不用确定对方在不在，省略确认过程。这种传输方式在我们生活当中如聊天，视频会议，桌面共享，下载是TCP

1)      将数据及源和目的封装成数据包中，不需要建立连接

2)      每个数据报的大小在限制在64k内

3)      因无连接，是不可靠协议

4)      不需要建立连接，速度快

TCP：面向连接，对方必须在，

1)      建立连接，形成传输数据的通道

2)      在连接中进行大数据量传输

3)      通过三次握手完成连接，是可靠协议

4)      必须建立连接，效率会稍低。

TCP相当于打电话，UDP相当于步话机，

Socket：网络编程就是Socket。Socket 就是为网络服务提供的一种机制。通信的两端都有Socket。网络通信其实就是Socket间的通信。数据在两个Socket间通过IO传输。

UDP传输

1)     DatagramSocket与DatagramPacket

DatagramSocket：此类表示用来发送和接收数据报包的套接字。

Send（DatagramPacket p）：从此套接字发送数据报包。

DatagramPacket ：此类表示数据报包。数据报包用来实现无连接包投递服务，每条报文仅根据该包中包含的信息从一台机器路由到另一台机器，从一台机器发送到另一台机器的多个包可能选择不同的路由，也可能按不同的顺序到达，补对包投递做出保证。既用来发送数据也用来封装数据。

2)     建立发送端，接收端

3)     建立数据包

4)     调用Socket的发送接收方法

5)     关闭Socket

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

UDP的发送端

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

 思路：

     1，建立UdpSocket服务

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

      3，通过Socket服务的发送功能，将数据包发出去

      4，关闭资源

public 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="udp lei le".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协议传输的数据并处理的

思路：

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

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

    3，通过socket服务的receive方法将收到的数据存入已定义好的数据包中

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

    5，关闭资源。

class UdpRece {
	/**
	 * 需求：定义一个应用程序，用于接收udp协议传输的数据并处理的
	 * 定义udp的接收端
	 * 思路：
	 * 1，建立udpsocket服务,通常会监听一个端口，其实就是给这个接收网络应用程序定义数字标识，方便于明确哪些数据过来该应用程序可以处理。
	 * 2，定义一个数据包，因为要存储接收到的字节数据，因为数据包对象中有更多功能可以提取字节数据中的不同数据信息
	 * 3，通过socket服务的receive方法将收到的数据存入已定义好的数据包中
	 * 4，通过数据包对象的特有功能 ，将这些不同的数据取出，打印在控制台上
	 * 5，关闭资源。
	 * @param args
	 */
	public static void main(String[] args) throws Exception
	{
		//1创建udp socket 建立端点
		DatagramSocket ds=new DatagramSocket(8888);
		while(true)
		{

                   //2.定义数据包，用于存储数据，

                   datagrampacket(byte[]buf,int length,InetAddress address,int port)
		 byte[] buf=new byte[1024];
		 DatagramPacket dp=new DatagramPacket(buf,buf.length);
		 //3，通过socket服务，receiver方法将收到数据存入数据包中
		 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();
	}
}

import java.io.*;
import java.net.*;
public class UdpSend2 {

	/**192.1.1.0网络段；192.1.1.255网络段中的广播地址。
	 * @param args
	 */
	public static void main(String[] args)throws Exception
	{
		DatagramSocket ds=new DatagramSocket();
		BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));
		String line=null;
		while((line=bufr.readLine())!=null)
		{
			if("886".equals(line))
				break;
			byte[]buf=line.getBytes();//先变成数组
			DatagramPacket dp=new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.123"),1000);
			ds.send(dp);
		}
		ds.close();

	}

}
class UdpRece2 {

	public static void main(String[] args) throws Exception
	{
		DatagramSocket ds=new DatagramSocket(10001);
		while(true)
		{ byte[] buf=new byte[1024];
			DatagramPacket dp=new DatagramPacket(buf,buf.length);
			ds.receive(dp);
			String ip=dp.getAddress().getHostAddress();
			String data=new String(dp.getData(),0,dp.getLength());
			System.out.println(ip+":::"+data);
		}
	}
}

需求：编写一个聊天程序
有收数据的部分，和发数据的部分；这两部分需要同时执行；那就需要用到多线程技术；一个线程控制收，一个线程控制发

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

import java.net.*;
import java.io.*;
public class ChatDemo {
	public static void main(String[] args)  throws Exception
	{
		DatagramSocket sendSocket=new DatagramSocket();
		DatagramSocket receSocket=new DatagramSocket();
		new Thread(new Send(sendSocket)).start();
		new Thread(new Rece(receSocket)).start();

	}

}
class Send implements Runnable
{  
	private DatagramSocket ds;
	public Send(DatagramSocket ds)
	{
		this.ds=ds;
	}
	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[] buf=line.getBytes();
			DatagramPacket dp=new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.255"),10000);
			ds.send(dp);
		}
		} catch (Exception e) {
			throw new RuntimeException("发送端失败");
		}
	}
}
class Rece implements Runnable
{
	private DatagramSocket ds;
	public Rece(DatagramSocket ds)
	{
		this.ds=ds;
	}
	public void run()
	{
	  try { while(true)
	  {
		  byte[] buf=new byte[1024];
		  DatagramPacket dp=new DatagramPacket(buf,buf.length);
		  ds.receive(dp);
		  String ip=dp.getAddress().getHostAddress();
		  String data=new String(dp.getData(),0,dp.getLength());
		  System.out.println(ip+":"+data);
	  }	
	} catch (Exception e) {
	        throw new RuntimeException("接收失败");
	}
	}
}

TCP传输

1)      Socket和ServerSocket

Socket此类实现客户端套接字，套接字是两台机器间通信的端点

ServerSocket

2)      建立客户端和服务器端

3)      建立连接后，通过Socket中的IO流进行数据的传输

4)      关闭socket

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

演示TCP传输
1，TCP分客户端和服务端

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

   服务端对应的对象是serverSocket

import java.io.*;
import java.net.*;

public class TcpClient {

	/**客户端
	 * 通过查阅socket对象，发现在该对象建立时，就可以去连接指定主机
	 * 因为TCP是面向连接的，所以在建立socket服务时，就要有服务端存在，并连接成功，形成通路后，在该通道进行数据的传输
	 *需求：给服务端发一个文本数据
	 * 步骤
	 * 1，创建socket服务，并指定要连接的主机和端口。
	 * 2,为发送数据，应该获取socket流中的输出流
	 * @param args
	 */
	public static void main(String[] args)throws Exception
	{
	   //创建客户端的socket服务，指定目的主机和端口。
	    Socket s=new Socket("192.168.1.123",1009);
	   //为发送数据，应该获取socket流中的输出流
              //InputStream in=s.getInputStream();//返回此套接字的输入流。
	   OutputStream out=s.getOutputStream();
	   out.write("tcp ge men lai l ".getBytes());
	   s.close();
     
	}

}
 class TcpServer {

	/**
	 * 服务端
	 * 通过查阅socket对象，发现在该对象建立时，就可以去连接指定主机
	 *accept():侦听并接受到此套接字的连接。
	 *需求：定义端点接收数据并打印在控制台上
	 * 步骤
	 * 1，建立服务端的socket服务，ServerSocket();
	 *       并监听一个端口
	 * 2，获取连接过来的客户端对象 ，
	 *       通过ServerSocket的accept方法，没有连接就会等，所以这个方法阻塞式的，
	 * 3，客户端如果发过来数据，那么服务端要使用对应的客户端对象，并获取到该客户端对象的读取流来读取发过来的数据
	 *    并打印在控制台。
	 * 4，关闭服务器(可选)
	 */
	public static void main(String[] args)throws Exception
	{
	    //创建客户端的socket服务，并监听一个端口
	  ServerSocket ss=new ServerSocket(1009);
	   //通过accept方法获取连接过来的客户端对象
	  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的传输的客户端和服务端的互访

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

客户端

1，建立socket服务，指定要连接的主机和端口

2，获取socket流中的输出流，将数据写到该流中，通过网络发送给服务端。

3，获取socket流中的输入流，将服务端反馈的数据获取到，并打印

 4，关闭客户端资源

import java.net.*;
import java.io.*;
public class TcpClient2 {

	public static void main(String[] args)throws Exception
	{
		Socket s=new Socket("192.168.2.1",1004);
		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(1004);
	         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时，转换结束

      分析：

      客户端

      既然是操作设备上的数据，那么就可以使用IO技术，并按照IO的操作规律来思考

      源：键盘输入

      目的：网络设备，网络输出流

      而且操作的是文本数据，可以选择字符流 

     步骤

      1，建立服务

      2，获取键盘录入

      3，将数据发给服务器

      4，后去服务端返回的大写数据

      5，结束，关资源。

     都是文本数据，可以使用字符流进行操作，同时提高效率，加入缓冲

import java.io.*;
import java.net.*;
public class TransClient {

	public static void main(String[] args)throws Exception
	{
		Socket s=new Socket("192.168.1.123",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;
			/*bufout.write(line);
			bufout.newLine();
			bufout.flush();*/
			out.println(line);
			String str=bufIn.readLine();
			System.out.println("server:"+str);
		}
			bufr.close();
			s.close();//
	}

}

 服务端

      源：socket读取流

      目的：socket输出流

      都是文本，装饰

 该例子出现的问题现象：客户端和服务端都在莫名的等待 ，为何呢？

 因为客户端和服务端都有阻塞式方法，这些方法没有读到结束标记，那么就一直等，而导致两端都在等待。开发时如果遇到就查看阻塞式方法，

class TransServer{

	public static void main(String[] args) throws Exception
	{
	    ServerSocket ss=new ServerSocket(100005);
	    Socket s=ss.accept();
	    String ip=s.getInetAddress().getHostAddress();
	    System.out.println(".....conneced"+ip);
	    //源：读取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)//readLine()阻塞式方法。
	{
		System.out.println(line);
		/*bufout.write(line.toUpperCase());
		bufout.newLine();
		bufout.flush();*/
		out.println(line.toUpperCase());
	}
	    s.close();
	    ss.close();
     }
}

文件的复制。
void shutdownInput() ；此套接字的输入流置于"流的末尾"

void shutdownOutput()；禁用此套接字的输出流。

import java.io.*;
import java.net.*;
public class TextClient {

	public static void main(String[] args)throws Exception
	{
           Socket s=new Socket("192.168.2.245",10006);
           BufferedReader bufr=new BufferedReader(new FileReader("IpDemo.java"));
           PrintWriter out=new PrintWriter(s.getOutputStream(),true);
           DataOutputStream dos=new DataOutputStream(s.getOutputStream());//操作基本数据类型的流对象。
             long time=System.currentTimeMillis();
           dos.writeLong(time);
           // out.println(time);
           String line=null;
           while((line=bufr.readLine())!=null)
           {
	     out.println(line);
            }
           /* out.println("over");//自定义结束。定义标记，第一种方式自定义结束标记，
            dos.writeLong(time);*/
          s.shutdownOutput();//关闭客户端的输出流，相当于给流中加入一个结束标记-1.禁止此套接字的输出流
            BufferedReader bufIn=new BufferedReader(new InputStreamReader(s.getInputStream()));
          String str=bufIn.readLine();
          System.out.println(str);
          bufr.close();
          s.close();
      }

}
 class TextServer {

	public static void main(String[] args) throws Exception
	{
	ServerSocket ss=new ServerSocket(10006);
	Socket s=ss.accept();
	String ip=s.getInetAddress().getHostAddress();
	System.out.println(ip+"..............connecsed");
	DataInputStream dis=new DataInputStream(s.getInputStream());
	long  l=dis.readLong();//
	BufferedReader bufIn=new BufferedReader(new InputStreamReader(s.getInputStream()));
	PrintWriter out=new PrintWriter(new FileWriter("server.txt"),true);
	String line=null;
	while((line=bufIn.readLine())!=null)
	{
	        /*if("over".equals(line))
			break;*/
	        out.println(line);	
	}
	PrintWriter pw=new PrintWriter(s.getOutputStream(),true);
	pw.println("上传成功");
	out.close();
	s.close();
	ss.close();
	}
}

TCP传输最容易出现的问题

客户端连接上服务端，两端都在等待，没有任何数据传输

通过例程分析：

因为read方法或是readline方法是阻塞式

解决方法：自定义结束标记

  使用shutdowninput shutdownoutput方法。

需求：简单的一个客户端和一个服务器上传图片

import java.io.*;
import java.net.*;
public class PicClient {

	/**客户端
	 * 1，服务端点
	 * 2，读取客户端已有的图片数据
	 * 3，通过socket输出流将数据发给服务端
	 * 4，读取服务端反馈信息
	 * 5，关闭
	 * @param args
	 */
	public static void main(String[] args) throws Exception
	{        if(args.length!=1)
	         {
		 System.out.println("请选择一个jpg格式的图片");
		 return;
	          }
		 File 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*8)
		 {
			 System.out.println("文件过大。没安好心");
			 return;
		 }
		Socket s=new Socket("192.168.1.2",1007);
                  FileInputStream fis=new FileInputStream("c:\\1.jpg");
		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 {

	/**服务器
	 * 这个服务端有个局限性，当A客户端连接上以后，被服务端获取到，服务端执行具体流程
	 * 这时B客户端连接，只有等待
	 * 因为服务端还没有处理完A客户端的请求，还有循环回来执行下次accept方法，所以
	 * 暂时获取不到B客户端对象
	 * 那么为了可以让多个客户端同时并发访问服务端
	 * 那么服务端最好就是将每个客户端封装到一个单独的线程中，这样，就可以同时处理多个客户端请求。
	 * @param args
	 * 如何定义线程？
	 * 只要明确了每一个客户端要在服务端执行的代码即可，将该代码存入run方法中。
	 */
	public static void main(String[] args) throws Exception
	{
		ServerSocket ss=new ServerSocket(1007);
		Socket s=ss.accept();//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();
	}
}

需求：上传图片，多个客户端传图片。

import java.io.*;
import java.net.*;
public class PicClient {
	/**客户端
	 * 1，服务端点
	 * 2，读取客户端已有的图片数据
	 * 3，通过socket输出流将数据发给服务端
	 * 4，读取服务端反馈信息
	 * 5，关闭
	 * @param args
	 */
	public static void main(String[] args) throws Exception
	{       if(args.length!=1)
	         {
		 System.out.println("请选择一个jpg格式的图片");
		 return;
	          }
		 File 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*8)
		 {
			 System.out.println("文件过大。没安好心");
			 return;
		 }
		Socket s=new Socket("192.168.1.2",1007);
                  //FileInputStream fis=new FileInputStream("c:\\1.jpg");
   		FileInputStream fis=new FileInputStream(file);
		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 PicThread implements Runnable
{
  private Socket s;
  PicThread(Socket s)
  {
	  this.s=s;
  }
  public void run()
  {        int count=1;
	  String ip=s.getInetAddress().getHostAddress();
	  try { 
		System.out.println(ip+".....connected");
		InputStream in=s.getInputStream();
		File file=new File(ip+"("+(count)+")"+".jpg");//ip（1）.jpg。
		while(file.exists())
		file=new File(ip+"("+(count++)+")"+".jpg");
		FileOutputStream fos=new FileOutputStream("server.bmp");
		byte[] buf=new byte[1024];
		int len=0;
		while((len=in.read())!=-1)
		{
			fos.write(buf,0,len);
		}
		OutputStream out=s.getOutputStream();
		out.write("上传成功".getBytes());
	} catch (Exception e) {
	 throw new RuntimeException(ip+"上传失败");
	}
  }
}
class PicServer {

	/**服务器
	 * 这个服务端有个局限性，当A客户端连接上以后，被服务端获取到，服务端执行具体流程
	 * 这时B客户端连接，只有等待
	 * 因为服务端还没有处理完A客户端的请求，还有循环回来执行下次accept方法，所以
	 * 暂时获取不到B客户端对象
	 * 
	 * 那么为了可以让多个客户端同时并发访问服务端
	 * 那么服务端最好就是将每个客户端封装到一个单独的线程中，这样，就可以同时处理多个客户端请求。
	 * @param args
	 * 如何定义线程？
	 * 只要明确了每一个客户端要在服务端执行的代码即可，将该代码存入run方法中。
	 */
	public static void main(String[] args) throws Exception
	{
		ServerSocket ss=new ServerSocket(1007);
	    while(true)
	     {
		/*Socket s=ss.accept();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();*/
	    	Socket s=ss.accept();
	    	new Thread(new PicThread(s)).start();
	    	
		}
                  //ss.close();
	}
}

客户端向服务端发送用户名请求登录，服务端通过验证，返回“欢迎光临”，未通过“用户补存在”。

import java.io.*;
import java.net.*;
/*客户端通过键盘录入用户名
 * 服务端对这个用户名进行校验
 * 如果该用户存在，在服务端显示xxx已登录，并在客户端显示xxx欢迎光临
 * 如果该用户存在，在服务端显示xxx尝试登录，并在客户端显示xxx该用户补存在。
 * 最多就登录三次。
 * */
public class LoginClient {
	public static void main(String[] args)throws Exception
	{
		Socket s=new Socket("192.168.1.2",10008);
		BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));;
		PrintWriter out=new PrintWriter(s.getOutputStream(),true);
		BufferedReader bufIn=new BufferedReader(new InputStreamReader(s.getInputStream()));
		for(int x=0;x<3;x++)
		{
			String line=bufr.readLine();
			if(line==null)
				break;
			out.println(line);
			String info=bufIn.readLine();
			System.out.println("info:"+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 x=0;x<3;x++)
		{   
			BufferedReader bufIn =new BufferedReader(new InputStreamReader(s.getInputStream()));
			String name=bufIn.readLine();
			//读文件
			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+",用户名不存在");
				break;
			}
		}
		s.close();
	} catch (Exception e) {
		throw new RuntimeException(ip+"校验失败");
	}
    }
}
class LoginServer {
	public static void main(String[] args)throws Exception
	{
		ServerSocket ss=new ServerSocket(10008);
		while(true)
		{
			Socket s=ss.accept();
			new Thread(new UserThread(s)).start();
		}
	}
<span style="color:#000000;">}</span>

演示客户端和服务端

1，客户端：浏览器（telnet）

      服务器：自定义

2，客户端：浏览器

     服务端：tomcat

3，客户端自定义

    服务端： tomcat服务器。

import java.net.*;
import java.io.*;
public class ServerDemo {

	/**演示客户端和服务端
	 *1，客户端：浏览器（telnet）
	 *   服务器 自定义
	 *2,客户端：浏览器
	 *  服务端：tomcat
	 *3，客户端 自定义
	 *  服务端 tomcat服务器。
	 * @param args
	 */
	public static void main(String[] args)throws Exception
	{
               ServerSocket ss =new ServerSocket(11000);
               Socket s=ss.accept();
               System.out.println(s.getInetAddress().getHostAddress());
               PrintWriter out=new PrintWriter(s.getOutputStream(),true);
               out.println("<font color='red' size='7'>客户端你好</font>");
               s.close();
               ss.close();
	}
}

自定义浏览器

import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.net.*;
public class MyIEByGUI {
	public static void main(String[] args) {
		new  MyIEByGUI ();
	}
	private void showDir()throws Exception
	{  
		ta.setText("");
		String url=tf.getText();//http://192.168.1.123:8080/myweb/demo.html
		int index1=url.indexOf("//")+2;
		int index2=url.indexOf("/",index1);
		
		String str=url.substring(index1,index2);
		String[]arr=str.split(":");
		String host=arr[0];
		int port=Integer.parseInt(arr[1]);
		String path=url.substring(index2);
                  //ta.setText(str+";;;;"+path);
		Socket s=new Socket(host,port);
		PrintWriter out=new PrintWriter(s.getOutputStream(),true);
		out.println("GET"+path+" HTTP/1.1");
		out.println("Host:192,168.1.253:1100");
		out.println();
		out.println();
		BufferedReader bufr=new BufferedReader(new InputStreamReader(s.getInputStream()));
		String line=null;
		while((line=bufr.readLine())!=null)
		{
                            //System.out.println(line);
			ta.append(line+"\r\n");
		}
		s.close();
	}
	private Frame f;
	private TextField tf;
	private Button but;
	private TextArea ta;
	private Dialog d;
	private Label lab;
	private Button okBut;
	 MyIEByGUI()
	{
		init();
	}
	public void init()
	{
		f=new Frame("my window");
		f.setBounds(300, 100, 500, 600);
		f.setLayout(new FlowLayout());
		tf=new TextField(30);
		but=new Button("转到");
		ta=new TextArea(25,70);
		d=new Dialog(f,"提示信息--self",true);
		lab=new Label();
		okBut=new Button("确定");
		d.setBounds(400,300,400,100);
		d.setLayout(new FlowLayout());
		d.add(lab);
		d.add(okBut);
		f.add(tf);
		f.add(but);
		f.add(ta);
		myEvent();
		f.setVisible(true);
		
	}
	private void myEvent(){
		okBut.addActionListener(new ActionListener()
		{
			public void actionPerformed(ActionEvent e)
			{
				d.setVisible(false);
			}
		});
		d.addWindowListener(new WindowAdapter()
		{
			public void windowClosing(WindowEvent e)
			{
				d.setVisible(false);
			}
		});
		tf.addKeyListener(new KeyAdapter()
		{
			public void keyPressed(KeyEvent e)
			{   try{
				if(e.getKeyCode()==KeyEvent.VK_ENTER)
				showDir();
			        }
			     catch(Exception ex){}	
			}
		});
		
		but.addActionListener(new ActionListener()
		{
			public void actionPerformed(ActionEvent e)
			{ try{showDir();}
			 catch(Exception e1)
			 {}
				
			}
		});
		f.addWindowListener(new WindowAdapter()
		{
			public void windowClosing(WindowEvent e)
			{
				System.exit(0);
			}
		});
	}
}

获取URL的信息：

import java.net.*;
public class UrlDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args)throws MalformedURLException//为报告的异常。
	{
		URL url=new URL("http://192.68.1.123/myweb/demo.html");
                  System.out.println("getprotocol()"+url.getProtocol());
                  System.out.println("gethost()"+url.getHost());
                  System.out.println("getport()"+url.getPort());//没有指定端口时，返回来-1
                  System.out.println("getpath"+url.getPath());
                  System.out.println("GETFILE"+url.getFile());//后面有参数
                     System.out.println("query"+url.getQuery());//后面的参数。
                     int port =url.getPort();
                  if(port==-1)
	         port=80;
     }

}
/*
 * string getFile()//获取此URL的文件名
 * string gethost()//获取此URL的主机名 (如果适用)
 * string getpath()//获取此URL的路径部分
 * string getport()//获取此URL的端口号。
 * string getprotocol()//获取此URL的协议名称
 * String getQuery()//获取此URL的查询部
 * */

与URL链接

import java.net.*;
import java.io.*;
public class URLConnectionDemo {

	/**URLConnection 抽象类是所有类的超类，它代表应用程序和URL之间的通信链接，此类的实例可用于读取和写入此URL引用的资源，通常，创建一个到URL的            连接需要几个步骤。
	 * 1，通过在URL，上调用openConnection()方法创建连接对象，
	 * 2，处理设置参数和一般请求属性
	 * 3，使用connect方法建立到远程对象的实际连接，
	 * 4，远程对象变为可用，远程对象的头字段和内容变为可访问。
	 * URLConnection openConnection()返回一个URLConnection对象，它表示到URL所引用的远程对象的连接。
	 * InputStream getInputStream()返回从此打开的连接读取的输入流。
            * InputStream openStream()打开到此URL的连接并返回一个用于从该连接读入的InputStream
	 * @param args
	 */
	public static void main(String[] args) throws Exception
	{
		URL url=new URL("http://192.68.1.123: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));
	}
}

——————————————————————

Socket()构造时用的connect（SocketAddress endpoint）:将此套接字连接到服务器。

public ServerSocket(int port,int backlog)throws IOException

port-指定的端口：或者为0，表示使用任何空闲端口。

backlog-队列的最大长度。

利用指定的backlog创建服务器套接字并将其绑定到指定的本机端口号。

————————————————————

域名解析：

———寄语：每个人都拥有不同的梦想，但实现梦想的路途都是自己亲身经历的。濛濛的梦想就在那里，努力为梦想努力中。。。加油濛濛。。。———       濛濛