Java网络编程（一）
Java网络编程：
1.1： 网络编程：对于我这个“研究不深”的网络菜鸟来说，我觉得网络编程就是实现计算机与计算机之间通信的编程。写些能够实现计算机与计算机之间的通信就行了（目前来说）。
1.2：一台计算机跟另外计算机通讯。
计算机与计算机通讯的三大要素：
1：ip地址---电脑
1.1:作用：唯一标识一台计算机。
回环地址：127.0.0.1==主机：localhost
主机地址作用：测试网卡是否正常。
2：找到相应的应用程序----端口号
端口号-----具有网络功能的应用程序的标识号，没有网络功能的程序具有端口号似乎没有用吧。端口号是用整数来表示：0-65535，正好是char类型数据的范围
端口是一个软件结构，被客户程序或服务程序用来发送和接收数据，一台服务器有256*256个端口。
0-1023是公认端口号，即已经公认定义或为将要公认定义的软件保留的
1024-65535是并没有公共定义的端口号，用户可以自己定义这些端口的作用。
端口与协议有关：TCP和UDP的端口互不相干
自定义端口最好别写前面的端口号，一般是写1024之后的。
关于端口号的详细说明：连接
3：计算机协议
3.1：UDP协议：视频传输会有得比较多。
3.2：TCP/IP协议,通讯所遵守的协议，这是很多协议的一个总称。
2：udp协议（比较少用）
2.1：InetAddress类（IP相关的类）。
1：通过ip地址获得InetAddress对象 InetAddress.getByName("ip地址");
2：获得本地的InetAddress InetAddress.getLocalHost()
3：获得对象的ip字符串 对象名.getHostAddress( )
4：获得对象的主机名 对象名.getHostName()
2.2：udp协议：收发的两端一般称作：发送端和接收端
1：特点：面向无连接：无论接收到是否开启，发送端都会将数据发送出去。
效率高，不可靠：UDP协议的传输效率是很高的，但是由于是向无连接的，所以发送出去的数据不一定会被接收到收到，而且在传输的过程中数据很可能会丢失（发送端发送一张2M的图片，接收端接收的可能只剩1M也说不定），所以这种协议不可靠。
发送和接收的是数据报包——Datagrampacket。
2：相关的类:
DatagramSocket, DatagramPacket.
3：关于UDP协议下DatagramSocket和DatagramPacket的案例
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
/*
* 1：发送端发送一个文件(文本文件，图片)给接收端.
*/
public class Send {//发送端
public static void main(String[] args) {
//读取文件操作
BufferedInputStream bis = null;
//读取文件的数组
byte[] b1 = new byte[1024];
//每次读取到的数组长度
int len = -1;
//创建UDP套接字
DatagramSocket ds = null;
//创建数据报包
DatagramPacket dp = null;
//创建数据报包要使用到的参数：
//1、字节数组（包数据）== 读取文件的数组
//2、包的长度 == 每次读取到的数组长度
//3、目标地址
InetAddress ia = null;
//4、地址端口
int port = 8888;
try {
ia = InetAddress.getLocalHost();//获取本机地址
//关联文件
bis = new BufferedInputStream(new FileInputStream("e:\\aa.mp3"));
//读取文件
while((len = bis.read(b1)) != -1){
ds = new DatagramSocket();
dp = new DatagramPacket(b1, len, ia, port);
ds.send(dp);//发送数据给接收端
}
//如果发送的数据为空了，就发送一次空的指示给接收端
if(len == -1){
ds = new DatagramSocket();
dp = new DatagramPacket(b1, 0, ia, port);
ds.send(dp);//发送数据给接收端
}
} catch (SocketException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
bis.close();//关闭流
} catch (IOException e) {
e.printStackTrace();
}
ds.close();//关闭套接字资源
}
}
}
发送端代码
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
public class Receive {//接收端
public static void main(String[] args) {
//文件写出流
BufferedOutputStream bos = null;
//创建UDP套接字对象
DatagramSocket ds = null;
//数据报包
DatagramPacket dp = null;
//端口号
int port = 8888;
byte[] b = new byte[1024];
int length = b.length;
try {
bos = new BufferedOutputStream(new FileOutputStream("e:\\bb.mp3"));
ds = new DatagramSocket(port);
while(true){
dp = new DatagramPacket(b, 0, length);
//接收数据
ds.receive(dp);
//写出数据
bos.write(b, 0, dp.getLength());
bos.flush();
//接受文件的长度是0的时候跳出循环
if(dp.getLength()==0){
break;
}
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
try {
bos.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
ds.close();
}
}
}
接收端代码
3：tcp协议：相连接的两端一般称为客户端（Client）和服务器端（Server）。都是以流的形式来发送和接收数据。
1：特点：面向连接，效率没有udp高，可靠（三次握手）。
tcp连接有3次握手完成一次连接：
1：客户端连接服务器端。等待服务器端响应
2：服务器端给出一个响应给客户端
3：服务器端准备发送数据。
2：相关的类.
客户端：Socket
服务器端：ServerSocket
2.1:客户端发送"HelloWorld"给服务器端，运行时要先开启服务器端。
import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
public class ClientDemo1 {//客户端
public static void main(String[] args) throws IOException {
//客户端套接字
Socket s = new Socket("127.0.0.1", 9999);
//要发送的数据
String str = "HelloWorld";
//获取客户端的输出流
OutputStream os = s.getOutputStream();
//输出数据
os.write(str.getBytes());
os.close();
s.close();
}
}
客户端代码
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class ServerDemo1 {//服务器端
public static void main(String[] args) throws IOException {
//服务器端套接字
ServerSocket ss = new ServerSocket(9999);
//接受数据的Socket
Socket s = ss.accept();
//接受数据相关的输入流
InputStream is = s.getInputStream();
byte[] b = new byte[1024];
int length = is.read(b);
//打印数据
System.out.println(new String(b, 0, length));
}
}
服务器端代码
3:两两聊天。但是不能够同时发送和接收数据。
一开始我的代码：两端即是客户端也是服务器端，造成这个的原因是不了解客户端与服务器端连接之后形成的“管道”是可以双向流动数据的。
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;
public class ClientDemo4 {
public static void main(String[] args)throws IOException {
/*
* 发送
*/
String host = "127.0.0.1";
// String host = "10.16.153.62";
Socket s = new Socket(host, 9999);
OutputStream os = s.getOutputStream();
Scanner sc = new Scanner(System.in);
String str = null;
/*
* 接收
*/
ServerSocket ss = new ServerSocket(8888);
Socket s2 = ss.accept();
InputStream is = s2.getInputStream();
byte[] b = new byte[1024];
String str2 = null;
int length = -1;
String address = s2.getInetAddress().getHostAddress();
int port = s2.getPort();
while(true){
str = sc.nextLine();
os.write(str.getBytes());
if("886".equals(str)){
break;
}
length = is.read(b);
str2 = new String(b, 0, length);
System.out.println(address+":"+port+"\t"+str2);
}
}
}
即是客户端也是服务器端之客户端
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;
public class ServerDemo4 {
public static void main(String[] args) throws IOException {
ServerSocket ss = new ServerSocket(9999);
Socket s = ss.accept();
InputStream is = s.getInputStream();
byte[] b = new byte[1024];
int length = -1;
String str = null;
String address = s.getInetAddress().getHostAddress();
int port = s.getPort();
String host = "127.0.0.1";
Socket s2 = new Socket(host, 8888);
OutputStream os = s2.getOutputStream();
Scanner sc = new Scanner(System.in);
String str2 = null;
while((length = is.read(b)) != -1){
str = new String(b, 0, length);
System.out.println(address+":"+port+"\t"+str);
str2 = sc.nextLine();
os.write(str2.getBytes());
if("886".equals(str2)){
break;
}
}
os.close();
is.close();
ss.close();
}
}
即是客户端也是服务器端之服务器端
修改后的代码：
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
/*
* 客户端发送"服务器端，你好啊"给服务器端。服务器端回应"客户端，你好啊"。
* 客户端：发送，接收数据。
* Socket
*/
public class ClientDemo5 {
public static void main(String[] args) {
Socket s = null;
OutputStream os = null;
InputStream is = null;
try {
s = new Socket("127.0.0.1", 9988);
byte[] b = "服务器端，你好啊".getBytes();
// 获得输出流
os = s.getOutputStream();
os.write(b);// 发送数据。
// 由于需要接收数据，所以需要获得输入流。
is = s.getInputStream();
byte[] b2 = new byte[1024];
int length = is.read(b2);
System.out.println(new String(b2, 0, length));
} catch (UnknownHostException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
try {
is.close();
os.close();
s.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
修改后的客户端
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class ServerDemo5 {
public static void main(String[] args) {
ServerSocket ss = null;
Socket s = null;
OutputStream os = null;
try {
ss = new ServerSocket(9988);
ss.accept();
InputStream is = s.getInputStream();
byte[] b = new byte[1024];
int length = is.read(b);
String str =new String(b, 0, length);
// System.out.println(str);
os = s.getOutputStream();
os.write(str.getBytes());
} catch (IOException e) {
e.printStackTrace();
}
finally{
try {
os.close();
ss.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
修改后的服务器端
4:两两聊天。
客户端：一边接收消息，一边发送消息。一个线程负责接收消息，一个线程负责发送消息。
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner; /*
* 两两聊天。客户端：一边接收消息，一边发送消息。
* 涉及到一边XXX一边XXX或者同时XXX的应该想到线程
* 一个线程负责接收消息，一个线程负责发送消息。
* (控制台实现)
*/
public class ClientDemo7 {
public static void main(String[] args) {
Socket s;
try {
String ip = "127.0.0.1";
s = new Socket(ip, 9988);
//启动一个发送消息的线程
ClientSend send = new ClientSend(s);
send.start();
//启动一个接收消息的线程
ClientReceice receice = new ClientReceice(s);
receice.start();
} catch (UnknownHostException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
} class ClientSend extends Thread{
private Socket s;
public ClientSend(Socket s){
this.s = s;
} @Override
public void run() {
OutputStream os = null;
Scanner sc = new Scanner(System.in);
try {
os = s.getOutputStream();
String str = null;
while(true){
str = sc.nextLine();
os.write(str.getBytes());
os.flush();
}
} catch (IOException e) {
e.printStackTrace();
}
}
} class ClientReceice extends Thread{
private Socket s;
public ClientReceice(Socket s){
this.s = s;
}
@Override
public void run() {
InputStream is = null;
try {
is = s.getInputStream();
byte[] b = new byte[1024];
int length = -1;
String str = null;
while((length = is.read(b)) != -1){
str = new String(b, 0, length);
System.out.println("服务器端："+str+"\r\n");
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
客户端代码
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner; /*
* 两两聊天。客户端：一边接收消息，一边发送消息。
* 一个线程负责接收消息，一个线程负责发送消息。
*/ public class ServerDemo7 { public static void main(String[] args) {
ServerSocket ss = null;
Socket s = null;
try {
ss = new ServerSocket(8888);
s = ss.accept();
//开启一个发送消息的线程
ServerSend send = new ServerSend(s);
send.start();
//开启一个接收消息的线程
ServerReceice receice = new ServerReceice(s);
receice.start();
} catch (IOException e) {
e.printStackTrace();
}
} } class ServerSend extends Thread{
private Socket s;
public ServerSend(Socket s){
this.s = s;
} @Override
public void run() {
OutputStream os = null;
Scanner sc = new Scanner(System.in);
try {
os = s.getOutputStream();
String str = null;
while(true){
str = sc.nextLine();
os.write(str.getBytes());
os.flush();
}
} catch (IOException e) {
e.printStackTrace();
}
}
} class ServerReceice extends Thread{
private Socket s;
public ServerReceice(Socket s){
this.s = s;
}
@Override
public void run() {
InputStream is = null;
try {
is = s.getInputStream();
byte[] b = new byte[1024];
int length = -1;
String str = null;
while((length = is.read(b)) != -1){
str = new String(b, 0, length);
System.out.println("客户端："+str);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
服务器端代码
Java网络编程（一）的更多相关文章
- 20145205 《Java程序设计》实验报告五：Java网络编程及安全
20145205 <Java程序设计>实验报告五:Java网络编程及安全 实验要求 1.掌握Socket程序的编写: 2.掌握密码技术的使用: 3.客户端中输入明文,利用DES算法加密,D ...
- Java 网络编程学习总结
新手一枚,Java学习中,把自己学习网络编程的知识总结一下,梳理下知识,方便日后查阅,高手莫进. 本文的主要内容: [1] 网络编程认识 [2] TCP/IP编程 ...
- 20145212 实验五《Java网络编程》
20145212 实验五<Java网络编程> 一.实验内容 1.运行下载的TCP代码,结对进行,一人服务器,一人客户端: 2.利用加解密代码包,编译运行代码,一人加密,一人解密: 3.集成 ...
- 20145213《Java程序设计》实验五Java网络编程及安全
20145213<Java程序设计>实验五Java网络编程及安全 实验内容 1.掌握Socket程序的编写. 2.掌握密码技术的使用. 3.设计安全传输系统. 实验预期 1.客户端与服务器 ...
- 20145206《Java程序设计》实验五Java网络编程及安全
20145206<Java程序设计>实验五 Java网络编程及安全 实验内容 1．掌握Socket程序的编写: 2．掌握密码技术的使用: 3．设计安全传输系统. 实验步骤 我和201451 ...
- 20145337实验五Java网络编程及安全
20145337实验五Java网络编程及安全 实验内容 掌握Socket程序的编写 掌握密码技术的使用 设计安全传输系统 实验步骤 基于Java Socket实现安全传输 基于TCP实现客户端和服务器 ...
- java 网络编程复习（转）
好久没有看过Java网络编程了,现在刚好公司有机会接触,顺便的拾起以前的东西 参照原博客:http://www.cnblogs.com/linzheng/archive/2011/01/23/1942 ...
- JAVA课程实验报告 实验五 Java网络编程及安全
北京电子科技学院(BESTI) 实 验 报 告 课程:Java程序设计 班级:1353 姓名:韩玉琪 学号:20135317 成绩: 指导教师:娄嘉 ...
- 20145225《Java程序设计》 实验五 Java网络编程及安全
20145225<Java程序设计> 实验五 Java网络编程及安全 实验报告 一.实验内容 基于Java Socket实现安全传输. 基于TCP实现客户端和服务器,结对编程一人负责客户端 ...
- Java 网络编程----基本概念
网络现在是一个非常普遍的概念. 以下是维基百科上的解释: 网络一词有多种意义,可解作: 网络流也简称为网络(network).一般用于管道系统.交通系统.通讯系统建模. 有时特指计算机网络. 或特指其 ...
随机推荐
- 一个GIS系统需具备的功能
数据的存储(数据结构) 图形显示 功能:拓扑分析 开源的GIS系统:QGIS,SharpMap 各个功能组件
- Oracle E-Business Suite R12.2的新技术特点
Oracle公司的系统研发开发与执行效率,让人不得不佩服.从2008年1月收购BEA到现在短短几年时间,就把Bea WebLogic产品融合到了Oracle公司自己的原研发产品之庞大的Oracle E ...
- Python 实现图片对比检测
在写测试框架的时候,需要用到图片对比的方法来判断用例执行的情况,问了一下度娘,原来可以用PIL模块处理: from PIL import Image # 先安装Pillow, \>pip in ...
- [Java]java内存及数据区
Java运行时的数据区包括:(其中前两个是线程共享的) 1.方法区(Method Area) 存储已被虚拟机加载的类信息.常量.静态变量.即时编译器编译后的代码等数据 2.堆(Heap) 存放对象实例 ...
- ASP.NET WebAPI 测试文档 (Swagger)
ASP.NET WebAPI使用Swagger生成测试文档 SwaggerUI是一个简单的Restful API测试和文档工具.简单.漂亮.易用(官方demo).通过读取JSON配置显示API .项目 ...
- 大公司怎么做Android代码混淆的？
3月17日,网易资深安全工程师钟亚平在安卓巴士全球开发者论坛上做了<安卓APP逆向与保护>的演讲.其中就谈到了关于代码混淆的问题.现摘取部分重点介绍如下: Java代码是非常容易反编译 ...
- 考取RHCE认证的历程，总结的经验
昨天去考试的,今天下午结果出来了,达到了我的预期.成功的获取了RHCE认证,以后我也是有证的人咯~,开个玩笑. 其实去年的时候我就曾经想要去考取的,我原来一直以为考取RHCE认证时考题都是英文的呢?因 ...
- WPF WindowStyle为None
当WindwoStyle为None时 窗口会出现边框,不会完全覆盖窗口 修改办法: 使用AllowsTransparency="True"即可
- Echart自定义属性3
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8&quo ...
- LOJ#6038. 「雅礼集训 2017 Day5」远行（LCT）
题面 传送门 题解 要不是因为数组版的\(LCT\)跑得实在太慢我至于去学指针版的么--而且指针版的完全看不懂啊-- 首先有两个结论 1.与一个点距离最大的点为任意一条直径的两个端点之一 2.两棵树之 ...