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

------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培训、期待与您交流！-------