------- android培训、java培训、期待与您交流！ ----------
网络编程
网络参考模型图解
各层的用处
开发主要在传输层和网际层。
传输层为：UDP和TCP等，网际层为：IP。
用户在应用层操作的数据，经过逐层封包，最后到物理层发送到另一个模型中，再进行逐层解包
原理图
网络通信三要素：IP地址，端口号，传输协议
UDP特点：
1、面向无连接，即将数据及源和目的封装成数据包中，不建立链接的发送
2、每个数据包的大小限制在64K之内
3、因无连接，是不可靠的协议
4、不建立连接，速度快。
TCP特点：
1、面向连接，在建立连接后，形成传输数据的通道
2、在连接中进行大数据量的传输
3、通过三次握手完成连接，是可靠的协议
4、必须建立连接，效率稍慢
通信步骤
1、找到IP地址国，际组织定义了通用协议，即TCP/IP。
2、数据要发送到对象指定应用程序，即逻辑端口（port）。
Socket机制
UDP传输
DatagramSocket：发送和接收数据包的套接字，即Socket。步骤
1、发送数据：
a、建立UDPSocket服务，在此无需指定端口，也可以将端口加入。
b、提供数据，并将数据封装到数据包中
c、通过socket服务的发送功能，将数据包发送出去
d、关闭资源
应用事例
public class UDPSendDemo {
<span style="white-space:pre"> </span>public static void main(String[] args) throws IOException {
<span style="white-space:pre"> </span>System.out.println("发送端启动......");
<span style="white-space:pre"> </span>
<span style="white-space:pre"> </span>//1,udpsocket服务。使用DatagramSocket对象。
<span style="white-space:pre"> </span>DatagramSocket ds = new DatagramSocket(8888);
<span style="white-space:pre"> </span>
<span style="white-space:pre"> </span>//2,将要发送的数据封装到数据包中。
<span style="white-space:pre"> </span>String str = "udp传输演示：哥们来了！";
<span style="white-space:pre"> </span>//使用DatagramPacket将数据封装到的该对象包中。
<span style="white-space:pre"> </span>byte[] buf = str.getBytes();
<span style="white-space:pre"> </span>
<span style="white-space:pre"> </span>DatagramPacket dp =
<span style="white-space:pre"> </span>new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.100"),10000);
<span style="white-space:pre"> </span>
<span style="white-space:pre"> </span>//3，通过udp的socket服务将数据包发送出去。使用send方法。
<span style="white-space:pre"> </span>ds.send(dp);
<span style="white-space:pre"> </span>
<span style="white-space:pre"> </span>//4，关闭资源。
<span style="white-space:pre"> </span>ds.close();
<span style="white-space:pre"> </span>
<span style="white-space:pre"> </span>
<span style="white-space:pre"> </span>}
}b、定义一个数据包，用来存储接收到的字节数据，因为数据包对象中有更多功能可以提取字节数据中的不同数据信息。
c、通过socket服务的receive方法接收到的数据存入已定义好的数据包中
d、通过数据包对象的特有功能，将这些不同的数据取出，打印在控制台上
e、关闭资源
应用事例
public class UDPReceDemo {
public static void main(String[] args) throws IOException {
System.out.println("接收端启动......");
//1,建立udp socket服务。
DatagramSocket ds = new DatagramSocket(10000);
//2,创建数据包。
byte[] buf = new byte[1024];
DatagramPacket dp = new DatagramPacket(buf,buf.length);
//3,使用接收方法将数据存储到数据包中。
ds.receive(dp);//阻塞式的。
//4，通过数据包对象的方法，解析其中的数据,比如，地址，端口，数据内容。
String ip = dp.getAddress().getHostAddress();
int port = dp.getPort();
String text = new String(dp.getData(),0,dp.getLength());
System.out.println(ip+":"+port+":"+text);
//5,关闭资源。
ds.close();
}
}TCP传输
TCP分客户端和服务端。
客户端用Socket，服务端用ServerSocket。
原理图
1，创建tcp客户端socket服务。使用的是Socket对象。
建议该对象一创建就明确目的地。要连接的主机。
2，如果连接建立成功，说明数据传输通道已建立。
该通道就是socket流 ,是底层建立好的。 既然是流，说明这里既有输入，又有输出。
想要输入或者输出流对象，可以找Socket来获取。
可以通过getOutputStream(),和getInputStream()来获取两个字节流。
3，使用输出流，将数据写出。
4，关闭资源。
应用事例
public class ClientDemo {
public static void main(String[] args) throws UnknownHostException, IOException {
//创建客户端socket服务。
Socket socket = new Socket("192.168.1.100",10002);
//获取socket流中的输出流。
OutputStream out = socket.getOutputStream();
//使用输出流将指定的数据写出去。
out.write("tcp演示：哥们又来了!".getBytes());
//关闭资源。
socket.close();
}
}服务端创建 1，创建服务端socket服务。通过ServerSocket对象。
2，服务端必须对外提供一个端口，否则客户端无法连接。
3，获取连接过来的客户端对象。
4，通过客户端对象获取socket流读取客户端发来的数据
并打印在控制台上。
5，关闭资源。关客户端，关服务端。
应用事例
public class ServerDemo {
public static void main(String[] args) throws IOException {
// 服务端接收客户端发送过来的数据，并打印在控制台上。
//1创建服务端对象。
ServerSocket ss = new ServerSocket(10002);
//2,获取连接过来的客户端对象。
Socket s = ss.accept();//阻塞式.
String ip = s.getInetAddress().getHostAddress();
//3，通过socket对象获取输入流，要读取客户端发来的数据
InputStream in = s.getInputStream();
byte[] buf = new byte[1024];
int len = in.read(buf);
String text = new String(buf,0,len);
System.out.println(ip+":"+text);
s.close();
ss.close();
}
}小练习
客户端输入字母数据，发送给服务端，服务端收到后显示在控制台，并将该数据转成大写返回给客户端，直到客户端输入over.转换结束. 创建一个英文大写转换服务器.
客户端
public class TransClient {
public static void main(String[] args) throws UnknownHostException, IOException {
/*
* 思路：
* 客户端：
* 1，需要先有socket端点。
* 2，客户端的数据源：键盘。
* 3，客户端的目的：socket.
* 4，接收服务端的数据，源：socket。
* 5，将数据显示在打印出来：目的：控制台.
* 6，在这些流中操作的数据，都是文本数据。
*
*
* 转换客户端:
* 1,创建socket客户端对象。
* 2,获取键盘录入。
* 3，将录入的信息发送给socket输出流。
*/
//1,创建socket客户端对象。
Socket s = new Socket("192.168.1.100",10004);
//2，获取键盘录入。
BufferedReader bufr =
new BufferedReader(new InputStreamReader(System.in));
//3,socket输出流。
PrintWriter out = new PrintWriter(s.getOutputStream(),true);
//4,socket输入流，读取服务端返回的大写数据
BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));
String line = null;
while((line=bufr.readLine())!=null){
if("over".equals(line))
break;
out.println(line);
//读取服务端发回的一行大写数。
String upperStr = bufIn.readLine();
System.out.println(upperStr);
}
s.close();
}
}<span style="font-family:SimSun;">public class TransServer {
public static void main(String[] args) throws IOException {
/*
*
* 转换服务端。
* 分析：
* 1，serversocket服务。
* 2，获取socket对象。
* 3，源：socket，读取客户端发过来的需要转换的数据。
* 4，目的：显示在控制台上。
* 5，将数据转成大写发给客户端。
*/
//1,
ServerSocket ss = new ServerSocket(10004);
//2,获取socket对象。
Socket s = ss.accept();
//获取ip.
String ip = s.getInetAddress().getHostAddress();
System.out.println(ip+"......connected");
//3,获取socket读取流，并装饰。
BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));
//4,获取socket的输出流，并装饰。
PrintWriter out = new PrintWriter(s.getOutputStream(),true);
String line = null;
while((line=bufIn.readLine())!=null){
System.out.println(line);
out.println(line.toUpperCase());
}
s.close();
ss.close();
}
}</span>单线程的服务端局限性：当A客户端连接上以后，被服务端获取到。服务端执行具体流程。这时B客户端连接，只能等待，这时获取不到B客户端对象。
那么为了可以让多个客户端同时并发访问服务端。服务端最好就是将每个客户端封装到一个单独的线程中，这样，就可以同时处理多个客户端请求。解决方法 ：只要明确了每一个客户端要在服务端执行的代码，将该代码存入run方法即可。
小练习2
客户端上传图片到服务端
客户端创建
public class UploadPicClient {
public static void main(String[] args) throws UnknownHostException, IOException {
//1,创建客户端socket。
Socket s = new Socket("192.168.1.100",10006);
//2,读取客户端要上传的图片文件。
FileInputStream fis = new FileInputStream("c:\\0.bmp");
//3,获取socket输出流，将读到图片数据发送给服务端。
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 lenIn = in.read(buf);
String text = new String(buf,0,lenIn);
System.out.println(text);
fis.close();
s.close();
}
}服务端创建之前先创建一个UploadTask方法类
public class UploadTask implements Runnable {
private static final int SIZE = 1024*1024*2;
private Socket s;
public UploadTask(Socket s) {
this.s = s;
}
public void run() {
int count = 0;
String ip = s.getInetAddress().getHostAddress();
System.out.println(ip + ".....connected");
try{
// 读取客户端发来的数据。
InputStream in = s.getInputStream();
// 将读取到数据存储到一个文件中。
File dir = new File("c:\\pic");
if (!dir.exists()) {
dir.mkdirs();
}
File file = new File(dir, ip + ".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);
if(file.length()>SIZE){
System.out.println(ip+"文件体积过大");
fos.close();
s.close();
System.out.println(ip+"...."+file.delete());
return ;
}
}
// 获取socket输出流，将上传成功字样发给客户端。
OutputStream out = s.getOutputStream();
out.write("上传成功".getBytes());
fos.close();
s.close();
}catch(IOException e){
}
}
}public class UploadPicServer {
public static void main(String[] args) throws IOException {
//创建tcp的socket服务端。
ServerSocket ss = new ServerSocket(10006);
while(true){
Socket s = ss.accept();
new Thread(new UploadTask(s)).start();
}
}
}
580
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
