java基础(四) java运算顺序的深入解析

1. 从左往右的计算顺序


  与C/C++不同的是,在Java中,表达式的计算与结果是确定的,不受硬件与环境的影响。如:


int i = 5;
int j = (i++) + (i++) +(i++);

  在C/C++中,这个例子的运算结果将会根据不同的开发环境而不同。Turbo C下,j的值是15;在VC下,j的值是 18。


  在Java中,表达式的计算顺序是从左往右的,也就是先计算左侧的结果,再计算右侧的结果。上面的例子计算结果就一定是 18。也就是说,右侧(i++)表达式使用的 i 的值 就是 左侧(i++)表达式计算完后 i 的值,即左侧比右侧先进行运算。


看下面几个例子


@ Example 1


  int a[] = new int[]{0,0,0,0};
int i = 1;
a[i++] = i++;
System.out.println(“i=”+i);
System.out.println(Arrays.toString(a));

运行结果:



i=3
[0, 2, 0, 0]



@ Example 2


    int a[] = new int[]{0,0,0,0};
int i = 1;
a[i++] = i = 4;
System.out.println(“i=”+i);
System.out.println(Arrays.toString(a));

运行结果:



i=4
[0, 4, 0, 0]



@ Example 3


    int a[] = new int[]{0,0,0,0};
int b[] = new int[]{1,2,3,4,5};
int cc[] = a;
int i = 1;
a[++i] = (a=b)[i];
System.out.println(“i=”+i);
System.out.println(“数组a[]: “+Arrays.toString(a));
System.out.println(“数组c[]: “+Arrays.toString(cc));

运行结果:



i=2
数组a[]: [1, 2, 3, 4, 5]
数组c[]: [0, 0, 3, 0]



2. 复合运算符的计算顺序


  复合运算符有一个特点:可以自动将右侧的运算结果类型转换成左侧操作数的类型。如:


byte b += 1;    //正确
b = b+1; //错误,1是整形int,所以右侧的b+1的结果是int类型。需强制转换

所以,复合类型的表达式,如 b += 1; 是相当于:


byte b = (int)(b + 1);

  除此之外, 复合运算符也是遵守操作数从右往左计算的原则。 也就是说,在执行赋值操作之前,首先会确定左侧的操作数。


看下面的几个例子:


         int a = 1;
a += ++a;
System.out.println(a);

运行结果:



3



  根据上面的所说的,这个程序就不难理解了,先计算左侧a的值是1,然后再计算出右侧++a表达式的值是 2 ,最后便是计算 1+2 的值为 3,赋值给a。


如果还是觉得难理解的,可以写成等价的普通式子,然后从左往右计算右侧的表达式。这可能比较容易理解:


a = a + ++a;

再看一个例子,加深理解:


         int a = 5;
a *= a=2;
System.out.println(a);

运行结果:
10



作者:jinggod
出处:http://www.cnblogs.com/jinggod/p/8424880.html


Compartir

java基础(一) 深入解析基本类型

一、基本类型的简介


基本类型的两条准则:



  • Java中,如果对整数不指定类型,默认时int类型,对小数不指定类型,默认是double类型。

  • 基本类型由小到大,可以自动转换,但是由大到小,则需要强制类型转换。


所占的字节数:


byte: 1个字节;
char: 2个字节;
short: 2个字节;
int: 4个字节;
long: 8个字节;
float: 4个字节;(6位小数,指数是:10^-38~10^38; 范围:)
double: 8个字节;


char:Java中用 “\u四位十六进制的数字 (即使在注释中出现\u,后面如果
跟的不是4个16进制的数字,也会报错)”表示将字符转换成对应的unicode编 码;也可以用字符来赋值如: char c=”\u0000” ,char的默认初始化值,unicode的null字符


基本类型的后缀:


long : l 或 L
float: f 或 F;
double: d 或 D


二、类型转换


  正如前面所说的,类型由大到小,是必需强制转换。但这并不意味着需要用户手动强制转换 —— 也就是 隐式转换。隐式转换 说的透彻点就是由编译器来进行强制转换,不需要用户再去写强制转换的代码。下面的前两个小点所说的便是特殊的隐式类型转换。


本小节所讨论的类型转换是不包括 类型由小到大的转换,讨论的是其他比较容易让人迷惑的类型转换


1. int类型的字面常量转换成比int类型低的变量类型


  所谓的字面常量就是值的本身,如 5、7、“aa”等等。我们先看个例子:


public static void main(String[] args) {
int a = 8; //8是字面常量
byte b = 9; //9是字面常量
char c = 9+5;//常量表达式
short s = (short) (c+10); //变量表达式,需要显式强制转换
}

  上面的代码是经过编译的,是正确的。b是byte类型,但b=9不需要显式地手动强制转换,这是因为9是字面常量,是由JVM自动完成。
  我们再来看一下c=9+5,c是char类型,9+5得到结果是int类型,但也不需要显式地手动强制转换。这是因为 9+5是常量表达式,所以在编译期间已经由编译器计算出结果了,即经过编译后,相当于 c=14,也是字面常量,所以可以隐式转换。同理,short s = (short) (c+10); 子所以不能隐式转换,就是因为表达式不是常量表达式,包含了变量,只能在运行期间完成,所以就要手动强制转换。


整形字面常量隐式转换的限制:



  • 整形字面常量的大小超出目标类型所能表示的范围时,要手动强制类型转换。


byte b = 128;//编译错误,128超出byte类型所能表示的范围
byte c = (byte)128;//编译通过


  • 对于传参数时,必须要显式地进行强制类型转换,明确转换的类型


编译器子所以这样要求,其实为了避免 方法重载出现的隐式转换 与 小类型自动转大类型 发生冲突。


public static void main(String[] args) {
shortMethod(8);//编译错误
shortMethod((short)8); //编译通过
longMethod(8);//编译通过,因为这是小类型变成大类型,是不需要强制类型转换的
}
public static void shortMethod(short c){
System.out.println(c);
}
public static void longMethod(short l){
System.out.println(l);
}


  • char类型的特殊情况 :下面再细讲


2. 复合运算符的隐式转换


  复合运算符(+=、-=、*=、/=、%=)是可以将右边表达式的类型自动强制转换成左边的类型


public static void main(String[] args) {
int a = 8;
short s = 5;
s += a;
s += a+5;
}

  s+=a、s+=a+5;的表达式计算结果都是int类型,但都不需要手动强制转换。其实,如果是反编译这段代码的class文件,你会发现s+=a;,其实是被编译器处理成了


s=(short)(s+a)

也就是说对于所有的复合运算的隐式类型转换,其实是编译器自动添加类型转换的代码。


所以,相对于整形字面常量的隐式转换,复合运算符的隐式转换则没有任何限制因为前者只能在编译器期间发生,后者则是编译器实实在在的补全了类型转换的代码。


3. 特殊的char类型


  char类型在基本类中是一个比较特殊的存在。这种特殊性在于char类型是一个无符号类型,所以char类型与其他基本类型不是子集与父集间的关系(其他类型都是有符号的类型)。也就是说,char类型与byte、short之间的转换都需要显式的强制类型转换(小类型自动转换成大类型失败)。


  同时,由于char类型是一个无符号类型,所以对于整形字面常量的隐式转换的限制,不仅包括字面常量数值的大小不能超出2个字节,还包括字面常量数值不能为负数


 byte b = 2;
char c = 2;//编译通过
c = 100000000000;//编译不通过,超出char类型的范围
char d = -2//字面常量为负数,编译不通过
d = (char)-100;//编译通过
char f = (char)b; //编译通过,必须显式的强制类型转换
f = b;//编译不通过,不能隐式转换
int i = c;//编译通过,可以不需要强制类型转换
short s = (short) c;//编译通过,必须显式地强制类型转换

  char类型是无符号的类型,这种无符号也体现在在其转换成int类型时,也就是说,char类型在扩展时,也是按无符号的方式扩展,扩展位填0。我们来看一个例子:


public static void main(String[] args) {
short s = -5;
char c = (char)s;
System.out.println(c==s); //false
System.out.println(“(int)c = “+(int)c); //转换成int类型,值为65531
System.out.println(“(short)c = “+(short)c); //-5
System.out.println(“(int)s = “+(int)s);//-5
}

运行结果:



false
(int)c = 65531
(short)c = -5
(int)s = -5



  从上面的结果发现,char类型的c 与 short类s其实存储字节码内容是一样的,但由于前者是无符号,所以扩展成int类型的结果是 65531,而不是 -5。运算符==比较的就是他们扩展成int类型的值,所以为fasle。


对char类型的类型转换,可以总结成以下几点:



  • char类型与byte、short的相互转换,都需要显式地强类型制转换。

  • 对于数值是负数的,都需要进行显式地强制类型转换,特别是在整形字面常量的隐式转换中。

  • char类型转换成int、long类型是符合 小类型转大类型的规则,即无需要强制类型转换。


4. 运算结果的类型


  在Java中,一个运算结果的类型是与表达式中类型最高的相等,如:


char cc = 5;
float dd = 0.6f+cc;//最高类型是float,运算结果是float
float ee = (float) (0.6d+cc);//最高类型是double,运算结果也是double
int aa = 5+cc;//最高类型是int,运算结果也为int

  但是,对于最高类型是byte、short、char的运算来说,则运行结果却不是最高类型,而是int类型。看下面的例子,c、d运算的最高类型都是char,但运算结果却是int,所以需要强制类型转换。


 byte b = 2;
char a = 5;
char c = (char) (a+b);//byte+char,运算结果的类型为int,需要强制类型转换
int e = a+b;//编译通过,不需要强制类型转换,可以证明是int
char d = (char) (a+c);//char+char,
short s1 = 5;
short s2 = 6;
short s3 =(short)s1+s2;

综上所述,java的运算结果的类型有两个性质:



  • 运算结果的类型必须是int类型或int类型以上。

  • 最高类型低于int类型的,运算结果都为int类型。否则,运算结果与表达式中最高类型一致。


三、浮点数类型


1. 浮点类型的介绍


  我们都知道,long类型转换成float类型是不需要强制类型转换的,也就是说相对于flaot类型,long类型是小类型,存储的范围要更小。然而flaot只占了4个字节,而long却占了8个字节,long类型的存储空间要比float类型大。这究竟是怎么一回事,我们接下来将细细分析。


  浮点数使用 IEEE(电气和电子工程师协会)格式。 浮点数类型使用 符号位、指数、有效位数(尾数)来表示。要注意一下,尾数的最高


在java中,float 和 double 的结构如下:


|类 型|符 号 位|指 数 域|有效位域|
|-|-|-|
|float|1位|8位|23位|
|double|1位 |11位|52位|


符号位: 0为正,1为负;
指数域: 无符号的,float的偏移量为127(即float的指数范围是-126~127,),double
有效位域: 无符号的;


2. 浮点类型的两个需要注意的地方


1)存储的小数的数值可能是模糊值


public static void main(String[] args) {
double d1 = 0.1;
double d2 = 0.2;
System.out.println(d1+d2 == 0.3);
System.out.println(d1+d2);
}

运行结果:



false
0.30000000000000004



  上述的运算结果并不是错误。这是因为无法用二进制来准确地存储的0.3,这是一个无限循环的值,与10进制的1/3很相似。不只是0.3,很多小数都是无法准确地用浮点型表示,其实这是由 小数的十进制转成二进制的算法所决定的,十进制的小数要不断乘2,知道最后的结果为整数才是最后的二进制值,但这有可能怎么也得不到整数,所以最后得到的结果可能是一个 无限值 ,浮点型就无法表示了


  但是对于 整数 来说,在浮点数的有效范围内,则都是精确的。同样,也是由于转换算法:十进制的整数转成二进制的算法是不断对2求余数,所以 不会存在无限值的情况;


2)浮点数的有效位及精度


  浮点型所能表示的有效位是有限的,所以哪怕是整数,只要超出有效位数,也只能存储相似值,也就是该数值的最低有效位将会丢失,从而造精度丢失。
  float类型的二进制有效位是24位,对应十进制的7 ~ 8位数字;double类型的二进制53位,对应十进制的10 ~ 11位数字。


double、float类型 所能表示的范围比int、long类型表示的范围要广,也浮点类型属于大类型。但是,并不能完美地表整形,浮点类型的精度丢失会造成一些问题。


public static void main(String[] args) {
int a = 3000000;
int b = 30000000;
float f1 = a;
float f2 = b;
System.out.println(“3000000==3000001 “+(f1==f1+1));
System.out.println(“30000000==30000001 “+(f2==f2+1));
System.out.println(“3000000的有效二进制位数:”+ Integer.toBinaryString(a).length());
System.out.println(“30000000的有效二进制位数:”+ Integer.toBinaryString(b).length());
}

运行结果:



3000000 == 3000001  false
30000000 == 30000001  true
3000000的有效二进制位数: 22
30000000的有效二进制位数: 25



  上面的例子很好体现了精度丢失所带来的后果:30000000==30000001 的比较居然为true了。而造成这种结果的原因就是 30000000的有效二进制位数是25位,超出了float所能表示的有效位24位,最后一位就被舍去,所以就造成在刚加的1也被舍去,因此30000000的加一操作前后的浮点型表示是一样的。


  当然,并不是超出浮点型的有效位就不能精确表示,其实,主要看的是最高有效位与最低非0有效位之间的 “间隙”,如果间隙的在浮点型的有效位数内,自然可以精确表示,因为舍去的低有效位都是0,自然就无所谓了。如果上面的例子的浮点型用的是double就不会丢失精度了,因为double的精度是52位。


3)解决浮点型精度丢失的问题


  浮点型带来精度丢失的问题是很让人头痛的,所以一般情况下,在程序中是不会使用float、double来存储比较大的数据。而商业计算往往要求结果精确。《Effactive Java》书中有一句话:



float和double类型的主要设计目标是为了科学计算和工程计算



JDK为此提供了两个高精度的大数操作类给我们:BigInteger、BigDecimal。



作者:jinggod
出处:http://www.cnblogs.com/jinggod/p/8424583.html


Compartir

【带你入门】java网络编程

网络编程


网络编程对于很多的初学者来说,都是很向往的一种编程技能,但是很多的初学者却因为很长一段时间无法进入网络编程的大门而放弃了对于该部分技术的学习。


在 学习网络编程以前,很多初学者可能觉得网络编程是比较复杂的系统工程,需要了解很多和网络相关的基础知识,其实这些都不是很必需的。首先来问一个问题:你 会打手机吗?很多人可能说肯定会啊,不就是按按电话号码,拨打电话嘛,很简单的事情啊!其实初学者如果入门网络编程的话也可以做到这么简单!


网络编程就是在两个或两个以上的设备(例如计算机)之间传输数据。程序员所作的事情就是把数据发送到指定的位置,或者接收到指定的数据,这个就是狭义的网络编程范畴。在发送和接收数据时,大部分的程序设计语言都设计了专门的API实现这些功能,程序员只需要调用即可。所以,基础的网络编程可以和打电话一样简单。


下面就开始Java语言的网络编程技术学习吧。


1.1 网络概述


网络编程技术是当前一种主流的编程技术,随着联网趋势的逐步增强以及网络应用程序的大量出现,所以在实际的开发中网络编程技术获得了大量的使用。本章中以浅 显的基础知识说明和实际的案例使广大初学者能够进入网络编程技术的大门,至于以后的实际修行就要阅读进阶的书籍以及进行大量的实际练习。


1.1.1 计算机网络概述


网络编程的实质就是两个(或多个)设备(例如计算机)之间的数据传输。


按照计算机网络的定义,通过一定的物理设备将处于不同位置的计算机连接起来组成的网络,这个网络中包含的设备有:计算机、路由器、交换机等等。


其实从软件编程的角度来说,对于物理设备的理解不需要很深刻,就像你打电话时不需要很熟悉通信网络的底层实现是一样的,但是当深入到网络编程的底层时,这些基础知识是必须要补的。


路由器和交换机组成了核心的计算机网络,计算机只是这个网络上的节点以及控制等,通过光纤、网线等连接将设备连接起来,从而形成了一张巨大的计算机网络。


网络最主要的优势在于共享:共享设备和数据,现在共享设备最常见的是打印机,一个公司一般一个打印机即可,共享数据就是将大量的数据存储在一组机器中,其它的计算机通过网络访问这些数据,例如网站、银行服务器等等。


如果需要了解更多的网络硬件基础知识,可以阅读《计算机网络》教材,对于基础进行强化,这个在基础学习阶段不是必须的,但是如果想在网络编程领域有所造诣,则是一个必须的基本功。


对于网络编程来说,最主要的是计算机和计算机之间的通信,这样首要的问题就是如何找到网络上的计算机呢?这就需要了解IP地址的概念。


为了能够方便的识别网络上的每个设备,网络中的每个设备都会有一个唯一的数字标识,这个就是IP地址。在计算机网络中,现在命名IP地址的规定是IPv4协议,该协议规定每个IP地址由4个0-255之间的数字组成,例如10.0.120.34。每个接入网络的计算机都拥有唯一的IP地址,这个IP地址可能是固定的,例如网络上各种各样的服务器,也可以是动态的,例如使用ADSL拨号上网的宽带用户,无论以何种方式获得或是否是固定的,每个计算机在联网以后都拥有一个唯一的合法IP地址,就像每个手机号码一样。


但是由于IP地址不容易记忆,所以为了方便记忆,有创造了另外一个概念——域名(Domain Name),例如sohu.com等。一个IP地址可以对应多个域名,一个域名只能对应一个IP地址。域名的概念可以类比手机中的通讯簿,由于手机号码不方便记忆,所以添加一个姓名标识号码,在实际拨打电话时可以选择该姓名,然后拨打即可。


在网络中传输的数据,全部是以IP地址作为地址标识,所以在实际传输数据以前需要将域名转换为IP地址,实现这种功能的服务器称之为DNS服务器,也就是通俗的说法叫做域名解析。例如当用户在浏览器输入域名时,浏览器首先请求DNS服务器,将域名转换为IP地址,然后将转换后的IP地址反馈给浏览器,然后再进行实际的数据传输。


当DNS服务器正常工作时,使用IP地址或域名都可以很方便的找到计算机网络中的某个设备,例如服务器计算机。当DNS不正常工作时,只能通过IP地址访问该设备。所以IP地址的使用要比域名通用一些。


IP地址和域名很好的解决了在网络中找到一个计算机的问题,但是为了让一个计算机可以同时运行多个网络程序,就引入了另外一个概念——端口(port)。


在介绍端口的概念以前,首先来看一个例子,一般一个公司前台会有一个电话,每个员工会有一个分机,这样如果需要找到这个员工的话,需要首先拨打前台总机,然后转该分机号即可。这样减少了公司的开销,也方便了每个员工。在该示例中前台总机的电话号码就相当于IP地址,而每个员工的分机号就相当于端口。


有了端口的概念以后,在同一个计算机中每个程序对应唯一的端口,这样一个计算机上就可以通过端口区分发送给每个端口的数据了,换句话说,也就是一个计算机上可以并发运行多个网络程序,而不会在互相之间产生干扰。


在硬件上规定,端口的号码必须位于0-65535之间,每个端口唯一的对应一个网络程序,一个网络程序可以使用多个端口。这样一个网络程序运行在一台计算上时,不管是客户端还是服务器,都是至少占用一个端口进行网络通讯。在接收数据时,首先发送给对应的计算机,然后计算机根据端口把数据转发给对应的程序。


有了IP地址和端口的概念以后,在进行网络通讯交换时,就可以通过IP地址查找到该台计算机,然后通过端口标识这台计算机上的一个唯一的程序。这样就可以进行网络数据的交换了。


但是,进行网络编程时,只有IP地址和端口的概念还是不够的,下面就介绍一下基础的网络编程相关的软件基础知识。


1.1. 2 网络编程概述


按照前面的介绍,网络编程就是两个或多个设备之间的数据交换,其实更具体的说,网络编程就是两个或多个程序之间的数据交换,和普通的单机程序相比,网络程序最大的不同就是需要交换数据的程序运行在不同的计算机上,这样就造成了数据交换的复杂。虽然通过IP地址和端口可以找到网络上运行的一个程序,但是如果需要进行网络编程,则还需要了解网络通讯的过程。


网络通讯基于“请求-响应”模型。为了理解这个模型,先来看一个例子,经常看电视的人肯定见过审讯的场面吧,一般是这样的:


       警察:姓名

嫌疑犯:XXX

警察:性别

嫌疑犯:男

警察:年龄

嫌疑犯:29

……

在这个例子中,警察问一句,嫌疑犯回答一句,如果警察不问,则嫌疑犯保持沉默。这种一问一答的形式就是网络中的“请求-响应”模型。也就是通讯的一端发送数据,另外一端反馈数据,网络通讯都基于该模型。


在网络通讯中,第一次主动发起通讯的程序被称作客户端(Client)程序,简称客户端,而在第一次通讯中等待连接的程序被称作服务器端(Server)程序,简称服务器。一旦通讯建立,则客户端和服务器端完全一样,没有本质的区别。


由此,网络编程中的两种程序就分别是客户端和服务器端,例如QQ程序,每个QQ用户安装的都是QQ客户端程序,而QQ服务器端程序则运行在腾讯公司的机房中,为大量的QQ用户提供服务。这种网络编程的结构被称作客户端/服务器结构,也叫做Client/Server结构,简称C/S结构。


使用C/S结 构的程序,在开发时需要分别开发客户端和服务器端,这种结构的优势在于由于客户端是专门开发的,所以根据需要实现各种效果,专业点说就是表现力丰富,而服 务器端也需要专门进行开发。但是这种结构也存在着很多不足,例如通用性差,几乎不能通用等,也就是说一种程序的客户端只能和对应的服务器端通讯,而不能和 其它服务器端通讯,在实际维护时,也需要维护专门的客户端和服务器端,维护的压力比较大。


其实在运行很多程序时,没有必要使用专用的客户端,而需要使用通用的客户端,例如浏览器,使用浏览器作为客户端的结构被称作浏览器/服务器结构,也叫做Browser/Server结构,简称为B/S结构。


使用B/S结构的程序,在开发时只需要开发服务器端即可,这种结构的优势在于开发的压力比较小,不需要维护客户端。但是这种结构也存在着很多不足,例如浏览器的限制比较大,表现力不强,无法进行系统级操作等。


总之C/S结构和B/S结构是现在网络编程中常见的两种结构,B/S结构其实也就是一种特殊的C/S结构。


另外简单的介绍一下P2P(Point to Point)程序,常见的如BT、电驴等。P2P程序是一种特殊的程序,应该一个P2P程序中既包含客户端程序,也包含服务器端程序,例如BT,使用客户端程序部分连接其它的种子(服务器端),而使用服务器端向其它的BT客户端传输数据。如果这个还不是很清楚,其实P2P程序和手机是一样的,当手机拨打电话时就是使用客户端的作用,而手机处于待机状态时,可以接收到其它用户拨打的电话则起的就是服务器端的功能,只是一般的手机不能同时使用拨打电话和接听电话的功能,而P2P程序实现了该功能。


最后再介绍一个网络编程中最重要,也是最复杂的概念——协议(Protocol)。按照前面的介绍,网络编程就是运行在不同计算机中两个程序之间的数据交换。在实际进行数据交换时,为了让接收端理解该数据,计算机比较笨,什么都不懂的,那么就需要规定该数据的格式,这个数据的格式就是协议。


如 果没有理解协议的概念,那么再举一个例子,记得有个电影叫《永不消逝的电波》,讲述的是地下党通过电台发送情报的故事,这里我们不探讨电影的剧情,而只关 心电台发送的数据。在实际发报时,需要首先将需要发送的内容转换为电报编码,然后将电报编码发送出去,而接收端接收的是电报编码,如果需要理解电报的内容 则需要根据密码本翻译出该电报的内容。这里的密码本就规定了一种数据格式,这种对于网络中传输的数据格式在网络编程中就被称作协议。


那么如何来编写协议格式呢?答案是随意。只要按照这种协议格式能够生成唯一的编码,按照该编码可以唯一的解析出发送数据的内容即可。也正因为各个网络程序之间协议格式的不同,所以才导致了客户端程序都是专用的结构。


在实际的网络程序编程中,最麻烦的内容不是数据的发送和接收,因为这个功能在几乎所有的程序语言中都提供了封装好的API进行调用,最麻烦的内容就是协议的设计以及协议的生产和解析,这个才是网络编程中最核心的内容。


关于网络编程的基础知识,就介绍这里,深刻理解IP地址、端口和协议等概念,将会极大的有助于后续知识的学习。
13.1.3 网络通讯方式


在现有的网络中,网络通讯的方式主要有两种:



  • TCP(传输控制协议)方式


  • UDP(用户数据报协议)方式



为 了方便理解这两种方式,还是先来看一个例子。大家使用手机时,向别人传递信息时有两种方式:拨打电话和发送短信。使用拨打电话的方式可以保证将信息传递给 别人,因为别人接听电话时本身就确认接收到了该信息。而发送短信的方式价格低廉,使用方便,但是接收人有可能接收不到。


在网络通讯中,TCP方式就类似于拨打电话,使用该种方式进行网络通讯时,需要建立专门的虚拟连接,然后进行可靠的数据传输,如果数据发送失败,则客户端会自动重发该数据。而UDP方式就类似于发送短信,使用这种方式进行网络通讯时,不需要建立专门的虚拟连接,传输也不是很可靠,如果发送失败则客户端无法获得。


这两种传输方式都是实际的网络编程中进行使用,重要的数据一般使用TCP方式进行数据传输,而大量的非核心数据则都通过UDP方式进行传递,在一些程序中甚至结合使用这两种方式进行数据的传递。


由于TCP需要建立专用的虚拟连接以及确认传输是否正确,所以使用TCP方式的速度稍微慢一些,而且传输时产生的数据量要比UDP稍微大一些。


关于网络编程的基础知识就介绍这么多,如果需要深入了解相关知识请阅读专门的计算机网络书籍,下面开始介绍Java语言中网络编程的相关技术。


1.2 网络编程技术


前面介绍了网络编程的相关基础知识,初步建立了网络编程的概念,但是实际学习网络编程还必须使用某种程序设计语言进行代码实现,下面就介绍一下网络编程的代码实现。


1.2.1 网络编程步骤


按照前面的基础知识介绍,无论使用TCP方式还是UDP方式进行网络通讯,网络编程都是由客户端和服务器端组成。当然,B/S结构的编程中只需要实现服务器端即可。所以,下面介绍网络编程的步骤时,均以C/S结构为基础进行介绍。


说明:这里的步骤实现和语言无关,也就是说,这个步骤适用于各种语言实现,不局限于Java语言。


1.2.1.1 客户端网络编程步骤

客户端(Client)是指网络编程中首先发起连接的程序,客户端一般实现程序界面和基本逻辑实现,在进行实际的客户端编程时,无论客户端复杂还是简单,以及客户端实现的方式,客户端的编程主要由三个步骤实现:


1、 建立网络连接


客户端网络编程的第一步都是建立网络连接。在建立网络连接时需要指定连接到的服务器的IP地址和端口号,建立完成以后,会形成一条虚拟的连接,后续的操作就可以通过该连接实现数据交换了。


2、 交换数据


连接建立以后,就可以通过这个连接交换数据了。交换数据严格按照请求响应模型进行,由客户端发送一个请求数据到服务器,服务器反馈一个响应数据给客户端,如果客户端不发送请求则服务器端就不响应。


根据逻辑需要,可以多次交换数据,但是还是必须遵循请求响应模型。


3、 关闭网络连接


在数据交换完成以后,关闭网络连接,释放程序占用的端口、内存等系统资源,结束网络编程。


最基本的步骤一般都是这三个步骤,在实际实现时,步骤2会出现重复,在进行代码组织时,由于网络编程是比较耗时的操作,所以一般开启专门的现场进行网络通讯。


1.2.1.2 服务器端网络编程步骤

服务器端(Server)是指在网络编程中被动等待连接的程序,服务器端一般实现程序的核心逻辑以及数据存储等核心功能。服务器端的编程步骤和客户端不同,是由四个步骤实现,依次是:


1、 监听端口


服务器端属于被动等待连接,所以服务器端启动以后,不需要发起连接,而只需要监听本地计算机的某个固定端口即可。


这个端口就是服务器端开放给客户端的端口,服务器端程序运行的本地计算机的IP地址就是服务器端程序的IP地址。


2、 获得连接


当客户端连接到服务器端时,服务器端就可以获得一个连接,这个连接包含客户端的信息,例如客户端IP地址等等,服务器端和客户端也通过该连接进行数据交换。


一般在服务器端编程中,当获得连接时,需要开启专门的线程处理该连接,每个连接都由独立的线程实现。


3、 交换数据


服务器端通过获得的连接进行数据交换。服务器端的数据交换步骤是首先接收客户端发送过来的数据,然后进行逻辑处理,再把处理以后的结果数据发送给客户端。简单来说,就是先接收再发送,这个和客户端的数据交换数序不同。


其实,服务器端获得的连接和客户端连接是一样的,只是数据交换的步骤不同。


当然,服务器端的数据交换也是可以多次进行的。


在数据交换完成以后,关闭和客户端的连接。


4、 关闭连接


当服务器程序关闭时,需要关闭服务器端,通过关闭服务器端使得服务器监听的端口以及占用的内存可以释放出来,实现了连接的关闭。


其实服务器端编程的模型和呼叫中心的实现是类似的,例如移动的客服电话10086就是典型的呼叫中心,当一个用户拨打10086时,转接给一个专门的客服人员,由该客服实现和该用户的问题解决,当另外一个用户拨打10086时,则转接给另一个客服,实现问题解决,依次类推。


在服务器端编程时,10086这个电话号码就类似于服务器端的端口号码,每个用户就相当于一个客户端程序,每个客服人员就相当于服务器端启动的专门和客户端连接的线程,每个线程都是独立进行交互的。


这就是服务器端编程的模型,只是TCP方式是需要建立连接的,对于服务器端的压力比较大,而UDP是不需要建立连接的,对于服务器端的压力比较小罢了。


1.2.1.3 小结

总之,无论使用任何语言,任何方式进行基础的网络编程,都必须遵循固定的步骤进行操作,在熟悉了这些步骤以后,可以根据需要进行逻辑上的处理,但是还是必须遵循固定的步骤进行。


其实,基础的网络编程本身不难,也不需要很多的基础网络知识,只是由于编程的基础功能都已经由API实现,而且需要按照固定的步骤进行,所以在入门时有一定的门槛,希望下面的内容能够将你快速的带入网络编程技术的大门。


1.2.2 Java网络编程技术


Java语言是在网络环境下诞生的,所以Java语言虽然不能说是对于网络编程的支持最好的语言,但是必须说是一种对于网络编程提供良好支持的语言,使用Java语言进行网络编程将是一件比较轻松的工作。


和网络编程有关的基本API位于java.net包中,该包中包含了基本的网络编程实现,该包是网络编程的基础。该包中既包含基础的网络编程类,也包含封装后的专门处理WEB相关的处理类。在本章中,将只介绍基础的网络编程类。


首先来介绍一个基础的网络类——InetAddress类。该类的功能是代表一个IP地址,并且将IP地址和域名相关的操作方法包含在该类的内部。


关于该类的使用,下面通过一个基础的代码示例演示该类的使用,代码如下:


 package inetaddressdemo;
import java.net.;
/**
演示InetAddress类的基本使用
/
public class InetAddressDemo {
public static void main(String[] args) {
try{
//使用域名创建对象
InetAddress inet1 = InetAddress.getByName(“www.163.com”);
System.out.println(inet1);
//使用IP创建对象
InetAddress inet2 = InetAddress.getByName(“127.0.0.1”);
System.out.println(inet2);
//获得本机地址对象
InetAddress inet3 = InetAddress.getLocalHost();
System.out.println(inet3);
//获得对象中存储的域名
String host = inet3.getHostName();
System.out.println(“域名:” + host);
//获得对象中存储的IP
String ip = inet3.getHostAddress();
System.out.println(“IP:” + ip);
}catch(Exception e){}
}
}

在该示例代码中,演示了InetAddress类的基本使用,并使用了该类中的几个常用方法,该代码的执行结果是:


www.163.com/220.181.28.50
/127.0.0.1
chen/192.168.1.100
域名:chen
IP:192.168.1.100

说明:由于该代码中包含一个互联网的网址,所以运行该程序时需要联网,否则将产生异常。


在后续的使用中,经常包含需要使用InetAddress对象代表IP地址的构造方法,当然,该类的使用不是必须的,也可以使用字符串来代表IP地址进行实现。


1.2.3 TCP编程


按照前面的介绍,网络通讯的方式有TCP和UDP两种,其中TCP方式的网络通讯是指在通讯的过程中保持连接,有点类似于打电话,只需要拨打一次号码(建立一次网络连接),就可以多次通话(多次传输数据)。这样方式在实际的网络编程中,由于传输可靠,类似于打电话,如果甲给乙打电话,乙说没有听清楚让甲重复一遍,直到乙听清楚为止,实际的网络传输也是这样,如果发送的一方发送的数据接收方觉得有问题,则网络底层会自动要求发送方重发,直到接收方收到为止。


在Java语言中,对于TCP方式的网络编程提供了良好的支持,在实际实现时,以java.net.Socket类代表客户端连接,以java.net.ServerSocket类代表服务器端连接。在进行网络编程时,底层网络通讯的细节已经实现了比较高的封装,所以在程序员实际编程时,只需要指定IP地址和端口号码就可以建立连接了。正是由于这种高度的封装,一方面简化了Java语言网络编程的难度,另外也使得使用Java语言进行网络编程时无法深入到网络的底层,所以使用Java语言进行网络底层系统编程很困难,具体点说,Java语言无法实现底层的网络嗅探以及获得IP包结构等信息。但是由于Java语言的网络编程比较简单,所以还是获得了广泛的使用。


在使用TCP方式进行网络编程时,需要按照前面介绍的网络编程的步骤进行,下面分别介绍一下在Java语言中客户端和服务器端的实现步骤。


在客户端网络编程中,首先需要建立连接,在Java API中以java.net.Socket类的对象代表网络连接,所以建立客户端网络连接,也就是创建Socket类型的对象,该对象代表网络连接,示例如下:


     Socket socket1 = new Socket(“192.168.1.103”,10000);
Socket socket2 = new Socket(“www.sohu.com”,80);

上面的代码中,socket1实现的是连接到IP地址是192.168.1.103的计算机的10000号端口,而socket2实现的是连接到域名是www.sohu.com的计算机的80号端口,至于底层网络如何实现建立连接,对于程序员来说是完全透明的。如果建立连接时,本机网络不通,或服务器端程序未开启,则会抛出异常。


连接一旦建立,则完成了客户端编程的第一步,紧接着的步骤就是按照“请求-响应”模型进行网络数据交换,在Java语言中,数据传输功能由Java IO实现,也就是说只需要从连接中获得输入流和输出流即可,然后将需要发送的数据写入连接对象的输出流中,在发送完成以后从输入流中读取数据即可。示例代码如下:


     OutputStream os = socket1.getOutputStream(); //获得输出流
InputStream is = socket1.getInputStream(); //获得输入流

上面的代码中,分别从socket1这个连接对象获得了输出流和输入流对象,在整个网络编程中,后续的数据交换就变成了IO操作,也就是遵循“请求-响应”模型的规定,先向输出流中写入数据,这些数据会被系统发送出去,然后在从输入流中读取服务器端的反馈信息,这样就完成了一次数据交换过程,当然这个数据交换过程可以多次进行。


这里获得的只是最基本的输出流和输入流对象,还可以根据前面学习到的IO知识,使用流的嵌套将这些获得到的基本流对象转换成需要的装饰流对象,从而方便数据的操作。


最后当数据交换完成以后,关闭网络连接,释放网络连接占用的系统端口和内存等资源,完成网络操作,示例代码如下:


      socket1.close();

这就是最基本的网络编程功能介绍。下面是一个简单的网络客户端程序示例,该程序的作用是向服务器端发送一个字符串“Hello”,并将服务器端的反馈显示到控制台,数据交换只进行一次,当数据交换进行完成以后关闭网络连接,程序结束。实现的代码如下:


package tcp;
import java.io.;
import java.net.;
/**
简单的Socket客户端
功能为:发送字符串“Hello”到服务器端,并打印出服务器端的反馈
/
public class SimpleSocketClient {
public static void main(String[] args) {
Socket socket = null;
InputStream is = null;
OutputStream os = null;
//服务器端IP地址
String serverIP = “127.0.0.1”;
//服务器端端口号
int port = 10000;
//发送内容
String data = “Hello”;
try {
//建立连接
socket = new Socket(serverIP,port);
//发送数据
os = socket.getOutputStream();
os.write(data.getBytes());
//接收数据
is = socket.getInputStream();
byte[] b = new byte[1024];
int n = is.read(b);
//输出反馈数据
System.out.println(“服务器反馈:” + new String(b,0,n));
} catch (Exception e) {
e.printStackTrace(); //打印异常信息
}finally{
try {
//关闭流和连接
is.close();
os.close();
socket.close();
} catch (Exception e2) {}
}
}
}

在该示例代码中建立了一个连接到IP地址为127.0.0.1,端口号码为10000的TCP类型的网络连接,然后获得连接的输出流对象,将需要发送的字符串“Hello”转换为byte数组写入到输出流中,由系统自动完成将输出流中的数据发送出去,如果需要强制发送,可以调用输出流对象中的flush方法实现。在数据发送出去以后,从连接对象的输入流中读取服务器端的反馈信息,读取时可以使用IO中的各种读取方法进行读取,这里使用最简单的方法进行读取,从输入流中读取到的内容就是服务器端的反馈,并将读取到的内容在客户端的控制台进行输出,最后依次关闭打开的流对象和网络连接对象。


这是一个简单的功能示例,在该示例中演示了TCP类型的网络客户端基本方法的使用,该代码只起演示目的,还无法达到实用的级别。


如果需要在控制台下面编译和运行该代码,需要首先在控制台下切换到源代码所在的目录,然后依次输入编译和运行命令:


     javacd . SimpleSocketClient.java
java tcp.SimpleSocketClient

和下面将要介绍的SimpleSocketServer服务器端组合运行时,程序的输出结果为:


     服务器反馈:Hello

介绍完一个简单的客户端编程的示例,下面接着介绍一下TCP类型的服务器端的编写。首先需要说明的是,客户端的步骤和服务器端的编写步骤不同,所以在学习服务器端编程时注意不要和客户端混淆起来。


在服务器端程序编程中,由于服务器端实现的是被动等待连接,所以服务器端编程的第一个步骤是监听端口,也就是监听是否有客户端连接到达。实现服务器端监听的代码为:


    ServerSocket ss = new ServerSocket(10000);

该代码实现的功能是监听当前计算机的10000号端口,如果在执行该代码时,10000号端口已经被别的程序占用,那么将抛出异常。否则将实现监听。


服务器端编程的第二个步骤是获得连接。该步骤的作用是当有客户端连接到达时,建立一个和客户端连接对应的Socket连 接对象,从而释放客户端连接对于服务器端端口的占用。实现功能就像公司的前台一样,当一个客户到达公司时,会告诉前台我找某某某,然后前台就通知某某某, 然后就可以继续接待其它客户了。通过获得连接,使得客户端的连接在服务器端获得了保持,另外使得服务器端的端口释放出来,可以继续等待其它的客户端连接。 实现获得连接的代码是:


     Socket socket = ss.accept();

该代码实现的功能是获得当前连接到服务器端的客户端连接。需要说明的是accept和前面IO部分介绍的read方法一样,都是一个阻塞方法,也就是当无连接时,该方法将阻塞程序的执行,直到连接到达时才执行该行代码。另外获得的连接会在服务器端的该端口注册,这样以后就可以通过在服务器端的注册信息直接通信,而注册以后服务器端的端口就被释放出来,又可以继续接受其它的连接了。


连接获得以后,后续的编程就和客户端的网络编程类似了,这里获得的Socket类型的连接就和客户端的网络连接一样了,只是服务器端需要首先读取发送过来的数据,然后进行逻辑处理以后再发送给客户端,也就是交换数据的顺序和客户端交换数据的步骤刚好相反。这部分的内容和客户端很类似,所以就不重复了,如果还不熟悉,可以参看下面的示例代码。


最后,在服务器端通信完成以后,关闭服务器端连接。实现的代码为:


    ss.close();

这就是基本的TCP类型的服务器端编程步骤。下面以一个简单的echo服务实现为例子,介绍综合使用示例。echo的意思就是“回声”,echo服务器端实现的功能就是将客户端发送的内容再原封不动的反馈给客户端。实现的代码如下:


package tcp;
import java.io.;
import java.net.
;
/
echo服务器
功能:将客户端发送的内容反馈给客户端
/

public class SimpleSocketServer {
public static void main(String[] args) {
ServerSocket serverSocket = null;
Socket socket = null;
OutputStream os = null;
InputStream is = null;
//监听端口号
int port = 10000;
try {
//建立连接
serverSocket = new ServerSocket(port);
//获得连接
socket = serverSocket.accept();
//接收客户端发送内容
is = socket.getInputStream();
byte[] b = new byte[1024];
int n = is.read(b);
//输出
System.out.println(“客户端发送内容为:” + new String(b,0,n));
//向客户端发送反馈内容
os = socket.getOutputStream();
os.write(b, 0, n);
} catch (Exception e) {
e.printStackTrace();
}finally{
try{
//关闭流和连接
os.close();
is.close();
socket.close();
serverSocket.close();
}catch(Exception e){}
}
}
}

在该示例代码中建立了一个监听当前计算机10000号端口的服务器端Socket连接,然后获得客户端发送过来的连接,如果有连接到达时,读取连接中发送过来的内容,并将发送的内容在控制台进行输出,输出完成以后将客户端发送的内容再反馈给客户端。最后关闭流和连接对象,结束程序。


在控制台下面编译和运行该程序的命令和客户端部分的类似。


这样,就以一个很简单的示例演示了TCP类型的网络编程在Java语言中的基本实现,这个示例只是演示了网络编程的基本步骤以及各个功能方法的基本使用,只是为网络编程打下了一个基础,下面将就几个问题来深入介绍网络编程深层次的一些知识。
为了一步一步的掌握网络编程,下面再研究网络编程中的两个基本问题,通过解决这两个问题将对网络编程的认识深入一层。


1、如何复用Socket连接?


在前面的示例中,客户端中建立了一次连接,只发送一次数据就关闭了,这就相当于拨打电话时,电话打通了只对话一次就关闭了,其实更加常用的应该是拨通一次电话以后多次对话,这就是复用客户端连接。


那 么如何实现建立一次连接,进行多次数据交换呢?其实很简单,建立连接以后,将数据交换的逻辑写到一个循环中就可以了。这样只要循环不结束则连接就不会被关 闭。按照这种思路,可以改造一下上面的代码,让该程序可以在建立连接一次以后,发送三次数据,当然这里的次数也可以是多次,示例代码如下:


package tcp;
import java.io.;
import java.net.*;
/
复用连接的Socket客户端
功能为:发送字符串“Hello”到服务器端,并打印出服务器端的反馈
/

public class MulSocketClient {
public static void main(String[] args) {
Socket socket = null;
InputStream is = null;
OutputStream os = null;
//服务器端IP地址
String serverIP = “127.0.0.1”;
//服务器端端口号
int port = 10000;
//发送内容
String data[] ={“First”,“Second”,“Third”};
try {
//建立连接
socket = new Socket(serverIP,port);
//初始化流
os = socket.getOutputStream();
is = socket.getInputStream();
byte[] b = new byte[1024];
for(int i = 0;i < data.length;i++){
//发送数据
os.write(data[i].getBytes());
//接收数据
int n = is.read(b);
//输出反馈数据
System.out.println(“服务器反馈:” + new String(b,0,n));
}
} catch (Exception e) {
e.printStackTrace(); //打印异常信息
}finally{
try {
//关闭流和连接
is.close();
os.close();
socket.close();
} catch (Exception e2) {}
}
}
}

该示例程序和前面的代码相比,将数据交换部分的逻辑写在一个for循环的内容,这样就可以建立一次连接,依次将data数组中的数据按照顺序发送给服务器端了。


如果还是使用前面示例代码中的服务器端程序运行该程序,则该程序的结果是:


java.net.SocketException: Software caused connection abort: recv failed
at java.net.SocketInputStream.socketRead0(Native Method)
at java.net.SocketInputStream.read(SocketInputStream.java:129)
at java.net.SocketInputStream.read(SocketInputStream.java:90)
at tcp.MulSocketClient.main(MulSocketClient.java:30)
服务器反馈:First

显然,客户端在实际运行时出现了异常,出现异常的原因是什么呢?如果仔细阅读前面的代码,应该还记得前面示例代码中的服务器端是对话一次数据以后就关闭了连接,如果服务器端程序关闭了,客户端继续发送数据肯定会出现异常,这就是出现该问题的原因。


按照客户端实现的逻辑,也可以复用服务器端的连接,实现的原理也是将服务器端的数据交换逻辑写在循环中即可,按照该种思路改造以后的服务器端代码为:


package tcp;
import java.io.;
import java.net.;
/**
复用连接的echo服务器
功能:将客户端发送的内容反馈给客户端
/
public class MulSocketServer {
public static void main(String[] args) {
ServerSocket serverSocket = null;
Socket socket = null;
OutputStream os = null;
InputStream is = null;
//监听端口号
int port = 10000;
try {
//建立连接
serverSocket = new ServerSocket(port);
System.out.println(“服务器已启动:”);
//获得连接
socket = serverSocket.accept();
//初始化流
is = socket.getInputStream();
os = socket.getOutputStream();
byte[] b = new byte[1024];
for(int i = 0;i < 3;i++){
int n = is.read(b);
//输出
System.out.println(“客户端发送内容为:” + new String(b,0,n));
//向客户端发送反馈内容
os.write(b, 0, n);
}
} catch (Exception e) {
e.printStackTrace();
}finally{
try{
//关闭流和连接
os.close();
is.close();
socket.close();
serverSocket.close();
}catch(Exception e){}
}
}
}

在该示例代码中,也将数据发送和接收的逻辑写在了一个for循环内部,只是在实现时硬性的将循环次数规定成了3次,这样代码虽然比较简单,但是通用性比较差。


以该服务器端代码实现为基础运行前面的客户端程序时,客户端的输出为:


服务器反馈:First

服务器反馈:Second

服务器反馈:Third

服务器端程序的输出结果为:


服务器已启动:

客户端发送内容为:First

客户端发送内容为:Second

客户端发送内容为:Third

在该程序中,比较明显的体现出了“请求-响应”模型,也就是在客户端发起连接以后,首先发送字符串“First”给服务器端,服务器端输出客户端发送的内容“First”,然后将客户端发送的内容再反馈给客户端,这样客户端也输出服务器反馈“First”,这样就完成了客户端和服务器端的一次对话,紧接着客户端发送“Second”给服务器端,服务端输出“Second”,然后将“Second”再反馈给客户端,客户端再输出“Second”,从而完成第二次会话,第三次会话的过程和这个一样。在这个过程中,每次都是客户端程序首先发送数据给服务器端,服务器接收数据以后,将结果反馈给客户端,客户端接收到服务器端的反馈,从而完成一次通讯过程。


在该示例中,虽然解决了多次发送的问题,但是客户端和服务器端的次数控制还不够灵活,如果客户端的次数不固定怎么办呢?是否可以使用某个特殊的字符串,例如quit,表示客户端退出呢,这就涉及到网络协议的内容了,会在后续的网络应用示例部分详细介绍。下面开始介绍另外一个网络编程的突出问题。


2、如何使服务器端支持多个客户端同时工作?


前面介绍的服务器端程序,只是实现了概念上的服务器端,离实际的服务器端程序结构距离还很遥远,如果需要让服务器端能够实际使用,那么最需要解决的问题就是——如何支持多个客户端同时工作。


一个服务器端一般都需要同时为多个客户端提供通讯,如果需要同时支持多个客户端,则必须使用前面介绍的线程的概念。简单来说,也就是当服务器端接收到一个连接时,启动一个专门的线程处理和该客户端的通讯。


按照这个思路改写的服务端示例程序将由两个部分组成,MulThreadSocketServer类实现服务器端控制,实现接收客户端连接,然后开启专门的逻辑线程处理该连接,LogicThread类实现对于一个客户端连接的逻辑处理,将处理的逻辑放置在该类的run方法中。该示例的代码实现为:


package tcp;
import java.net.ServerSocket;
import java.net.Socket;
/
支持多客户端的服务器端实现
/

public class MulThreadSocketServer {
public static void main(String[] args) {
ServerSocket serverSocket = null;
Socket socket = null;
//监听端口号
int port = 10000;
try {
//建立连接
serverSocket = new ServerSocket(port);
System.out.println(“服务器已启动:”);
while(true){
//获得连接
socket = serverSocket.accept();
//启动线程
new LogicThread(socket);
}
} catch (Exception e) {
e.printStackTrace();
}finally{
try{
//关闭连接
serverSocket.close();
}catch(Exception e){}
}
}
}

在该示例代码中,实现了一个while形式的死循环,由于accept方法是阻塞方法,所以当客户端连接未到达时,将阻塞该程序的执行,当客户端到达时接收该连接,并启动一个新的LogicThread线程处理该连接,然后按照循环的执行流程,继续等待下一个客户端连接。这样当任何一个客户端连接到达时,都开启一个专门的线程处理,通过多个线程支持多个客户端同时处理。


下面再看一下LogicThread线程类的源代码实现:


package tcp;
import java.io.;
import java.net.
;
/
服务器端逻辑线程
/

public class LogicThread extends Thread {
Socket socket;
InputStream is;
OutputStream os;
public LogicThread(Socket socket){
this.socket = socket;
start(); //启动线程
}
public void run(){
byte[] b = new byte[1024];
try{
//初始化流
os = socket.getOutputStream();
is = socket.getInputStream();
for(int i = 0;i < 3;i++){
//读取数据
int n = is.read(b);
//逻辑处理
byte[] response = logic(b,0,n);
//反馈数据
os.write(response);
}
}catch(Exception e){
e.printStackTrace();
}finally{
close();
}
}
/
关闭流和连接
/

private void close(){
try{
//关闭流和连接
os.close();
is.close();
socket.close();
}catch(Exception e){}
}
/
逻辑处理方法,实现echo逻辑
@param b 客户端发送数据缓冲区
@param off 起始下标
@param len 有效数据长度
@return
/

private byte[] logic(byte[] b,int off,int len){
byte[] response = new byte[len];
//将有效数据拷贝到数组response中
System.arraycopy(b, 0, response, 0, len);
return response;
}
}

在该示例代码中,每次使用一个连接对象构造该线程,该连接对象就是该线程需要处理的连接,在线程构造完成以后,该线程就被启动起来了,然后在run方法内部对客户端连接进行处理,数据交换的逻辑和前面的示例代码一致,只是这里将接收到客户端发送过来的数据并进行处理的逻辑封装成了logic方法,按照前面介绍的IO编程的内容,客户端发送过来的内容存储在数组b的起始下标为0,长度为n个中,这些数据是客户端发送过来的有效数据,将有效的数据传递给logic方法,logic方法实现的是echo服务的逻辑,也就是将客户端发送的有效数据形成以后新的response数组,并作为返回值反馈。


在线程中将logic方法的返回值反馈给客户端,这样就完成了服务器端的逻辑处理模拟,其他的实现和前面的介绍类似,这里就不在重复了。


这里的示例还只是基础的服务器端实现,在实际的服务器端实现中,由于硬件和端口数的限制,所以不能无限制的创建线程对象,而且频繁的创建线程对象效率也比较低,所以程序中都实现了线程池来提高程序的执行效率。


这里简单介绍一下线程池的概念,线程池(Thread pool)是池技术的一种,就是在程序启动时首先把需要个数的线程对象创建好,例如创建5000个线程对象,然后当客户端连接到达时从池中取出一个已经创建完成的线程对象使用即可。当客户端连接关闭以后,将该线程对象重新放入到线程池中供其它的客户端重复使用,这样可以提高程序的执行速度,优化程序对于内存的占用等。


关于基础的TCP方式的网络编程就介绍这么多,下面介绍UDP方式的网络编程在Java语言中的实现。


网络通讯的方式除了TCP方式以外,还有一种实现的方式就是UDP方式。UDP(User Datagram Protocol),中文意思是用户数据报协议,方式类似于发短信息,是一种物美价廉的通讯方式,使用该种方式无需建立专用的虚拟连接,由于无需建立专用的连接,所以对于服务器的压力要比TCP小很多,所以也是一种常见的网络编程方式。但是使用该种方式最大的不足是传输不可靠,当然也不是说经常丢失,就像大家发短信息一样,理论上存在收不到的可能,这种可能性可能是1%,反正比较小,但是由于这种可能的存在,所以平时我们都觉得重要的事情还是打个电话吧(类似TCP方式),一般的事情才发短信息(类似UDP方式)。网络编程中也是这样,必须要求可靠传输的信息一般使用TCP方式实现,一般的数据才使用UDP方式实现。


UDP方式的网络编程也在Java语言中获得了良好的支持,由于其在传输数据的过程中不需要建立专用的连接等特点,所以在Java API中设计的实现结构和TCP方式不太一样。当然,需要使用的类还是包含在java.net包中。


在Java API中,实现UDP方式的编程,包含客户端网络编程和服务器端网络编程,主要由两个类实现,分别是:


DatagramSocket


DatagramSocket类实现“网络连接”,包括客户端网络连接和服务器端网络连接。虽然UDP方式的网络通讯不需要建立专用的网络连接,但是毕竟还是需要发送和接收数据,DatagramSocket实现的就是发送数据时的发射器,以及接收数据时的监听器的角色。类比于TCP中的网络连接,该类既可以用于实现客户端连接,也可以用于实现服务器端连接。


DatagramPacket


DatagramPacket类实现对于网络中传输的数据封装,也就是说,该类的对象代表网络中交换的数据。在UDP方式的网络编程中,无论是需要发送的数据还是需要接收的数据,都必须被处理成DatagramPacket类型的对象,该对象中包含发送到的地址、发送到的端口号以及发送的内容等。其实DatagramPacket类的作用类似于现实中的信件,在信件中包含信件发送到的地址以及接收人,还有发送的内容等,邮局只需要按照地址传递即可。在接收数据时,接收到的数据也必须被处理成DatagramPacket类型的对象,在该对象中包含发送方的地址、端口号等信息,也包含数据的内容。和TCP方式的网络传输相比,IO编程在UDP方式的网络编程中变得不是必须的内容,结构也要比TCP方式的网络编程简单一些。


下面介绍一下UDP方式的网络编程中,客户端和服务器端的实现步骤,以及通过基础的示例演示UDP方式的网络编程在Java语言中的实现方式。


UDP方式的网络编程,编程的步骤和TCP方式类似,只是使用的类和方法存在比较大的区别,下面首先介绍一下UDP方式的网络编程客户端实现过程。


UDP客户端编程涉及的步骤也是4个部分:建立连接、发送数据、接收数据和关闭连接。


首先介绍UDP方式的网络编程中建立连接的实现。其中UDP方式的建立连接和TCP方式不同,只需要建立一个连接对象即可,不需要指定服务器的IP和端口号码。实现的代码为:


     DatagramSocket ds = new DatagramSocket();

这样就建立了一个客户端连接,该客户端连接使用系统随机分配的一个本地计算机的未用端口号。在该连接中,不指定服务器端的IP和端口,所以UDP方式的网络连接更像一个发射器,而不是一个具体的连接。


当然,可以通过制定连接使用的端口号来创建客户端连接。


                   DatagramSocket ds = new DatagramSocket(5000);

这样就是使用本地计算机的5000号端口建立了一个连接。一般在建立客户端连接时没有必要指定端口号码。


接着,介绍一下UDP客户端编程中发送数据的实现。在UDP方式的网络编程中,IO技术不是必须的,在发送数据时,需要将需要发送的数据内容首先转换为byte数组,然后将数据内容、服务器IP和服务器端口号一起构造成一个DatagramPacket类型的对象,这样数据的准备就完成了,发送时调用网络连接对象中的send方法发送该对象即可。例如将字符串“Hello”发送到IP是127.0.0.1,端口号是10001的服务器,则实现发送数据的代码如下:


      String s = “Hello”;
String host = “127.0.0.1”;
int port = 10001;
//将发送的内容转换为byte数组
byte[] b = s.getBytes();
//将服务器IP转换为InetAddress对象
InetAddress server = InetAddress.getByName(host);
//构造发送的数据包对象
DatagramPacket sendDp = new DatagramPacket(b,b.length,server,port);
//发送数据
ds.send(sendDp);

在该示例代码中,不管发送的数据内容是什么,都需要转换为byte数组,然后将服务器端的IP地址构造成InetAddress类型的对象,在准备完成以后,将这些信息构造成一个DatagramPacket类型的对象,在UDP编程中,发送的数据内容、服务器端的IP和端口号,都包含在DatagramPacket对象中。在准备完成以后,调用连接对象ds的send方法把DatagramPacket对象发送出去即可。


按照UDP协议的约定,在进行数据传输时,系统只是尽全力传输数据,但是并不保证数据一定被正确传输,如果数据在传输过程中丢失,那就丢失了。


UDP方式在进行网络通讯时,也遵循“请求-响应”模型,在发送数据完成以后,就可以接收服务器端的反馈数据了。


下面介绍一下UDP客户端编程中接收数据的实现。当数据发送出去以后,就可以接收服务器端的反馈信息了。接收数据在Java语言中的实现是这样的:首先构造一个数据缓冲数组,该数组用于存储接收的服务器端反馈数据,该数组的长度必须大于或等于服务器端反馈的实际有效数据的长度。然后以该缓冲数组为基础构造一个DatagramPacket数据包对象,最后调用连接对象的receive方法接收数据即可。接收到的服务器端反馈数据存储在DatagramPacket类型的对象内部。实现接收数据以及显示服务器端反馈内容的示例代码如下:


     //构造缓冲数组
byte[] data = new byte[1024];
//构造数据包对象
DatagramPacket received = new DatagramPacket(data,data.length);
//接收数据
ds.receive(receiveDp);
//输出数据内容
byte[] b = receiveDp.getData(); //获得缓冲数组
int len = receiveDp.getLength(); //获得有效数据长度
String s = new String(b,0,len);
System.out.println(s);

在该代码中,首先构造缓冲数组data,这里设置的长度1024是预估的接收到的数据长度,要求该长度必须大于或等于接收到的数据长度,然后以该缓冲数组为基础,构造数据包对象,使用连接对象ds的receive方法接收反馈数据,由于在Java语言中,除String以外的其它对象都是按照地址传递,所以在receive方法内部可以改变数据包对象receiveDp的内容,这里的receiveDp的功能和返回值类似。数据接收到以后,只需要从数据包对象中读取出来就可以了,使用DatagramPacket对象中的getData方法可以获得数据包对象的缓冲区数组,但是缓冲区数组的长度一般大于有效数据的长度,换句话说,也就是缓冲区数组中只有一部分数据是反馈数据,所以需要使用DatagramPacket对象中的getLength方法获得有效数据的长度,则有效数据就是缓冲数组中的前有效数据长度个内容,这些才是真正的服务器端反馈的数据的内容。


UDP方式客户端网络编程的最后一个步骤就是关闭连接。虽然UDP方式不建立专用的虚拟连接,但是连接对象还是需要占用系统资源,所以在使用完成以后必须关闭连接。关闭连接使用连接对象中的close方法即可,实现的代码如下:


                   ds.close();

需要说明的是,和TCP建立连接的方式不同,UDP方式的同一个网络连接对象,可以发送到达不同服务器端IP或端口的数据包,这点是TCP方式无法做到的。


介绍完了UDP方式客户端网络编程的基础知识以后,下面再来介绍一下UDP方式服务器端网络编程的基础知识。


UDP方式网络编程的服务器端实现和TCP方式的服务器端实现类似,也是服务器端监听某个端口,然后获得数据包,进行逻辑处理以后将处理以后的结果反馈给客户端,最后关闭网络连接,下面依次进行介绍。


首先UDP方式服务器端网络编程需要建立一个连接,该连接监听某个端口,实现的代码为:


    DatagramSocket ds = new DatagramSocket(10010);

由于服务器端的端口需要固定,所以一般在建立服务器端连接时,都指定端口号。例如该示例代码中指定10010端口为服务器端使用的端口号,客户端端在连接服务器端时连接该端口号即可。


接着服务器端就开始接收客户端发送过来的数据,其接收的方法和客户端接收的方法一直,其中receive方法的作用类似于TCP方式中accept方法的作用,该方法也是一个阻塞方法,其作用是接收数据。


接收到客户端发送过来的数据以后,服务器端对该数据进行逻辑处理,然后将处理以后的结果再发送给客户端,在这里发送时就比客户端要麻烦一些,因为服务器端需要获得客户端的IP和客户端使用的端口号,这个都可以从接收到的数据包中获得。示例代码如下:


    //获得客户端的IP
InetAddress clientIP = receiveDp.getAddress();
//获得客户端的端口号
Int clientPort = receiveDp.getPort();

使用以上代码,就可以从接收到的数据包对象receiveDp中获得客户端的IP地址和客户端的端口号,这样就可以在服务器端中将处理以后的数据构造成数据包对象,然后将处理以后的数据内容反馈给客户端了。


最后,当服务器端实现完成以后,关闭服务器端连接,实现的方式为调用连接对象的close方法,示例代码如下:


      ds.close();

介绍完了UDP方式下的客户端编程和服务器端编程的基础知识以后,下面通过一个简单的示例演示UDP网络编程的基本使用。


该示例的功能是实现将客户端程序的系统时间发送给服务器端,服务器端接收到时间以后,向客户端反馈字符串“OK”。实现该功能的客户端代码如下所示:


package udp;
import java.net.;
import java.util.
;
/
简单的UDP客户端,实现向服务器端发生系统时间功能
/

public class SimpleUDPClient {
public static void main(String[] args) {
DatagramSocket ds = null; //连接对象
DatagramPacket sendDp; //发送数据包对象
DatagramPacket receiveDp; //接收数据包对象
String serverHost = “127.0.0.1”; //服务器IP
int serverPort = 10010; //服务器端口号
try{
//建立连接
ds = new DatagramSocket();
//初始化发送数据
Date d = new Date(); //当前时间
String content = d.toString(); //转换为字符串
byte[] data = content.getBytes();
//初始化发送包对象
InetAddress address = InetAddress.getByName(serverHost);
sendDp = new DatagramPacket(data,data.length,address,serverPort);
//发送
ds.send(sendDp);
//初始化接收数据
byte[] b = new byte[1024];
receiveDp = new DatagramPacket(b,b.length);
//接收
ds.receive(receiveDp);
//读取反馈内容,并输出
byte[] response = receiveDp.getData();
int len = receiveDp.getLength();
String s = new String(response,0,len);
System.out.println(“服务器端反馈为:” + s);
}catch(Exception e){
e.printStackTrace();
}finally{
try{
//关闭连接
ds.close();
}catch(Exception e){}
}
}
}

在该示例代码中,首先建立UDP方式的网络连接,然后获得当前系统时间,这里获得的系统时间是客户端程序运行的本地计算机的时间,然后将时间字符串以及服务器端的IP和端口,构造成发送数据包对象,调用连接对象ds的send方法发送出去。在数据发送出去以后,构造接收数据的数据包对象,调用连接对象ds的receive方法接收服务器端的反馈,并输出在控制台。最后在finally语句块中关闭客户端网络连接。


和下面将要介绍的服务器端一起运行时,客户端程序的输出结果为:


  服务器端反馈为:OK

下面是该示例程序的服务器端代码实现:


      package udp;
import java.net.*;
/
简单UDP服务器端,实现功能是输出客户端发送数据,
并反馈字符串“OK”给客户端
/

public class SimpleUDPServer {
public static void main(String[] args) {
DatagramSocket ds = null; //连接对象
DatagramPacket sendDp; //发送数据包对象
DatagramPacket receiveDp; //接收数据包对象
final int PORT = 10010; //端口
try{
//建立连接,监听端口
ds = new DatagramSocket(PORT);
System.out.println(“服务器端已启动:”);
//初始化接收数据
byte[] b = new byte[1024];
receiveDp = new DatagramPacket(b,b.length);
//接收
ds.receive(receiveDp);
//读取反馈内容,并输出
InetAddress clientIP = receiveDp.getAddress();
int clientPort = receiveDp.getPort();
byte[] data = receiveDp.getData();
int len = receiveDp.getLength();
System.out.println(“客户端IP:” + clientIP.getHostAddress());
System.out.println(“客户端端口:” + clientPort);
System.out.println(“客户端发送内容:” + new String(data,0,len));
//发送反馈
String response = “OK”;
byte[] bData = response.getBytes();
sendDp = new DatagramPacket(bData,bData.length,clientIP,clientPort);
//发送
ds.send(sendDp);
}catch(Exception e){
e.printStackTrace();
}finally{
try{
//关闭连接
ds.close();
}catch(Exception e){}
}
}
}

在该服务器端实现中,首先监听10010号端口,和TCP方式的网络编程类似,服务器端的receive方法是阻塞方法,如果客户端不发送数据,则程序会在该方法处阻塞。当客户端发送数据到达服务器端时,则接收客户端发送过来的数据,然后将客户端发送的数据内容读取出来,并在服务器端程序中打印客户端的相关信息,从客户端发送过来的数据包中可以读取出客户端的IP以及客户端端口号,将反馈数据字符串“OK”发送给客户端,最后关闭服务器端连接,释放占用的系统资源,完成程序功能示例。


和前面TCP方式中的网络编程类似,这个示例也仅仅是网络编程的功能示例,也存在前面介绍的客户端无法进行多次数据交换,以及服务器端不支持多个客户端的问题,这两个问题也需要对于代码进行处理才可以很方便的进行解决。


在解决该问题以前,需要特别指出的是UDP方式的网络编程由于不建立虚拟的连接,所以在实际使用时和TCP方式存在很多的不同,最大的一个不同就是“无状态”。该特点指每次服务器端都收到信息,但是这些信息和连接无关,换句话说,也就是服务器端只是从信息是无法识别出是谁发送的,这样就要求发送信息时的内容需要多一些,这个在后续的示例中可以看到。


下面是实现客户端多次发送以及服务器端支持多个数据包同时处理的程序结构,实现的原理和TCP方式类似,在客户端将数据的发送和接收放入循环中,而服务器端则将接收到的每个数据包启动一个专门的线程进行处理。实现的代码如下:


 package udp;
import java.net.;
import java.util.
;
/
简单的UDP客户端,实现向服务器端发生系统时间功能
该程序发送3次数据到服务器端
/

public class MulUDPClient {
public static void main(String[] args) {
DatagramSocket ds = null; //连接对象
DatagramPacket sendDp; //发送数据包对象
DatagramPacket receiveDp; //接收数据包对象
String serverHost = “127.0.0.1”; //服务器IP
int serverPort = 10012; //服务器端口号
try{
//建立连接
ds = new DatagramSocket();
//初始化
InetAddress address = InetAddress.getByName(serverHost);
byte[] b = new byte[1024];
receiveDp = new DatagramPacket(b,b.length);
System.out.println(“客户端准备完成”);
//循环30次,每次间隔0.01秒
for(int i = 0;i < 30;i++){
//初始化发送数据
Date d = new Date(); //当前时间
String content = d.toString(); //转换为字符串
byte[] data = content.getBytes();
//初始化发送包对象
sendDp = new DatagramPacket(data,data.length,address, serverPort);
//发送
ds.send(sendDp);
//延迟
Thread.sleep(10);
//接收
ds.receive(receiveDp);
//读取反馈内容,并输出
byte[] response = receiveDp.getData();
int len = receiveDp.getLength();
String s = new String(response,0,len);
System.out.println(“服务器端反馈为:” + s);
}
}catch(Exception e){
e.printStackTrace();
}finally{
try{
//关闭连接
ds.close();
}catch(Exception e){}
}
}
}

在该示例中,将和服务器端进行数据交换的逻辑写在一个for循环的内部,这样就可以实现和服务器端的多次交换了,考虑到服务器端的响应速度,在每次发送之间加入0.01秒的时间间隔。最后当数据交换完成以后关闭连接,结束程序。


实现该逻辑的服务器端程序代码如下:


package udp;
import java.net.;
/
可以并发处理数据包的服务器端
功能为:显示客户端发送的内容,并向客户端反馈字符串“OK”
/

public class MulUDPServer {
public static void main(String[] args) {
DatagramSocket ds = null; //连接对象
DatagramPacket receiveDp; //接收数据包对象
final int PORT = 10012; //端口
byte[] b = new byte[1024];
receiveDp = new DatagramPacket(b,b.length);
try{
//建立连接,监听端口
ds = new DatagramSocket(PORT);
System.out.println(“服务器端已启动:”);
while(true){
//接收
ds.receive(receiveDp);
//启动线程处理数据包
new LogicThread(ds,receiveDp);
}
}catch(Exception e){
e.printStackTrace();
}finally{
try{
//关闭连接
ds.close();
}catch(Exception e){}
}
}
}

该代码实现了服务器端的接收逻辑,使用一个循环来接收客户端发送过来的数据包,当接收到数据包以后启动一个LogicThread线程处理该数据包。这样服务器端就可以实现同时处理多个数据包了。


实现逻辑处理的线程代码如下:


package udp;
import java.net.;
/
逻辑处理线程
/

public class LogicThread extends Thread {
/连接对象/
DatagramSocket ds;
/**接收到的数据包/
DatagramPacket dp;
public LogicThread(DatagramSocket ds,DatagramPacket dp){
this.ds = ds;
this.dp = dp;
start(); //启动线程
}
public void run(){
try{
//获得缓冲数组
byte[] data = dp.getData();
//获得有效数据长度
int len = dp.getLength();
//客户端IP
InetAddress clientAddress = dp.getAddress();
//客户端端口
int clientPort = dp.getPort();
//输出
System.out.println(“客户端IP:” + clientAddress.getHostAddress());
System.out.println(“客户端端口号:” + clientPort);
System.out.println(“客户端发送内容:” + new String(data,0,len));
//反馈到客户端
byte[] b = “OK”.getBytes();
DatagramPacket sendDp = new DatagramPacket(b,b.length,clientAddress,clientPort);
//发送
ds.send(sendDp);
}catch(Exception e){
e.printStackTrace();
}
}
}

在该线程中,只处理一次UDP通讯,当通讯结束以后线程死亡,在线程内部,每次获得客户端发送过来的信息,将获得的信息输出到服务器端程序的控制台,然后向客户端反馈字符串“OK”。


由于UDP数据传输过程中可能存在丢失,所以在运行该程序时可能会出现程序阻塞的情况。如果需要避免该问题,可以将客户端的网络发送部分也修改成线程实现。


关于基础的UDP网络编程就介绍这么多了,下面将介绍一下网络协议的概念。


网络协议


对于需要从事网络编程的程序员来说,网络协议是一个需要深刻理解的概念。那么什么是网络协议呢?


网络协议是指对于网络中传输的数据格式的规定。对于网络编程初学者来说,没有必要深入了解TCP/IP协议簇,所以对于初学者来说去读大部头的《TCP/IP协议》也不是一件很合适的事情,因为深入了解TCP/IP协议是网络编程提高阶段,也是深入网络编程底层时才需要做的事情。


对于一般的网络编程来说,更多的是关心网络上传输的逻辑数据内容,也就是更多的是应用层上的网络协议,所以后续的内容均以实际应用的数据为基础来介绍网络协议的概念。


那么什么是网络协议呢,下面看一个简单的例子。春节晚会上“小沈阳”和赵本山合作的小品《不差钱》中,小沈阳和赵本山之间就设计了一个协议,协议的内容为:


       如果点的菜价钱比较贵是,就说没有。

按照该协议的规定,就有了下面的对话:


       赵本山:4斤的龙虾

小沈阳:(经过判断,得出价格比较高),没有

赵本山:鲍鱼

小沈阳:(经过判断,得出价格比较高),没有

这就是一种双方达成的一种协议约定,其实这种约定的实质和网络协议的实质是一样的。网络协议的实质也是客户端程序和服务器端程序对于数据的一种约定,只是由于以计算机为基础,所以更多的是使用数字来代表内容,这样就显得比较抽象一些。


下 面再举一个简单的例子,介绍一些基础的网络协议设计的知识。例如需要设计一个简单的网络程序:网络计算器。也就是在客户端输入需要计算的数字和运算符,在 服务器端实现计算,并将计算的结果反馈给客户端。在这个例子中,就需要约定两个数据格式:客户端发送给服务器端的数据格式,以及服务器端反馈给客户端的数 据格式。


可能你觉得这个比较简单,例如客户端输入的数字依次是12和432,输入的运算符是加号,可能最容易想到的数据格式是形成字符串“12+432”,这样格式的确比较容易阅读,但是服务器端在进行计算时,逻辑就比较麻烦,因为需要首先拆分该字符串,然后才能进行计算,所以可用的数据格式就有了一下几种:


          “12,432,+”     格式为:第一个数字,第二个数字,运算符

“12,+,432” 格式为:第一个数字,运算符,第二个数字

其实以上两种数据格式很接近,比较容易阅读,在服务器端收到该数据格式以后,使用“,”为分隔符分割字符串即可。


假设对于运算符再进行一次约定,例如约定数字0代表+,1代表减,2代表乘,3代表除,整体格式遵循以上第一种格式,则上面的数字生产的协议数据为:


      “12,432,0”

这就是一种基本的发送的协议约定了。


另 外一个需要设计的协议格式就是服务器端反馈的数据格式,其实服务器端主要反馈计算结果,但是在实际接受数据时,有可能存在格式错误的情况,这样就需要简单 的设计一下服务器端反馈的数据格式了。例如规定,如果发送的数据格式正确,则反馈结果,否则反馈字符串“错误”。这样就有了以下的数据格式:


     客户端:“1,111,1”         服务器端:”-110”

客户端:“123,23,0” 服务器端:“146”

客户端:“1,2,5” 服务器端:“错误”

这样就设计出了一种最最基本的网络协议格式,从该示例中可以看出,网络协议就是一种格式上的约定,可以根据逻辑的需要约定出各种数据格式,在进行设计时一般遵循“简单、通用、容易解析”的原则进行。


而对于复杂的网络程序来说,需要传输的数据种类和数据量都比较大,这样只需要依次设计出每种情况下的数据格式即可,例如QQ程序,在该程序中需要进行传输的网络数据种类很多,那么在设计时就可以遵循:登录格式、注册格式、发送消息格式等等,一一进行设计即可。所以对于复杂的网络程序来说,只是增加了更多的命令格式,在实际设计时的工作量增加不是太大。


不管怎么说,在网络编程中,对于同一个网络程序来说,一般都会涉及到两个网络协议格式:客户端发送数据格式和服务器端反馈数据格式,在实际设计时,需要一一对应。这就是最基本的网络协议的知识。


网络协议设计完成以后,在进行网络编程时,就需要根据设计好的协议格式,在程序中进行对应的编码了,客户端程序和服务器端程序需要进行协议处理的代码分别如下。


客户端程序需要完成的处理为:



  • 客户端发送协议格式的生成


  • 服务器端反馈数据格式的解析



服务器端程序需要完成的处理为:



  • 服务器端反馈协议格式的生成


  • 客户端发送协议格式的解析



这里的生成是指将计算好的数据,转换成规定的数据格式,这里的解析指,从反馈的数据格式中拆分出需要的数据。在进行对应的代码编写时,严格遵循协议约定即可。


所以,对于程序员来说,在进行网络程序编写时,需要首先根据逻辑的需要设计网络协议格式,然后遵循协议格式约定进行协议生成和解析代码的编写,最后使用网络编程技术实现整个网络编程的功能。


由于各种网络程序使用不同的协议格式,所以不同网络程序的客户端之间无法通用。


而对于常见协议的格式,例如HTTP(Hyper Text Transfer Protocol,超文本传输协议)、FTP(File Transfer Protocol,文件传输协议),SMTP(Simple Mail Transfer Protocol,简单邮件传输协议)等等,都有通用的规定,具体可以查阅相关的RFC文档。


最后,对于一种网络程序来说,网络协议格式是该程序最核心的技术秘密,因为一旦协议格式泄漏,则任何一个人都可以根据该格式进行客户端的编写,这样将影响服务器端的实现,也容易出现一些其它的影响。


1.2.6小结


关于网络编程基本的技术就介绍这么多,该部分介绍了网络编程的基础知识,以及Java语言对于网络编程的支持,网络编程的步骤等,并详细介绍了TCP方式网络编程和UDP方式网络编程在Java语言中的实现。


网络协议也是网络程序的核心,所以在实际开始进行网络编程时,设计一个良好的协议格式也是必须进行的工作。


网络编程示例


“实践出真知”,所以在进行技术学习时,还是需要进行很多的练习,才可以体会技术的奥妙,下面通过两个简单的示例,演示网络编程的实际使用。


1.3.1质数判别示例


该示例实现的功能是质数判断,程序实现的功能为客户端程序接收用户输入的数字,然后将用户输入的内容发送给服务器端,服务器端判断客户端发送的数字是否是质数,并将判断的结果反馈给客户端,客户端根据服务器端的反馈显示判断结果。


质数的规则是:最小的质数是2,只能被1和自身整除的自然数。当用户输入小于2的数字,以及输入的内容不是自然数时,都属于非法输入。


网络程序的功能都分为客户端程序和服务器端程序实现,下面先描述一下每个程序分别实现的功能:


1、 客户端程序功能:



  • 接收用户控制台输入


  • 判断输入内容是否合法


  • 按照协议格式生成发送数据


  • 发送数据


  • 接收服务器端反馈


  • 解析服务器端反馈信息,并输出



2、 服务器端程序功能:



  • 接收客户端发送数据


  • 按照协议格式解析数据


  • 判断数字是否是质数


  • 根据判断结果,生成协议数据


  • 将数据反馈给客户端



分解好了网络程序的功能以后,就可以设计网络协议格式了,如果该程序的功能比较简单,所以设计出的协议格式也不复杂。


客户端发送协议格式:



  • 将用户输入的数字转换为字符串,再将字符串转换为byte数组即可。


  • 例如用户输入16,则转换为字符串“16”,使用getBytes转换为byte数组。


  • 客户端发送“quit”字符串代表结束连接



服务器端发送协议格式:



  • 反馈数据长度为1个字节。数字0代表是质数,1代表不是质数,2代表协议格式错误。


  • 例如客户端发送数字12,则反馈1,发送13则反馈0,发送0则反馈2。



功能设计完成以后,就可以分别进行客户端和服务器端程序的编写了,在编写完成以后联合起来进行调试即可。


下面分别以TCP方式和UDP方式实现该程序,注意其实现上的差异。不管使用哪种方式实现,客户端都可以多次输入数据进行判断。对于UDP方式来说,不需要向服务器端发送quit字符串。


以TCP方式实现的客户端程序代码如下:


package example1;
import java.io.;
import java.net.
;
/
以TCP方式实现的质数判断客户端程序
/

public class TCPPrimeClient {
static BufferedReader br;
static Socket socket;
static InputStream is;
static OutputStream os;
/服务器IP/
final static String HOST = “127.0.0.1”;
/**服务器端端口/
final static int PORT = 10005;
public static void main(String[] args) {
init(); //初始化
while(true){
System.out.println(“请输入数字:”);
String input = readInput(); //读取输入
if(isQuit(input)){ //判读是否结束
byte[] b = “quit”.getBytes();
send(b);
break; //结束程序
}
if(checkInput(input)){ //校验合法
//发送数据
send(input.getBytes());
//接收数据
byte[] data = receive();
//解析反馈数据
parse(data);
}else{
System.out.println(“输入不合法,请重新输入!”);
}
}
close(); //关闭流和连接
}
/
初始化
/

private static void init(){
try {
br = new BufferedReader(
new InputStreamReader(System.in));
socket = new Socket(HOST,PORT);
is = socket.getInputStream();
os = socket.getOutputStream();
} catch (Exception e) {}
}
/
读取客户端输入
/

private static String readInput(){
try {
return br.readLine();
} catch (Exception e) {
return null;
}
}
/
判断是否输入quit
@param input 输入内容
@return true代表结束,false代表不结束
/

private static boolean isQuit(String input){
if(input == null){
return false;
}else{
if(“quit”.equalsIgnoreCase(input)){
return true;
}else{
return false;
}
}
}
/
校验输入
@param input 用户输入内容
@return true代表输入符合要求,false代表不符合
/

private static boolean checkInput(String input){
if(input == null){
return false;
}
try{
int n = Integer.parseInt(input);
if(n >= 2){
return true;
}else{
return false;
}
}catch(Exception e){
return false; //输入不是整数
}
}
/
向服务器端发送数据
@param data 数据内容
*/

private static void send(byte[] data){
try{
os.write(data);
}catch(Exception e){}
}
/
接收服务器端反馈
@return 反馈数据
/

private static byte[] receive(){
byte[] b = new byte[1024];
try {
int n = is.read(b);
byte[] data = new byte[n];
//复制有效数据
System.arraycopy(b, 0, data, 0, n);
return data;
} catch (Exception e){}
return null;
}
/**
解析协议数据
@param data 协议数据
/

private static void parse(byte[] data){
if(data == null){
System.out.println(“服务器端反馈数据不正确!”);
return;
}
byte value = data[0]; //取第一个byte
//按照协议格式解析
switch(value){
case 0:
System.out.println(“质数”);
break;
case 1:
System.out.println(“不是质数”);
break;
case 2:
System.out.println(“协议格式错误”);
break;
}
}
/
关闭流和连接
/

private static void close(){
try{
br.close();
is.close();
os.close();
socket.close();
}catch(Exception e){
e.printStackTrace();
}
}
}

在该代码中,将程序的功能使用方法进行组织,使得结构比较清晰,核心的逻辑流程在main方法中实现。


以TCP方式实现的服务器端的代码如下:


package example1;
import java.net.*;
/
以TCP方式实现的质数判别服务器端
/

public class TCPPrimeServer {
public static void main(String[] args) {
final int PORT = 10005;
ServerSocket ss = null;
try {
ss = new ServerSocket(PORT);
System.out.println(“服务器端已启动:”);
while(true){
Socket s = ss.accept();
new PrimeLogicThread(s);
}
} catch (Exception e) {}
finally{
try {
ss.close();
} catch (Exception e2) {}
}
}
}
package example1;
import java.io.;
import java.net.
;
/
实现质数判别逻辑的线程
/

public class PrimeLogicThread extends Thread {
Socket socket;
InputStream is;
OutputStream os;
public PrimeLogicThread(Socket socket){
this.socket = socket;
init();
start();
}
/
初始化
/

private void init(){
try{
is = socket.getInputStream();
os = socket.getOutputStream();
}catch(Exception e){}
}
public void run(){
while(true){
//接收客户端反馈
byte[] data = receive();
//判断是否是退出
if(isQuit(data)){
break; //结束循环
}
//逻辑处理
byte[] b = logic(data);
//反馈数据
send(b);
}
close();
}
/
接收客户端数据
@return 客户端发送的数据
*/

private byte[] receive(){
byte[] b = new byte[1024];
try {
int n = is.read(b);
byte[] data = new byte[n];
//复制有效数据
System.arraycopy(b, 0, data, 0, n);
return data;
} catch (Exception e){}
return null;
}
/
向客户端发送数据
@param data 数据内容
/

private void send(byte[] data){
try{
os.write(data);
}catch(Exception e){}
}
/**
判断是否是quit
@return 是返回true,否则返回false
/

private boolean isQuit(byte[] data){
if(data == null){
return false;
}else{
String s = new String(data);
if(s.equalsIgnoreCase(“quit”)){
return true;
}else{
return false;
}
}
}
private byte[] logic(byte[] data){
//反馈数组
byte[] b = new byte[1];
//校验参数
if(data == null){
b[0] = 2;
return b;
}
try{
//转换为数字
String s = new String(data);
int n = Integer.parseInt(s);
//判断是否是质数
if(n >= 2){
boolean flag = isPrime(n);
if(flag){
b[0] = 0;
}else{
b[0] = 1;
}
}else{
b[0] = 2; //格式错误
System.out.println(n);
}
}catch(Exception e){
e.printStackTrace();
b[0] = 2;
}
return b;
}
/

@param n
@return
/

private boolean isPrime(int n){
boolean b = true;
for(int i = 2;i <= Math.sqrt(n);i++){
if(n % i == 0){
b = false;
break;
}
}
return b;
}
/
关闭连接
/

private void close(){
try {
is.close();
os.close();
socket.close();
} catch (Exception e){}
}
}

本示例使用的服务器端的结构和前面示例中的结构一致,只是逻辑线程的实现相对来说要复杂一些,在线程类中的logic方法中实现了服务器端逻辑,根据客户端发送过来的数据,判断是否是质数,然后根据判断结果按照协议格式要求,生成客户端反馈数据,实现服务器端要求的功能。


猜数字小游戏


下面这个示例是一个猜数字的控制台小游戏。该游戏的规则是:当客户端第一次连接到服务器端时,服务器端生产一个【0,50】之间的随机数字,然后客户端输入数字来猜该数字,每次客户端输入数字以后,发送给服务器端,服务器端判断该客户端发送的数字和随机数字的关系,并反馈比较结果,客户端总共有5次猜的机会,猜中时提示猜中,当输入”quit”时结束程序。


和前面的示例类似,在进行网络程序开发时,首先需要分解一下功能的实现,觉得功能是在客户端程序中实现还是在服务器端程序中实现。区分的规则一般是:客户端 程序实现接收用户输入等界面功能,并实现一些基础的校验降低服务器端的压力,而将程序核心的逻辑以及数据存储等功能放在服务器端进行实现。遵循该原则划分 的客户端和服务器端功能如下所示。


客户端程序功能列表:



  • 接收用户控制台输入


  • 判断输入内容是否合法


  • 按照协议格式发送数据


  • 根据服务器端的反馈给出相应提示


    服务器端程序功能列表:


  • 接收客户端发送数据


  • 按照协议格式解析数据


  • 判断发送过来的数字和随机数字的关系


  • 根据判断结果生产协议数据


  • 将生产的数据反馈给客户端



在该示例中,实际使用的网络命令也只有两条,所以显得协议的格式比较简单。


其中客户端程序协议格式如下:



  • 将用户输入的数字转换为字符串,然后转换为byte数组


  • 发送“quit”字符串代表退出



其中服务器端程序协议格式如下:



  • 反馈长度为1个字节,数字0代表相等(猜中),1代表大了,2代表小了,其它数字代表错误。


实现该程序的代码比较多,下面分为客户端程序实现和服务器端程序实现分别进行列举。


客户端程序实现代码如下:


package guess;
import java.net.;
import java.io.
;
/
猜数字客户端
/

public class TCPClient {
public static void main(String[] args) {
Socket socket = null;
OutputStream os = null;
InputStream is = null;
BufferedReader br = null;
byte[] data = new byte[2];
try{
//建立连接
socket = new Socket(
“127.0.0.1”,10001);
//发送数据
os= socket.getOutputStream();
//读取反馈数据
is = socket.getInputStream();
//键盘输入流
br = new BufferedReader(
new InputStreamReader(System.in));
//多次输入
while(true){
System.out.println(“请输入数字:”);
//接收输入
String s = br.readLine();
//结束条件
if(s.equals(“quit”)){
os.write(“quit”.getBytes());
break;
}
//校验输入是否合法
boolean b = true;
try{
Integer.parseInt(s);
}catch(Exception e){
b = false;
}
if(b){ //输入合法
//发送数据
os.write(s.getBytes());
//接收反馈
is.read(data);
//判断
switch(data[0]){
case 0:
System.out.println(“相等!祝贺你!”);
break;
case 1:
System.out.println(“大了!”);
break;
case 2:
System.out.println(“小了!”);
break;
default:
System.out.println(“其它错误!”);
}
//提示猜的次数
System.out.println(“你已经猜了” + data[1] + “次!”);
//判断次数是否达到5次
if(data[1] >= 5){
System.out.println(“你挂了!”);
//给服务器端线程关闭的机会
os.write(“quit”.getBytes());
//结束客户端程序
break;
}
}else{ //输入错误
System.out.println(“输入错误!”);
}
}
}catch(Exception e){
e.printStackTrace();
}finally{
try{
//关闭连接
br.close();
is.close();
os.close();
socket.close();
}catch(Exception e){
e.printStackTrace();
}
}
}
}

在该示例中,首先建立一个到IP地址为127.0.0.1的端口为10001的连接,然后进行各个流的初始化工作,将逻辑控制的代码放入在一个while循环中,这样可以在客户端多次进行输入。在循环内部,首先判断用户输入的是否为quit字符串,如果是则结束程序,如果输入不是quit,则首先校验输入的是否是数字,如果不是数字则直接输出“输入错误!”并继续接收用户输入,如果是数字则发送给服务器端,并根据服务器端的反馈显示相应的提示信息。最后关闭流和连接,结束客户端程序。


服务器端程序的实现还是分为服务器控制程序和逻辑线程,实现的代码分别如下:


package guess;
import java.net.*;
/
TCP连接方式的服务器端
实现功能:接收客户端的数据,判断数字关系
/

public class TCPServer {
public static void main(String[] args) {
try{
//监听端口
ServerSocket ss = new ServerSocket(10001);
System.out.println(“服务器已启动:”);
//逻辑处理
while(true){
//获得连接
Socket s = ss.accept();
//启动线程处理
new LogicThread(s);
}
}catch(Exception e){
e.printStackTrace();
}
}
}
package guess;
import java.net.;
import java.io.;
import java.util.
;
/*
逻辑处理线程
*/

public class LogicThread extends Thread {
Socket s;
static Random r = new Random();
public LogicThread(Socket s){
this.s = s;
start(); //启动线程
}
public void run(){
//生成一个[0,50]的随机数
int randomNumber = Math.abs(r.nextInt() % 51);
//用户猜的次数
int guessNumber = 0;
InputStream is = null;
OutputStream os = null;
byte[] data = new byte[2];
try{
//获得输入流
is = s.getInputStream();
//获得输出流
os = s.getOutputStream();
while(true){ //多次处理
//读取客户端发送的数据
byte[] b = new byte[1024];
int n = is.read(b);
String send = new String(b,0,n);
//结束判别
if(send.equals(“quit”)){
break;
}
//解析、判断
try{
int num = Integer.parseInt(send);
//处理
guessNumber++; //猜的次数增加1
data[1] = (byte)guessNumber;
//判断
if(num > randomNumber){
data[0] = 1;
}else if(num < randomNumber){
data[0] = 2;
}else{
data[0] = 0;
//如果猜对
guessNumber = 0; //清零
randomNumber = Math.abs(r.nextInt() % 51);
}
//反馈给客户端
os.write(data);
}catch(Exception e){ //数据格式错误
data[0] = 3;
data[1] = (byte)guessNumber;
os.write(data); //发送错误标识
break;
}
os.flush(); //强制发送
}
}catch(Exception e){
e.printStackTrace();
}finally{
try{
is.close();
os.close();
s.close();
}catch(Exception e){}
}
}
}

在 该示例中,服务器端控制部分和前面的示例中一样。也是等待客户端连接,如果有客户端连接到达时,则启动新的线程去处理客户端连接。在逻辑线程中实现程序的 核心逻辑,首先当线程执行时生产一个随机数字,然后根据客户端发送过来的数据,判断客户端发送数字和随机数字的关系,然后反馈相应的数字的值,并记忆客户 端已经猜过的次数,当客户端猜中以后清零猜过的次数,使得客户端程序可以继续进行游戏。


总体来说,该程序示例的结构以及功能都与上一个程序比较类似,希望通过比较这两个程序,加深对于网络编程的认识,早日步入网络编程的大门。



转自:http://www.cnblogs.com/springcsc/archive/2009/12/03/1616413.html
文章有不当之处,欢迎指正,你也可以关注我的微信公众号:好好学java,获取优质资源。


Compartir

love story

这里写图片描述

Compartir

设计模式——开发常用的设计模式梳理

. 基础学习:UML四种关系


耦合度大小关系



泛化 = 实现 > 组合 > 聚合 > 关联 > 依赖



依赖(Dependency)


好好学java
好好学java

一个人(Person)可以买车(car)和房子(House),那么就可以称:Person类依赖于Car类和House类
这里注意与下面的关联关系区分:Person类里并没有使用Car和House类型的属性,Car和House的实例是以参量的方式传入到buy()方法中。
依赖关系在Java语言中体现为局域变量、方法的形参,或者对静态方法的调用。


关联(Association)


好好学java
好好学java

它使一个类知道另一个类的属性和方法。
关联可以是双向的,也可以是单向的。
在Java语言中,关联关系一般使用成员变量来实现。


聚合(Aggregation)


好好学java
好好学java

聚合是关联关系的一种,是强的关联关系。
聚合是整体和个体之间的关系,但个体可以脱离整体而存在。
例如,汽车类与引擎类、轮胎类,以及其它的零件类之间的关系便整体和个体的关系。
与关联关系一样,聚合关系也是通过成员变量实现的。但是关联关系所涉及的两个类是处在同一层次上的,而在聚合关系中,两个类是处在不平等层次上的,一个代表整体,另一个代表部分。


组合(Composition)


好好学java
好好学java

组合是关联关系的一种,是比聚合关系强的关系,也以成员变量的形式出现。
在某一个时刻,部分对象只能和一个整体对象发生组合关系,由后者排他地负责生命周期。
部分和整体的生命周期一样。
整体可以将部分传递给另一个对象,这时候该部分的生命周期由新整体控制,然后旧整体可以死亡。


. 策略模式


什么是策略模式


一个类中的一些行为,可能会随着系统的迭代而发生变化。为了使得该类满足开放-封闭原则(即:具备可扩展性 或 弹性),我们需要将这些未来会发生动态变化的行为从该类中剥离出来,并通过预测未来业务发展的方式,为这些行为抽象出共有的特征,封装在抽象类或接口中,并通过它们的实现类提供具体的行为。原本类中需要持有该抽象类/接口的引用。在使用时,将某一个具体的实现类对象注入给该类所持有的接口/抽象类的引用。


类图描述


好好学java
好好学java

如果类A中有两个行为X和Y会随着业务的发展而变化,那么,我们需要将这两个行为从类A中剥离出来,并形成各自的继承体系(策略体系)。每个继承体系(策略体系)的顶层父类/接口中定义共有行为的抽象函数,每个子类/实现类中定义该策略体系具体的实现。


其中,每一个被抽象出来的继承体系被称为一个策略体系,每个具体的实现类被称为策略。


此时,策略体系已经构建完成,接下来需要改造类A。
在类A中增加所需策略体系的顶层父类/接口,并向外暴露一个共有的函数action给调用者使用。


在Spring项目中,策略类和类A之间的依赖关系可以通过依赖注入来完成。


到此为止,策略模式已经构建完成,下面我们来看优缺点分析。


策略模式的优点


1. 满足开放封闭原则


如果类A需要更换一种策略的时候,只需修改Spring的XML配置文件即可,其余所有的代码均不需要修改。


比如,将类A的策略X_1更换成X_2的方法如下:


<bean id=“a” class=“类A”>
<!– 将原本策略实现类X_1修改为策略实现类X_2即可 –>
<property name=“策略接口X” class=“策略实现类X_2” />
</bean>

此外,如果需要新增一种策略,只需要为策略接口X添加一个新的实现类即可,并覆盖其中的commonAction函数。然后按照上面的方式修改XML文件即可。


在这个过程中,在保持原有Java代码不发生变化的前提下,扩展性了新的功能,从而满足开放封闭原则。


2. 可方便地创建具有不同策略的对象


如果我们需要根据不同的策略创建多种类A的对象,那么使用策略模式就能很容易地实现这一点。


比如,我们要创建三个A类的对象,a、b、c。其中,a使用策略X_1和Y_1,b使用策略X_2和Y_2,c使用策略X_3和Y_3。
要创建这三个对象,我们只需在XML中作如下配置即可:


<bean id=“a” class=“类A”>
<property name=“策略接口X” class=“策略实现类X_1” />
<property name=“策略接口Y” class=“策略实现类Y_1” />
</bean>
<bean id=“b” class=“类A”>
<property name=“策略接口X” class=“策略实现类X_2” />
<property name=“策略接口Y” class=“策略实现类Y_2” />
</bean>
<bean id=“c” class=“类A”>
<property name=“策略接口X” class=“策略实现类X_3” />
<property name=“策略接口Y” class=“策略实现类Y_3” />
</bean>

答疑



问:如何实现部分继承?也就是类Son1只继承Father的一部分功能,Son2继承Father的另一部分功能。



这是设计上的缺陷,当出现这种情况时,应当将父类再次拆分成2个子类,保证任何一个父类的行为和特征均是该继承体系中共有的!


好好学java
好好学java


问:随着需求的变化,父类中需要增加共有行为时怎么办?这就破坏了“开放封闭原则”。



这并未破坏“开放封闭原则”!在系统迭代更新的过程中,修改原有的代码是在所难免的,这并不违背“开放封闭原则”。
“开放封闭原则”要求我们:当系统在迭代过程中,第一次出现某一类型的需求时,是允许修改的;在此时,应该对系统进行修改,并进行合理地设计,以保证对该类型需求的再次修改具备可扩展性。当再一次出现该类型的需求时,就不应该修改原有代码,只允许通过扩展来满足需求。


. 观察者模式


观察者模式是什么


如果出现如下场景需求时,就需要使用观察者模式。


如果存在一系列类,他们都需要向指定类获取指定的数据,当获取到数据后需要触发相应的业务逻辑。这种场景就可以用观察者模式来实现。


在观察者模式中,存在两种角色,分别是:观察者和被观察者。被观察者即为数据提供者。他们呈多对一的关系。


类图描述


好好学java
好好学java


  • 被观察者是数据提供方,观察者是数据获取方


  • 一个普通的类,如果要成为观察者,获取指定的数据,一共需要如下几步:



    • 首先,需要实现Observer接口,并实现update函数;

    • 然后,在该函数中定义获取数据后的业务逻辑;
      update(Observable, Object)一共有两个参数:
      Observable:被观察者对象(数据提供方)
      Object:数据本身

    • 最后,通过调用 被观察者 的addObservable()或者通过Spring的XML配置文件完成观察者向被观察者的注入。此时,该观察者对象就会被添加进 被观察者 的List中。

  • 调用者才是真正的数据提供方。当调用者需要广播最新数据时,只需调用 被观察者 的notidyObservers()函数,该函数会遍历List集合,并依次调用每个Observer的update函数,从而完成数据的发送,并触发每个Observer收到数据后的业务逻辑。



两种注册观察者的方式


将Observer注册进Observable中有如下两种方式:


1. 运行前,通过Spring XML


在系统运行前,如果观察者数量可以确定,并在运行过程中不会发生变化,那么就可以在XML中完成List对象的注入,这种方式代码将会比较简洁。


1、配置好所有 观察者 bean


<!– 创建observerA –>
<bean name=“observerA” class=“ObservserA”>
</bean>
<!– 创建observerB–>
<bean name=“observerB” class=“ObservserB”>
</bean>

2、 配置好 被观察者 bean,并将所有观察者bean注入给被观察者bean


<!– 创建observable –>
<bean name=“observable” class=“Observable”>
<property name=“observerList”>
<list>
<ref bean=“observerA” />
<ref bean=“observerB” />
</list>
</property>
</bean>

2. 运行中,通过addObserver()函数


在Spring初始化的时候,通过addObserver()函数将所有Observer对象注入Observable的observerList中。


@Component
public class InitConfiguration implements ApplicationListener<ContextRefreshedEvent>{
@Override
public void onApplicationEvent(ContextRefreshedEvent arg0) {
if(event.getApplicationContext().getParent() == null){
Observable observable = (Observable)event.getApplicationContext().getBean(“observable”);
ObserverA observerA = (ObserverA)event.getApplicationContext().getBean(“observerA”);
ObserverB observerB = (ObserverB)event.getApplicationContext().getBean(“observerB”);
observable.setObserverList(Arrays.asList(observerA, observerB));
}
}
}


建议使用第一种方式初始化所有的观察者,此外,被观察者仍然需要提供addObserver()函数供系统在运行期间动态地添加、删除观察者对象。



JDK提供的观察者模式工具包


JDK已经提供了观察者模式的工具包,包括Observable类和Observer接口。若要实现观察者模式,直接使用这两个工具包即可。


. 装饰模式


何时使用



  • 需要增强一个对象中某些函数的功能。


  • 需要动态地给一个对象增加功能,这些功能可以再动态地撤销。


  • 需要增加 由一些基本功能排列组合 而产生的大量功能,从而使继承体系大爆炸。



类图描述


好好学java
好好学java

在装饰模式中的各个角色有:



  • 抽象构件(Component)角色:给出一个抽象接口,以规范准备接收附加责任的对象。


  • 具体构件(Concrete Component)角色:定义一个将要接收附加责任的类。


  • 装饰(Decorator)角色:持有一个构件(Component)对象的实例,并定义一个与抽象构件接口一致的接口。


  • 具体装饰(Concrete Decorator)角色:负责给构件对象”贴上”附加的责任。



Decorator中包含Component的成员变量,每个Concrete Decorator实现类均需要实现operation()函数,该函数大致过程如下:


class ConcreteDecorator {
private Component component;
返回类型 operation(){
// 执行上一层的operation(),并获取返回结果
返回结果 = component.operation();
// 拿到返回结果后,再做额外的处理
处理返回结果
return 返回结果;
}
}

使用装饰类的过程如下:


// 准备好所有装饰类
DecoratorA decoratorA = new DecoratorA();
DecoratorB decoratorB = new DecoratorB();
DecoratorC decoratorC = new DecoratorC();
// 准备好 被装饰的类
Component component = new Component();
// 组装装饰类
decoratorC.setComponent(decoratorB);
decoratorB.setComponent(decoratorA);
decoratorA.setComponent(component);
// 执行
decoratorC.operation();

执行过程如下:


好好学java
好好学java

优点


1、Decorator模式与继承关系的目的都是要扩展对象的功能,但是Decorator可以提供比继承更多的灵活性。继承通过覆盖的方式重写需要扩展的函数,当然也可以通过super.xxx()获取原本的功能,然后在该功能基础上扩展新功能,但它只能增加某一项功能;如果要通过继承实现增加多种功能,那么需要多层继承多个类来实现;而Decorator模式可以在原有功能的基础上通过组合来增加新功能,这些新功能已经被封装成一个个独立的装饰类,在运行期间通过搭积木的方式选择装饰类拼凑即可。


2、通过使用不同的具体装饰类以及这些装饰类的排列组合,设计师可以创造出很多不同行为的组合。


缺点


1、这种比继承更加灵活机动的特性,也同时意味着更加多的复杂性。
2、装饰模式会导致设计中出现许多小类,如果过度使用,会使程序变得很复杂。


3、装饰模式是针对抽象组件(Component)类型编程。但是,如果你要针对具体组件编程时,就应该重新思考你的应用架构,以及装饰者是否合适。当然也可以改变Component接口,增加新的公开的行为,实现“半透明”的装饰者模式。在实际项目中要做出最佳选择。


设计原则



  • 多用组合,少用继承。
    利用继承设计子类的行为,是在编译时静态决定的,而且所有的子类都会继承到相同的行为。然而,如果能够利用组合的做法扩展对象的行为,就可以在运行时动态地进行扩展。


. 单例模式


Java中单例(Singleton)模式是一种广泛使用的设计模式。单例模式的主要作用是保证在Java程序中,某个类只有一个实例存在。一些管理器和控制器常被设计成单例模式。


单例模式有很多好处,它能够避免实例对象的重复创建,不仅可以减少每次创建对象的时间开销,还可以节约内存空间;能够避免由于操作多个实例导致的逻辑错误。如果一个对象有可能贯穿整个应用程序,而且起到了全局统一管理控制的作用,那么单例模式也许是一个值得考虑的选择。


单例模式有很多种写法,大部分写法都或多或少有一些不足。下面将分别对这几种写法进行介绍。


. 饿汉模式


public class Singleton{  
private static Singleton instance = new Singleton();
private Singleton(){}
public static Singleton newInstance(){
return instance;
}
}


  • 类的构造函数定义为private,保证其他类不能实例化此类;

  • 然后提供了一个静态实例并返回给调用者;

  • 饿汉模式在类加载的时候就对实例进行创建,实例在整个程序周期都存在

  • 优点:只在类加载的时候创建一次实例,不会存在多个线程创建多个实例的情况,避免了多线程同步的问题。

  • 缺点:即使这个单例没有用到也会被创建,而且在类加载之后就被创建,内存就被浪费了。

  • 适用场景:这种实现方式适合单例占用内存比较小,在初始化时就会被用到的情况。但是,如果单例占用的内存比较大,或单例只是在某个特定场景下才会用到,使用饿汉模式就不合适了,这时候就需要用到懒汉模式进行延迟加载。


. 懒汉模式(存在线程安全性问题)


public class Singleton{  
private static Singleton instance = null;
private Singleton(){}
public static Singleton newInstance(){
if(null == instance){
instance = new Singleton();
}
return instance;
}
}


  • 懒汉模式中单例是在需要的时候才去创建的,如果单例已经创建,再次调用获取接口将不会重新创建新的对象,而是直接返回之前创建的对象。

  • 如果某个单例使用的次数少,并且创建单例消耗的资源较多,那么就需要实现单例的按需创建,这个时候使用懒汉模式就是一个不错的选择。

  • 但是这里的懒汉模式并没有考虑线程安全问题,在多个线程可能会并发调用它的getInstance()方法,导致创建多个实例,因此需要加锁解决线程同步问题,实现如下。


. 懒汉模式(线程安全,但效率低)


public class Singleton{  
private static Singleton instance = null;
private Singleton(){}
public static synchronized Singleton newInstance(){
if(null == instance){
instance = new Singleton();
}
return instance;
}
}

加锁的懒汉模式看起来即解决了线程并发问题,又实现了延迟加载,然而它存在着性能问题,依然不够完美。synchronized修饰的同步方法比一般方法要慢很多,如果多次调用getInstance(),累积的性能损耗就比较大了。


. 懒汉模式(线程安全,效率高)


public class Singleton {  
private static Singleton instance = null;
private Singleton(){}
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}

这种方式比上一种方式只多加了一行代码,那就是在synchronized之上又加了一层判断if (instance == null)。这样当单例创建完毕后,不用每次都进入同步代码块,从而能提升效率。当然,除了初始化单例对象的线程ThreadA外,可能还存在少数线程,在ThreadA创建完单例后,刚释放锁的时候进入同步代码块,但此时有第二道if (instance == null)判断,因此也就避免了创建多个对象。而且进入同步代码块的线程相对较少。


. 静态内部类(懒汉+无锁)


public class Singleton{  
private static class SingletonHolder{
public static Singleton instance = new Singleton();
}
private Singleton(){}
public static Singleton newInstance(){
return SingletonHolder.instance;
}
}

这种方式同样利用了类加载机制来保证只创建一个instance实例。它与饿汉模式一样,也是利用了类加载机制,因此不存在多线程并发的问题。不一样的是,它是在内部类里面去创建对象实例。这样的话,只要应用中不使用内部类,JVM就不会去加载这个单例类,也就不会创建单例对象,从而实现懒汉式的延迟加载。也就是说这种方式可以同时保证延迟加载和线程安全。


. 枚举


public enum Singleton{  
instance;
public void whateverMethod(){}
}

上面提到的四种实现单例的方式都有共同的缺点:


1、需要额外的工作来实现序列化,否则每次反序列化一个序列化的对象时都会创建一个新的实例。
2、可以使用反射强行调用私有构造器(如果要避免这种情况,可以修改构造器,让它在创建第二个实例的时候抛异常)。


而枚举类很好的解决了这两个问题,使用枚举除了线程安全和防止反射调用构造器之外,还提供了自动序列化机制,防止反序列化的时候创建新的对象。因此,《Effective Java》作者推荐使用的方法。不过,在实际工作中,很少看见有人这么写。


. 模板方法模式


定义


在父类中定义算法的流程,而算法的某些无法确定的细节,通过抽象函数的形式,在子类中去实现。


也可以理解为,一套算法的某些步骤可能随着业务的发展而改变,那么我们可以将确定的步骤在父类中实现,而可变的步骤作为抽象函数让其在子类中实现。



  • 在模板方法模式中,父类是一个抽象类,算法的每一步都被封装成一个函数,templateMethod函数将所有算法步骤串联起来。

  • 对于不变的步骤,用private修饰,防止子类重写;

  • 对于可变的步骤,用abstract protected修饰,必须要求子类重写;

  • 子类重写完所有抽象函数后,调用templateMethod即可执行算法。


. 外观模式


外观模式这种思想在项目中普遍存在,也极其容易理解,大家一定用过,只是没有上升到理论的层面。这里对这种思想进行介绍。


外观模式他屏蔽了系统功能实现的复杂性,向客户端提供一套极其简单的接口。客户端只需要知道接口提供什么功能,如何调用就行了,不需要管这些接口背后是如何实现的。从而使得客户端和系统之间的耦合度大大降低,客户端只需跟一套简单的Facade接口打交道即可。


. 适配器模式


定义


作为一个基金交易平台,需要提供一套接口规范,供各个基金公司接入。然而,各个基金公司的接口各不相同,没有办法直接和平台接口对接。此时,各个基金公司需要自行实现一个适配器,适配器完成不同接口的转换工作,使得基金公司的接口和平台提供的接口对接上。


. 三种适配器


适配器模式有三种实现方式,下面都以基金交易平台的例子来解释。



  • 基金公司的交易接口:


/
基金公司的交易接口
/

class FundCompanyTrade{
/
买入函数
/

public void mairu() {
// ……
}
/
卖出函数
/

public void maichu() {
// ……
}
}


  • 基金交易平台的交易接口


/
基金交易平台的交易接口
/

interface FundPlatformTrade {
// 买入接口
void buy();
// 卖出接口
void sell();
}


  • 基金交易平台均通过如下代码调用各个基金公司的交易接口:


class Client {
@Autowired
private FundPlatformTrade fundPlatformTrade;
/
买入基金
/

public void buy() {
fundPlatformTrade.buy();
}
/
卖出基金
/

public void sell() {
fundPlatformTrade.sell();
}
}

方式1:类适配器



通过继承来实现接口的转换。




  • 基金交易适配器:


class Adapter extends FundCompanyTrade implements FundPlatformTrade {
void buy() {
mairu();
}
void sell(){
maichu();
}
}

适配器Adapter继承了FundCompanyTrade,因此拥有了FundCompanyTrade买入和卖出的能力;适配器Adapter又实现了FundPlatformTrade,因此需要实现其中的买入和卖出接口,这个过程便完成了基金公司交易接口向基金平台交易接口的转换。


使用时,只需将Adapter通过Spring注入给Client类的fundPlatformTrade成员变量即可:


<!– 声明Adapter对象 –>
<bean name=“adapter” class=“Adapter”>
</bean>
<!– 将adapter注入给Client –>
<bean class=“Client”>
<property name=“fundPlatformTrade” ref=“adapter” />
</bean>

方式2:对象适配器



通过组合来实现接口的转换。




  • 基金交易适配器:


class Adapter implements FundPlatformTrade {
@Autowired
private FundCompanyTrade fundCompanyTrade;
void buy() {
fundCompanyTrade.mairu();
}
void sell(){
fundCompanyTrade.maichu();
}
}

这种方式中,适配器Adapter并未继承FundCompanyTrade,而是将该对象作为成员变量注入进来,一样可以达到同样的效果。


方式3:接口适配器


当存在这样一个接口,其中定义了N多的方法,而我们现在却只想使用其中的一个到几个方法,如果我们直接实现接口,那么我们要对所有的方法进行实现,哪怕我们仅仅是对不需要的方法进行置空(只写一对大括号,不做具体方法实现)也会导致这个类变得臃肿,调用也不方便,这时我们可以使用一个抽象类作为中间件,即适配器,用这个抽象类实现接口,而在抽象类中所有的方法都进行置空,那么我们在创建抽象类的继承类,而且重写我们需要使用的那几个方法即可。



  • 目标接口:A


public interface A {
void a();
void b();
void c();
void d();
void e();
void f();
}


  • 适配器:Adapter
    实现所有函数,将所有函数先置空。


public abstract class Adapter implements A {
public void a(){
throw new UnsupportedOperationException(“对象不支持这个功能”);
}
public void b(){
throw new UnsupportedOperationException(“对象不支持这个功能”);
}
public void c(){
throw new UnsupportedOperationException(“对象不支持这个功能”);
}
public void d(){
throw new UnsupportedOperationException(“对象不支持这个功能”);
}
public void e(){
throw new UnsupportedOperationException(“对象不支持这个功能”);
}
public void f(){
throw new UnsupportedOperationException(“对象不支持这个功能”);
}
}


  • 实现类:Ashili
    继承适配器类,选择性地重写相应函数。


public class Ashili extends Adapter {
public void a(){
System.out.println(“实现A方法被调用”);
}
public void d(){
System.out.println(“实现d方法被调用”);
}
}

. 迭代器模式


定义



迭代器模式用于在无需了解容器内部细节的情况下,实现容器的迭代。



容器用于存储数据,而容器的存储结构种类繁多。在不使用适配器模式的情况下,如果要迭代容器中的元素,就需要充分理解容器的存储结构。存储结构不同,导致了不同容器的迭代方式都不一样。这无疑增加了我们使用容器的成本。


而迭代器模式提出了一种迭代容器元素的新思路,迭代器规定了一组迭代容器的接口,作为容器使用者,只需会用这套迭代器即可。容器本身需要实现这套迭代器接口,并实现其中的迭代函数。也就是容器提供方在提供容器的同时,还需要提供迭代器的实现。因为容器本身是了解自己的存储结构的,由它来实现迭代函数非常合适。而我们作为容器的使用者,只需知道怎么用迭代器即可,无需了解容器内部的存储结构。


类图描述


好好学java
好好学java

在迭代器模式中,一共有两种角色:迭代器 和 容器



  • 迭代器 Iterator:封装了迭代容器的接口


  • 容器 Container:存储元素的东西



    • 容器若要具备迭代的能力,就必须拥有getIterator()函数,该函数将会返回一个迭代器对象

    • 每个容器都有属于自己的迭代器内部类,该内部类实现了Iterator接口,并实现了其中用于迭代的两个函数hasNext()和next()

    • boolean hasNext():用于判断当前容器是否还有尚未迭代完的元素

    • Object next():用于获取下一个元素


代码实现



  • 迭代器接口:


public interface Iterator {
public boolean hasNext();
public Object next();
}


  • 容器接口:


public interface Iterator {
public boolean hasNext();
public Object next();
}


  • 具体的容器(必须实现Container接口):


public class NameRepository implements Container {
public String names[] = {“Robert” , “John” ,“Julie” , “Lora”};
@Override
public Iterator getIterator() {
return new NameIterator();
}
private class NameIterator implements Iterator {
int index;
@Override
public boolean hasNext() {
if(index < names.length){
return true;
}
return false;
}
@Override
public Object next() {
if(this.hasNext()){
return names[index++];
}
return null;
}
}
}


  • 具体的容器实现了Container接口,并实现了其中的getIterator()函数,该函数用于返回该容器的迭代器对象。

  • 容器内部需要实现自己的迭代器内部类,该内部类实现Iterator接口,并实现了其中的hasNext()和next()函数。


当容器和容器的迭代器创建完毕后,接下来就轮到用户使用了,使用就非常简单了:


public class IteratorPatternDemo {
public static void main(String[] args) {
NameRepository namesRepository = new NameRepository();
for(Iterator iter = namesRepository.getIterator(); iter.hasNext();){
String name = (String)iter.next();
System.out.println(“Name : “ + name);
}
}
}


  • 对于使用者而言,只要知道Iterator接口,就能够迭代所有不同种类的容器了。


. 组合模式


定义



组合模式定义了树形结构的物理存储方式。



现实世界中树形结构的东西,在代码实现中,都可以用组合模式来表示。


比如:多级菜单、公司的组织结构等等。


下面就以多级菜单为例,介绍组合模式。


例子


假设我们要实现一个多级菜单,并实现多级菜单的增删改查操作。菜单如下:


一级菜单A
二级菜单A_1
三级菜单A_1_1
三级菜单A_1_2
三级菜单A_1_3
二级菜单A_2
一级菜单B
二级菜单B_1
二级菜单B_2
二级菜单B_3
二级菜单B_4
三级菜单B_4_1
三级菜单B_4_2
三级菜单B_4_3
一级菜单C
二级菜单C_1
二级菜单C_2
二级菜单C_3

菜单的特点如下:



  • 深度不限,可以有无限级菜单

  • 每层菜单数量不限


类图描述



  • Item表示树中的节点;

  • Item中包含两个成员变量:

    • parent:指向当前节点的父节点

    • childList:当前节点的子节点列表

  • 这种Item中又包含Item的关系就构成了组合模式。


注意:循环引用


在构建树的过程中,可能会出现循环引用,从而在遍历树的时候可能就会出现死循环。因此,我们需要在添加节点的时候避免循环引用的出现。


我们可以在Item中再添加一个List成员变量,用于记录根节点到当前节点的路径。该路径可以用每个节点的ID表示。一旦新加入的节点ID已经出现在当前路径中的时候,就说明出现了循环引用,此时应该给出提示。


. 状态模式


使用场景


如果一个函数中出现大量的、复杂的if-else判断,这时候就要考虑使用状态模式了。


因为大量的if-else中往往包含了大量的业务逻辑,很有可能会随着业务的发展而变化。如果将这些业务逻辑都写死在一个类中,那么当业务逻辑发生变化的时候就需要修改这个类,从而违反了开放封闭原则。而状态模式就能很好地解决这一问题。


状态模式将每一个判断分支都封装成一个独立的类,每一个判断分支成为一种“状态”,因此每一个独立的类就成为一个“状态类”。并且由一个全局状态管理者Context来维护当前的状态。


类图描述



  • 在状态模式中,每一个判断分支被成为一种状态,每一种状态,都会被封装成一个单独的状态类;

  • 所有的状态类都有一个共同的接口——State

  • State接口中有一个doAction函数,每个状态类的状态处理逻辑均在该函数中完成;必须将Context对象作为doAction函数的参数传入。该函数的结构如下:


class StateA implements State{
public void doAction(Context context){
if (满足条件) {
// 执行相应的业务逻辑
}
else {
// 设置下一跳状态
context.setState(new StateB());
// 执行下一跳状态
context.doCurState();
}
}
}


  • 每个状态类的doAction函数中都有且仅有一对if-else,if中填写满足条件时的业务逻辑,而else中填写不满足条件时的业务逻辑。


  • else中的代码都一样,有且仅有这两步:
    首先将context的state设为下一个状态对象;
    然后调用context的doCurState()执行;


  • Context类其实就是原本包含那个巨大、复杂的if-else的类。该类中持有了State对象,表示当前要执行的状态对象。


  • Context类必须要有一个doCurState函数,该函数的代码都一样:state.doAction()


  • 开启状态判断过程的代码如下:



// 准备好第一个状态
StateA stateA = new StateA();
// 设置第一个状态
context.setState(stateA);
// 开始执行
context.doCurState();

优点


状态模式将原本在一个类中的庞大的if-else拆分成一个个独立的状态类。原本这个包含庞大if-else的类成为Context,包含了当前的状态。Context只需要知道起始状态类即可,不需要知道其他状态类的存在。也就是Context只与第一个状态类发生耦合。而每一个状态类只和下一个状态类发生耦合,从而形成一条状态判断链。状态类之间的耦合通过Spring XML文件配置。这样,当判断逻辑发生变化的时候,只需要新增状态类,并通过修改XML的方式将新的状态类插入到判断逻辑中。从而满足了开放封闭原则。
代理模式


. 代理模式


好好学java
好好学java

代理模式是在不改变目标类和使用者的前提下,扩展该类的功能。


代理模式中存在『目标对象』和『代理对象』,它们必须实现相同的接口。用户直接使用代理对象,而代理对象会将用户的请求交给目标对象处理。代理对象可以对用户的请求增加额外的处理。


Java动态代理的使用



  • 首先你得拥有一个目标对象,该对象必须要实现一个接口:


public interface Subject   
{
public void doSomething();
}

public class RealSubject implements Subject   
{
public void doSomething()
{
System.out.println( “call doSomething()” );
}
}


  • 其次,为目标对象增加额外的逻辑:

    • 自定义一个类,并实现InvocationHandler接口;

    • 实现invoke函数,并将需要增加的逻辑写在该函数中;


public class ProxyHandler implements InvocationHandler   
{
private Object proxied;
public ProxyHandler( Object proxied )
{
this.proxied = proxied;
}
public Object invoke( Object proxy, Method method, Object[] args ) throws Throwable
{
//在转调具体目标对象之前,可以执行一些功能处理
//转调具体目标对象的方法
return method.invoke( proxied, args);
//在转调具体目标对象之后,可以执行一些功能处理
}
}


  • 创建代理对象,调用者直接使用该对象即可:


RealSubject real = new RealSubject();   
Subject proxySubject = (Subject)Proxy.newProxyInstance(Subject.class.getClassLoader(),
new Class[]{Subject.class},
new ProxyHandler(real));
proxySubject.doSomething();


转自:http://blog.csdn.net/u010425776/article/details/79211117
文章有不当之处,欢迎指正,你也可以关注我的微信公众号:好好学java,获取java等优质视频教程、学习资源。


Compartir