java网络编程介绍与实例

【网络传输流程】
1：找到对方IP
2：数据要发送到对方指定的应用程序上，为了标识这些应用程序，给这些应用程序用数字标识，这个数字称为端口
3：定义通讯规则，这个通讯规则称为协议，国际组织定义了通用协议TCP/IP
IP地址：本地回环地址127.0.0.1 主机名localhost


【获取ip】InetAddress只是一个数字标识，不用封装成对象，因此不用new
【端口】0~65536 其中0~1024是系统保留端口，0为网络端口255为广播端口(该网段内所有应用程序发消息)
【UDP与TCP区别】
UDP：
1：将数据源和目的封装成数据包中，不需要建立连接。
2：每个数据包限制在64K内
3：因无连接，是不可靠连接(相当于发短信)
4：不需要建立连接，速度快
TCP：
1：建立连接，形成传输数据的通道(相当于打电话)
2：在连接中形成大数据量的传输
3：通过三次握手完成，是可靠协议
4：必须建立连接，效率较低


【socket】
1：socket是为网络服务提供的一种机制
2：通讯的两端都有socket
3：网络通信其实就是socket通信
4：数据在两个socket之间通过io传输


【简单demo】
package net;


import java.net.InetAddress;
import java.net.UnknownHostException;


public class IPDemo {


public static void main(String[] args) throws UnknownHostException {
//获取本地主机
/* InetAddress i =  InetAddress.getLocalHost();
System.out.println(i);
System.out.println(i.getHostAddress());
System.out.println(i.getHostName());*/

//获取任意主机
InetAddress[] ia = InetAddress.getAllByName("www.baidu.com");
for(InetAddress i:ia){
System.out.println(i.getHostAddress());
System.out.println(i.getHostName());
}
}
}
【UDPsend】
package net;
import java.io.IOException;
import java.net.*;
import java.rmi.dgc.DGC;
/*
 * 通过utp传输协议，发送一段文字数据 
 * 思路：
 * 1：建立UDPScoket数据服务
 * 2：提供数据，并将数据封装到包中
 * 3：通过socket服务发送功能，将数据包发送出去
 * 4：关闭资源
 */
public class UDPSend {
public static void main(String[] args) {
//1:创建udp服务，通过datagramSocket对象
DatagramSocket dg = null;
DatagramPacket  dp = null;
try {
dg= new DatagramSocket();
} catch (SocketException e) {
e.printStackTrace();
}
//2:确定数据，并封装成包
byte[] data = "udp ssend message hello world".getBytes();
try {
dp = new DatagramPacket(data,data.length,InetAddress.getByName("111.114.119.108"),10000);
} catch (UnknownHostException e) {
e.printStackTrace();
}
//3:用socket服务的send方法将数据发出
try {
dg.send(dp);
} catch (IOException e) {
e.printStackTrace();
}
//4:关闭资源
dg.close();
}
}
【UDPreceive】
package net;


import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;


/*
 * 需求：定义一个应用程序，用于接受用UDP协议传输的数据，通常会监听一个端口，其实就是给该应用程序定义数字标识
 * 1：定义socket服务
 * 2：定义数据包，储存接受的字节数据
 * 3：通过socket的receive方法接受数据并存入数据包
 * 4：将数据取出
 * 5：关闭资源
 * 
 */
public class UDPReceive {


public static void main(String[] args) throws Exception {
//1：创建udpSocket服务
DatagramSocket ds = new DatagramSocket(10000);
//2: 定义数据包，用于存储数据 
byte[] buf = new byte[1024];
DatagramPacket dp = new DatagramPacket(buf,buf.length);
//3:通过receive方法接受并存入
ds.receive(dp);
//4:拆包获取数据
String ip = dp.getAddress().getHostAddress();
int port = dp.getPort();
int hostname = dp.getOffset();
//String data = dp.getData().toString();//字节型，直接字符串化，乱码
String data = new String(dp.getData(),0,dp.getLength());
System.out.println(ip+"\t"+port+"\t"+hostname+"\t"+data);
//5:关闭资源
}
}
【聊天demo】
package net;
import java.net.*;
import java.io.*;
public class ChatDemo {
public static void main(String[] args) throws SocketException {
DatagramSocket sendS = new DatagramSocket();
DatagramSocket ReceS = new DatagramSocket(10002);
new Thread(new Send(sendS)).start();
new Thread(new Receive(ReceS)).start();
}
}
class Send implements Runnable{
@Override
public void run() {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String line = null;
try {
while((line = br.readLine()) != null){
if("886".equals(line)){
break;
}
byte[] buf = line.getBytes();
DatagramPacket dp = new DatagramPacket(buf,buf.length,InetAddress.getByName("111.114.119.11"),10002);
ds.send(dp);
}
ds.close();
} catch (Exception e) {
new RuntimeException("发送失败");
}
}
private static DatagramSocket ds;
public  Send(DatagramSocket ds){
this.ds = ds;
}
}


class Receive implements Runnable {
@Override
public void run() {
try {
while(true){
byte[] buf = new byte[1024*64];
DatagramPacket dp = new DatagramPacket(buf,buf.length);
ds.receive(dp);
String ip = dp.getAddress().getHostAddress()+"\t";
String data = new String(dp.getData(),0,dp.getLength());
System.out.println(ip+data);
}
} catch (Exception e) {
new RuntimeException("接受失败");
} 
}
private static DatagramSocket ds;
public Receive(DatagramSocket ds) {
this.ds = ds;
}
}
【TCP传输】
【TCPClient】
package net;
/*
 * tcp分为客户端和服务端
 * 1，客户端对应的对象是Socket
 * 2，服务端对应的对象是ServerSocket
 * --客户端
 * 通过Socket方法创建 该对象在建立时，就可以去连接指定主机(也可以不指定，建立完成 后用connect方法指定)
 */
import java.io.*;
import java.net.*;
public class TCPCliect {
public static void main(String[] args) throws UnknownHostException, IOException {
//创建Socket服务，指定目的主机和端口
Socket s = new Socket("111.114.119.11",10003);
//为了发送数据，获取Socket对象的输出流(该留在Socket建立的时候就存在了)
OutputStream out = s.getOutputStream();
out.write("sssssssssss".getBytes());
s.close();
}
}
【TCPServer】
package net;
/*--服务端
 * 1，创建服务器对象，SocketServer建立，并监听一个端口
 * 2，获取连接过来的客户端对象，通过accept方法，该方法是阻塞式方法
 * 3，如果客户端发过来数据，服务端通过获取对应的客户端对象，从而获取对应数据
 */
import java.io.*;
import java.net.*;
public class TCPServer {
public static void main(String[] args) throws IOException {
//建立服务端对象，并监听端口
ServerSocket ss = new ServerSocket(10003);
//获取客户端对象
Socket s = ss.accept();
String ip = ss.getInetAddress().getHostAddress();
int d = ss.getLocalPort();
System.out.println(ip+d);
//获取客户端的对应流
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();
}
}