传智播客风清扬视频-------网络编程简介
计算机网络模型
OSI（Open System Interconnection开放系统互连）参考模型
TCP/IP参考模型
OSI 应用层--表示层--会话层--传输层--网络层--数据链路层--物理层
TCP/IP 应用层----------------传输层--网络层--主机至网络层
网络模型7层概述：
1.物理层：主要定义物理设备标准，如网线的接口类型、光纤的接口类型、各种传输介质的传输速率等。它的主要作用是传输比特流（就是由1、0转化为电流强弱来进行传输,到达目的地后在转化为1、0，也就是我们常说的数模转换与模数转换）。这一层的数据叫做比特。
2. 数据链路层：主要将从物理层接收的数据进行MAC地址（网卡的地址）的封装与解封装。常把这一层的数据叫做帧。在这一层工作的设备是交换机，数据通过交换机来传输。
3. 网络层：主要将从下层接收到的数据进行IP地址（例192.168.0.1)的封装与解封装。在这一层工作的设备是路由器，常把这一层的数据叫做数据包。
4. 传输层：定义了一些传输数据的协议和端口号（WWW端口80等），如：TCP（传输控制协议，传输效率低，可靠性强，用于传输可靠性要求高，数据量大的数据），UDP（用户数据报协议，与TCP特性恰恰相反，用于传输可靠性要求不高，数据量小的数据，如QQ聊天数据就是通过这种方式传输的）。 主要是将从下层接收的数据进行分段和传输，到达目的地址后再进行重组。常常把这一层数据叫做段。
5.会话层：通过传输层（端口号：传输端口与接收端口）建立数据传输的通路。主要在你的系统之间发起会话或者接受会话请求（设备之间需要互相认识可以是IP也可以是MAC或者是主机名）
6.表示层：主要是进行对接收的数据进行解释、加密与解密、压缩与解压缩等（也就是把计算机能够识别的东西转换成人能够能识别的东西（如图片、声音等）。
7.应用层： 主要是一些终端的应用，比如说FTP（各种文件下载），WEB（IE浏览），QQ之类的（可以把它理解成我们在电脑屏幕上可以看到的东西．就是终端应用）。
网络编程三要素：
A：IP地址
B：端口
C：协议
举例:
我想和林青霞说话了。肿么办?
A:我要找到林青霞。
B:对她说话，要对耳朵说。
C:我说什么呢?"I Love You"
但是，她没学过英语，听不懂。
我没必要说英语，说汉语就可以了：我爱你
IP地址：
网络中计算机的唯一标识
计算机只识别二进制的数据，所以IP地址为二进制数据。
但为了便于记忆，把IP地址的每一个字节上的数据换算成十进制，采用“点分十进制”。如IP：192.168.1.100
IP地址的组成：网络号段+主机号段
A类： 第一号段为网络号段+后三段的主机号段。
一个网络号，可以有256*256*256=16777216台主机
B类： 前二号段为网络号段+后二段的主机号段。
一个网络号，可以有256*256=65536台主机
C类： 前三号段为网络号段+后一段的主机号段。
一个网络号，可以有256台主机。
IP地址的分类：
A类 1.0.0.1---127.255.255.254
(1)10.X.X.X是私有地址(私有地址就是在互联网上不使用，
而被用在局域网络中的地址)
(2)127.X.X.X是保留地址，用做循环测试用的。
B类 128.0.0.1---191.255.255.254
172.16.0.0---172.31.255.255是私有地址。
169.254.X.X是保留地址。
C类 192.0.0.1---223.255.255.254
192.168.X.X是私有地址
D类 224.0.0.1---239.255.255.254 保留地址
E类 240.0.0.1---247.255.255.254 保留地址
两个DOS命令：
ipconfig 查看本机ip地址
ping 后面跟ip地址。测试本机与指定的ip地址间的通信是否有问题
特殊的IP地址：
127.0.0.1 回环地址(表示本机)
x.x.x.255 广播地址
x.x.x.0 网络地址
端口号：
下在运行的程序的标识
有效端口0~65535 ， 其中0~1024系统使用或保留端口。
协议：
通信的规则
UDP协议 特点：把数据打包；数据有限制；不建立连接；速度快；不可靠
TCP协议 特点：建立连接通道；数据无限制；速度慢；可靠
[b]TCP连接三次握手[/b]
手机能够使用联网功能是因为手机底层实现了TCP/IP协议，可以使手机终端通过无线网络建立TCP连接。TCP协议可以对上层网络提供接口，使上层网络数据的传输建立在“无差别”的网络之上。
建立起一个TCP连接需要经过“三次握手”：
第一次握手：客户端发送syn包(syn=j)到服务器，并进入SYN_SEND状态，等待服务器确认；
第二次握手：服务器收到syn包，必须确认客户的SYN（ack=j+1），同时自己也发送一个SYN包（syn=k），即SYN+ACK包，此时服务器进入SYN_RECV状态；
第三次握手：客户端收到服务器的SYN＋ACK包，向服务器发送确认包ACK(ack=k+1)，此包发送完毕，客户端和服务器进入ESTABLISHED状态，完成三次握手。
握手过程中传送的包里不包含数据，三次握手完毕后，客户端与服务器才正式开始传送数据。理想状态下，TCP连接一旦建立，在通信双方中的任何一方主动关闭连接之前，TCP 连接都将被一直保持下去。断开连接时服务器和客户端均可以主动发起断开TCP连接的请求，断开过程需要经过“四次握手”（过程就不细写了，就是服务器和客户端交互，最终确定断开）
如果一个类没有构造方法：
* A:成员全部是静态的(Math,Arrays,Collections)
* B:单例设计模式(Runtime)
* C:类中有静态方法返回该类的对象(InetAddress)
* class Demo {
* private Demo(){}
*
* public static Demo getXxx() {
* return new Demo();
* }
* }
*
InetAddress
成员方法：public static InetAddress getByName(String name)
根据主机名或者IP地址的字符串表示得到的IP地址对象
获取主机名和IP地址
public class InetAddressDemo { public static void main(String[] args) throws UnknownHostException { // public static InetAddress getByName(String host) // InetAddress address = InetAddress.getByName("liuyi"); // InetAddress address = InetAddress.getByName("192.168.12.92"); InetAddress address = InetAddress.getByName("192.168.12.63");
// 获取两个东西：主机名，IP地址 // public String getHostName() String name = address.getHostName(); // public String getHostAddress() String ip = address.getHostAddress(); System.out.println(name + "---" + ip); }}
通过UDP协议传输数据：
UDP协议接收数据：
A：创建接收端Socket对象
B：创建一个数据包（接收容器）
C：调用Socket对象的接收方法接收数据
D：解析数据包，并显示在控制台
E：释放资源
UDP协议发送数据：
A：创建发送端Socket对象
B：创建数据，并把数据打包
C：调用Socket对象的发送方法发送数据包
D：释放资源
public class ReceiveDemo { public static void main(String[] args) throws IOException { // 创建接收端Socket对象 // DatagramSocket(int port) DatagramSocket ds = new DatagramSocket(10086);
// 创建一个数据包(接收容器) // DatagramPacket(byte[] buf, int length) byte[] bys = new byte[1024]; int length = bys.length; DatagramPacket dp = new DatagramPacket(bys, length);
// 调用Socket对象的接收方法接收数据 // public void receive(DatagramPacket p) ds.receive(dp); // 阻塞式
// 解析数据包，并显示在控制台 // 获取对方的ip // public InetAddress getAddress() InetAddress address = dp.getAddress(); String ip = address.getHostAddress(); // public byte[] getData():获取数据缓冲区 // public int getLength():获取数据的实际长度 byte[] bys2 = dp.getData(); int len = dp.getLength(); String s = new String(bys2, 0, len); System.out.println(ip + "传递的数据是:" + s);
// 释放资源 ds.close(); }}
public class SendDemo { public static void main(String[] args) throws IOException { // 创建发送端Socket对象 // DatagramSocket() DatagramSocket ds = new DatagramSocket();
// 创建数据，并把数据打包 // DatagramPacket(byte[] buf, int length, InetAddress address, int port) // 创建数据 byte[] bys = "hello,udp,我来了".getBytes(); // 长度 int length = bys.length; // IP地址对象 InetAddress address = InetAddress.getByName("192.168.12.92"); // 端口 int port = 10086; DatagramPacket dp = new DatagramPacket(bys, length, address, port);
// 调用Socket对象的发送方法发送数据包 // public void send(DatagramPacket p) ds.send(dp);
// 释放资源 ds.close(); }}
注意：
多次启动接收端： java.net.BindException:
Address already in use: Cannot bind 端口被占用。
简洁版： 数据从键盘录入
public class ReceiveDemo { public static void main(String[] args) throws IOException { // 创建接收端的Socket对象 DatagramSocket ds = new DatagramSocket(12345);
while (true) { // 创建一个包裹 byte[] bys = new byte[1024]; DatagramPacket dp = new DatagramPacket(bys, bys.length);
// 接收数据 ds.receive(dp);
// 解析数据 String ip = dp.getAddress().getHostAddress(); String s = new String(dp.getData(), 0, dp.getLength()); System.out.println("from " + ip + " data is : " + s); }
// 释放资源 // 接收端应该一直开着等待接收数据，是不需要关闭 // ds.close(); }}
/* * 数据来自于键盘录入 * 键盘录入数据要自己控制录入结束。 */public class SendDemo { public static void main(String[] args) throws IOException { // 创建发送端的Socket对象 DatagramSocket ds = new DatagramSocket();
// 封装键盘录入数据 BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); String line = null; while ((line = br.readLine()) != null) { if ("886".equals(line)) { break; }
// 创建数据并打包 byte[] bys = line.getBytes(); // DatagramPacket dp = new DatagramPacket(bys, bys.length, // InetAddress.getByName("192.168.12.92"), 12345); DatagramPacket dp = new DatagramPacket(bys, bys.length, InetAddress.getByName("192.168.12.255"), 12345);
// 发送数据 ds.send(dp); }
// 释放资源 ds.close(); }}
使用多线程实现，在一个窗口输入和接收
/* * 通过多线程改进刚才的聊天程序，这样我就可以实现在一个窗口发送和接收数据了 */public class ChatRoom { public static void main(String[] args) throws IOException { DatagramSocket dsSend = new DatagramSocket(); DatagramSocket dsReceive = new DatagramSocket(12306);
SendThread st = new SendThread(dsSend); ReceiveThread rt = new ReceiveThread(dsReceive);
Thread t1 = new Thread(st); Thread t2 = new Thread(rt);
t1.start(); t2.start(); }}
import java.io.IOException;import java.net.DatagramPacket;import java.net.DatagramSocket;
public class ReceiveThread implements Runnable { private DatagramSocket ds;
public ReceiveThread(DatagramSocket ds) { this.ds = ds; }
@Override public void run() { try { while (true) { // 创建一个包裹 byte[] bys = new byte[1024]; DatagramPacket dp = new DatagramPacket(bys, bys.length);
// 接收数据 ds.receive(dp);
// 解析数据 String ip = dp.getAddress().getHostAddress(); String s = new String(dp.getData(), 0, dp.getLength()); System.out.println("from " + ip + " data is : " + s); } } catch (IOException e) { e.printStackTrace(); } }
}
public class SendThread implements Runnable {
private DatagramSocket ds;
public SendThread(DatagramSocket ds) { this.ds = ds; }
@Override public void run() { try { // 封装键盘录入数据 BufferedReader br = new BufferedReader(new InputStreamReader( System.in)); String line = null; while ((line = br.readLine()) != null) { if ("886".equals(line)) { break; }
// 创建数据并打包 byte[] bys = line.getBytes(); // DatagramPacket dp = new DatagramPacket(bys, bys.length, // InetAddress.getByName("192.168.12.92"), 12345); DatagramPacket dp = new DatagramPacket(bys, bys.length, InetAddress.getByName("192.168.12.255"), 12306);
// 发送数据 ds.send(dp); }
// 释放资源 ds.close(); } catch (IOException e) { e.printStackTrace(); } }
}TCP协议发送数据：
A：创建发送端的Socket对象
这一步如果成功，就说明连接已经建立成功。
B：获取输出流，写数据
C：释放资源
java.net.ConnectException: Connection refused: connect
连接被拒绝。TCP协议一定要先启服务器
TCP协议接收数据：
A：创建接收端的Socket对象
B：监听客户端连接。返回一个对应的Socket对象
C：获取输入流，读取数据显示在控制台
D：释放资源
public class ServerDemo { public static void main(String[] args) throws IOException { // 创建接收端的Socket对象 // ServerSocket(int port) ServerSocket ss = new ServerSocket(8888);
// 监听客户端连接。返回一个对应的Socket对象 // public Socket accept() Socket s = ss.accept(); // 侦听并接受到此套接字的连接。此方法在连接传入之前一直阻塞。
// 获取输入流，读取数据显示在控制台 InputStream is = s.getInputStream();
byte[] bys = new byte[1024]; int len = is.read(bys); // 阻塞式方法 String str = new String(bys, 0, len);
String ip = s.getInetAddress().getHostAddress();
System.out.println(ip + "---" + str);
// 释放资源 s.close(); // ss.close(); //这个不应该关闭 }}
public class ClientDemo { public static void main(String[] args) throws IOException { // 创建发送端的Socket对象 // Socket(InetAddress address, int port) // Socket(String host, int port) // Socket s = new Socket(InetAddress.getByName("192.168.12.92"), 8888); Socket s = new Socket("192.168.12.92", 8888);
// 获取输出流，写数据 // public OutputStream getOutputStream() OutputStream os = s.getOutputStream(); os.write("hello,tcp,我来了".getBytes());
// 释放资源 s.close(); }}服务器端收到数据，并发送数据反馈给客户端
public class ServerDemo { public static void main(String[] args) throws IOException { // 创建服务器Socket对象 ServerSocket ss = new ServerSocket(9999);
// 监听客户端的连接 Socket s = ss.accept(); // 阻塞
// 获取输入流 InputStream is = s.getInputStream(); byte[] bys = new byte[1024]; int len = is.read(bys); // 阻塞 String server = new String(bys, 0, len); System.out.println("server:" + server);
// 获取输出流 OutputStream os = s.getOutputStream(); os.write("数据已经收到".getBytes());
// 释放资源 s.close(); // ss.close(); }}
public class ClientDemo { public static void main(String[] args) throws IOException { // 创建客户端Socket对象 Socket s = new Socket("192.168.12.92", 9999);
// 获取输出流 OutputStream os = s.getOutputStream(); os.write("今天天气很好,适合睡觉".getBytes());
// 获取输入流 InputStream is = s.getInputStream(); byte[] bys = new byte[1024]; int len = is.read(bys);// 阻塞 String client = new String(bys, 0, len); System.out.println("client:" + client);
// 释放资源 s.close(); }}客户端键盘录入，服务器输出到控制台
public class ClientDemo { public static void main(String[] args) throws IOException { // 创建客户端Socket对象 Socket s = new Socket("192.168.12.92", 22222);
// 键盘录入数据 BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); // 把通道内的流给包装一下 BufferedWriter bw = new BufferedWriter(new OutputStreamWriter( s.getOutputStream()));
String line = null; while ((line = br.readLine()) != null) { // 键盘录入数据要自定义结束标记 if ("886".equals(line)) { break; } bw.write(line); bw.newLine(); bw.flush(); }
// 释放资源 // bw.close(); // br.close(); s.close(); }}
public class ServerDemo { public static void main(String[] args) throws IOException { // 创建服务器Socket对象 ServerSocket ss = new ServerSocket(22222);
// 监听客户端连接 Socket s = ss.accept();
// 包装通道内容的流 BufferedReader br = new BufferedReader(new InputStreamReader( s.getInputStream())); String line = null; while ((line = br.readLine()) != null) { System.out.println(line); }
// br.close(); s.close(); // ss.close(); }}客户端键盘录入，服务器输出文本文件
public class ServerDemo { public static void main(String[] args) throws IOException { // 创建服务器Socket对象 ServerSocket ss = new ServerSocket(23456);
// 监听客户端连接 Socket s = ss.accept();
// 封装通道内的数据 BufferedReader br = new BufferedReader(new InputStreamReader( s.getInputStream())); // 封装文本文件 BufferedWriter bw = new BufferedWriter(new FileWriter("a.txt"));
String line = null; while ((line = br.readLine()) != null) { bw.write(line); bw.newLine(); bw.flush(); }
bw.close(); // br.close(); s.close(); // ss.close(); }}
public class ClientDemo { public static void main(String[] args) throws IOException { // 创建客户端Socket对象 Socket s = new Socket("192.168.12.92", 23456);
// 封装键盘录入 BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); // 封装通道内的数据 BufferedWriter bw = new BufferedWriter(new OutputStreamWriter( s.getOutputStream()));
String line = null; while ((line = br.readLine()) != null) { if ("over".equals(line)) { break; }
bw.write(line); bw.newLine(); bw.flush(); }
// bw.close(); // br.close(); s.close(); }}
客户端文本文件，服务器输出到控制台
public class ServerDemo { public static void main(String[] args) throws IOException { // 创建服务器Socket对象 ServerSocket ss = new ServerSocket(34567);
// 监听客户端连接 Socket s = ss.accept();
// 封装通道内的流 BufferedReader br = new BufferedReader(new InputStreamReader( s.getInputStream()));
String line = null; while ((line = br.readLine()) != null) { System.out.println(line); }
s.close(); }}
public class ClientDemo { public static void main(String[] args) throws IOException { // 创建Socket对象 Socket s = new Socket("192.168.12.92", 34567);
// 封装文本文件 BufferedReader br = new BufferedReader(new FileReader( "InetAddressDemo.java")); // 封装通道内的流 BufferedWriter bw = new BufferedWriter(new OutputStreamWriter( s.getOutputStream()));
String line = null; while ((line = br.readLine()) != null) { bw.write(line); bw.newLine(); bw.flush(); }
br.close(); s.close(); }}客户端上传文件，服务器端保存文件
public class UploadServer { public static void main(String[] args) throws IOException { // 创建服务器端的Socket对象 ServerSocket ss = new ServerSocket(11111);
// 监听客户端连接 Socket s = ss.accept();
// 封装通道内的流 BufferedReader br = new BufferedReader(new InputStreamReader( s.getInputStream())); // 封装文本文件 BufferedWriter bw = new BufferedWriter(new FileWriter("Copy.java"));
String line = null; while ((line = br.readLine()) != null) { bw.write(line); bw.newLine(); bw.flush(); }
bw.close(); s.close(); }}
public class UploadClient { public static void main(String[] args) throws IOException { // 创建客户端Socket对象 Socket s = new Socket("192.168.12.92", 11111);
// 封装文本文件 BufferedReader br = new BufferedReader(new FileReader( "InetAddressDemo.java")); // 封装通道内流 BufferedWriter bw = new BufferedWriter(new OutputStreamWriter( s.getOutputStream()));
String line = null; while ((line = br.readLine()) != null) { bw.write(line); bw.newLine(); bw.flush(); }
// 释放资源 br.close(); s.close(); }}客户端文件文件，服务器返回客户端一个反馈
按照我们正常的思路加入反馈信息，结果却没反应。为什么呢?
* 读取文本文件是可以以null作为结束信息的，但是呢，通道内是不能这样结束信息的。
* 所以，服务器根本就不知道你结束了。而你还想服务器给你反馈。所以，就相互等待了。
* 如何解决呢?
* A:在多写一条数据，告诉服务器，读取到这条数据说明我就结束，你也结束吧。
* 这样做可以解决问题，但是不好。
* B:Socket对象提供了一种解决方案
* public void shutdownOutput()
public class UploadClient { public static void main(String[] args) throws IOException { // 创建客户端Socket对象 Socket s = new Socket("192.168.12.92", 11111);
// 封装文本文件 BufferedReader br = new BufferedReader(new FileReader( "InetAddressDemo.java")); // 封装通道内流 BufferedWriter bw = new BufferedWriter(new OutputStreamWriter( s.getOutputStream()));
String line = null; while ((line = br.readLine()) != null) { // 阻塞 bw.write(line); bw.newLine(); bw.flush(); }
//自定义一个结束标记// bw.write("over");// bw.newLine();// bw.flush();
//Socket提供了一个终止，它会通知服务器你别等了，我没有数据过来了 s.shutdownOutput();
// 接收反馈 BufferedReader brClient = new BufferedReader(new InputStreamReader( s.getInputStream())); String client = brClient.readLine(); // 阻塞 System.out.println(client);
// 释放资源 br.close(); s.close(); }}
public class UploadServer { public static void main(String[] args) throws IOException { // 创建服务器端的Socket对象 ServerSocket ss = new ServerSocket(11111);
// 监听客户端连接 Socket s = ss.accept();// 阻塞
// 封装通道内的流 BufferedReader br = new BufferedReader(new InputStreamReader( s.getInputStream())); // 封装文本文件 BufferedWriter bw = new BufferedWriter(new FileWriter("Copy.java"));
String line = null; while ((line = br.readLine()) != null) { // 阻塞 // if("over".equals(line)){ // break; // } bw.write(line); bw.newLine(); bw.flush(); }
// 给出反馈 BufferedWriter bwServer = new BufferedWriter(new OutputStreamWriter( s.getOutputStream())); bwServer.write("文件上传成功"); bwServer.newLine(); bwServer.flush();
// 释放资源 bw.close(); s.close(); }}采用UDP上传文件
public class UploadClient { public static void main(String[] args) throws IOException { // 创建客户端Socket对象 Socket s = new Socket("192.168.12.92", 19191);
// 封装图片文件 BufferedInputStream bis = new BufferedInputStream(new FileInputStream( "林青霞.jpg")); // 封装通道内的流 BufferedOutputStream bos = new BufferedOutputStream(s.getOutputStream());
byte[] bys = new byte[1024]; int len = 0; while ((len = bis.read(bys)) != -1) { bos.write(bys, 0, len); bos.flush(); }
s.shutdownOutput();
// 读取反馈 InputStream is = s.getInputStream(); byte[] bys2 = new byte[1024]; int len2 = is.read(bys2); String client = new String(bys2, 0, len2); System.out.println(client);
// 释放资源 bis.close(); s.close(); }}
public class UploadServer { public static void main(String[] args) throws IOException { // 创建服务器Socket对象 ServerSocket ss = new ServerSocket(19191);
// 监听客户端连接 Socket s = ss.accept();
// 封装通道内流 BufferedInputStream bis = new BufferedInputStream(s.getInputStream()); // 封装图片文件 BufferedOutputStream bos = new BufferedOutputStream( new FileOutputStream("mn.jpg"));
byte[] bys = new byte[1024]; int len = 0; while ((len = bis.read(bys)) != -1) { bos.write(bys, 0, len); bos.flush(); }
// 给一个反馈 OutputStream os = s.getOutputStream(); os.write("图片上传成功".getBytes());
bos.close(); s.close(); }}通过while循环可以改进一个服务器接收多个客户端
public class UploadServer { public static void main(String[] args) throws IOException { // 创建服务器端的Socket对象 ServerSocket ss = new ServerSocket(11111);
while (true) { // 监听客户端连接 Socket s = ss.accept();// 阻塞
// 封装通道内的流 BufferedReader br = new BufferedReader(new InputStreamReader( s.getInputStream())); // 封装文本文件 BufferedWriter bw = new BufferedWriter(new FileWriter("Copy.java"));
String line = null; while ((line = br.readLine()) != null) { // 阻塞 bw.write(line); bw.newLine(); bw.flush(); }
// 给出反馈 BufferedWriter bwServer = new BufferedWriter( new OutputStreamWriter(s.getOutputStream())); bwServer.write("文件上传成功"); bwServer.newLine(); bwServer.flush();
// 释放资源 bw.close(); s.close(); } }}
public class UploadClient { public static void main(String[] args) throws IOException { // 创建客户端Socket对象 Socket s = new Socket("192.168.12.92", 11111);
// 封装文本文件 BufferedReader br = new BufferedReader(new FileReader( "InetAddressDemo.java")); // 封装通道内流 BufferedWriter bw = new BufferedWriter(new OutputStreamWriter( s.getOutputStream()));
String line = null; while ((line = br.readLine()) != null) { // 阻塞 bw.write(line); bw.newLine(); bw.flush(); }
// Socket提供了一个终止，它会通知服务器你别等了，我没有数据过来了 s.shutdownOutput();
// 接收反馈 BufferedReader brClient = new BufferedReader(new InputStreamReader( s.getInputStream())); String client = brClient.readLine(); // 阻塞 System.out.println(client);
// 释放资源 br.close(); s.close(); }}
使用多线程上传多个文件
public class UserThread implements Runnable { private Socket s;
public UserThread(Socket s) { this.s = s; }
@Override public void run() { try { // 封装通道内的流 BufferedReader br = new BufferedReader(new InputStreamReader( s.getInputStream())); // 封装文本文件 // BufferedWriter bw = new BufferedWriter(new // FileWriter("Copy.java"));
// 为了防止名称冲突 String newName = System.currentTimeMillis() + ".java"; BufferedWriter bw = new BufferedWriter(new FileWriter(newName));
String line = null; while ((line = br.readLine()) != null) { // 阻塞 bw.write(line); bw.newLine(); bw.flush(); }
// 给出反馈 BufferedWriter bwServer = new BufferedWriter( new OutputStreamWriter(s.getOutputStream())); bwServer.write("文件上传成功"); bwServer.newLine(); bwServer.flush();
// 释放资源 bw.close(); s.close(); } catch (IOException e) { e.printStackTrace(); } }
}
public class UploadServer { public static void main(String[] args) throws IOException { // 创建服务器Socket对象 ServerSocket ss = new ServerSocket(11111);
while (true) { Socket s = ss.accept(); new Thread(new UserThread(s)).start(); } }}
public class UploadClient { public static void main(String[] args) throws IOException { // 创建客户端Socket对象 Socket s = new Socket("192.168.12.92", 11111);
// 封装文本文件 // BufferedReader br = new BufferedReader(new FileReader( // "InetAddressDemo.java")); BufferedReader br = new BufferedReader(new FileReader( "ReceiveDemo.java")); // 封装通道内流 BufferedWriter bw = new BufferedWriter(new OutputStreamWriter( s.getOutputStream()));
String line = null; while ((line = br.readLine()) != null) { // 阻塞 bw.write(line); bw.newLine(); bw.flush(); }
// Socket提供了一个终止，它会通知服务器你别等了，我没有数据过来了 s.shutdownOutput();
// 接收反馈 BufferedReader brClient = new BufferedReader(new InputStreamReader( s.getInputStream())); String client = brClient.readLine(); // 阻塞 System.out.println(client);
// 释放资源 br.close(); s.close(); }}
总结：
网络编程(理解)
(1)网络编程：用Java语言实现计算机间数据的信息传递和资源共享
(2)网络编程模型
(3)网络编程的三要素
A:IP地址
a:点分十进制
b:IP地址的组成
c:IP地址的分类
d:dos命令
e:InetAddress
B:端口
是应用程序的标识。范围：0-65535。其中0-1024不建议使用。
C:协议
UDP:数据打包,有限制,不连接,效率高,不可靠
TCP:建立数据通道,无限制,效率低,可靠
(3)Socket机制
A:通信两端都应该有Socket对象
B:所有的通信都是通过Socket间的IO进行操作的
(4)UDP协议发送和接收数据(掌握 自己补齐代码)
发送：
创建UDP发送端的Socket对象
创建数据并把数据打包
发送数据
释放资源
接收：
创建UDP接收端的Socket对象
创建数据包用于接收数据
接收数据
解析数据包
释放资源
(5)TCP协议发送和接收数据(掌握 自己补齐代码)
发送：
创建TCP客户端的Socket对象
获取输出流，写数据
释放资源
接收：
创建TCP服务器端的Socket对象
监听客户端连接
获取输入流，读取数据
释放资源
(6)案例：
A:UDP
a:最基本的UDP协议发送和接收数据
b:把发送数据改进为键盘录入
c:一个简易聊天小程序并用多线程改进
B:TCP
a:最基本的TCP协议发送和接收数据
b:服务器给出反馈
c:客户端键盘录入服务器控制台输出
d:客户端键盘录入服务器写到文本文件
e:客户端读取文本文件服务器控制台输出
f:客户端读取文本文件服务器写到文本文件
g:上传图片
h:多线程改进上传文件
传智播客风清扬视频-------网络编程简介相关推荐
- 传智播客风清扬视频-------线程简介
想了解线程,必须先了解进程,因为线程是依赖进程存在的. 什么是进程? 进程就是正在运行的程序:是系统进行资源分配和调用的独立单位.每一个进程都有它自己的内存空间和系统资源. 多进程有什么意义? 单进程 ...
- 长沙理工计算机竞赛黑马,2018年传智播客首届“黑马杯”高校编程大赛圆满落幕...
原标题:2018年传智播客首届"黑马杯"高校编程大赛圆满落幕 传智播客首届"黑马杯"高校编程大赛于2018年9月10日正式举办.本次大赛是面向高校大学生开放的I ...
- 传智播客C语言视频第二季(第一季基础上增加诸多C语言案例讲解，有效下载期为10.5-10.10关闭
分享一下我老师大神的人工智能教程!零基础,通俗易懂!http://blog.csdn.net/jiangjunshow 也欢迎大家转载本篇文章.分享知识,造福人民,实现我们中华民族伟大复兴! 卷 ba ...
- 传智播客C语言视频第二季(第一季基础上增加诸多C语言案例讲解，有效下载期为10.5-10.10关闭)
卷 backup 的文件夹 PATH 列表 卷序列号为 00000025 D4A8:14B0 J:. │ 1.txt │ c语言经典案例效果图示.doc │ ├─1传智播客_尹成_C语言从菜鸟到 ...
- 传智播客C语言视频第二季(第一季基础上增加诸多C语言案例讲解，有效下载期为10.5-10.10关闭)...
卷 backup 的文件夹 PATH 列表 卷序列号为 00000025 D4A8:14B0 J:. │ 1.txt │ c语言经典案例效果图示.doc │ ├─1传智播客_尹成_C语言从菜鸟到 ...
- 传智播客C语言视频第二季 第一季基础上增加诸多C语言案例讲解，有效下载期为10 5-10 10关闭
分享一下我老师大神的人工智能教程.零基础!通俗易懂!风趣幽默!还带黄段子!希望你也加入到我们人工智能的队伍中来!https://blog.csdn.net/jiangjunshow 卷 backup ...
- 传智播客-php基础视频,传智播客PHP核心基础视频教程推荐（资源）
PHP,是英文超级文本预处理语言Hypertext Preprocessor的缩写.PHP 是一种 HTML 内嵌式的语言,是一种在服务器端执行的嵌入HTML文档的脚本语言,语言的风格有类似于C语言, ...
- java工作流 传智播客_Activiti工作流视频教学（企业开发实战讲解）_传智播客
Activiti工作流视频教学(企业开发实战讲解)_传智播客课程简介: Activiti工作流视频教学(企业开发实战讲解)_传智播客本教学共分4天进行讲解,本站提供第1天内容在线观看,全集教学请在本站 ...
- 传智播客软件测试学习视频汇总：
课程名称 分类 URL 提取码 软件测试入门到精通 视频 http://yun.itheima.com/course/490.html?aoe cnj1 资料 https://pan.baidu.co ...
最新文章
- 【c语言】扶老奶奶过街
- 深度丨如果机器人三定律被打破，我们可以做些什么？
- CISCO路由器ADSL拨号配置
- Linux驱动之平台设备
- 【STM32】F1 系列驱动全彩显示屏
- kotlin实现继承_Kotlin程序| 继承的例子
- 企业基础管理薄弱，激励机制不健全怎么办？
- python的datetime模块用法_Python3.5内置模块之time与datetime模块用法实例分析
- 网口压线顺序_RJ45水晶头排线顺序
- 集成银联支付-代付功能
- 高等代数_证明_矩阵乘以自身的转置的特征值不小于0
- JavaScript --------WebS APIs学习之DOM(三)
- Windows安装和设置教程
- html文件svchost,解决html文件的DropFileName = svchost.exe木马
- 浮点数转换为大写货币金额
- Java学习---控制流程与方法
- 我的世界java蜜蜂_在最新的《我的世界》Java版更新中 蜜蜂是所有的热点
- C# Md5与AES加密解密源码记录
- Gradle build.gradle配置
- UML用例图-用例图