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
}
}
}
