Java学习14-网络编程

1.关于InetAddress

InetAddress：构造方法私有，不能直接创建对象。
InetAddress getByName(String host):在给定主机名的情况下确定主机的ip地址。
InetAddress getLocalHost()：返回本地主机。
InetAddress[] getAllByName(String host)
ip.getHostAddress(), 
ip.getHostName()

<span style="font-family:Microsoft YaHei;font-size:14px;">import java.net.InetAddress;

public class Demo1 {
	public static void main(String[] args) throws Exception {
		
		InetAddress i = InetAddress.getLocalHost();
		System.out.println(i);
		
		i = InetAddress.getByName("www.baidu.com");
		System.out.println(i);
		System.out.println(i.getHostAddress());
		
		System.out.println(i.getHostName());
	}
}</span>

输出：
XP-201304252326/10.6.147.2
www.baidu.com/61.135.169.105
61.135.169.105

www.baidu.com

2、端口号：

        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传输。

 

3.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、在接收端，要指定监听的端口。

package nuddles.j2seDemo;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;

public class UdpClient {

	/**
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		DatagramSocket ds = new DatagramSocket(10000);
//		新建一个socket监听某个端口
		byte[] buf = new byte[1024];
		DatagramPacket dp = new DatagramPacket(buf, buf.length);
		 ds.receive(dp);
//		 接收一个数据包
		String ip = dp.getAddress().toString();
		int port = dp.getPort();
//		byte[] buf2 = dp.getData();
		String data =new String(dp.getData(),0,dp.getLength());
//		获得数据
		System.out.println(data);
		System.out.println(ip);
		System.out.println(port);
	}

}

          

package nuddles.j2seDemo;

import java.io.IOException;

public class UdpDemo {

	/**
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		DatagramSocket ds = new DatagramSocket();
//		先建立一个socket
		byte[] buf = new byte[1024];
		buf = new String("haha").getBytes();
		DatagramPacket dp = new DatagramPacket(buf,buf.length,InetAddress.getLocalHost(),10000);
//		封装一个数据包
		ds.send(dp);
		System.out.println(dp.getPort());
//		发出去
		ds.close();
//		关掉
		
	}

}

编写一个聊天程序。

有收数据的部分，和发数据的部分。

这两部分需要同时执行。

那就需要用到多线程技术。

一个线程控制收，一个线程控制发。

 因为收和发动作是不一致的，所以要定义两个run方法。

而且这两个方法要封装到不同的类中。

package nuddles.j2seDemo;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;

public class UdpChat {

	/**
	 * @param args
	 * @throws SocketException 
	 */
	public static void main(String[] args) throws SocketException {
		// TODO Auto-generated method stub
		DatagramSocket ds1 = new DatagramSocket();
		DatagramSocket ds2 = new DatagramSocket(10004);
		new Thread(new UdpSend(ds1)).start();
		new Thread(new UdpRecieve(ds2)).start();
		
		
		
	}

}

class UdpSend implements Runnable{
	private DatagramSocket ds ;
	UdpSend(DatagramSocket ds){
		this.ds = ds;
	}
	public void run() {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		byte[] buf = new byte[1024];
		String line;
		while (true) {
			try {
				line = br.readLine();
			if (line.equals("over")) {
				break;
			}
			buf = line.getBytes();
			DatagramPacket dp = new DatagramPacket(buf,0,buf.length,InetAddress.getLocalHost(),10004);
			ds.send(dp);
			} catch (Exception e) {
				// TODO: handle exception
				e.printStackTrace();
			}
			
		}
		ds.close();
	}
}


class UdpRecieve implements Runnable{
	DatagramSocket ds;

	public UdpRecieve(DatagramSocket ds) {
		super();
		this.ds = ds;
	}
	@Override
	public void run() {
		// TODO Auto-generated method stub
		byte[] buf = new byte[1024];
		DatagramPacket dp = new DatagramPacket(buf,buf.length);
		while (true) {
			try {
				ds.receive(dp);
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			String data = new String(dp.getData(),0,dp.getLength());
			System.out.println(data);
		
		}
	}
}

4.TCP传输
两个端点的建立连接后会有一个传输数据的通道，这通道称为流，而且是建立在网络基础上的流，称之为socket流。该流中既有读取，也有写入。
tcp的两个端点：一个是客户端，一个是服务端。
客户端：对应的对象，Socket
服务端：对应的对象，ServerSocket
TCP客户端：
①：建立tcp的socket服务，最好明确具体的地址和端口。这个对象在创建时，就已经可以对指定ip和端口进行连接(三次握手)。
②：如果连接成功，就意味着通道建立了，socket流就已经产生了。只要获取到socket流中的读取流和写入流即可，只要通过getInputStream和getOutputStream就可以获取两个流对象。
③：关闭资源。
import java.net.*;
import java.io.*;
//需求：客户端给服务器端发送一个数据。
class  TcpClient{
        public static void main(String[] args) throws Exception{
                Socket s = new Socket("10.1.31.69",10002);
                OutputStream out = s.getOutputStream();//获取了socket流中的输出流对象。
                out.write("tcp演示，哥们又来了!".getBytes());
                s.close();
}
}


TCP服务端：
①：创建服务端socket服务，并监听一个端口。
②：服务端为了给客户端提供服务，获取客户端的内容，可以通过accept方法获取连接过来的客户端对象。
③：可以通过获取到的socket对象中的socket流和具体的客户端进行通讯。
④：如果通讯结束，关闭资源。注意：要先关客户端，再关服务端。
我的总结：对于UDP和TCP，既可以定义输出流也可以创建输入流，具体情况根据需要构建；比如：我们需要客户端给服务器端发送数据，服务器端再给客户端反馈数据；那么就要在客户端和服务器端分别多加一个输入流和输出流！否则，发不出去，收不到！

练习利用TCP上传文件（其实就是复制）

<pre name="code" class="java">package nuddles.j2seDemo;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;

public class PicUpload {

	/**
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		ServerSocket ss = new ServerSocket(9999);
		Socket s = new Socket("127.1.1.0",9999);
		new Thread(new TcpServer(ss)).start();
		new Thread(new TcpClient(s)).start();
		

	}

}

class TcpServer implements Runnable{
	  private ServerSocket ss;

	public TcpServer(ServerSocket ss) {
		super();
		this.ss = ss;
	}
	

	 @Override
	public void run() {
		// TODO Auto-generated method stub
		 try {
			 Socket s =ss.accept();
			FileWriter fw = new FileWriter("d:\\tcp.txt");
			BufferedWriter bw = new BufferedWriter(fw);
			BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
			String line = null;
			while ((line = br.readLine())!=null) {
				bw.write(line);
				bw.newLine();
				bw.flush();
			}
			s.shutdownInput();
			bw.close();
			System.out.println("上传成功");
			
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		 
	}
}

class TcpClient implements Runnable{
	private Socket s;

	public TcpClient(Socket s) {
		super();
		this.s = s;
	}
	@Override
	public void run() {
		// TODO Auto-generated method stub
		try {
			BufferedReader br = new BufferedReader(new FileReader("d:\\count.txt"));
			BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
			String line = null;
			while ((line = br.readLine())!=null) {
				bw.write(line);
				bw.newLine();
				bw.flush();
//				一定要记得刷新
			}
			s.shutdownOutput();
//			要关闭，不然会一直阻塞
			s.close();
			
		} catch (Exception e) {
			// TODO: handle exception
		}
		
		
	}
}