javaSE第二十六天
(1)网络编程：用Java语言实现计算机间数据的信息传递和资源共享 414
A:InetAddress: 此类表示互联网协议 (IP) 地址。 416
B: UDP协议下的Socket对象类DatagramSocket 418
第二十六天
1:网络编程(理解)
(1)网络编程：用Java语言实现计算机间数据的信息传递和资源共享
(2)网络编程模型
(3)网络编程的三要素
A:IP地址
a:点分十进制
b:IP地址的组成
c:IP地址的分类
d:dos命令
e:InetAddress
B:端口
是应用程序的标识。范围：0-65535。其中0-1024不建议使用。
C:协议
UDP:数据打包,有限制,不连接,效率高,不可靠
TCP:建立数据通道,无限制,效率低,可靠
|
/* * 网络编程三要素： A:IP地址 B:端口 C:协议
举例: 我想和林青霞说话了。肿么办? A:我要找到林青霞。 B:对她说话，要对耳朵说。 C:我说什么呢?"I Love You" 但是，她没学过英语，听不懂。 我没必要说英语，说汉语就可以了：我爱你
IP地址: 网络中计算机的唯一标识。
计算机只能识别二进制的数据，所以我们的IP地址应该是一个二进制的数据。 但是呢，我们配置的IP地址确不是二进制的，为什么呢? IP：192.168.1.100 换算：11000000 10101000 00000001 01100100 假如真是：11000000 10101000 00000001 01100100的话。 我们如果每次再上课的时候要配置该IP地址，记忆起来就比较的麻烦。 所以，为了方便表示IP地址，我们就把IP地址的每一个字节上的数据换算成十进制，然后用.分开来表示： "点分十进制"
IP地址的组成：网络号段+主机号段 A类：第一号段为网络号段+后三段的主机号段 一个网络号：256*256*256 = 16777216 B类：前二号段为网络号段+后二段的主机号段 一个网络号：256*256 = 65536 C类：前三号段为网络号段+后一段的主机号段
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 ping 后面跟ip地址。测试本机与指定的ip地址间的通信是否有问题
特殊的IP地址： 127.0.0.1 回环地址(表示本机) x.x.x.255 广播地址 x.x.x.0 网络地址
端口号： 正在运行的程序的标识。 有效端口：0~65535，其中0~1024系统使用或保留端口。
协议： 通信的规则
UDP： 把数据打包 数据有限制 不建立连接 速度快 不可靠
TCP： 建立连接通道 数据无限制 速度慢 可靠
举例： UDP：发短信 TCP：打电话 */ |
(4)网络编程中主要类介绍：
A:InetAddress: 此类表示互联网协议 (IP) 地址。
构造方法：
public
static InetAddress getByName(String host)：根据主机名或者ip地址
的字符串表现形式创建IP地址对象
普通方法：
public String getHostName()：获取主机名
public String getHostAddress()：获取IP地址
案例演示：
|
import java.net.InetAddress; import java.net.UnknownHostException;
/* * 如果一个类没有构造方法： * A:成员全部是静态的(Math,Arrays,Collections) * B:单例设计模式(Runtime) * C:类中有静态方法返回该类的对象(InetAddress) * class Demo { * private Demo(){} * * public static Demo getXxx() { * return new Demo(); * } * } * * 看IP地址类：InetAddress的成员方法： * public static InetAddress getByName(String host): * 根据主机名或者IP地址的字符串表示得到IP地址对象 * * 普通方法： * public String getHostName()：获取该IP地址对象的主机名 * public String getHostAddress():获取主机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("asus");
// 获取两个东西：主机名，IP地址 // public String getHostName() String name = address.getHostName(); // public String getHostAddress() String ip = address.getHostAddress(); System.out.println(name + "---" + ip); } } |
B: UDP协议下的Socket对象类DatagramSocket
1.发送端：
|
import java.io.IOException; import java.net.DatagramPacket; import java.net.DatagramSocket; import java.net.InetAddress; /* * UDP协议发送数据： * A:创建发送端Socket对象 * B:创建数据，并把数据打包 * C:调用Socket对象的发送方法发送数据包 * D:释放资源 * * 说明：UDP协议下的接收端和发送端的Socket对象都是同一个类DatagramSocket * * DatagramSocket类的方法： * 构造方法：public DatagramSocket() * 普通方法：public void send(DatagramPacket p): * 从此套接字发送数据报包 * public void close() * 关闭此数据报套接字。 * public synchronized void receive(DatagramPacket p)： * 从此套接字接收数据报包。 * * DatagramPacket数据包类： * 构造方法：public DatagramPacket(byte buf[], int length, InetAddress address, int port) 构造数据报包，用来将长度为 length 的包发送到指定主机上的指定端口号
public DatagramPacket(byte buf[], int length)： 构造 DatagramPacket，用来接收长度为 length 的数据包
public synchronized InetAddress getAddress()： 返回某台机器的 IP 地址对象 public synchronized byte[] getData()：返回数据缓冲区 public synchronized int getLength()：返回将要发送或接收到的数据的长度 */ 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(); } } |
2.接收端：
|
import java.io.IOException; import java.net.DatagramPacket; import java.net.DatagramSocket; import java.net.InetAddress;
/* * UDP协议接收数据： * A:创建接收端Socket对象 * B:创建一个数据包(接收容器) * C:调用Socket对象的接收方法接收数据 * D:解析数据包，并显示在控制台 * E:释放资源 */ 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(); } } |
C: TCP协议下的主要类介绍：
客户端的主要类：Socket类
构造方法
public Socket(String host, int
port)：创建一个流套接字并将其连接到指定主机上的指定端口号。
普通方法：
public OutputStream getOutputStream()：返回此套接字的输出流。
public InputStream getInputStream()：返回此套接字的输入流
public
synchronized
void close()：关闭此套接字
服务器端的主要类：ServerSocket类
构造方法
public ServerSocket(int
port)：创建绑定到特定端口的服务器套接字
普通方法
public Socket accept()：侦听并接受到此套接字的连接
案例演示：
1.客户端：
|
import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.net.Socket;
/* * TCP协议发送数据： * A:创建发送端的Socket对象 * 这一步如果成功，就说明连接已经建立成功了。 * B:获取输出流，写数据 * C:释放资源 * * TCP协议下的套接字类: * 套接字类：发送端的socket * 构造方法：public Socket(String host, int port) * 创建一个流套接字并将其连接到指定主机上的指定端口号。 * 普通方法： * public OutputStream getOutputStream()： * 返回此套接字的输出流。 * public InputStream getInputStream()： * 返回此套接字的输入流 * * public synchronized void close()：关闭此套接字 * * * 连接被拒绝。TCP协议一定要先看服务器。 * java.net.ConnectException: Connection refused: connect */ 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(); } } |
2.服务器端：
|
import java.io.IOException; import java.io.InputStream; import java.net.ServerSocket; import java.net.Socket;
/* * TCP协议接收数据： * A:创建接收端的Socket对象 * B:监听客户端连接。返回一个对应的Socket对象 * C:获取输入流，读取数据显示在控制台 * D:释放资源 * * 服务器端的套接字类：ServerSocket * 构造方法： * public ServerSocket(int port)：创建绑定到特定端口的服务器套接字 * * 普通方法： * public Socket accept():侦听并接受到此套接字的连接 * 说明：不应该关闭服务器端的套接字连接 */ 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(); //这个不应该关闭 } } |
(5)Socket机制
A:通信两端都应该有Socket对象
B:所有的通信都是通过Socket间的IO进行操作的
(4)UDP协议发送和接收数据(掌握)
1.原理图解
2.发送：步骤
A:创建UDP发送端的Socket对象
B:创建数据并把数据打包
C:发送数据
D:释放资源
|
import java.io.IOException; import java.net.DatagramPacket; import java.net.DatagramSocket; import java.net.InetAddress; /* * 发送端： */ public class SendDemo { public static void main(String[] args) throws IOException { // 创建发送端的Socket对象 DatagramSocket ds = new DatagramSocket();
// 创建数据并打包 byte[] bys = "helloworld".getBytes(); DatagramPacket dp = new DatagramPacket(bys, bys.length, InetAddress.getByName("192.168.12.92"), 12345);
// 发送数据 ds.send(dp);
// 释放资源 ds.close(); } } |
3.接收：步骤
A:创建UDP接收端的Socket对象
B:创建数据包用于接收数据
C:接收数据
D:解析数据包
E:释放资源
|
/* * 多次启动接收端： * 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);
// 创建一个包裹 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(); } } |
(5)TCP协议发送和接收数据(掌握)
A：原理图解
2.发送：步骤
a.创建TCP客户端的Socket对象
b.获取输出流，写数据
c.释放资源
|
import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.net.Socket; /* * 客户端： */ 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(); } } |
3.接收：步骤
A:创建TCP服务器端的Socket对象
B:监听客户端连接
C:获取输入流，读取数据
D:释放资源
|
import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.net.ServerSocket; import java.net.Socket; /* * 服务器端： */ 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(); } } |
(6)案例：
A:UDP
a:最基本的UDP协议发送和接收数据
1.发送端
|
import java.io.IOException; import java.net.DatagramPacket; import java.net.DatagramSocket; import java.net.InetAddress; /* * 发送端： */ public class SendDemo { public static void main(String[] args) throws IOException { // 创建发送端的Socket对象 DatagramSocket ds = new DatagramSocket();
// 创建数据并打包 byte[] bys = "helloworld".getBytes(); DatagramPacket dp = new DatagramPacket(bys, bys.length, InetAddress.getByName("192.168.12.92"), 12345);
// 发送数据 ds.send(dp);
// 释放资源 ds.close(); } } |
2.接收端：
|
import java.io.IOException; import java.net.DatagramPacket; import java.net.DatagramSocket;
/* * 多次启动接收端： * 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);
// 创建一个包裹 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(); } } |
b:把发送数据改进为键盘录入
1.发送端
|
import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.net.DatagramPacket; import java.net.DatagramSocket; import java.net.InetAddress;
/* * 需求：数据来自于键盘录入 * 键盘录入数据要自己控制录入结束。 */ 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(); } } |
2.接收端：
|
import java.io.IOException; import java.net.DatagramPacket; import java.net.DatagramSocket;
/* * 多次启动接收端： * 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(); } } |
c:一个简易聊天小程序并用多线程改进
1.发送端，实现多线程
|
import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.net.DatagramPacket; import java.net.DatagramSocket; import java.net.InetAddress; /* * 发送端:实现多线程 */ 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(); } }
} |
2.接收端，实现多线程
|
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(); } }
} |
3.测试类
|
import java.io.IOException; import java.net.DatagramSocket;
/* * 测试类：通过多线程改进刚才的聊天程序，这样我就可以实现在一个窗口发送和接收数据了 */ public class ChatRoom { public static void main(String[] args) throws IOException { //创建发送端Socket对象 DatagramSocket dsSend = new DatagramSocket(); //创建接收端Socket对象 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(); } } |
B:TCP
a: 服务器给出反馈
1.客户端
|
import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.net.Socket; /* * 客户端： */ 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(); } } |
2.服务器端：
|
import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.net.ServerSocket; import java.net.Socket; /* * 服务器端： */ 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(); } } |
c:客户端键盘录入服务器控制台输出
1.客户端
|
import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.IOException; import java.io.InputStreamReader; import java.io.OutputStreamWriter; import java.net.Socket;
/* * 需求：客户端键盘录入，服务器输出到控制台 */ public class ClientDemo { public static void main(String[] args) throws IOException { // 创建客户端Socket对象 Socket s = new Socket("127.0.0.1", 22223);
// 键盘录入数据 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(); } } |
2.服务器端：
|
import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.net.ServerSocket; import java.net.Socket; /* * 服务器端： */ public class ServerDemo { public static void main(String[] args) throws IOException { // 创建服务器Socket对象 ServerSocket ss = new ServerSocket(22223);
// 监听客户端连接 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(); } } |
d:客户端键盘录入服务器写到文本文件
1.客户端
|
import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.IOException; import java.io.InputStreamReader; import java.io.OutputStreamWriter; import java.net.Socket;
/* * 需求：客户端键盘录入，服务器输出文本文件 */ 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(); } } |
2.服务器端：
|
import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.FileWriter; import java.io.IOException; import java.io.InputStreamReader; import java.net.ServerSocket; import java.net.Socket; /* * 服务器端： */ 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(); } } |
e:客户端读取文本文件服务器控制台输出
1.客户端
|
import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.FileReader; import java.io.IOException; import java.io.OutputStreamWriter; import java.net.Socket;
/* * 需求：客户端读取文本文件，服务器输出到控制台 */ 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(); } } |
2.服务器端：
|
import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.net.ServerSocket; import java.net.Socket; /* * 服务器端： */ 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(); } } |
f:客户端读取文本文件服务器写到文本文件
1.客户端
|
import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.FileReader; import java.io.IOException; import java.io.InputStreamReader; import java.io.OutputStreamWriter; import java.net.Socket;
/* * 需求：上传一个文件到服务器 * * 按照我们正常的思路加入反馈信息，结果却没反应。为什么呢? * 读取文本文件是可以以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(); } } |
2.服务器端：
|
import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.FileWriter; import java.io.IOException; import java.io.InputStreamReader; import java.io.OutputStreamWriter; import java.net.ServerSocket; import java.net.Socket; /* * 服务器端： */ 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(); } } |
g:上传图片
1.发送端
|
import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.FileInputStream; import java.io.IOException; import java.io.InputStream; import java.net.Socket; /* * 需求：上传图片 */ 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(); } } |
2.服务器端：
|
import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.OutputStream; import java.net.ServerSocket; import java.net.Socket; /* * 服务器端： */ 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(); } } |
h:多线程改进上传文件
1.多线程类
|
import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.FileWriter; import java.io.IOException; import java.io.InputStreamReader; import java.io.OutputStreamWriter; import java.net.Socket; /* * 多线程类： */ 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(); } }
} |
2.客户端
|
import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.FileReader; import java.io.IOException; import java.io.InputStreamReader; import java.io.OutputStreamWriter; import java.net.Socket; /* * 需求:多线程上传文件 */ 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(); } } |
3.服务器端：
|
import java.io.IOException; import java.net.ServerSocket; import java.net.Socket; /* * 服务器端： */ 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(); } } } |
javaSE第二十六天的更多相关文章
- IT第二十六天 - Swing、上周总结
IT第二十六天 上午 Swing 1.对于方法的参数如果是int数值类型,应该直接调用该类中的常量属性,而不应该直接填入数字 2.Toolkit类中定义的方法是可以直接访问本地计算机(操作系统)信息的 ...
- Python第二十六天 python装饰器
Python第二十六天 python装饰器 装饰器Python 2.4 开始提供了装饰器( decorator ),装饰器作为修改函数的一种便捷方式,为工程师编写程序提供了便利性和灵活性装饰器本质上就 ...
- 孤荷凌寒自学python第二十六天python的time模块的相关方法
孤荷凌寒自学python第二十六天python的time模块的相关方法 (完整学习过程屏幕记录视频地址在文末,手写笔记在文末) 要使用time模块的相关方法,必须在文件顶端引用: import tim ...
- javaSE第十六天
第十六天 140 1:List的子类(掌握) 140 (1)List的子类特点 140 (2)ArrayList 141 A:没有特有功能需要学习 141 B:案例 ...
- javaSE第二十五天
第二十五天 399 1:如何让Netbeans的东西Eclipse能访问. 399 2:GUI(了解) 399 (1)用户图形界面 399 (2)两个包: 399 (3) ...
- javaSE第二十四天
第二十四天 363 1:多线程(理解) 363 (1)JDK5以后的Lock锁 363 A:定义 363 B:方法: 364 C:具体应用(以售票程序为例) 364 ...
- JavaScript(第二十六天)【表单处理】
为了分担服务器处理表单的压力,JavaScript提供了一些解决方案,从而大大打破了处处依赖服务器的局面. 一．表单介绍 在HTML中,表单是由<form>元素来表示的,而在JavaS ...
- (93)Wangdao.com_第二十六天_鼠标事件
鼠标事件 与鼠标相关的事件,继承了 MouseEvent 接口 分类: click 按下鼠标(通常是按下主按钮)时触发. mousedown 首先触发,mouseup 接着 ...
- c++第二十六天
p131~p135: 1.除非必要否则不使用后缀加加(减减),会有额外的性能开销. 2.混用解引用和递增运算符.*pointer++,后缀运算符优先于解引用运算符. 3.运算对象可按任意顺序求值,即使 ...
随机推荐
- Ubuntu离线安装包制作（转载）
From:http://blog.csdn.net/nupt123456789/article/details/11649603 1.应用场景 a.需要在多台电脑上安装同一软件,且软件很大,下载需要时 ...
- java反射1
一.Class部分 加载类的几种方式 // 1. Class clazz = Class.forName("com.wzh.test.reflect.Person"); // 2. ...
- JAVA中继承时方法的重载(overload)与重写/覆写(override)
JAVA继承时方法的重载(overload)与重写/覆写(override) 重载-Override 函数的方法参数个数或类型不一致,称为方法的重载. 从含义上说,只要求参数的个数或参数的类型不一致就 ...
- HDU 4405 【概率dp】
题意: 飞行棋,从0出发要求到n或者大于n的步数的期望.每一步可以投一下筛子,前进相应的步数,筛子是常见的6面筛子. 但是有些地方可以从a飞到大于a的b,并且保证每个a只能对应一个b,而且可以连续飞, ...
- Node.js发送邮件
1.使用nodemailer模块 var nodemailer = require("nodemailer"); 2.代码如下 exports.send_email = funct ...
- ubuntu14.04开启crontab日志
ubuntu默认没有开启cron日志记录 1. 修改rsyslog sudo vim /etc/rsyslog.d/50-default.conf cron.* /var/log/cron.log # ...
- 为view添加约束constraints
在相应要设置约束的view中按住鼠标右键进行拖拽,然后向指定的方向添加约束,如图: 拖拽的时候会显示一条蓝线,如上图所示,然后手指离开鼠标的时候会弹出向对应的约束供添加约束的时候进行使用如图:
- Sqoop2常用命令介绍
命令行操作之Create Command 1.Create Connection Function create connection --cid 1 说明:Create new connectio ...
- NEERC 2013, Eastern subregional contest
I. The old Padawan Time limit: 0.5 secondMemory limit: 64 MB Yoda: Use the Force. Yes. Now, the ston ...
- HDU 4390 Number Sequence 容斥原理
Number Sequence Time Limit: 10000/3000 MS (Java/Others) Memory Limit: 65536/65536 K (Java/Others) ...