黑马程序员————网络编程

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！-------

一、网络模型

 

 

二、网络通讯要素

 

1，IP地址:InetAddress 

  1，网络中设备的标识 

  2，不易记忆，可用主机名 

  3，本地回环地址：127.0.0.1 主机名：localhost 

2，端口号 

  1，用于标识进程的逻辑地址，不同进程的标识 

  2，有效端口：0~65535，其中0~1024系统使用或保留端口

3，传输协议 

1，通讯的规则 

2，常见协议：TCP，UDP 

 

三、TCP和UDP

 

TCP：

将数据及源和目的封装成数据包中，不要建立连接

每个数据的大小限制在64k以内

因无连接，所以是不可靠的协议

不需要建立连接，速度快

 

UDP：

建立连接，形成传输的数据的通道

在连接中进行大量数据的传输

通过三次握手来完成连接，是可靠的连接

必须建立连接，效率会低

 

四、IP对象

 

方法:

1.static InetAddress getLocalHost();本地主机（IP和主机名），返回的是对象

2.String getHostName();  获取主机的名

3.String getHostAddress(); 获取主机IP

4.static InetAddress getByName() 获取其他主机的IP

public static void main(String[] args) throws UnknownHostException {
//获取主机Ip地址对象..InetAddress没有构造函数
InetAddress ip = InetAddress.getLocalHost();
System.out.println(ip.getHostName());//获取主机名
System.out.println(ip.getHostAddress());//获取主机地址
System.out.println(ip);
//获取其他主机的Ip地址
ip = InetAddress.getByName("www.baidu.com");//拿到www.baidu.com的IP地址
System.out.println(ip);
}

Socket：套接字

1，Socket就是为网络服务提供的一种机制。

2，通信两端都有Socket

3，网络通信其实就是Socket间的通信。

4，数据在连个Socket间通过IO传输。

 

例如:轮船运输货物，需要从一端到另外一端，这个端就是Socket

 

五、UDP

类似于对讲机

发送端：

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
public class SendDemo {
/**
 * @param args
 * @throws IOException 
 */
/*
 * 创建UDP传输的发送端
 * 1.建立UDP的Socket服务
 * 2.将要发送的数据封装进数据包中
 * 3.通过UDP的socket服务将数据发送出去
 * 4.关闭socket服务
 */
public static void main(String[] args) throws IOException {
//建立UDP的Socket服务，用DatagramSocket对象
DatagramSocket ds = new DatagramSocket();
//将要发送的信息转换成字节
String str = "我来了";
byte[] buf = str.getBytes();
//使用DatagramPacket将数据封装进数据包中
DatagramPacket dp =
new DatagramPacket(buf, buf.length,InetAddress.getByName("192.168.1.113"),1000);
//发送数据，用send方法
ds.send(dp);
//关闭资源
ds.close();
}
}

接收端：

import java.net.DatagramPacket;
import java.net.DatagramSocket;
public class ReceiveDemo {
/**
 * @param args
 * @throws Exception 
 */
/*
 * 创建UDP传输的接受端
 * 1.建立UDP的Socket服务
 * 2.创建数据包用于接受数据包中的数据，方便用数据包对象的方法解析这些数据
 * 3.用socket服务的Receive方法接受数据存储到数据包中
 * 4.通过数据包中的方法解析数据包中的数据
 * 5.关闭资源
 */
public static void main(String[] args) throws Exception {
//建立UDP的Socket服务
DatagramSocket ds = new DatagramSocket(10000);
//创建数据包
byte[] buf = new byte[1024];
DatagramPacket dp = new DatagramPacket(buf, buf.length);
//使用socket的接受方法接受数据存储到数据包中
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);
ds.close();
}
}

六、TCP

 

Socket和ServerSocket

建立客户端和服务端

建立连接后，通过socket中的IO流进行数据的传输

关闭socket流

 

客服端：

package net;
 
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
 
public class ClientDemo1 {
 
/**
 * @param args
 * @throws IOException
 */
public static void main(String[] args) throws IOException {
/*
 * Tcp传输，客户端建立的过程。
 * 1，创建tcp客户端socket服务。使用的是Socket对象。建议该对象一创建就明确目的地。要连接的主机。 
 * 2，如果连接建立成功，说明数据传输通道已建立。 该通道就是socket流 ,是底层建立好的。
 * 既然是流，说明这里既有输入，又有输出。 想要输入或者输出流对象，可以找Socket来获取。
 * 可以通过getOutputStream(),和getInputStream()来获取两个字节流。 
 * 3，使用输出流，将数据写出。
 * 4，关闭资源。
 */
 
Socket socket = new Socket("127.0.0.1", 10010);
 
OutputStream out = socket.getOutputStream();
 
out.write("tcp演示：哥们又来了!".getBytes());
 
// 读取服务端返回的数据,使用socket读取流。
InputStream in = socket.getInputStream();
byte[] buf = new byte[1024];
 
int len = in.read(buf);
 
String text = new String(buf, 0, len);
 
System.out.println(text);
 
// 关闭资源。
socket.close();
 
}
 
}

服务端：

package net;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class ServerDemo1 {
 
/**
 * @param args
 * @throws IOException
 */
public static void main(String[] args) throws IOException {
/*
 * 建立tcp服务端的思路：
 * 1，创建服务端socket服务。通过ServerSocket对象。
 * 2，服务端必须对外提供一个端口，否则客户端无法连接。 
 * 3，获取连接过来的客户端对象。
 * 4，通过客户端对象获取socket流读取客户端发来的数据 并打印在控制台上。
 * 5，关闭资源。关客户端，关服务端。
 */
 
// 1创建服务端对象。
ServerSocket ss = new ServerSocket(10010);
 
// 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);
 
// 使用客户端socket对象的输出流给客户端返回数据
OutputStream out = s.getOutputStream();
out.write("收到".getBytes());
 
s.close();
ss.close();
}
}
 

七、网络编程的例子

 

例1：

客户端输入字母数据，发送给服务端， 服务端收到后显示在控制台，并将该数据转成大写返回给客户端 

客服端：

package net;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
 
public class TestClientDemo {
 
/**
 * @param args
 * @throws IOException
 */
public static void main(String[] args) throws IOException {
/*
 * 思路： 客户端：
 *  1，需要先有socket端点。 
 *  2，客户端的数据源：键盘。 
 *  3，客户端的目的：socket.
 *  4，接收服务端的数据，源：socket。
 *  5，将数据显示在打印出来：目的：控制台. 6，在这些流中操作的数据，都是文本数据。
 * 
 * 转换客户端: 
 *  1,创建socket客户端对象。
 *  2,获取键盘录入。 
 *  3，将录入的信息发送给socket输出流。
 */
 
// 1,创建socket客户端对象。
Socket s = new Socket("127.0.0.1", 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();
}
}
 

服务端：

package net;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
 
public class TestServerDemo {
 
/**
 * @param args
 * @throws IOException 
 */
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();
}
}
 

例2：上传图片

客户端：
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
 
public class LoadCilent {
 
/**
 * @param args
 * @throws IOException
 */
public static void main(String[] args) throws IOException {
// 创建客服端的socket对象
Socket s = new Socket("127.0.0.1", 10003);
// 创建源数据
FileInputStream fis = new FileInputStream("f:\\0.jpg");
// 创建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(bufIn);
String text = new String(bufIn, 0, lenIn);
System.out.println(text);
s.close();
}
 
}

服务端：

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
 
public class LoadServer {
 
/**
 * @param args
 * @throws IOException
 */
public static void main(String[] args) throws IOException {
// 创建Server服务
ServerSocket ss = new ServerSocket(10003);
// 获取socket对象
Socket s = ss.accept();
 
String ip = s.getInetAddress().getHostAddress();
System.out.println(ip + ".........connected");
// 创建socket读取流
InputStream in = s.getInputStream();
//
File dir = new File("f:\\pic");
if (!dir.exists())
dir.mkdir();
File file = new File(dir, ip + ".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);
}
// 创建socket的输出流，发送给客户端图片上传成功
OutputStream out = s.getOutputStream();
out.write("上传成功".getBytes());
fos.close();
s.close();
ss.close();
}
}

 

八、网络结构

 

1.C/S  client/server

特点：

该结构的软件，客户端和服务端都需要编写。

可发成本较高，维护较为麻烦。

好处：

客户端在本地可以分担一部分运算。

 

2.B/S  browser/server

 

特点：

该结构的软件，只开发服务器端，不开发客户端，因为客户端直接由浏览器取代。 

开发成本相对低，维护更为简单。

 

缺点：所有运算都要在服务端完成。

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！-------