---------------------- android培训、java培训、期待与您交流! ----------------------
一.网络编程基础知识
计算机网络就是实现了多个计算机互联的系统,相互连接的计算机之间能够彼此进行数据交换,和城市道路交通系统与交通规则类似,计算机网络总是伴随着计算机网络协议一起使用的,网络协议规定了计算机间的物理,机械,电气等等规则。网络应用程序就是,已实现了网络互联的不同计算机上运行的程序,这些程序相互之间可以交换数据,编写网络应用程序,首先必须明确网络程序所要使用的网络协议,TCP/IP是网络应用程序的首选协议,大多数网络程序都是以这个协议为基础的。
计算机网络的两种参考模型:
网络通信的三个要素:
1.IP地址:InetAddress,网络中设备的标识,不易记忆,可用主机名,本地回环地址:127.0.0.1 主机名:localhost;
2.端口号:不同的应用程序使用不同的端口,让数据帧要交给指定的应用程序,端口的取值范围从0—65535,普通的网络应用程序应当使用1024以上的端口数,从而避免端口号已经被另一个应用或系统服务所用,其中0~1024系统使用或保留端口;
3.传输协议:即通讯的规则,常见协议:TCP,UDP。
UDP的特点:
将数据及源和目的封装成数据包中,不需要建立连接,每个数据报的大小在限制在64k内,因无连接,是不可靠协议,但是它不需要建立连接,速度快,一般的聊天程序,网络视频会议,桌面共享均采用这种方式。
TCP的特点:
建立连接,形成传输数据的通道,在连接中进行大数据量传输,通过三次握手完成连接,是可靠协议,必须建立连接,效率会稍低。更类似于打电话的过程,用于下载等应用。
一.Socket编程
Socket是网络驱动层提供给应用程序编程的接口和一种机制,可以认为Socket是应用程序创建的一个港口码头,应用程序只要把货物的集装箱(在程序中就是要通过网络发送的数据)放到港口码头上,就算完成了货物的运行,对于接受方来讲,应用程序也需要创建一个港口码头,然后一直等待到该码头的货物到达,最后从码头上取走货物,即发给该应用程序的数据,Socket在应用程序中创建,通过一种绑定机制与驱动程序建立关系,告诉自己所对应的IP和Port,然后,应用程序收到与该Socket绑定的IP+Port相关的数据后,有驱动程序交给Socket,应用程序便可以从该Socket中提取接收到的数据。
Java分别为UDP和TCP两种通信协议提供了相应的编程类,这些类存放在java.net包中,与UDP对应的是DatagramSocket,与TCP对应的是ServerSocket(用于服务器端)和Socket(用于客户端),网络通信实际上就是两个网络程序之间在收发数据,只要端口号不同,我们也可以在一台计算机上进行两个网络程序之间的通信。
二.编写UDP网络程序
常见步骤:
1.定义DatagramSocket与DatagramPacket对象。
2.建立发送端,接收端。
3.建立数据包。
4.调用Socket的发送接收方法。
5.关闭Socket。
发送端和接收端要定义不同的代码,分开来写:
UDP发送端:在发送端,要在数据包对象中明确目的地IP及端口。
典型的代码:
DatagramSocket ds = new DatagramSocket();//定义一个DatagramSocket对象
byte[] by = “hello,udp”.getBytes();
DatagramPacket dp = new DatagramPacket(by,0,by.length,//定义一个数据包对象
InetAddress.getByName(“127.0.0.1”),10000);
ds.send(dp);//发送数据
ds.close();
UDP接收端:在接收端,要指定监听的端口。
典型的代码:
DatagramSocket ds = new DatagramSocket(10000);//定义指定监听端口的DatagramSocket对象
byte[] by = new byte[1024];
DatagramPacket dp = new DatagramPacket(by,by.length);//定义数据包对象接收数据
ds.receive(dp);//接受
String str = new String(dp.getData(),0,dp.getLength());
System.out.println(str+"--"+dp.getAddress());
ds.close();
实例:用udp发送接收一段文字信息
import java.net.*;
/*
需求:通过udp传输方式,将一段文字数据发送出去。,
定义一个udp发送端。
思路:
1,建立updsocket服务。
2,提供数据,并将数据封装到数据包中。
3,通过socket服务的发送功能,将数据包发出去。
4,关闭资源。
*/
class UdpSend
{
public static void main(String[] args) throws Exception
{
//创建udp服务。通过DatagramSocket对象。
DatagramSocket ds = new DatagramSocket(8888);
byte[] buf = "udp ge men lai le ".getBytes();//把数据变成字节数组
DatagramPacket dp =new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.254"),10000);
//通过socket服务,将已有的数据包发送出去。通过send方法。
ds.send(dp);
//关闭资源。
ds.close();
}
}
/*
需求:
定义一个应用程序,用于接收udp协议传输的数据并处理的。
定义udp的接收端。
思路:
1,定义udpsocket服务。通常会监听一个端口。其实就是给这个接收网络应用程序定义数字标识。方便于明确哪些数据过来该应用程序可以处理。
2,定义一个数据包,因为要存储接收到的字节数据。
因为数据包对象中有更多功能可以提取字节数据中的不同数据信息。
3,通过socket服务的receive方法将收到的数据存入已定义好的数据包中。
4,通过数据包对象的特有功能。将这些不同的数据取出。打印在控制台上。
5,关闭资源。
*/
class UdpRece
{
public static void main(String[] args) throws Exception
{
//创建udp socket,建立端点。
DatagramSocket ds = new DatagramSocket(10000);
while(true)
{
//定义数据包。用于存储数据。
byte[] buf = new byte[1024];
DatagramPacket dp = new DatagramPacket(buf,buf.length);
//通过服务的receive方法将收到数据存入数据包中。
ds.receive(dp);//阻塞式方法。
//通过数据包的方法获取其中的数据。
String ip = dp.getAddress().getHostAddress();
String data = new String(dp.getData(),0,dp.getLength());
int port = dp.getPort();
System.out.println(ip+"::"+data+"::"+port);
}
//关闭资源
//ds.close();
}
}
如果需要发送从键盘录入的数据并接收,则将代码改成如下:
import java.net.*;
import java.io.*;
class UdpSend2
{
public static void main(String[] args) throws Exception
{
DatagramSocket ds = new DatagramSocket();//定义Socket服务
BufferedReader bufr =
new BufferedReader(new InputStreamReader(System.in));//用转换流和字符读取缓冲来读取键盘录入
String line = null;
while((line=bufr.readLine())!=null)//一次读取一行
{
if("886".equals(line))//如果输入了886,则结束
break;
byte[] buf = line.getBytes();//把读取的一行数据编程字节数组
DatagramPacket dp =
new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.255"),10001);//把数据打包
ds.send(dp);//发送
}
ds.close();
}
}
class UdpRece2
{
public static void main(String[] args) throws Exception
{
DatagramSocket ds = new DatagramSocket(10001);//定义监听指定端口的Socket
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方法,而且这两个方法要封装到不同的类中。
步骤:1.定义Send类,实现Runnable接口,用构造函数接受一个DatagramSocket类型的对象,在run方法中写入发送键盘输入数据的程序。
2.同样的建立rece类用于接受发送线程发送的数据。
3.在主函数执行两个线程。
*/
import java.io.*;
import java.net.*;
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)
{
byte[] buf = line.getBytes();
DatagramPacket dp =
new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.255"),10002);
ds.send(dp);
if("886".equals(line))
break;
}
}
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());
if("886".equals(data))
{
System.out.println(ip+"....离开聊天室");
break;
}
System.out.println(ip+":"+data);
}
}
catch (Exception e)
{
throw new RuntimeException("接收端失败");
}
}
}
class ChatDemo
{
public static void main(String[] args) throws Exception
{
DatagramSocket sendSocket = new DatagramSocket();
DatagramSocket receSocket = new DatagramSocket(10002);
new Thread(new Send(sendSocket)).start();
new Thread(new Rece(receSocket)).start();
}
}
二.编写TCP网络应用程序
利用UDP通信的两个程序是平等的,没有主次之分,两个程序代码可以是完全一样的,然而利用TCP协议进行通信的两个应用程序,却是有主次之分的,一个称为服务器程序,另外一个称为客户机程序,两者的功能和编写方法大不同,这是TCP与UDP之间很大的不同。
服务器程序:类似114查号台,内部有一个总机,专门接听客户端,并不会与客户端有对话,而是给客户端分配空闲的座机与客户对话,在没有空闲的时候,让对方排队等候,若流量太大则彻底拒绝服务。
客户端程序:类似普通电话,向服务器端程序请求服务。
Java中提供了ServerSocket类用于完成类似114查号台总机的功能,Socket类用于完成普通电话和114查号台的座机功能,这个交互的过程如下:
1) 服务端程序创建一个ServerSocket,然后调用accept方法等待客户连接。
2) 客户端创建一个Socket并请求与服务端建立连接。
3) 服务器端接受客户的连接请求,并创建一个新的Socket与该客户建立专线连接。
4) 刚才建立了连接的两个Socket在一个单独的线程(有服务器端创建)上对话。
5) 服务器端开始等待新的连接请求。
实例:一个演示TCP传输的小程序
/*
需求:给服务端发送给一个文本数据。
思路:客户端程序:通过查阅socket对象,发现在该对象建立时,就可以去连接指定主机。因为tcp是面向连接的。所以在建立socket服务时,就要有服务端存在,并连接成功。形成通路后,在该通道进行数据的传输。
步骤:
1,创建Socket服务。并指定要连接的主机和端口
2,利用Socket的getOutputStream方法获取一个输出流对象
3,向输出流写入数据
4,关闭Socket。
*/
import java.io.*;
import java.net.*;
class TcpClient
{
public static void main(String[] args) throws Exception
{
//创建客户端的socket服务。指定目的主机和端口
Socket s = new Socket("192.168.1.254",10003);
//为了发送数据,应该获取socket流中的输出流。
OutputStream out = s.getOutputStream();
out.write("tcp ge men lai le ".getBytes());//向输出流写入数据
s.close();
}
}
/*
需求:编写服务器端程序,定义端点接收数据并打印在控制台上。
步骤:
1,建立服务端的socket服务,并监听一个端口。
2,获取连接过来的客户端对象,通过ServerSokcet的 accept方法。没有连接就会等,所以这个方法是阻塞式的。
3,客户端如果发过来数据,那么服务端要使用对应的客户端对象,并获取到该客户端对象的读取流来读取发过来的数据,并打印在控制台。
4,关闭服务端。(可选)
*/
class TcpServer
{
public static void main(String[] args) throws Exception
{
//建立服务端socket服务。并监听一个端口。
ServerSocket ss = new ServerSocket(10003);
//通过accept方法获取连接过来的客户端对象。
while(true)
{
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实现客户端与服务器端的互访
import java.io.*;
import java.net.*;
/*
演示tcp的传输的客户端和服务端的互访。
需求:客户端给服务端发送数据,服务端收到后,给客户端反馈信息。
客户端:
1,建立socket服务。指定要连接主机和端口。
2,获取socket流中的输出流。将数据写到该流中。通过网络发送给服务端。
3,获取socket流中的输入流,将服务端反馈的数据获取到,并打印。
4,关闭客户端资源。
*/
class TcpClient2
{
public static void main(String[] args)throws Exception
{
Socket s = new Socket("192.168.1.254",10004);
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(10004);
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);//服务器端收到数据后休眠10秒
out.write("我是服务器这端,收到,你也好".getBytes());
s.close();
ss.close();
}
}
实例:用多个客户端向服务端发送图片数据
/*
需求:用TCP向服务器端上传图片。
客户端实现步骤:
1,服务端点。
2,读取客户端已有的图片数据。
3,通过socket 输出流将数据发给服务端。
4,读取服务端反馈信息。
5,关闭。
*/
import java.io.*;
import java.net.*;
class PicClient
{
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()))//三个If用来排除可能的错误
{
System.out.println("该文件有问题,要么不存在,要么不是文件");
return ;
}
if(!file.getName().endsWith(".jpg"))
{
System.out.println("图片格式错误,请重新选择");
return ;
}
if(file.length()>1024*1024*5)
{
System.out.println("文件过大,没安好心");
return ;
}
Socket s = new Socket("192.168.1.254",10007);//建立指定连接主机和端口的Socket对象
FileInputStream fis = new FileInputStream(file);//定义文件读取流读取图片文件
OutputStream out = s.getOutputStream();//获取Socket的写入流
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();
}
}
/*
需求:编写服务端程序
思路:需要避免服务端的局限性:当A客户端连接上以后。被服务端获取到。服务端执行具体流程。这时B客户端连接,只有等待,因为服务端还没有处理完A客户端的请求,还有循环回来执行下次accept方法。所以暂时获取不到B客户端对象,那么为了可以让多个客户端同时并发访问服务端。那么服务端最好就是将每个客户端封装到一个单独的线程中,这样,就可以同时处理多个客户端请求,如何定义线程呢?只要明确了每一个客户端要在服务端执行的代码即可。将该代码存入run方法中。
*/
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 dir = new File("d:\\pic");
File file = new File(dir,ip+"("+(count)+")"+".jpg");
while(file.exists())
file = new File(dir,ip+"("+(count++)+")"+".jpg");//如果指定的文件名已经存在,则更改文件名
FileOutputStream fos = new FileOutputStream(file);//向文件中写入读到的数据
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();
}
catch (Exception e)
{
throw new RuntimeException(ip+"上传失败");
}
}
}
class PicServer
{
public static void main(String[] args) throws Exception
{
ServerSocket ss = new ServerSocket(10007);//指定ServerSocket监听客户端的端口
while(true)
{
Socket s = ss.accept();//获取与客户端建立了连接的Socket对象
new Thread(new PicThread(s)).start();//每建立一个Socket连接,打开一个新的线程,实现多客户并发访问
}
//ss.close();
}
---------------------- android培训、java培训、期待与您交流! ----------------------