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网络编程(一)的更多相关文章

  1. 20145205 《Java程序设计》实验报告五:Java网络编程及安全

    20145205 <Java程序设计>实验报告五:Java网络编程及安全 实验要求 1.掌握Socket程序的编写: 2.掌握密码技术的使用: 3.客户端中输入明文,利用DES算法加密,D ...

  2. Java 网络编程学习总结

    新手一枚,Java学习中,把自己学习网络编程的知识总结一下,梳理下知识,方便日后查阅,高手莫进. 本文的主要内容: [1]    网络编程认识                [2]  TCP/IP编程 ...

  3. 20145212 实验五《Java网络编程》

    20145212 实验五<Java网络编程> 一.实验内容 1.运行下载的TCP代码,结对进行,一人服务器,一人客户端: 2.利用加解密代码包,编译运行代码,一人加密,一人解密: 3.集成 ...

  4. 20145213《Java程序设计》实验五Java网络编程及安全

    20145213<Java程序设计>实验五Java网络编程及安全 实验内容 1.掌握Socket程序的编写. 2.掌握密码技术的使用. 3.设计安全传输系统. 实验预期 1.客户端与服务器 ...

  5. 20145206《Java程序设计》实验五Java网络编程及安全

    20145206<Java程序设计>实验五 Java网络编程及安全 实验内容 1.掌握Socket程序的编写: 2.掌握密码技术的使用: 3.设计安全传输系统. 实验步骤 我和201451 ...

  6. 20145337实验五Java网络编程及安全

    20145337实验五Java网络编程及安全 实验内容 掌握Socket程序的编写 掌握密码技术的使用 设计安全传输系统 实验步骤 基于Java Socket实现安全传输 基于TCP实现客户端和服务器 ...

  7. java 网络编程复习(转)

    好久没有看过Java网络编程了,现在刚好公司有机会接触,顺便的拾起以前的东西 参照原博客:http://www.cnblogs.com/linzheng/archive/2011/01/23/1942 ...

  8. JAVA课程实验报告 实验五 Java网络编程及安全

    北京电子科技学院(BESTI) 实     验    报     告 课程:Java程序设计  班级:1353  姓名:韩玉琪  学号:20135317 成绩:             指导教师:娄嘉 ...

  9. 20145225《Java程序设计》 实验五 Java网络编程及安全

    20145225<Java程序设计> 实验五 Java网络编程及安全 实验报告 一.实验内容 基于Java Socket实现安全传输. 基于TCP实现客户端和服务器,结对编程一人负责客户端 ...

  10. Java 网络编程----基本概念

    网络现在是一个非常普遍的概念. 以下是维基百科上的解释: 网络一词有多种意义,可解作: 网络流也简称为网络(network).一般用于管道系统.交通系统.通讯系统建模. 有时特指计算机网络. 或特指其 ...

随机推荐

  1. 使用Nmap攻击靶机和使用Wireshark进行嗅探、分析

    使用Nmap攻击靶机和使用Wireshark进行嗅探.分析 在上一次课中已经对Nmap的使用.原理已经做了很多学习,这次的课更多地针对Wireshark进行学习和使用. 使用192.168.200.1 ...

  2. 用 Servlet 进行上载的原理和实现

    Servlet 是用 Java 编写的.协议和平台都独立的服务器端组件,使用请求/响应的模式,提供了一个基于 Java 的服务器解决方案.使用 Servlet 可以方便地处理在 HTML 页面表单中提 ...

  3. 测试嵌入GeoGebra网页

    使用 http://ggbstudy.top/tools/ggb2html/ 将GGB文件免费托管,然后在博客内容中点击“HTML”按钮插入GGB网页地址: <iframe src=" ...

  4. 7、Docker Container

    7.1 什么是Container 通过image创建(copy) 在Image layer之上建立一个Container layer(可读写) 类比面向对象:类和实例 Image负责APP的存储和分发 ...

  5. 介绍自己,并介绍github注册过程和初步使用

    我是一名南通大学的学生,我叫李可,学号是1413042029,班级:网络工程141,我是一名网络工程专业的学生,我一般喜欢看看课外书. 现在我介绍一下我注册github的过程: 1.登陆https:/ ...

  6. [python01] python列表,元组对比Erlang的区别总结

    数据结构是通过某种方式组织在一起的数据元素的集合,这些数据元素可以是数字,字符,甚至可以是其他的数据结构. python最基本的数据结构是sequence(序列):6种内建的序列:列表,元组,字符串, ...

  7. 三部曲搭建本地nuget服务器(图文版)

    下载Demo: 1.新建web的空项目 2.引入nuget包 3.修改配置文件config(可以默认) 运行效果:

  8. 10-09 Linux的文件系统介绍以及各种设备的说明

    Linux的文件编程 linux文件管理系统分为3部分:与文件管理有关的软件,被管理的文件,实施文件管理需要的数据结构 用C语言建立,打开,关闭文件,向文件写入和读出数据等. Linux文件系统简介 ...

  9. ES6——异步操作之Promise

    基本概念: Promise : 是 ES6 中新增的异步编程解决方案,提现在代码中他是一个对象 可以通过Promise构造函数来实例化. -new Promise(cb) ===> 实例的基本使 ...

  10. Fiddler4无法抓取HttpWebRequest本地请求的解决办法

    网上很多解决案例是如下方代码设置代理,但在我的Fiddler4环境下无效,后寻得官方处理方法证实与代理无关. HttpWebRequest request= WebRequest.Create(&qu ...