JavaSE| 网络编程
URL
URI(Uniform resource identifier)：表示一个统一资源标识符 (URI) 引用，用来唯一的标识一个资源。
URL(Uniform Resource Locator)：类 URL 代表一个统一资源定位符，它是指向互联网“资源”的指针。资源可以是简单的文件或目录，也可以是对更为复杂的对象的引用，例如对数据库或搜索引擎的查询。它是一种具体的URI，即URL可以用来标识一个资源，而且还指明了如何locate这个资源。URI不能用于定位任何资源，它的唯一作用是解析，而URL则包含一个可打开到达该资源的输入流。 URL的基本结构由5部分组成：
<传输协议>://<主机名>:<端口号>/<文件名>#片段名
<传输协议>://<主机名>:<端口号>/<文件名>?参数列表
其中#片段名：即锚点，例如看小说，直接定位到章节
例如：http://java.sun.com/index.html#chapter1
参数列表格式：参数名=参数值&参数名=参数值....
例如: http://192.168.1.100:8080/helloworld/index.jsp?username=chai&password=123
URL url = new URL("http://www.baidu.com:80/index.html?keyword=java");
System.out.println("协议:" + url.getProtocol());
System.out.println("主机名:" + url.getHost());
System.out.println("端口号:" + url.getPort());
System.out.println("文件路径:" + url.getPath());
System.out.println("文件名:" + url.getFile());
System.out.println("在文件中的相对位置(喵点):" + url.getRef());//注意如果存在锚点，那么查询名返回null，因为#后面全部当做锚点了
System.out.println("获取该url的查询名字:" + url.getQuery());
public final InputStream openStream()：返回一个用于从该连接读入的 InputStream。
URL url2 = new URL("http://www.baidu.com");
InputStream input = url.openStream(); //返回一个用于从该连接读入的 InputStream
byte[] data = new byte[1024];
int len;
while((len = input.read(data)) != -1){
String s = new String(data, 0, len, "UTF-8");
System.out.println(s);
}
input.close();
URLConnection
URL的方法openStream()，能从网络上读取数据，但是无法给服务器端发送数据，若希望给服务器端发送数据，则需要URLConnection。
它代表应用程序和 URL 之间的通信链接。此类的实例可用于读取和写入此 URL 引用的资源。通常，创建一个到 URL 的连接需要几个步骤：
- 通过 URL对象调用
openConnection方法创建URLConnection连接对象。 - 处理设置参数和一般请求属性。
- 使用
connect方法建立到远程对象的实际连接。
远程对象变为可用。远程对象的头字段和内容变为可访问
从客户端读取发生给服务端（服务端做处理再返回给客户端）
public class TestServer {
public static void main(String[] args) throws IOException {
//1.开启服务,等待客户端连接
ServerSocket server = new ServerSocket(9999);//开启服务器
Socket socket = server.accept(); //接收客户的连接
System.out.println("开启服务,连接成功");
//2.接收客户端发来的消息输入:
InputStream inputStream = socket.getInputStream(); //以字节流接收客户端的信息,通过socket接收
InputStreamReader isr = new InputStreamReader(inputStream); //把字节流转成字符流
BufferedReader br = new BufferedReader(isr);//提高效率加上缓冲流
//3.给客户端返回消息输出:
OutputStream os = socket.getOutputStream(); //输出,通过socket输出
PrintStream ps = new PrintStream(os);
//System.out.println(ps);
//对接收的消息做处理
String line;
while((line = br.readLine()) != null){
StringBuilder s = new StringBuilder(line);
System.out.println("收到消息:" + s.toString());
s.reverse();
ps.println(s);
System.out.println("已做处理:" + s);
}
ps.close();
os.close();
br.close();
isr.close();
inputStream.close();
socket.close();
server.close();
}
}
public class Testclient {
public static void main(String[] args) throws UnknownHostException, IOException {
//1.连接服务器
Socket socket = new Socket("localhost", 9999);
//2.从键盘输入消息
Scanner input = new Scanner(System.in); //输入流inputStream
//3.输出给服务端
OutputStream outputStream = socket.getOutputStream();//以字节流通过socket输出给服务端
PrintStream ps = new PrintStream(outputStream);//按行打印
//4.接收服务端发来的消息
InputStream inputStream = socket.getInputStream(); //从网络中通过socket接收服务端发来的
InputStreamReader isr = new InputStreamReader(inputStream);//把字节流转成字符流
BufferedReader br = new BufferedReader(isr); //用缓存包装
//对键盘输入的信息做处理
while(true){
System.out.println("单词:");
String word = input.next(); //从键盘中接收消息
if("bye".equals(word)){
break;
}
System.out.println("从键盘输入:" + word);
ps.println(word); //给服务器发送单词消息; ps.print(word)用这个发送不出去！！！！
String line = br.readLine();
System.out.print("返回的单词是:" + line);
}
inputStream.close();
outputStream.close();
input.close();
socket.close();
}
}
接收多个客户端发来的消息
package com.atguigu.manytcpsendword; import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket; public class TestServer { public static void main(String[] args) throws IOException {
//1. 开启服务器
ServerSocket server = new ServerSocket(8080);
//2. 接收n个客户端发来的消息
while(true){
Socket socket = server.accept(); String ip = socket.getInetAddress().getHostAddress();
System.out.println(ip + "接入");//记录接入的ip地址
MyMessage m = new MyMessage(socket); //在构造器中赋值
m.start();
} }
} class MyMessage extends Thread{ private Socket socket; //socket负责收发消息, public MyMessage(Socket socket) {
super();
this.socket = socket;
}
public void run(){ InputStream is = null;
InputStreamReader isr = null;
BufferedReader br = null;
OutputStream os = null;
PrintStream ps = null;
try {
//1. 接收客户端发来的消息,从网络中读取-->字节流-字符流 -->
is = socket.getInputStream();
isr = new InputStreamReader(is);
br = new BufferedReader(isr); //2. 对接收的消息做处理然后返回给客户端
os = socket.getOutputStream();
ps = new PrintStream(os); String line; while((line = br.readLine()) != null){ //line = br.readLine();
StringBuffer s = new StringBuffer(line);
s.reverse();
ps.println(s);
System.out.println("已处理完毕并返回给客户端" + s);
} } catch (IOException e1) {
e1.printStackTrace();
}
try {
ps.close();
os.close();
br.close();
isr.close();
is.close();
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
//server.close();
} }
package com.atguigu.manytcpsendword; import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.Socket;
import java.util.Scanner; public class TestClient { public static void main(String[] args) throws IOException {
Socket socket = new Socket("localhost", 8080);
Scanner input = new Scanner(System.in);
//输出给服务端
OutputStream os = socket.getOutputStream();
PrintStream ps = new PrintStream(os); //接收服务端消息
InputStream is = socket.getInputStream();
InputStreamReader isr = new InputStreamReader(is);//把接收的字节转成字节
BufferedReader br = new BufferedReader(isr); //把字节包装下提高效率
while(true){
System.out.println("留言:");
String str = input.next(); if("bye".equalsIgnoreCase(str)){
break;
}
//给服务端发 消息
ps.println(str);
//接收服务端发来的消息
String line = br.readLine();
System.out.println("接收到服务端发来的消息:" + line);
}
br.close();
isr.close();
is.close();
ps.close();
os.close();
input.close();
socket.close(); } }
传输文件
public class Server {
public static void main(String[] args) throws IOException {
//1.创建服务器
ServerSocket server = new ServerSocket(9999);
Socket socket = server.accept();
String ip = socket.getInetAddress().getHostAddress();
System.out.println(ip + "已接入");
//2.从客户端读取数据
DataInputStream dis = new DataInputStream(socket.getInputStream());
String fileName = dis.readUTF();
//先确定输出文件的路径,然后再写入数据
FileOutputStream fos = new FileOutputStream("upload/" + fileName);
//读取内容
byte[] data = new byte[1024];
int len;
while((len = dis.read(data)) != -1){
fos.write(data, 0, len);
}
//3.写完之后给客户端回个信号
PrintStream ps = new PrintStream(socket.getOutputStream());
ps.println("接收完毕,请客户端查阅");
ps.close();
fos.close();
dis.close();
socket.close();
server.close();
}
}
public class Client {
public static void main(String[] args) throws UnknownHostException, IOException {
//1.连接服务器
Socket socket = new Socket("localhost", 9999);
//2.给服务器上传文件
//一.先输入地址
Scanner input = new Scanner(System.in);
System.out.println("文件地址:");
String filePath = input.next();
File file = new File(filePath); //因为它是一个file字符串路径对象,所以要用DataIn。。
String pathName = file.getName();
//二.把文件路径和文件名对象化传给服务端
DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
dos.writeUTF(pathName); //对象化文件名后,读取时还要同样的readUTF( )
//三.按照字节读取文件内容
FileInputStream fis = new FileInputStream(file);
byte[] data = new byte[1024];
int len;
while((len = fis.read(data)) != -1){ //读取文件内容并写入
dos.write(data, 0, len);
}
socket.shutdownOutput(); //要先关闭输出流
BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream())); //接收服务端返回的字符串
String line = br.readLine();
System.out.println("接收服务端返回的结果:" + line);
br.close();
fis.close();
dos.close();
input.close();
socket.close();
}
}
可接收多个客户端发来的文件
package com.atguigu.fileputmany; import java.io.DataInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket; public class Server { public static void main(String[] args) throws IOException {
//1.创建服务器
ServerSocket server = new ServerSocket(9999); while(true){
Socket socket = server.accept();
String ip = socket.getInetAddress().getHostAddress();
System.out.println(ip + "已接入");
MyFile m = new MyFile(socket);
m.start(); }
}
} class MyFile extends Thread{
private Socket socket; public MyFile(Socket socket) {
super();
this.socket = socket;
} public void run(){
//2.从客户端读取数据
DataInputStream dis = null;
FileOutputStream fos = null;
PrintStream ps = null;
try {
dis = new DataInputStream(socket.getInputStream());
String fileName = dis.readUTF();
//先确定输出文件的路径,然后再写入数据
fos = new FileOutputStream("upload/" + fileName);
//读取内容
byte[] data = new byte[1024];
int len;
while((len = dis.read(data)) != -1){
fos.write(data, 0, len);
}
//3.写完之后给客户端回个信号
ps = new PrintStream(socket.getOutputStream());
ps.println("接收完毕,请客户端查阅"); } catch (IOException e1) {
e1.printStackTrace();
} try {
ps.close();
fos.close();
dis.close();
socket.close();
//server.close();
} catch (IOException e) {
e.printStackTrace();
} } }
package com.atguigu.fileputmany; import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner; public class Client { public static void main(String[] args) throws UnknownHostException, IOException { //1.连接服务器
Socket socket = new Socket("localhost", 9999); //2.给服务器上传文件
//一.先输入地址
Scanner input = new Scanner(System.in); System.out.println("文件地址:");
String filePath = input.next();
File file = new File(filePath); //因为它是一个file字符串路径对象,所以要用DataIn。。
String pathName = file.getName(); //二.把文件路径和文件名对象化传给服务端
DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
dos.writeUTF(pathName); //对象化文件名后,读取时还要同样的readUTF( ) //三.按照字节读取文件内容
FileInputStream fis = new FileInputStream(file); byte[] data = new byte[1024];
int len;
while((len = fis.read(data)) != -1){ //读取文件内容并写入
dos.write(data, 0, len); }
socket.shutdownOutput(); //要先关闭输出流,不然接收不到服务端返回的消息 BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream())); //接收服务端返回的字符串
String line = br.readLine();
System.out.println("接收服务端返回的结果:" + line);
br.close();
fis.close();
dos.close();
input.close();
socket.close();
}
}
用TCP实现多人聊天
package com.atguigu.chat; import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList; public class TestServer { public static void main(String[] args) throws IOException {
//1.启动服务器
ServerSocket server = new ServerSocket(9999);
ArrayList<Socket> onLine = new ArrayList<Socket>(); //创建集合装开启的线程; while(true){
Socket socket = server.accept();
System.out.println(socket.getInetAddress().getHostAddress() + "连接成功");
//每连接一个,往里边放一个
onLine.add(socket);
Message m = new Message(socket, onLine);
m.start();
} }
} class Message extends Thread{
private Socket socket;
private ArrayList<Socket> onLine;
private String ip;
public Message(Socket socket, ArrayList<Socket> onLine) {
super();
this.socket = socket;
this.onLine = onLine;
}
public void run(){
ip = socket.getInetAddress().getHostAddress();
sendToOther(ip + "上线了"); //小功能,xx上线了,在receive公共聊天室; BufferedReader br = null;
try {
//接收客户端的消息; 把字节变成字符流并提高效率
br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
String line;
while((line = br.readLine()) != null){
//把消息转发给其他的客户端receive公共聊天室;这里写一个方法
sendToOther(line);
}
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
br.close();
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
onLine.remove(socket);
sendToOther(ip + "下线了");
}
}
public void sendToOther(String str){ ArrayList<Socket> offline = new ArrayList<Socket>(); for (Socket socket :onLine) { //遍历的是onLine!!!!
if(!(socket.equals(this.socket))){ //如果不是自己就转发
try{
PrintStream ps = new PrintStream(socket.getOutputStream());
ps.println(str);
}catch(IOException e){
e.printStackTrace();
offline.add(socket);
}
}
}
for (Socket off : offline) {
offline.remove(off);
}
}
}
package com.atguigu.chat; import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner; public class TestClient { public static void main(String[] args) throws UnknownHostException, IOException {
//1.连接服务器
Socket socket = new Socket("localhost",9999);
//创建两个线程,一个用来发send消息; 一个用来接收receive消息(作为公共的聊天场所)
Send send = new Send(socket);
Receive receive = new Receive(socket); send.start();
receive.start(); try {
send.join();
receive.setExited(true);
receive.join();
} catch (InterruptedException e) { e.printStackTrace();
}
socket.close(); }
} class Send extends Thread{ private Socket socket; public Send(Socket socket) {
super();
this.socket = socket;
} public void run(){
Scanner input = new Scanner(System.in); //从键盘输入消息 PrintStream ps = null;
try {
ps = new PrintStream(socket.getOutputStream());//将键盘输入的消息发出
while(true){
System.out.println("畅聊:");
String message = input.nextLine();
if("bye".equalsIgnoreCase(message)){
break;
}
ps.println(message); //发送出去;
} } catch (IOException e) {
e.printStackTrace();
} finally{
input.close();
} } } class Receive extends Thread{ private Socket socket;
private boolean exited; public Receive(Socket socket) {
super();
this.socket = socket;
}
public void setExited(boolean exited) {
this.exited = exited;
} public void run(){
BufferedReader br = null;
try {
//字节输入流 -->字符 --> 包装下提高效率
br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
String line;
while((line = br.readLine()) != null && !exited){
System.out.println(line);
} } catch (IOException e) {
e.printStackTrace();
}
}
}
基于UDP多人聊天（使用MulticastSocket实现多点广播）
package com.atguigu.udp; import java.io.IOException;
import java.net.DatagramPacket;
import java.net.InetAddress;
import java.net.MulticastSocket;
import java.util.Scanner; public class TestMulticastSocket {
static Scanner input = new Scanner(System.in);
static String username; public static void main(String[] args) throws IOException {
//1. 创建Socket
MulticastSocket ms = new MulticastSocket(9999);
InetAddress ip = InetAddress.getByName("230.0.0.1"); ms.joinGroup(ip); //把这个ms添加到广播组中
ms.setLoopbackMode(false); //如果为true是禁止回传; System.out.println("用户名:");
username = input.nextLine(); Send send = new Send(ms, ip);
Receive receive = new Receive(ms); send.start();
receive.start(); try {
send.join();
receive.setExited(true);
receive.join(); } catch (InterruptedException e) {
e.printStackTrace();
}
ms.close(); } static class Send extends Thread{ //静态内部类
private MulticastSocket socket; //类
private InetAddress ip; //类
public Send(MulticastSocket socket, InetAddress ip) {
super();
this.socket = socket;
this.ip = ip;
}
public void run(){
while(true){
System.out.println("输入消息:");
String message = input.nextLine();
if("bye".equalsIgnoreCase(message)){
break;
}
//1.创建数据报DatagramPacket
byte[] data = (username + "说:" + message).getBytes(); //把键盘输入的转成字节数组
DatagramPacket dp = new DatagramPacket(data, data.length, ip, 9999); try {
//2.调用调用MulticastSocket类socket 的send方法将数据报发送出去;
socket.send(dp); } catch (IOException e) {
e.printStackTrace();
} } } }
static class Receive extends Thread{
private MulticastSocket socket;
private boolean exited;
public Receive(MulticastSocket socket) {
super();
this.socket = socket;
}
public void setExited(boolean exited) {
this.exited = exited;
} public void run(){ while(!exited){
//1.建立数据报DatagramPacket
byte[] data = new byte[1024];
DatagramPacket dp = new DatagramPacket(data, data.length);
try {
//2.调用MulticastSocket socket的seceive方法发送数据报;
socket.receive(dp);
//3.拆解数据报
int len = dp.getLength();
System.out.println("本次收到的消息:" + new String(data, 0, len)); } catch (IOException e) {
e.printStackTrace();
}
}
} } }
基于UDP协议的网络编程
TCP：(Transmission Control Protocol，传输控制协议），面向连接的，可靠的，基于字节流的传输层的网络协议。
服务器端：ServerSocket和Socket，客户端：Socket
getInputStream()和getOutputStream()
UDP：(User Datagram Protocol，用户数据报协议)，非面向连接的（无连接的），面向事务的基于数据报的不可靠的传输层的网络协议。
UDP：快，适用于（是否接收到消息要求不高，但是对速度要求高，必须小的），大小限制在64K
通信的两端也有Socket：DatagramSocket
DatagramPacket数据报
1、“发送端”
步骤流程：
1、建立发送端的DatagramSocket，需要指定本端的端口号
2、建立数据包DatagramPacket
数据
接收端的IP地址
接收端的端口号
3、调用DatagramSocket的发送方法
4、关闭DatagramSocket 2、“接收端”
步骤流程：
1、建立接收端的DatagramSocket，需要指定本端的IP地址和端口号
2、建立数据包DatagramPacket
需要指定装数据的数组
3、调用Socket的接收方法
4、拆封数据
5、关闭Socket
JavaSE| 网络编程的更多相关文章
- JavaSE——网络编程基础知识
计算机网络的分类: 局域网(LAN) 指在一个较小地理范围内的各种计算机网络设备互联在一起的通信网络,可以包括一个或多个子网,通常局限在几千米的范围之内. 城域网(MAN) 主要由城域范围内的各个局域 ...
- [javaSE] 网络编程（概述）
网络通信的步骤, 1.找到对方的ip 2.数据发送到对方指定的应用程序上,为了标识这些应用程序,用数字进行标识,这个数字就是端口 3.定义通信规则,这个规则就称为协议 国际组织定义了通用协议 TCP/ ...
- [javaSE] 网络编程（TCP通信）
客户端A与服务端建立通信,服务端获取到客户端A的Socket对象,通过这个通路进行通信 客户端: 获取Socket对象,new出来,创建客户端的Socket服务,构造参数:Sting主机,int 端口 ...
- [javaSE] 网络编程（UDP通信）
UDP发送端 获取DatagramSocket对象,new出来 获取DatagramPacket对象,new出来,构造参数:byte[]数组,int长度,InetAddress对象,int端口 调用D ...
- [javaSE] 网络编程（TCP，UDP，Socket特点）
UDP特点: 面向无连接,把数据打包发过去,收不收得到我不管 数据大小有限制,一次不能超过64k,可以分成多个包 这是个不可靠的协议 速度很快 视频直播,凌波客户端,feiQ都是UDP协议 TCP特点 ...
- [javaSE] 网络编程（TCP服务端客户端互访阻塞）
客户端给服务端发送数据,服务端收到数据后,给客户端反馈数据 客户端: 获取Socket对象,new出来,构造参数:String的ip地址,int的端口号 调用Socket对象的getOutputStr ...
- [javaSE] 网络编程（浏览器客户端-自定义服务端）
获取ServerSocket对象,new出来构造参数:int类型端口号 调用ServerSocket对象的accept()方法,得到Socket对象 获取PrintWriter对象,new出来,构造参 ...
- [javaSE] 网络编程（URLConnection）
获取URL对象,new出来,构造参数:String的路径 调用URL对象的openConnection()方法,获取URLConnection对象 调用URLConnection对象的getInput ...
- [javaSE] 网络编程（URL）
获取URL对象,new出来,构造参数:String的路径 调用URL对象的getProtocal()方法,获取协议 调用URL对象的getHost()方法,获取主机 调用URL对象的getPath() ...
随机推荐
- 【原创】大数据基础之Hive（5）性能调优Performance Tuning
1 compress & mr hive默认的execution engine是mr hive> set hive.execution.engine;hive.execution.eng ...
- Solidity函数view,pure,constant的用法
函数访问权限:public,external,private,internal //子类可以得到父类下面的方法,父类用了public,external的话 pragma solidity ^; con ...
- 14)django-模板(计数器)
模块中for循环自带计数器. 使用场景:表格数据相增加序列号. 问:可以使用表的自增加序列做为序列号,但是这个存在个问题,即表中数据被删除,则会出现序列不连续. 1)每个循环都有6个公共方法,双循环有 ...
- iOS运行时使用（动态添加方法）
1 举例 我们实现一个Person类 然后Person 其实是没得对象方法eat:的 下面调用person的eat方法 程序是会奔溃的 那么需要借助运行时动态的添加方法 Person *p = [[ ...
- input标签 disabled 和 readonly的区别
需求描述:今天提交代码,老大审了一下,给我指出了一个改正的地方,XXX的详细信息页面(不是修改页面) input的内容是不能改的,给我指出的时候,我立马就知道了这个该怎么改了,加个readonly不就 ...
- Java在线备份和还原MySQL数据库。
2018年6月29日14:00:48 阅读数:1534 今天整了整整一整天,终于使用Java在线备份和还原MySQL数据库了,哎,备份倒是很快,就是在还原的时候遇到了一个问题,也不报错,结果将sql语 ...
- 没有系列化导致错误：java.io.NotSerializableException: com.bjpowernode.bean.Team
java.io.NotSerializableException: com.bjpowernode.bean.Team Cause: java.io.NotSerializableException: ...
- idea首次创建新模块的详细操作
依赖网址:https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api/3.1.0 https://mvnrepository. ...
- 常见的爬虫分析库（2）-xpath语法
xpath简介 1.xpath使用路径表达式在xml和html中进行导航 2.xpath包含标准函数库 3.xpath是一个w3c的标准 xpath节点关系 1.父节点 2.子节点 3.同胞节点 4. ...
- 在Ubuntu下创建一个新的用户
Step1:添加新用户useradd -r -m -s /bin/bash 用户名 Step2:配置新用户密码passwd 用户名 Step3:给新添加的用户增加ROOT权限vim /etc/sudo ...