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. SSO单点登录三种情况的实现方式详解(转载)

    单点登录(SSO——Single Sign On)对于我们来说已经不陌生了.对于大型系统来说使用单点登录可以减少用户很多的麻烦.就拿百度来说吧,百度下面有很多的子系统——百度经验.百度知道.百度文库等 ...

  2. JDBC 中 socketTimeout 的作用

    如果我们把socketTimeout设置如下: socketTimeout=60000; 这意味着60秒以内服务器必须开始给客户端吐数据,以保持socket的活性.配置成60秒,一般查询都不会遇到问题 ...

  3. datetime.date(2014, 4, 25) is not JSON serializable

    # 背景 接口期望返回json格式数据,但数据存储在mysql中,先将mysql的数据转为dict,然后将dict转为json格式,然后就报这个错误了的,原因就是时间格式转换问题 # 解决方法 1. ...

  4. Nuget~打包时添加powershell初始化脚本

    对于进行nuget打包时,有时我们需要添加一个配置文件,就是一些文本文件,而这些文件我们在网站发布时需要同时复制到输出目录,否则会出现文件丢失的问题,我们在打包时通过添加powershell脚本来解决 ...

  5. you need to be root to perform this command

    在linux 终端执行某条命令时 提示一下错误 you need to be root to perform this command 是提示要获取root权限 输入su 回车输入密码 即可解决 参考 ...

  6. sqlserver排名函数

    在做开发的时候,排名函数是sqlserver经常用到的函数,在分页的时候需要用,分组的时候也要用,主要排名函数有row-number,rank(),dense-rank(),NTILE()接下来详细说 ...

  7. django系列6--Ajax01 特点, 基本格式, 向前端发送数据

    一.Ajax了解 AJAX(Asynchronous Javascript And XML)优点是在不重新加载整个页面的情况下,可以与服务器交换数据并更新部分网页内容 优点: 1.ajax使用Java ...

  8. 在Gogland里对GO程序进行单元测试!

    单元测试在程序开发中具有很重要的作用! 1,可以保证程序代码的健壮,能够最小范围测试程序代码,从而保证程序的正确性! 2,可以通过单元测试代码快速了解当前的程序. 我在先前的几个软件公司工作时候,都对 ...

  9. 【OCP 12c】最新CUUG OCP-071考试题库(63题)

    63.(22-4) choose the best answer: View the Exhibit and examine the data in the PRODUCTS table. Which ...

  10. java使用Redis1--安装与简单使用

    环境: CentOS6.4,Redis3.0.3 一.Redis安装(需要安装gcc) 官网http://download.redis.io/releases/redis-3.0.3.tar.gz上下 ...