亚洲精品高清在线,亚洲av无码一区二区三区人妖,亚洲精品国偷自产在线

Tue, 17 Sep 2013 09:51:00 GMT

11.3 I/O�c�M��?/div>

�׃��在IO操作中，需要��用的数据源有很多�Q�作��Z��个IO技术的初学者，从读写文件开始学习IO技术是一个比较好的选择。因为文件是一�U�常见的数据源，而且��d��文�g也是�E�序员进行IO�~�程的一个基本能力。本章IO�cȝ��使用��׃��d��文�g开始�?/div>

11.3.1 文�g操作

文�g(File)�?最常见的数据源之一�Q�在�E�序中经帔R��要将数据存储到文件中�Q�例如图片文件、声��x��件等数据文�g�Q�也�l�常需要根据需要从指定的文件中�q�行数据的读取。当�Ӟ�� 在实际��用时�Q�文仉��包含一个的格式�Q�这个格式需要程序员�Ҏ��需要进行设计，��d��已有的文件时也需要熟悉对应的文�g格式�Q�才能把数据从文件中正确的读取出来�?/div>

文�g的存储介质有很多�Q�例如硬盘、光盘和U盘等�Q�由于IO�c�设计时�Q�从数据源�{换�ؓ��对象的操作由API实现了，所以存储介质的不同对于�E�序员来说是透明的，和实际编写代码无兟�?/div>

11.3.1.1 文�g的概�?/div>

文�g是计��机中一�U�基本的数据存储形式�Q�在实际存储数据�Ӟ��如果对于数据的读写速度要求不是很高�Q�存储的数据量不是很大时�Q��用文件作��Z��U�持久数据存储的方式是比较好的选择�?/div>

存储在文件内部的数据和内存中的数据不同，存储在文件中的数据是一�U?#8220;持久存储”�Q�也��是当程序退出或计算机关��Z��后，数据�q�是存在的，而内存内部的数据在程序退出或计算机关��Z��后，数据��׃��׃��?/div>

在不同的存储介质中，文�g中的数据都是以一定的��序依次存储��h��Q�在实际��d��时由��g以及操作�pȝ��完成对于数据的控�Ӟ��保证�E�序��d��到的数据和存储的��序保持一致�?/div>

每个文�g以一个文件�\径和文�g名称�q�行表示�Q�在需要访问该文�g的时�Q�只需要知道该文�g的�\径以及文件的全名卛_��。在不同的操作系�l�环境下�Q�文件�\径的表示形式是不一��L��Q�例如在Windows操作�pȝ��中一般的表示形式为C:\windows\system�Q�而Unix上的表示形式�?user/my。所以如果需要让Java�E�序能够在不同的操作�pȝ��下运行，书写文�g路径时还需要比较注意�?/div>

11.3.1.1.1 �l�对路径和相对�\�?/div>

�l�对路径是指书写文�g的完整�\径，例如d:\java\Hello.java�Q�该路径中包含文件的完整路径d:\java以及文�g的全名Hello.java。��用该路径可以唯一的找��C��个文�Ӟ��不会产生歧义。但是��用绝对�\径在表示文�g�Ӟ��受到的限制很大，且不能在不同的操作系�l�下�q�行�Q�因��Z��同操作系�l�下�l�对路径的表辑�Ş式存在不同�?/div>

相对路径是指书写文�g的部分�\径，例如\test\Hello.java�Q�该路径中只包含文�g的部分�\径\test和文件的全名Hello.java�Q�部分�\径是指当前�\径下的子路径�Q�例如当前程序在d:\abc下运行，则该文�g的完整�\径就是d:\abc\test。��用这�U��Ş式，可以更加通用的代表文件的位置�Q��得文件�\径��生一定的灉|��性�?/div>

在Eclipse��目中运行程序时�Q�当前�\径是��目的根目录�Q�例如工作空间存储在d:\javaproject�Q�当前项目名�U�是Test�Q�则当前路径是：d:\javaproject\Test。在控制��C��面运行程序时�Q�当前�\径是class文�g所在的目录�Q�如果class文�g包含包名�Q�则以该class文�g最��层的包名作为当前�\径�?/div>

另外在Java语言的代码内部书写文件�\径时�Q�需要注意大��写�Q�大��写需要保持一��_��路径中的文�g夹名�U�区分大��写。由�?#8217;\’是Java语言中的�Ҏ��字符�Q�所以在代码内部书写文�g路径�Ӟ��例如代表“c:\test\java\Hello.java”�Ӟ��需要书写成“c:\\test\\java\\Hello.java”�?#8220;c:/test/java/Hello.java”�Q�这些都需要在代码中注意�?/div>

11.3.1.1.2 文�g名称

文�g名称一般采�?#8220;文�g�?后缀�?#8221;的�Ş式进行命名，其中“文�g�?#8221;用来表示文�g的作用，而��用后�~�名来表示文�g的类型，�q�是当前操作�pȝ��中常见的一�U��Ş式，例如“readme.txt”文�g�Q�其中readme代表该文件时说明文�g�Q�而txt后缀名代表文件时文本文�g�c�d��Q�在操作�pȝ��中，�q�会自动��特定格式的后缀名和对应的程序关联，在双击该文�g时��用特定的�E�序打开�?/div>

其实在文件名�U�只是一个标�C�，和实际存储的文�g内容没有必然的联�p�，只是使用�q�种方式方便文�g的��用。在�E�序中需要存储数据时�Q�如果自��p��计了特定的文件格式，则可以自定义文�g的后�~�名，来标�C��q��文�g�c�d��?/div>

和文件�\径一��P��在Java代码内部书写文�g名称时也区分大小写，文�g名称的大��写必须和操作系�l�中的大��写保持一致�?/div>

另外�Q�在书写文�g名称时不要忘��C��写文件的后缀名�?/div>

11.3.1.2 File�c?/div>

��Z��很方便的代表文�g的概念，以及存储一些对于文件的基本操作�Q�在java.io包中设计了一个专门的�c?#8212;—File�c�R�?/div>

在File�c�M��包含了大部分和文件操作的功能�Ҏ��Q�该�cȝ��对象可以代表一个具体的文�g或文件夹�Q�所以以前曾有�h��该�cȝ��c�d��修改成FilePath�Q�因��c�M��可以代表一个文件夹�Q�更准确的说是可以代表一个文件�\径�?/div>

下面介绍一下File�cȝ��基本使用�?/div>

1、File对象代表文�g路径

File�cȝ��对象可以代表一个具体的文�g路径�Q�在实际代表�Ӟ��可以使用�l�对路径也可以��用相对�\径�?/div>

下面是创建的文�g对象�C�Z��?/div>

public File(String pathname)

该示例中使用一个文件�\径表�C�Z��个File�cȝ��对象�Q�例如：

File f1 = new File(“d:\\test\\1.txt”);

File f2 = new File(“1.txt”);

File f3 = new File(“e:\\abc”);

�q�里的f1和f2对象分别代表一个文�Ӟ��f1是绝对�\径，而f2是相对�\径，f3则代表一个文件夹�Q�文件夹也是文�g路径的一�U��?/div>

public File(String parent, String child)

也可以��用父路径和子路径�l�合�Q�实��C��表文件�\径，例如�Q?/div>

File f4 = new File(“d:\\test\\”,”1.txt”);

�q�样代表的文件�\径是�Q�d:\test\1.txt�?/div>

2、File�c�d��用方�?/div>

File�c�M��包含了很多获得文件或文�g夹属性的�Ҏ��Q��用�v来比较方便，下面��常见的�Ҏ��介绍如下�Q?/div>

a、createNewFile�Ҏ��

public boolean createNewFile() throws IOException

该方法的作用是创建指定的文�g。该�Ҏ��只能用于创徏文�g�Q�不能用于创建文件夹�Q�且文�g路径中包含的文�g夹必��d��在�?/div>

b、delect�Ҏ��

public boolean delete()

该方法的作用是删除当前文件或文�g夏V��如果删除的是文件夹�Q�则该文件夹必须为空。如果需要删除一个非�I�的文�g夹，则需要首先删除该文�g夹内部的每个文�g和文件夹�Q�然后在可以删除�Q�这个需要书写一定的逻辑代码实现�?/div>

c、exists�Ҏ��

public boolean exists()

该方法的作用是判断当前文件或文�g�Ҏ��否存在�?/div>

d、getAbsolutePath�Ҏ��

public String getAbsolutePath()

该方法的作用是获得当前文件或文�g夹的�l�对路径。例如c:\test\1.t则返回c:\test\1.t�?/div>

e、getName�Ҏ��

public String getName()

该方法的作用是获得当前文件或文�g夹的名称。例如c:\test\1.t�Q�则�q�回1.t�?/div>

f、getParent�Ҏ��

public String getParent()

该方法的作用是获得当前�\径中的父路径。例如c:\test\1.t则返回c:\test�?/div>

g、isDirectory�Ҏ��

public boolean isDirectory()

该方法的作用是判断当前File对象是否是目录�?/div>

h、isFile�Ҏ��

public boolean isFile()

该方法的作用是判断当前File对象是否是文件�?/div>

i、length�Ҏ��

public long length()

该方法的作用是返回文件存储时占用的字节数。该数��D��得的是文件的实际大小�Q�而不是文件在存储时占用的�I�间数�?/div>

j、list�Ҏ��

public String[] list()

该方法的作用是返回当前文件夹下所有的文�g名和文�g夹名�U�。说明，该名�U�C��是绝对�\径�?/div>

k、listFiles�Ҏ��

public File[] listFiles()

该方法的作用是返回当前文件夹下所有的文�g对象�?/div>

l、mkdir�Ҏ��

public boolean mkdir()

该方法的作用是创建当前文件文件夹�Q�而不创徏该�\径中的其它文件夹。假设d盘下只有一个test文�g夹，则创建d:\test\abc文�g夹则成功�Q�如果创建d:\a\b文�g夹则创徏��p�|�Q�因��路径中d:\a文�g夹不存在。如果创建成功则�q�回true�Q�否则返回false�?/div>

m、mkdirs�Ҏ��

public boolean mkdirs()

该方法的作用是创建文件夹�Q�如果当前�\径中包含的父目录不存在时�Q�也会自动根据需要创建�?/div>

n、renameTo�Ҏ��

public boolean renameTo(File dest)

该方法的作用是修�Ҏ��件名。在修改文�g名时不能改变文�g路径�Q�如果该路径下已有该文�g�Q�则会修改失败�?/div>

o、setReadOnly�Ҏ��

public boolean setReadOnly()

该方法的作用是设�|�当前文件或文�g夹�ؓ只读�?/div>

3、File�c�d��本示�?/div>

以上各方法实现的��试代码如下�Q?/div>

import java.io.File;

/**

* File�c�M��用示�?/div>

public class FileDemo {

public static void main(String[] args) {

//创徏File对象

File f1 = new File("d:\\test");

File f2 = new File("1.txt");

File f3 = new File("e:\\file.txt");

File f4 = new File("d:\\","1.txt");

//创徏文�g

try{

boolean b = f3.createNewFile();

}catch(Exception e){

e.printStackTrace();

}

//判断文�g是否存在

System.out.println(f4.exists());

//获得文�g的绝对�\�?/div>

System.out.println(f3.getAbsolutePath());

//获得文�g�?/div>

System.out.println(f3.getName());

//获得父�\�?/div>

System.out.println(f3.getParent());

//判断是否是目�?/div>

System.out.println(f1.isDirectory());

//判断是否是文�?/div>

System.out.println(f3.isFile());

//获得文�g长度

System.out.println(f3.length());

//获得当前文�g夹下所有文件和文�g夹名�U?/div>

String[] s = f1.list();

for(int i = 0;i < s.length;i++){

System.out.println(s[i]);

}

//获得文�g对象

File[] f5 = f1.listFiles();

for(int i = 0;i < f5.length;i++){

System.out.println(f5[i]);

}

//创徏文�g�?/div>

File f6 = new File("e:\\test\\abc");

boolean b1 = f6.mkdir();

System.out.println(b1);

b1 = f6.mkdirs();

System.out.println(b1);

//修改文�g�?/div>

File f7 = new File("e:\\a.txt");

boolean b2 = f3.renameTo(f7);

System.out.println(b2);

//讄��文�g为只�?/div>

f7.setReadOnly();

}

4、File�cȝ��合示�?/div>

下面以两个示例演�C�File�cȝ��l�合使用。第一个示例是昄��某个文�g夹下的所有文件和文�g夹，原理是输出当前名�U�ͼ�然后判断当前File�?象是文�g�q�是文�g夹，如果则获得该文�g夹下的所有子文�g和子文�g夹，�q��归调用该方法实现。第二个�C�Z��是删除某个文件夹下的所有文件和文�g夹，原理是判�?是否是文�Ӟ��如果是文件则直接删除�Q�如果是文�g夹，则获得该文�g夹下所有的子文件和子文件夹�Q�然后递归调用该方法处理所有子文�g和子文�g夹，然后��空文�g 夹删除。则��试时�}慎��用第二个�Ҏ��Q�以免删除自己有用的数据文�g。示例代码如下：

import java.io.File;

/**

* 文�g�l�合使用�C�Z��

public class AdvanceFileDemo {

public static void main(String[] args) {

File f = new File("e:\\Book");

printAllFile(f);

File f1 = new File("e:\\test");

deleteAll(f1);

}

/**

* 打印f路径下所有的文�g和文件夹

* @param f 文�g对象

public static void printAllFile(File f){

//打印当前文�g�?/div>

System.out.println(f.getName());

//是否是文件夹

if(f.isDirectory()){

//获得该文件夹下所有子文�g和子文�g�?/div>

File[] f1 = f.listFiles();

//循环处理每个对象

int len = f1.length;

for(int i = 0;i < len;i++){

//递归调用�Q�处理每个文件对�?/div>

printAllFile(f1[i]);

}

/**

* 删除对象f下的所有文件和文�g�?/div>

* @param f 文�g路径

public static void deleteAll(File f){

//文�g

if(f.isFile()){

f.delete();

}else{ //文�g�?/div>

//获得当前文�g夹下的所有子文�g和子文�g�?/div>

File f1[] = f.listFiles();

//循环处理每个对象

int len = f1.length;

for(int i = 0;i < len;i++){

//递归调用�Q�处理每个文件对�?/div>

deleteAll(f1[i]);

}

//删除当前文�g�?/div>

f.delete();

}

关于File�cȝ��使用��׃��l�这么多�Q�其它的�Ҏ��和��用时需要注意的问题�q�需要多�q�行�l�习和实际��用�?/div>

11.3.1.3 ��d��文�g

虽然前面介绍了流的概念，但是�q�个概念对于初学者来��_��q�是比较抽象的，下面以实际的��d��文�g��Z��子，介绍��的概念�Q�以及输入流的基本��用�?/div>

按照前面介绍的知识，��文件中的数据读入程序，是将�E�序外部的数据传入程序中�Q�应该��用输入流——InputStream或Reader。而由于读取的是特定的数据�?#8212;—文�g�Q�则可以使用输入对应的子�c�FileInputStream或FileReader实现�?/div>

在实际书写代码时�Q�需要首先熟悉读取文件在�E�序中实现的�q�程。在Java语言的IO�~�程中，��d��文�g是分两个步骤�Q?、将文�g中的数据转换为流�Q?、读取流内部的数据。其中第一个步骤由�pȝ��完成�Q�只需要创建对应的��对象即可，对象创徏完成以后步骤1��完成了�Q�第二个步骤使用输入��对象中的read�Ҏ��卛_��实现了�?/div>

使用输入��进行编�E�时�Q�代码一般分�?个部分：1、创建流对象�Q?、读取流对象内部的数据，3、关闭流对象。下面以��d��文�g的代码示例：

import java.io.*;

/**

* 使用FileInputStream��d��文�g

public class ReadFile1 {

public static void main(String[] args) {

//声明��对�?/div>

FileInputStream fis = null;

try{

//创徏��对�?/div>

fis = new FileInputStream("e:\\a.txt");

//��d��数据�Q��ƈ��读取到的数据存储到数组�?/div>

byte[] data = new byte[1024]; //数据存储的数�l?/div>

int i = 0; //当前下标

//��d��中的第一个字节数�?/div>

int n = fis.read();

//依次��d��后箋的数�?/div>

while(n != -1){ //未到达流的末��?/div>

//��有效数据存储到数组�?/div>

data[i] = (byte)n;

//下标增加

i++;

//��d��下一个字节的数据

n = fis.read();

}

//解析数据

String s = new String(data,0,i);

//输出字符�?/div>

System.out.println(s);

}catch(Exception e){

e.printStackTrace();

}finally{

try{

//关闭��，释放资源

fis.close();

}catch(Exception e){}

}

在该�C�Z��代码中，首先创徏一个FileInputStream�c�d��的对象fis�Q?/div>

fis = new FileInputStream("e:\\a.txt");

�q�样建立了一个连接到数据源e:\a.txt的流�Q��ƈ��该数据源中的数据�{换�ؓ��对象fis�Q�以后程序读取数据源中的数据�Q�只需要从��对象fis中读取即可�?/div>

��d��fis中的数据�Q�需要��用read�Ҏ��Q�该�Ҏ��是从InputStream�c�M��l�承�q�来的方法，该方法的作用是每�ơ读取流中的一个字节，如果需要读取流中的所有数据，需要��用��@环读取，当到达流的末��时�Q�read�Ҏ��的返回值是-1�?/div>

在该�C�Z��中，首先��d��中的第一个字节：

int n = fis.read();

�q�将��d��的��D��值给int值n�Q�如果流fis为空�Q�则n的值是-1�Q�否则n中的最后一个字节包含的时流fis中的�W�一个字节，该字节被��d��以后�Q�将被从��fis中删除�?/div>

然后循环��d��中的其它数据，如果��d��到的数据不是-1�Q�则��已�l�读取到的数据n强制转换为byte�Q�即取n中的有效数据——最后一个字节，�q�存储到数组data中，然后调用��对象fis中的read�Ҏ��l�箋��d��中的下一个字节的数据。一直这样��@环下去，直到��d��到的数据�?1�Q�也��是��d��到流的末��ֈ�循环�l�束�?/div>

�q�里的数�l�长度是1024�Q�所以要求流中的数据长度不能��过1024�Q�所以该�C�Z��代码在这里具有一定的局限性。如果流的数据个数比较多�Q�则可以��?024扩大到合适的个数卛_��?/div>

�l�过上面的��@环以后，��可以将��中的数据依�ơ存储到data数组中，存储到data数组中有效数据的个数是i个，卛_�@环次数�?/div>

其实截至到这里，IO操作中的��d��数据已经完成�Q�然后再按照数据源中的数据格式，�q�里是文件的格式�Q�解析读取出的byte数组卛_��?/div>

该示例代码中的解析，只是��从��对象中��d��到的有效的数据，也就是data数组中的前n个数据，转换为字�W�串�Q�然后进行输出�?/div>

在该�C�Z��代码中，只是在catch语句中输出异常的信息�Q�便于代码的调试�Q�在实际的程序中�Q�需要根据情况进行一定的逻辑处理�Q�例如给出提�C�Z��息等�?/div>

最后在finally语句块中�Q�关闭流对象fis�Q�释放流对象占用的资源，关闭数据源，实现��操作的�l�束工作�?/div>

上面详细介绍了读取文件的�q�程�Q�其实在实际��d��数据时�Q�还可以使用其它的read�Ҏ��Q�下面的�C�Z��代码是��用另外一个read�Ҏ��实现��d��的代码：

import java.io.FileInputStream;

/**

* 使用FileInputStream��d��文�g

public class ReadFile2 {

public static void main(String[] args) {

//声明��对�?/div>

FileInputStream fis = null;

try{

//创徏��对�?/div>

fis = new FileInputStream("e:\\a.txt");

//��d��数据�Q��ƈ��读取到的数据存储到数组�?/div>

byte[] data = new byte[1024]; //数据存储的数�l?/div>

int i = fis.read(data);

//解析数据

String s = new String(data,0,i);

//输出字符�?/div>

System.out.println(s);

}catch(Exception e){

e.printStackTrace();

}finally{

try{

//关闭��，释放资源

fis.close();

}catch(Exception e){}

}

该示例代码中�Q�只使用一行代码：

int i = fis.read(data);

��实��C��流对象fis中的数据��d��到字节数�l�data中。该行代码的作用是将fis��中的数据读取出来，�q�依�ơ存储到数组data中，�q�回��gؓ实际��d��的有效数据的个数�?/div>

使用该中方式在进行读取时�Q�可以简化读取的代码�?/div>

当然�Q�在��d��文�g�Ӟ��也可以��用Reader�cȝ��子类FileReader�q�行实现�Q�在�~�写代码�Ӟ��只需要将上面�C�Z��代码中的byte数组替换成char数组卛_��?/div>

使用FileReader��d��文�g�Ӟ��是按照char为单位进行读取的�Q�所以更适合于文本文件的��d��Q�而对于二�q�制文�g或自定义格式的文件来��_��q�是使用FileInputStream�q�行��d��Q�方便对于读取到的数据进行解析和操作�?/div>

��d��其它数据源的操作和读取文件类��|��最大的区别在于建立��对象时选择的类不同�Q�而流对象一旦徏立，则基本的��d��Ҏ��是一��P��如果只��用最基本的read�Ҏ��q�行��d��Q�则使用基本上是一致的。这也是IO�c�设计的初衷�Q��得对于流对象的操作保持一��_��化IO�c�M��用的隑ֺ��?/div>

�E��?/div>

基本的输出流包含OutputStream和Writer两个�Q�区别是OutputStream体系中的�c?也就是OutputStream的子�c?是按照字节写入的�Q�而Writer体系中的�c?也就是Writer的子�c?是按照字�W�写入的�?/div>

使用输出��进行编�E�的步骤是：

1、徏立输出流

建立对应的输出流对象�Q�也��是完成由流对象到外部数据源之间的�{换�?/div>

2、向��中写入数据

��需要输出的数据�Q�调用对应的write�Ҏ��写入到流对象中�?/div>

3、关闭输出流

在写入完毕以后，调用��对象的close�Ҏ��关闭输出��，释放资源�?/div>

在��用输出流向外部输出数据时�Q�程序员只需要将数据写入��对象即可，底层的API实现��流对象中的内容写入外部数据源，�q�个写入的过�E�对于程序员来说是透明的，不需要专门书写代码实现�?/div>

在向文�g中输出数据，也就是写文�g�Ӟ��使用对应的文件输出流�Q�包括FileOutputStream和FileWriter两个�c�，下面以FileOutputStream��Z��子说明输出流的��用。示例代码如下：

import java.io.*;

/**

* 使用FileOutputStream写文件示�?/div>

public class WriteFile1 {

public static void main(String[] args) {

String s = "Java语言";

int n = 100;

//声明��对�?/div>

FileOutputStream fos = null;

try{

//创徏��对�?/div>

fos = new FileOutputStream("e:\\out.txt");

//转换为byte数组

byte[] b1 = s.getBytes();

//换行�W?/div>

byte[] b2 = "\r\n".getBytes();

byte[] b3 = String.valueOf(n).getBytes();

//依次写入文�g

fos.write(b1);

fos.write(b2);

fos.write(b3);

} catch (Exception e) {

e.printStackTrace();

}finally{

try{

fos.close();

}catch(Exception e){}

}

该示例代码写入的文�g使用��C��本打开以后�Q�内容�ؓ�Q?/div>

Java语言

100

在该�C�Z��代码中，演示了将一个字�W�串和一个int�c�d��的��g��ơ写入到同一个文件中。在写入文�g�Ӟ��首先创徏了一个文件输出流对象fos�Q?/div>

fos = new FileOutputStream("e:\\out.txt");

该对象创��Z��后，��实��C��从流到外部数据源e:\out.txt的连接。说明：当外部文件不存在�Ӟ��pȝ��会自动创��文�g�Q�但是如果文件�\径中包含未创建的目录时将出现异常。这里书写的文�g路径可以是绝对�\径也可以是相对�\径�?/div>

�?实际写入文�g�Ӟ��有两�U�写入文件的方式�Q�覆盖和�q�加。其�?#8220;覆盖”是指清除原文件的内容�Q�写入新的内容，默认采用该种形式写文�Ӟ��“�q�加”是指在已有文�?的末��ֆ�入内容，保留原来的文件内容，例如写日志文件时�Q�一般采用追加。在实际使用时可以根据需要采用适合的�Ş式，可以使用�Q?/div>

public FileOutputStream(String name, boolean append) throws FileNotFoundException

只需要��用该构造方法在构造FileOutputStream对象�Ӟ��第二个参数append的��D��|��ؓtrue卛_��?/div>

��对象创建完成以后，��可以��用OutputStream中提供的wirte�Ҏ��向流中依�ơ写入数据了。最基本的写入方法只支持byte数组格式的数据，所以如果需要将内容写入文�g�Q�则需要把对应的内定w��先�{换�ؓbyte数组�?/div>

�q�里以如下格式写入数据：首先写入字符串s�Q��用String�cȝ��getBytes�Ҏ��该字符串�{换�ؓbyte数组�Q�然后写入字�W�串“\r\n”�Q��{换方式同上，该字�W�串的作用是实现文本文�g的换行显�C�，最后写入int数据n�Q�首先将n转换为字�W�串�Q�再转换为byte数组。这�U�写入数据的��序以及转换为byte数组的方式就是流的数据格式，也就是该文�g的格式。因��里写的都是文本文�Ӟ��所以写入的内容以明文的形式昄��出来�Q�也可以�Ҏ��自己需要存储的数据讑֮�特定的文件格式�?/div>

其实�Q�所有的数据文�g�Q�包括图片文件、声��x��件等�{�，都是以一定的数据格式存储数据的，在保存该文�g�Ӟ��需要保存的数据按照该文件的数据格式依次写入卛_��Q�而在打开该文件时�Q�将��d��到的数据按照该文件的格式解析成对应的逻辑卛_��?/div>

最后，在数据写入到��内部以后，如果需要立卛_��写入��内部的数据强制输出到外部的数据源，则可以��用流对象的flush�Ҏ��实现。如果不需要强制输出，则只需要在写入�l�束以后�Q�关闭流对象卛_��。在关闭��对象时�Q�系�l�首先将��中未输出到数据源中的数据强制输出，然后再释放该��对象占用的内存�I�间�?/div>

使用FileWriter写入文�g�Ӟ��步骤和创建流对象的操作都和该�C�Z��代码一��_��只是在�{换数据时�Q�需要将写入的数据�{换�ؓchar数组�Q�对于字�W�串来说�Q�可以��用String中的toCharArray�Ҏ��实现转换�Q�然后按照文件格式写入数据即可�?/div>

对于其它�c�d��的字节输出流/字符输出��来��_��只是在逻辑上连接不同的数据源，在创建对象的代码上会存在一定的不同�Q�但是一旦流对象创徏完成以后�Q�基本的写入�Ҏ��都是write�Ҏ��Q�也需要首先将需要写入的数据按照一定的格式转换为对应的byte数组/char数组�Q�然后依�ơ写入即可�?/div>

所以IO�cȝ��q�种设计形式�Q�只需要熟悉该体系中的某一个类的��用以后，��可以触�c�L��通的学会其它相同�c�d��的类的��用，从而简化程序员的学习，使得使用时保持统一�?/div>

不高�?/a> 2013-09-17 17:51 发表评论

Netty 3.1 中文用户手册

Fri, 07 Jun 2013 08:11:00 GMT

序言

本指南对Netty �q�行了介�l��ƈ指出其意义所在�?br />

1. 问题

现在�Q�我们��用适合一般用途的应用或组件来和彼此通信。例如，我们常常使用一个HTTP客户端从�q�程服务器获取信息或者通过web services�q�行�q�程�Ҏ��的调用�?br />
然而，一个适合普通目的的协议或其实现�q�不具备其规模上的扩展性。例如，我们无法使用一个普通的HTTP服务器进行大型文�Ӟ��电邮信息的交互，或者处理金融信息和多�h游戏数据那种要求准实时消息传递的应用场景。因此，�q�些都要求��用一个适用于特�D�目的�ƈ�l�过高度优化的协议实现。例如，你可能想要实��C��个对 ��Z��AJAX的聊天应用，媒体��或大文件传输进行过�Ҏ��优化的HTTP服务器。你甚至可能惛_��设计和实��C��个全新的�Q�特定于你的需求的通信协议�?br />
另一�U�无法避免的场景是你可能不得不��用一�U�专有的协议和原有系�l�交互。在�q�种情况下，你需要考虑的是如何能够快速的开发出�q�个协议的实现�ƈ且同时还没有牺牲最�l�应用的性能和稳定性�?br />

2. �Ҏ��

Netty 是一个异步的�Q�事仉��动的�|�络�~�程框架和工��P��使用Netty 可以快速开发出可维护的�Q�高性能、高扩展能力的协议服务及其客��L��应用�?br />
也就是说�Q�Netty 是一个基于NIO的客��P��服务器端�~�程框架�Q��用Netty 可以��保你快速和��单的开发出一个网�l�应用，例如实现了某�U�协议的客户�Q�服务端应用。Netty相当��化和��线化了�|�络应用的编�E�开发过�E�，例如�Q�TCP和UDP的socket服务开发�?br />
“快�?#8221;�?#8220;��?#8221;�q�不意味着会让你的最�l�应用��生维护性或性能上的问题。Netty 是一个吸收了多种协议的实现经验，�q�些协议包括FTP,SMPT,HTTP�Q�各�U�二�q�制�Q�文本协议，�q�经�q�相当精心设计的��目�Q�最�l�，Netty 成功的找��C��一�U�方式，在保证易于开发的同时�q�保证了其应用的性能�Q�稳定性和伸羃性�?br />
一些用户可能找��C��某些同样声称��h��q�些�Ҏ��的�~�程框架�Q�因此你们可能想问Netty 又有什么不一��L��地方。这个问题的�{�案是Netty ��目的设计哲学。从创立之初�Q�无论是在API�q�是在其实现上Netty 都致力于��Z��提供最��适的使用体验。虽然这�q�不是显而易见的�Q�但你终��会认识到这�U�设计哲学将令你在阅��L��指南和��用Netty 时变得更加得��L��和容易�?br />
�W�一�? 开�?br />

�q�一章节��围�l�Netty的核心结构展开�Q�同旉��过一些简单的例子可以让你更快的了解Netty的��用。当你读完本章，你将有能力��用Netty完成客户端和服务端的开发�?br />
如果你更喜欢自上而下式的学习方式�Q�你可以首先完成 �W�二章：架构总览的学习，然后再回到这里�?br />
1.1. 开始之�?br />

�q�行本章�C�Z��E�序的两个最低要求是�Q�最新版本的Netty�E�序以及JDK 1.5或更高版本。最新版本的Netty�E�序可在��目下蝲��?下蝲。下载正��版本的JDK�Q�请��C��偏好的JDK站点下蝲�?br />
�q�就已经��_��了吗�Q�实际上你会发现�Q�这两个条�g已经��_��你完成�Q何协议的开发了。如果不是这��P��误��p�Netty��目�C�֌� �Q�让我们知道�q�缺��了什么�?br />
最�l�但不是臛_��Q�当你想了解本章所介绍的类的更多信息时请参考API手册。�ؓ方便你的使用�Q�这��文档中所有的�c�d��均连接至在线API手册。此外，如果本篇文档中有��M��错误信息�Q�无论是语法错误�Q�还是打印排版错误或者你有更好的��Q�请不要��虑�Q�立卌��p�Netty��目�C�֌� �?br />
1.2. 抛弃协议服务

在这个世界上最��化的协议不是“Hello,world!”而是抛弃协议。这是一�U�丢弃接收到的�Q何数据�ƈ不做��M��回应的协议�?br />
实现抛弃协议�Q�DISCARD protocol�Q�，你仅需要忽略接受到的�Q何数据即可。让我们直接从处理器�Q�handler�Q�实现开始，�q�个处理器处理Netty的所有I/O事�g�?br />
Java代码
package org.jboss.netty.example.discard;

@ChannelPipelineCoverage("all")1
public class DiscardServerHandler extends SimpleChannelHandler {2

@Override
public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) {3
}

@Override
public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e) {4
e.getCause().printStackTrace();

Channel ch = e.getChannel();
ch.close();
}
}

代码说明

1)ChannelPipelineCoverage注解了一�U�处理器�c�d��Q�这个注解标�C�Z��一个处理器�?否可被多个Channel通道�׃�n�Q�同时关联着ChannelPipeline�Q�。DiscardServerHandler没有处理��M��有状态的信息�Q?因此�q�里的注解是“all”�?br />
2)DiscardServerHandler�l�承了SimpleChannelHandler�Q�这也是一个ChannelHandler 的实现。SimpleChannelHandler提供了多�U�你可以重写的事件处理方法。目前直接��承SimpleChannelHandler已经��_�� 了，�q�不需要你完成一个自��q��处理器接口�?br />
3)我们�q�里重写了messageReceived事�g处理�Ҏ��。这个方法由一个接收了客户端传送数据的MessageEvent事�g调用。在�q�个例子中，我们忽略接收到的��M��数据�Q��ƈ以此来实��C��个抛弃协议（DISCARD protocol�Q��?br />
4)exceptionCaught 事�g处理�Ҏ��׃��个ExceptionEvent异常事�g调用�Q�这个异�怺�件�v因于Netty的I/O异常或一个处理器实现的内部异常。多数情况下�Q�捕�?到的异常应当被记录下来，�q�在�q�个�Ҏ��中关闭这个channel通道。当然处理这�U�异常情�늚��Ҏ��实现可能因你的实际需求而有所不同�Q�例如，在关闭这个连接之前你可能会发送一个包含了错误码的响应消息�?br />
目前�q�展不错�Q�我们已�l�完成了抛弃协议服务器的一半开发工作。下面要做的是完成一个可以启动这个包含DiscardServerHandler处理器服务的��L��法�?br />

Java代码
package org.jboss.netty.example.discard;

import java.net.InetSocketAddress;
import java.util.concurrent.Executors;

public class DiscardServer {

public static void main(String[] args) throws Exception {
ChannelFactory factory =
new NioServerSocketChannelFactory (
Executors.newCachedThreadPool(),
Executors.newCachedThreadPool());

ServerBootstrap bootstrap = new ServerBootstrap (factory);

DiscardServerHandler handler = new DiscardServerHandler();
ChannelPipeline pipeline = bootstrap.getPipeline();
pipeline.addLast("handler", handler);

bootstrap.setOption("child.tcpNoDelay", true);
bootstrap.setOption("child.keepAlive", true);

bootstrap.bind(new InetSocketAddress(8080));
}
}

代码说明

1)ChannelFactory 是一个创建和��理Channel通道及其相关资源的工厂接口，它处理所有的I/O��h��q��生相应的I/O ChannelEvent通道事�g。Netty 提供了多�U?ChannelFactory 实现。这里我们需要实��C��个服务端的例子，因此我们使用NioServerSocketChannelFactory实现。另一仉��要注意的事情是这个工厂�ƈ自己不负责创建I/O�U�程。你应当在其构造器中指定该工厂使用的线�E�池�Q�这样做的好处是你获得了更高的控制力来管理你的应用环境中使用的线�E�，例如一个包含了安全��理的应用服务�?br />
2)ServerBootstrap 是一个设�|�服务的帮助�c�R��你甚至可以在这个服务中直接讄��一个Channel通道。然而请注意�Q�这是一个繁琐的�q�程�Q�大多数情况下�ƈ不需要这样做�?br />
3)�q�里�Q�我们将DiscardServerHandler处理器添加至默认的ChannelPipeline通道。�Q何时候当服务器接收到一个新的连接，一个新的ChannelPipeline��道对象��被创徏�Q��ƈ且所有在�q�里��d��的ChannelHandler对象��被��d��臌��个新�?ChannelPipeline��道对象。这很像是一�U�浅拯��操作�Q�a shallow-copy operation�Q�；所有的Channel通道以及其对应的ChannelPipeline实例��分享相同的DiscardServerHandler 实例�?br />
4)你也可以讄��我们在这里指定的�q�个通道实现的配�|�参数。我们正在写的是一个TCP/IP服务�Q�因此我们运行设定一些socket选项�Q�例�?tcpNoDelay和keepAlive。请注意我们在配�|�选项里添加的"child."前缀。这意味着�q�个配置��仅适用于我们接收到的通道实例�Q�而不是ServerSocketChannel实例。因此，你可以这��L��一个ServerSocketChannel讑֮�参数�Q?br />bootstrap.setOption("reuseAddress", true);

5)我们�l�箋。剩下要做的是绑定这个服务��用的端口�q�且启动�q�个服务。这里，我们�l�定本机所有网卡（NICs,network interface cards�Q�上�?080端口。当�Ӟ��你现在也可以对应不同的绑定地址多次调用�l�定操作�?br />
大功告成�Q�现在你已经完成你的�W�一个基于Netty的服务端�E�序�?br />
1.3. 查看接收到的数据

现在你已�l�完成了你的�W�一个服务端�E�序�Q�我们需要测试它是否可以真正的工作。最��单的�Ҏ��是��用telnet 命��o。例如，你可以在命��o行中输入“telnet localhost 8080 ”或其他类型参数�?br />
然而，我们可以认�ؓ服务器在正常工作吗？�׃��q�是一个丢球协议服务，所以实际上我们无法真正的知道。你最�l�将收不��C�Q何回应。�ؓ了证明它在真正的工作�Q�让我们修改代码打印其接收到的数据�?br />我们已经知道当完成数据的接收后将产生MessageEvent消息事�g�Q��ƈ且也会触发messageReceived处理�Ҏ��。所以让我在DiscardServerHandler处理器的messageReceived�Ҏ��内增加一些代码�?br />
Java代码
@Override
public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) {
ChannelBuffer buf = (ChannelBuffer) e.getMessage();
while(buf.readable()) {
System.out.println((char) buf.readByte());
}
}

代码说明

1) 基本上我们可以假定在socket的传输中消息�c�d��L��ChannelBuffer。ChannelBuffer是Netty的一个基本数据结构，�q�个�?据结构存储了一个字节序列。ChannelBuffer�c�M��于NIO的ByteBuffer�Q�但是前者却更加的灵�z�d��易于使用。例如，Netty允许你创 ��Z��个由多个ChannelBuffer构徏的复合ChannelBuffer�c�d��Q�这样就可以减少不必要的内存拯��ơ数�?br />
2) 虽然ChannelBuffer有些�c�M��于NIO的ByteBuffer�Q�但强烈��你参考Netty的API手册。学会如何正��的使用ChannelBuffer是无障碍使用Netty的关键一步�?br />
如果你再�ơ运行telnet命��o�Q�你��会看到你所接收到的数据�?br />抛弃协议服务的所有源代码均存攑֜�在分发版的org.jboss.netty.example.discard包下�?br />

1.4. 响应协议服务

目前�Q�我们虽然��用了数据�Q�但最�l�却未作��M��回应。然而一般情况下�Q�一个服务都需要回应一个请求。让我们实现ECHO协议来学习如何完成一个客戯��求的回应消息�Q�ECHO协议规定要返回�Q何接收到的数据�?br />
与我们上一节实现的抛弃协议服务唯一不同的地�Ҏ��Q�这里需要返回所有的接收数据而不是仅仅打印在控制��C��上。因此我们再�ơ修改messageReceived�Ҏ��p��够了�?br />
Java代码
@Override
public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) {
Channel ch = e.getChannel();
ch.write(e.getMessage());
}
代码说明
1) 一个ChannelEvent通道事�g对象自��n存有一个和其关联的Channel对象引用。这个返回的Channel通道对象代表了这个接�?MessageEvent消息事�g的连接（connection�Q�。因此，我们可以通过调用�q�个Channel通道对象的write�Ҏ��向远�E�节点写入返回数据�?br />
现在如果你再�ơ运行telnet命��o�Q�你��会看到服务器返回的你所发送的��M��数据�?br />
相应服务的所有源代码存放在分发版的org.jboss.netty.example.echo包下�?br />
1.5. 旉��协议服务

�q�一节需要实现的协议是TIME协议。这是一个与先前所介绍的不同的例子。这个例子里�Q�服务端�q�回一�?2位的整数消息�Q�我们不接受��h��中包含的��M��数据�q�且当消息返回完毕后立即关闭�q�接。通过�q�个例子你将学会如何构徏和发送消息，以及当完成处理后如何��d��关闭�q�接�?br />
因�ؓ我们会忽略接收到的�Q何数据而只是返回消息，�q�应当在建立�q�接后就立即开始。因此这�ơ我们不再��用messageReceived�Ҏ��Q�取而代之的是��用channelConnected�Ҏ��。下面是具体的实玎ͼ�

Java代码
package org.jboss.netty.example.time;

@ChannelPipelineCoverage("all")
public class TimeServerHandler extends SimpleChannelHandler {

@Override
public void channelConnected(ChannelHandlerContext ctx, ChannelStateEvent e) {
Channel ch = e.getChannel();

ChannelBuffer time = ChannelBuffers.buffer(4);
time.writeInt(System.currentTimeMillis() / 1000);

ChannelFuture f = ch.write(time);

f.addListener(new ChannelFutureListener() {
public void operationComplete(ChannelFuture future) {
Channel ch = future.getChannel();
ch.close();
}
});
}

@Override
public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e) {
e.getCause().printStackTrace();
e.getChannel().close();
}
}

代码说明
1) 正如我们解释�q�的�Q�channelConnected�Ҏ��在一个连接徏立后立即触发。因此让我们在这个方法里完成一个代表当前时��_��U�）�?2位整数消息的构徏工作�?br />
2) ��Z��发送一个消息，我们需要分配一个包含了�q�个消息的buffer�~�冲。因为我们将要写入一�?2位的整数�Q�因此我们需要一�?字节�?ChannelBuffer。ChannelBuffers是一个可以创建buffer�~�冲的帮助类。除了这个buffer�?法，ChannelBuffers�q�提供了很多和ChannelBuffer相关的实用方法。更多信息请参考API手册�?br />
另外�Q�一个很不错的方法是使用静态的导入方式�Q?br />import static org.jboss.netty.buffer.ChannelBuffers.*;
...
ChannelBuffer dynamicBuf = dynamicBuffer(256);
ChannelBuffer ordinaryBuf = buffer(1024);

3) 像通常一��P��我们需要自己构造消息�?br />
但是打住�Q�flip在哪�Q�过��L��们在使用NIO发送消息时不是常常需要调�?ByteBuffer.flip()�Ҏ��吗？实际上ChannelBuffer之所以不需要这个方法是因�ؓ ChannelBuffer有两个指针；一个对应读操作�Q�一个对应写操作。当你向一�?ChannelBuffer写入数据的时候写指针的烦引��g��会增加，但与此同时读指针的烦引��g��会有��M��变化。读写指针的索引值分别代表了�q�个消息的开始、结束位�|��?br />
与之相应的是�Q�NIO的buffer�~�冲没有为我们提供如此简�z�的一�U�方法，除非你调用它的flip�Ҏ��。因此，当你忘记调用flip�Ҏ��而引起发送错�?�Ӟ��你便会陷入困境。这��L��错误不会再Netty中发生，因�ؓ我们对应不同的操作类型有不同的指针。你会发现就像你已习惯的�q�样�q�程变得更加�Ҏ��—一�U�没有flippling的体验！

另一炚w��要注意的是这个写�Ҏ��q�回了一个ChannelFuture对象。一个ChannelFuture 对象代表了一个尚未发生的I/O操作。这意味着�Q��Q何已��h��的操作都可能是没有被立即执行的，因�ؓ在Netty内部所有的操作都是异步的。例如，下面的代码可能会关闭一个连接，�q�个操作甚至会发生在消息发送之前：

Channel ch = ...;
ch.write(message);
ch.close();

因此�Q�你需要这个write�Ҏ��q�回的ChannelFuture对象�Q�close�Ҏ��需要等待写操作异步完成之后的ChannelFuture通知/监听触发。需要注意的是，关闭�Ҏ��仍旧不是立即关闭一个连接，它同样也是返回了一个ChannelFuture对象�?br />
4) 在写操作完成之后我们又如何得到通知�Q�这个只需要简单的��个返回的ChannelFuture对象增加一个ChannelFutureListener 卛_��。在�q�里我们创徏了一个匿名ChannelFutureListener对象�Q�在�q�个ChannelFutureListener对象内部我们处理�?异步操作完成之后的关闭操作�?br />
另外�Q�你也可以通过使用一个预定义的监听类来简化代码�?br />f.addListener(ChannelFutureListener.CLOSE);

1.6. 旉��协议服务客户�?br />

不同于DISCARD和ECHO协议服务�Q�我们需要一个时间协议服务的客户端，因�ؓ��Z��无法直接��一�?2位的二进制数据�{换一个日历时间。在�q�一节我们将学习如何��保服务器端工作正常�Q�以及如何��用Netty完成客户端的开发�?br />
使用Netty开发服务器端和客户端代码最大的不同是要求��用不同的Bootstrap及ChannelFactory。请参照以下的代码：

Java代码
package org.jboss.netty.example.time;

import java.net.InetSocketAddress;
import java.util.concurrent.Executors;

public class TimeClient {

public static void main(String[] args) throws Exception {
String host = args[0];
int port = Integer.parseInt(args[1]);

ChannelFactory factory =
new NioClientSocketChannelFactory (
Executors.newCachedThreadPool(),
Executors.newCachedThreadPool());

ClientBootstrap bootstrap = new ClientBootstrap (factory);

TimeClientHandler handler = new TimeClientHandler();
bootstrap.getPipeline().addLast("handler", handler);

bootstrap.setOption("tcpNoDelay" , true);
bootstrap.setOption("keepAlive", true);

bootstrap.connect (new InetSocketAddress(host, port));
}
}
代码说明
1) 使用NioClientSocketChannelFactory而不是NioServerSocketChannelFactory来创建客��L��的Channel通道对象�?br />
2) 客户端的ClientBootstrap对应ServerBootstrap�?br />
3) ��h��意，�q�里不存在��?#8220;child.”前缀的配�|�项�Q�客��L��的SocketChannel实例不存在父�U�Channel对象�?br />
4) 我们应当调用connect�q�接�Ҏ��Q�而不是之前的bind�l�定�Ҏ��?br />
正如你所看到的，�q�与服务端的启动�q�程是完全不一��L��。ChannelHandler又该如何实现呢？它应当负责接收一�?2位的整数�Q�将其�{换�ؓ可读的格式后�Q�打印输出时��_��q�关闭这个连接�?br />

Java代码
package org.jboss.netty.example.time;

import java.util.Date;

@ChannelPipelineCoverage("all")
public class TimeClientHandler extends SimpleChannelHandler {

@Override
public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) {
ChannelBuffer buf = (ChannelBuffer) e.getMessage();
long currentTimeMillis = buf.readInt() * 1000L;
System.out.println(new Date(currentTimeMillis));
e.getChannel().close();
}

@Override
public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e) {
e.getCause().printStackTrace();
e.getChannel().close();
}
}

�q�看��h��很是��单，与服务端的实��C��q�未有什么不同。然而，�q�个处理器却时常会因为抛出IndexOutOfBoundsException异常而拒�l�工作。我们将在下一节讨��个问题��生的原因�?br />
1.7. ��数据的传输处理

1.7.1. Socket Buffer的缺�?br />

对于例如TCP/IP�q�种��Z��的传输协议实现�Q�接收到的数据会被存储在socket的接受缓冲区内。不�q�的是，�q�种��Z��的传输�~�冲区�ƈ不是一个包�?列，而是一个字节队列。这意味着�Q�即使你以两个数据包的�Ş式发送了两条消息�Q�操作系�l�却不会把它们看成是两条消息�Q�而仅仅是一个批�ơ的字节序列。因此，�?�q�种情况下我们就无法保证收到的数据恰好就是远�E�节�Ҏ��发送的数据。例如，让我们假设一个操作系�l�的TCP/IP堆栈收到了三个数据包�Q?br />

+-----+-----+-----+
| ABC | DEF | GHI |
+-----+-----+-----+

�׃��q�种��传输协议的普遍性质�Q�在你的应用中有较高的可能会把这些数据读取�ؓ另外一�U��Ş式：

+----+-------+---+---+
| AB | CDEFG | H | I |
+----+-------+---+---+

因此对于数据的接收方�Q�不��是服务端还是客��L��Q�应当重构这些接收到的数据，让其变成一�U�可让你的应用逻辑易于理解的更有意义的数据�l�构。在上面所�q�的�q�个例子中，接收到的数据应当重构��Z��面的形式�Q?br />

+-----+-----+-----+
| ABC | DEF | GHI |
+-----+-----+-----+

1.7.2. �W�一�U�方�?br />

现在让我们回到时间协议服务客��L��的例子中。我们在�q�里遇到了同��L��问题。一�?2位的整数是一个非常小的数据量�Q�因此它常常不会被切分在不同的数据段内。然而，问题是它��实可以被切分在不同的数据段内，�q�且�q�种可能性随着��量的增加而提高�?br />
最��单的�Ҏ��是在�E�序内部创徏一个可准确接收4字节数据的篏�U�性缓册Ӏ�下面的代码是修复了�q�个问题后的TimeClientHandler实现�?br />

Java代码
package org.jboss.netty.example.time;

import static org.jboss.netty.buffer.ChannelBuffers.*;

import java.util.Date;

@ChannelPipelineCoverage("one")
public class TimeClientHandler extends SimpleChannelHandler {

private final ChannelBuffer buf = dynamicBuffer();

@Override
public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) {
ChannelBuffer m = (ChannelBuffer) e.getMessage();
buf.writeBytes(m);

if (buf.readableBytes() >= 4) {
long currentTimeMillis = buf.readInt() * 1000L;
System.out.println(new Date(currentTimeMillis));
e.getChannel().close();
}
}

@Override
public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e) {
e.getCause().printStackTrace();
e.getChannel().close();
}
}

代码说明

1) �q�一�ơ我们��?#8220;one”做�ؓChannelPipelineCoverage的注解倹{��这是由于这个修改后的TimeClientHandler不在�?在内部保持一个buffer�~�冲�Q�因此这个TimeClientHandler实例不可以再被多个Channel通道或ChannelPipeline�?享。否则这个内部的buffer�~�冲��无法缓冲正��的数据内容�?br />
2) 动态的buffer�~�冲也是ChannelBuffer的一�U�实玎ͼ�其拥有动态增加缓冲容量的能力。当你无法预估消息的数据长度�Ӟ��动态的buffer�~�冲是一�U�很有用的缓冲结构�?br />
3) 首先�Q�所有的数据��会被篏�U�的�~�冲至buf容器�?br />
4) 之后�Q�这个处理器��会��查是否收��C��_��的数据然后再�q�行真实的业务逻辑处理�Q�在�q�个例子中需要接�?字节数据。否则，Netty��重复调用messageReceived�Ҏ��Q�直�?字节数据接收完成�?br />
�q�里�q�有另一个地斚w��要进行修攏V��你是否�q�记得我们把TimeClientHandler实例��d��C��q�个ClientBootstrap实例的默认ChannelPipeline��道里？�q�意味着同一个TimeClientHandler实例��被多个Channel通道�׃�n�Q�因此接受的数据也将�?到破坏。�ؓ了给每一个Channel通道创徏一个新的TimeClientHandler实例�Q�我们需要实��C��?ChannelPipelineFactory��道工厂�Q?br />
Java代码
package org.jboss.netty.example.time;

public class TimeClientPipelineFactory implements ChannelPipelineFactory {

public ChannelPipeline getPipeline() {
ChannelPipeline pipeline = Channels.pipeline();
pipeline.addLast("handler", new TimeClientHandler());
return pipeline;
}
}

现在�Q�我们需要把TimeClient下面的代码片�D�：

Java代码
TimeClientHandler handler = new TimeClientHandler();
bootstrap.getPipeline().addLast("handler", handler);

替换为：

Java代码
bootstrap.setPipelineFactory(new TimeClientPipelineFactory());

虽然�q�看上去有些复杂�Q��ƈ且由于在TimeClient内部我们只创��Z��一个连接（connection�Q�，因此我们在这里确实没必要引入TimeClientPipelineFactory实例�?br />
然而，当你的应用变得越来越复杂�Q�你��M��需要实现自��q��ChannelPipelineFactory�Q�这个管道工厂将会��o你的��道配置变得更加��h��灉|��性�?br />
1.7.3. �W�二�U�方�?br />

虽然�W�二�U�方案解决了旉��协议客户端遇到的问题�Q�但是这个修改后的处理器实现看上��d��不再那么��z�。设想一�U�更为复杂的�Q�由多个可变长度字段�l�成的协议。你的ChannelHandler实现��变得越来越难以�l�护�?br />
正如你已注意到的�Q�你可以��Z��个ChannelPipeline��d��多个ChannelHandler�Q�因此，��Z��减小应用的复杂性，你可以把�q�个臃肿�?ChannelHandler切分为多个独立的模块单元。例如，你可以把TimeClientHandler切分��Z��个独立的处理器：

TimeDecoder�Q�解��x��据分�D늚�问题�?br /> TimeClientHandler�Q�原始版本的实现�?br />�q�运的是�Q�Netty提供了一个可扩展的类�Q�这个类可以直接拿过来��用帮你完成TimeDecoder的开发：

Java代码
package org.jboss.netty.example.time;

public class TimeDecoder extends FrameDecoder {

@Override
protected Object decode(
ChannelHandlerContext ctx, Channel channel, ChannelBuffer buffer) {

if (buffer.readableBytes() < 4) {
return null;
}

return buffer.readBytes(4);
}
}

代码说明
1) �q�里不再需要��用ChannelPipelineCoverage的注解，因�ؓFrameDecoder��L��被注解�ؓ“one”�?br />
2) 当接收到新的数据后，FrameDecoder会调用decode�Ҏ��Q�同时传入一个FrameDecoder内部持有的篏�U�型buffer�~�冲�?br />
3) 如果decode�q�回null��|��q�意味着�q�没有接收到��_��的数据。当有��够数量的数据后FrameDecoder会再�ơ调用decode�Ҏ��?br />
4) 如果decode�Ҏ��q�回一个非�I��|��q�意味着decode�Ҏ��已经成功完成一条信息的解码。FrameDecoder��丢弃这个内部的累计型缓册Ӏ�请�?意你不需要对多条消息�q�行解码�Q�FrameDecoder��保持对decode�Ҏ��的调用，直到decode�Ҏ��q�回非空对象�?br />
如果你是一个勇于尝试的人，你或许应当��用ReplayingDecoder�Q�ReplayingDecoder更加��化了解码的过�E�。�ؓ此你需要查看API手册获得更多的帮助信息�?br />
Java代码
package org.jboss.netty.example.time;

public class TimeDecoder extends ReplayingDecoder {

@Override
protected Object decode(
ChannelHandlerContext ctx, Channel channel,
ChannelBuffer buffer, VoidEnum state) {

return buffer.readBytes(4);
}
}

此外�Q�Netty�q��ؓ你提供了一些可以直接��用的decoder实现�Q�这些decoder实现不仅可以让你非常�Ҏ��的实现大多数协议�Q��ƈ且还会帮你避免某些臃�ѝ��难以维护的处理器实现。请参考下面的代码包获得更加详�l�的实例�Q?br />
org.jboss.netty.example.factorial for a binary protocol, and
org.jboss.netty.example.telnet for a text line-based protocol
1.8. 使用POJO代替ChannelBuffer

目前为止所有的实例�E�序都是使用ChannelBuffer做�ؓ协议消息的原始数据结构。在�q�一节，我们��改�q�时间协议服务的客户/服务端实玎ͼ�使用POJO 而不是ChannelBuffer做�ؓ协议消息的原始数据结构�?br />
在你的ChannelHandler实现中��用POJO的优势是很明昄��Q�从你的ChannelHandler实现中分��M��ChannelBuffer�?取数据的代码�Q�将有助于提高你的ChannelHandler实现的可�l�护性和可重用性。在旉��协议服务的客�?服务端代码中�Q�直接��?ChannelBuffer��d��一�?2位的整数�q�不是一个主要的问题。然而，你会发现�Q�当你试囑֮��C��个真实的协议的时候，�q�种代码上的分离是很有必�?的�?br />
首先�Q�让我们定义一个称之�ؓUnixTime的新�c�d��?br />
Java代码
package org.jboss.netty.example.time;

import java.util.Date;

public class UnixTime {
private final int value;

public UnixTime(int value) {
this.value = value;
}

public int getValue() {
return value;
}

@Override
public String toString() {
return new Date(value * 1000L).toString();
}
}

现在让我们重��C��改TimeDecoder实现�Q�让其返回一个UnixTime�Q�而不是一个ChannelBuffer�?br />
Java代码
@Override
protected Object decode(
ChannelHandlerContext ctx, Channel channel, ChannelBuffer buffer) {
if (buffer.readableBytes() < 4) {
return null;
}

return new UnixTime(buffer.readInt());
}

FrameDecoder和ReplayingDecoder允许你返回一个�Q何类型的对象。如果它们仅允许�q�回一个ChannelBuffer�c?型的对象�Q�我们将不得不插入另一个可以从ChannelBuffer对象转换为UnixTime对象的ChannelHandler实现�?br />

有了�q�个修改后的decoder实现�Q�这个TimeClientHandler便不会再依赖ChannelBuffer�?br />
Java代码
@Override
public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) {
UnixTime m = (UnixTime) e.getMessage();
System.out.println(m);
e.getChannel().close();
}

更加��单优雅了�Q�不是吗�Q�同��L��技巧也可以应用在服务端�Q�让我们现在更新TimeServerHandler的实玎ͼ�

Java代码
@Override
public void channelConnected(ChannelHandlerContext ctx, ChannelStateEvent e) {
UnixTime time = new UnixTime(System.currentTimeMillis() / 1000);
ChannelFuture f = e.getChannel().write(time);
f.addListener(ChannelFutureListener.CLOSE);
}

现在剩下的唯一需要修改的部分是这个ChannelHandler实现�Q�这个ChannelHandler实现需要把一个UnixTime对象重新转换��Z��个ChannelBuffer。但�q�却已是相当��单了�Q�因为当你对消息�q�行�~�码的时候你不再需要处理数据包的拆分及�l�装�?br />
Java代码
package org.jboss.netty.example.time;

import static org.jboss.netty.buffer.ChannelBuffers.*;

@ChannelPipelineCoverage("all")
public class TimeEncoder extends SimpleChannelHandler {

public void writeRequested(ChannelHandlerContext ctx, MessageEvent e) {
UnixTime time = (UnixTime) e.getMessage();

ChannelBuffer buf = buffer(4);
buf.writeInt(time.getValue());

Channels.write(ctx, e.getFuture(), buf);
}
}

代码说明

1) 因�ؓ�q�个encoder是无状态的�Q�所以其使用的ChannelPipelineCoverage注解值是“all”。实际上�Q�大多数encoder实现都是无状态的�?br />
2) 一个encoder通过重写writeRequested�Ҏ��来实现对写操作请求的拦截。不�q�请注意虽然�q�个writeRequested�Ҏ��使用了和 messageReceived�Ҏ��一��L��MessageEvent参数�Q�但是它们却分别对应了不同的解释。一个ChannelEvent事�g可以既是一个上升流事�g�Q�upstream event�Q�也可以是一个下降流事�g�Q�downstream event�Q�，�q�取决于事�g��的方向。例如：一个MessageEvent消息事�g可以作�ؓ一个上升流事�g�Q�upstream event�Q�被messageReceived�Ҏ��调用�Q�也可以作�ؓ一个下降流事�g�Q�downstream event�Q�被writeRequested�Ҏ��调用。请参考API手册获得上升��事�Ӟ��upstream event�Q�和下降��事�Ӟ��downstream event�Q�的更多信息�?br />
3) 一旦完成了POJO和ChannelBuffer转换�Q�你应当��保把这个新的buffer�~�冲转发臛_��前的 ChannelDownstreamHandler处理�Q�这个下降通道的处理器由某个ChannelPipeline��理。Channels提供了多个可以创建和发送ChannelEvent事�g的帮助方法。在�q�个例子中，Channels.write(...)�Ҏ��创徏了一个新�?MessageEvent事�g�Q��ƈ把这个事件发送给了先前的处于某个ChannelPipeline内的 ChannelDownstreamHandler处理器�?br />
另外�Q�一个很不错的方法是使用静态的方式导入Channels�c�：

import static org.jboss.netty.channel.Channels.*;
...
ChannelPipeline pipeline = pipeline();
write(ctx, e.getFuture(), buf);
fireChannelDisconnected(ctx);

最后的��d��是把�q�个TimeEncoder插入服务端的ChannelPipeline�Q�这是一个很��单的步骤�?br />
1.9. 关闭你的应用

如果你运行了TimeClient�Q�你肯定可以注意刎ͼ��q�个应用�q�没有自动退��只是在那里保持着无意义的�q�行。跟�t�堆栈记录你可以发现�Q�这里有一些运�?状态的I/O�U�程。�ؓ了关闭这些I/O�U�程�q�让应用优雅的退出，你需要释放这些由ChannelFactory分配的资源�?br />
一个典型的�|�络应用的关闭过�E�由以下三步�l�成�Q?br />
关闭负责接收所有请求的server socket�?br />关闭所有客��L��socket或服务端为响应某个请求而创建的socket�?br />释放ChannelFactory使用的所有资源�?br />��Z��让TimeClient执行�q�三步，你需要在TimeClient.main()�Ҏ��内关闭唯一的客戯��接以及ChannelFactory使用的所有资源，�q�样做便可以优雅的关闭这个应用�?br />
Java代码
package org.jboss.netty.example.time;

public class TimeClient {
public static void main(String[] args) throws Exception {
...
ChannelFactory factory = ...;
ClientBootstrap bootstrap = ...;
...
ChannelFuture future = bootstrap.connect(...);
future.awaitUninterruptible();
if (!future.isSuccess()) {
future.getCause().printStackTrace();
}
future.getChannel().getCloseFuture().awaitUninterruptibly();
factory.releaseExternalResources();
}
}
代码说明
1) ClientBootstrap对象的connect�Ҏ��q�回一个ChannelFuture对象�Q�这个ChannelFuture对象��告知这个连接操作的成功或失败状态。同时这个ChannelFuture对象也保存了一个代表这个连接操作的Channel对象引用�?br />
2) ��d��式的�{�待�Q�直到ChannelFuture对象�q�回�q�个�q�接操作的成功或��p�|状态�?br />
3) 如果�q�接��p�|�Q�我们将打印�q�接��p�|的原因。如果连接操作没有成功或者被取消�Q�ChannelFuture对象的getCause()�Ҏ��返回连接失败的原因�?br />
4) 现在�Q�连接操作结束，我们需要等待�ƈ且一直到�q�个Channel通道�q�回的closeFuture关闭�q�个�q�接。每一个Channel都可获得自己的closeFuture对象�Q�因此我们可以收到通知�q�在�q�个关闭旉��Ҏ��行某�U�操作�?br />
�q�且即�ɘq�个�q�接操作��p�|�Q�这个closeFuture仍旧会收到通知�Q�因��个代表连接的 Channel对象��会在连接操作失败后自动关闭�?br />
5) 在这个时间点�Q�所有的�q�接已被关闭。剩下的唯一工作是释放ChannelFactory通道工厂使用的资源。这一步仅需要调�?releaseExternalResources()�Ҏ��卛_��。包括NIO Secector和线�E�池在内的所有资源将被自动的关闭和终止�?br />
关闭一个客��L��应用是很��单的�Q�但又该如何关闭一个服务端应用呢？你需要释攑օ��l�定的端口�ƈ关闭所有接受和打开的连接。�ؓ了做到这一点，你需要��用一�U�数据结构记录所有的�z�d��q�接�Q�但�q�却�q�不是一件容易的事。幸�q�的是，�q�里有一�U�解��x��案，ChannelGroup�?br />
ChannelGroup是Java 集合 API的一个特有扩展，ChannelGroup内部持有所有打开状态的Channel通道。如果一个Channel通道对象被加入到 ChannelGroup�Q�如果这个Channel通道被关闭，ChannelGroup��自动移除这个关闭的Channel通道对象。此外，你还可以�?一个ChannelGroup对象内部的所有Channel通道对象执行相同的操作。例如，当你关闭服务端应用时你可以关闭一个ChannelGroup 内部的所有Channel通道对象�?br />
��Z��记录所有打开的socket�Q�你需要修改你的TimeServerHandler实现�Q�将一个打开的Channel通道加入全局的ChannelGroup对象�Q�TimeServer.allChannels:

Java代码
@Override
public void channelOpen(ChannelHandlerContext ctx, ChannelStateEvent e) {
TimeServer.allChannels.add(e.getChannel());
}
代码说明
是的�Q�ChannelGroup是线�E�安全的�?br />
现在�Q�所有活动的Channel通道��被自动的维护，关闭一个服务端应用有如关闭一个客��L��应用一��L��单�?br />
Java代码
package org.jboss.netty.example.time;

public class TimeServer {

static final ChannelGroup allChannels = new DefaultChannelGroup("time-server" );

public static void main(String[] args) throws Exception {
...
ChannelFactory factory = ...;
ServerBootstrap bootstrap = ...;
...
Channel channel = bootstrap.bind(...);
allChannels.add(channel);
waitForShutdownCommand();
ChannelGroupFuture future = allChannels.close();
future.awaitUninterruptibly();
factory.releaseExternalResources();
}
}
代码说明
1) DefaultChannelGroup需要一个组名作为其构造器参数。这个组名仅是区分每个ChannelGroup的一个标�C��?br />
2) ServerBootstrap对象的bind�Ҏ��q�回了一个绑定了本地地址的服务端Channel通道对象。调用这个Channel通道的close()�Ҏ��释放这个Channel通道�l�定的本地地址�?br />
3) 不管�q�个Channel对象属于服务端，客户端，�q�是为响应某一个请求创建，��M��一�U�类型的Channel对象都会被加入ChannelGroup。因此，你尽可在关闭服务时关闭所有的Channel对象�?br />
4) waitForShutdownCommand()是一个想象中�{�待关闭信号的方法。你可以在这里等待某个客��L��的关闭信��h��者JVM的关闭回调命令�?br />
5) 你可以对ChannelGroup��理的所有Channel对象执行相同的操作。在�q�个例子里，我们��关闭所有的通道�Q�这意味着�l�定在服务端特定地址�?Channel通道��解除绑定，所有已建立的连接也��异步关闭。�ؓ了获得成功关闭所有连接的通知�Q�close()�Ҏ��返回一�?ChannelGroupFuture对象�Q�这是一个类似ChannelFuture的对象�?br />
1.10. 总述

在这一章节�Q�我们快速浏览�ƈ�C��了如何��用Netty开发网�l�应用。下一章节��涉及更多的问题。同时请��C��Q��ؓ了帮助你以及能够让Netty��Z��你的回馈得到持箋的改�q�和提高�Q�Netty�C�֌� ��永�q�欢�q�你的问题及��?br />

�W�二�? 架构总览

在这个章节，我们��阐�q�Netty提供的核心功能以及在此基��之上如何构徏一个完备的�|�络应用�?br />
2.1. 丰富的缓冲实�?br />

Netty使用自徏的buffer API�Q�而不是��用NIO的ByteBuffer来代表一个连�l�的字节序列。与ByteBuffer相比�q�种方式拥有明显的优�ѝ��Netty使用新的 buffer�c�d��ChannelBuffer�Q�ChannelBuffer被设计�ؓ一个可从底层解决ByteBuffer问题�Q��ƈ可满��x��常网�l�应用开�?需要的�~�冲�c�d��。这些很��L��Ҏ��包括：

如果需要，允许使用自定义的�~�冲�c�d��?br />复合�~�冲�c�d��中内�|�的透明的零拯��实现�?br />开��即用的动态缓冲类型，��h��像StringBuffer一��L��动态缓冲能力�?br />不再需要调用的flip()�Ҏ��?br />正常情况下具有比ByteBuffer更快的响应速度�?br />更多信息请参考：org.jboss.netty.buffer package description

2.2. �l�一的异�?I/O API

传统的Java I/O API在应对不同的传输协议旉��要��用不同的�c�d��和方法。例如：java.net.Socket �?java.net.DatagramSocket它们�q�不��h��相同的超�c�d��Q�因此，�q�就需要��用不同的调用方式执行socket操作�?br />
�q�种模式上的不匹配��得在更换一个网�l�应用的传输协议时变得繁杂和困难。由于（Java I/O API�Q�缺乏协议间的移植性，当你试图在不修改�|�络传输层的前提下增加多�U�协议的支持�Q�这时便会��生问题。�ƈ且理��Z��Ԍ��多种应用层协议可�q�行在多�U�传�?层协议之上例如TCP/IP,UDP/IP,SCTP和串口通信�?br />
让这�U�情况变得更�p�的是，Java新的I/O�Q�NIO�Q�API与原有的��d��式的I/O�Q�OIO�Q�API�q�不兼容�Q�NIO.2(AIO)也是如此。由于所有的API无论是在其设计上�q�是性能上的�Ҏ��都与彼此不同，在进入开发阶�D�，你常�怼�被迫的选择一�U�你需要的API�?br />
例如�Q�在用户数较��的时候你可能会选择使用传统的OIO(Old I/O) API�Q�毕竟与NIO相比使用OIO��更加容易一些。然而，当你的业务呈指数增长�q�且服务器需要同时处理成千上万的客户�q�接时你便会遇到问题。这�U�情况下你可能会��试使用NIO�Q�但是复杂的NIO Selector�~�程接口又会耗费你大量时间�ƈ最�l�会�ȝ��你的快速开发�?br />
Netty有一个叫做Channel的统一的异步I/O�~�程接口�Q�这个编�E�接口抽象了所有点对点的通信操作。也��是��_��如果你的应用是基于Netty的某一�U�传输实玎ͼ�那么同样的，你的应用也可以运行在Netty的另一�U�传输实��C��。Netty提供了几�U�拥有相同编�E�接口的基本传输实现�Q?br />

NIO-based TCP/IP transport (See org.jboss.netty.channel.socket.nio),
OIO-based TCP/IP transport (See org.jboss.netty.channel.socket.oio),
OIO-based UDP/IP transport, and
Local transport (See org.jboss.netty.channel.local).
切换不同的传输实现通常只需对代码进行几行的修改调整�Q�例如选择一个不同的ChannelFactory实现�?br />
此外�Q�你甚至可以利用新的传输实现没有写入的优势，只需替换一些构造器的调用方法即可，例如串口通信。而且�׃��核心API��h��高度的可扩展性，你还可以完成自己的传输实现�?br />
2.3. ��Z��拦截链模式的事�g模型

一个定义良好�ƈ��h��扩展能力的事件模型是事�g驱动开发的必要条�g。Netty��h��定义良好的I/O事�g模型。由于严格的层次�l�构区分了不同的事�g�c�d��Q�因此Netty也允�怽�在不破坏现有代码的情况下实现自己的事件类型。这是与其他框架相比另一个不同的地方。很多NIO框架没有或者仅有有限的事�g模型�?念；在你试图��d��一个新的事件类型的时候常帔R��要修改已有的代码�Q�或者根本就不允�怽��q�行�q�种扩展�?br />
在一个ChannelPipeline内部一个ChannelEvent被一�l�ChannelHandler处理。这个管道是拦截�q��o�?模式的一�U�高�U��Ş式的实现�Q�因此对于一个事件如何被处理以及��道内部处理器间的交互过�E�，你都��拥有绝对的控制力。例如，你可以定义一个从socket��d��到数据后的操作：

Java代码
public class MyReadHandler implements SimpleChannelHandler {
public void messageReceived(ChannelHandlerContext ctx, MessageEvent evt) {
Object message = evt.getMessage();
// Do something with the received message.
...

// And forward the event to the next handler.
ctx.sendUpstream(evt);
}
}

同时你也可以定义一�U�操作响应其他处理器的写操作��h��Q?br />
Java代码
public class MyWriteHandler implements SimpleChannelHandler {
public void writeRequested(ChannelHandlerContext ctx, MessageEvent evt) {
Object message = evt.getMessage();
// Do something with the message to be written.
...

// And forward the event to the next handler.
ctx.sendDownstream(evt);
}
}

有关事�g模型的更多信息，请参考API文档ChannelEvent和ChannelPipeline部分�?br />
2.4. 适用快速开发的高��l��g

上述所提及的核心组件已�l��够实现各�U�类型的�|�络应用�Q�除此之外，Netty也提供了一�p�d��的高�U�组件来加速你的开发过�E��?br />
2.4.1. Codec框架

��像“1.8. 使用POJO代替ChannelBuffer”一节所展示的那��P��从业务逻辑代码中分��d��议处理部分��L��一个很不错的想法。然而如果一切从零开始便会遭�?到实��C��的复杂性。你不得不处理分�D늚�消息。一些协议是多层的（例如构徏在其他低层协议之上的协议�Q�。一些协议过于复杂以致难以在一��C��机（single state machine�Q�上实现�?br />
因此�Q�一个好的网�l�应用框架应该提供一�U�可扩展�Q�可重用�Q�可单元��试�q�且是多层的codec框架�Q��ؓ用户提供易维护的codec代码�?br />
Netty提供了一�l�构建在其核心模块之上的codec实现�Q�这些简单的或者高�U�的codec实现帮你解决了大部分在你�q�行协议处理开发过�E�会遇到的问题，无论�q�些协议是简单的�q�是复杂的，二进制的或是��单文本的�?br />
2.4.2. SSL / TLS 支持

不同于传�l�阻塞式的I/O实现�Q�在NIO模式下支持SSL功能是一个艰隄��工作。你不能只是��单的包装一下流数据�q�进行加密或解密工作�Q�你不得不借助�?javax.net.ssl.SSLEngine�Q�SSLEngine是一个有状态的实现�Q�其复杂性不亚于SSL自��n。你必须��理所有可能的状态，例如�?码套�Ӟ��密钥协商�Q�或重新协商�Q�，证书交换以及认证�{�。此外，与通常期望情况相反的是SSLEngine甚至不是一个绝对的�U�程安全实现�?br />
在Netty内部�Q�SslHandler��装了所有艰隄��l�节以及使用SSLEngine可能带来的陷阱。你所做的仅是配置�q�将该SslHandler插入��C��的ChannelPipeline中。同样Netty也允�怽�实现像StartTlS 那样所拥有的高�U�特性，�q�很�Ҏ��?br />
2.4.3. HTTP实现

HTTP无疑是互联网上最受欢�q�的协议�Q��ƈ且已�l�有了一些例如Servlet容器�q�样的HTTP实现。因此，��Z��么Netty�q�要在其核心模块之上构徏一套HTTP实现�Q?br />
与现有的HTTP实现相比Netty的HTTP实现是相当与众不同的。在HTTP消息的低层交互过�E�中你将拥有�l�对的控制力。这是因为Netty�?HTTP实现只是一些HTTP codec和HTTP消息�cȝ��单组合，�q�里不存在�Q何限�?#8212;—例如那种被迫选择的线�E�模型。你可以随心所�Ʋ的�~�写那种可以完全按照你期望的工作方式工作的客��L��或服务器端代码。这包括�U�程模型�Q�连接生命期�Q�快�~�码�Q�以及所有HTTP协议允许你做的，所有的一切，你都��拥有绝对的控制力�?br />
�׃��q�种高度可定制化的特性，你可以开发一个非帔R��效的HTTP服务器，例如�Q?br />
要求持久化链接以及服务器端推送技术的聊天服务�Q�e.g. Comet �Q?br />需要保持链接直��x��个文件下载完成的媒体��服务（e.g. 2��时长的电媄�Q?br />需要上传大文�g�q�且没有内存压力的文件服务（e.g. 上传1GB文�g的请求）
支持大规模mash-up应用以及��C��万计�q�接的第三方web services异步处理�q�_��
2.4.4. Google Protocol Buffer 整合

Google Protocol Buffers 是快速实��C��个高效的二进制协议的理想�Ҏ��。通过使用ProtobufEncoder和ProtobufDecoder�Q�你可以把Google Protocol Buffers �~�译�?(protoc)生成的消息类攑օ�到Netty的codec实现中。请参�?#8220;LocalTime ”实例�Q�这个例子也同时昄��出开发一个由��单协议定�?的客户及服务端是多么的容易�?br />
2.5. 总述
在这一章节�Q�我们从功能�Ҏ��的角度回顾了Netty的整体架构。Netty有一个简单却不失强大的架构。这个架构由三部分组�?#8212;—�~�冲�Q�buffer�Q�，通道�Q�channel�Q�，事�g模型�Q�event model�Q?#8212;—所有的高��Ҏ��都构徏在这三个核心�l��g之上。一旦你理解了它们之间的工作原理�Q�你便不隄��解在本章��要提及的更多高��Ҏ��?br />
你可能对Netty的整体架构以及每一部分的工作原理仍旧存有疑问。如果是�q�样�Q�最好的方式是告诉我�?应该如何改进�q�䆾指南

不高�?/a> 2013-06-07 16:11 发表评论

parseInt�?8,09bug

Thu, 08 Nov 2012 05:49:00 GMT

bug描述:
parseInt("08")=0;
parseInt("09")=0;

�q�里先回��一下parseInt的函数声�?

/*
* ��字�W�串解析成数字时�Q�从左向右依此解析，解析到第一个非法字�W�即停止�?br /> * 若指定radix�?-36之间的数字，则按相应的进制进行解析；
* 若radix指定�?�Q�或大于36的数字，则直接返回NaN
* 若指定radix�?�Q�或未指定radix�Q�则�Ҏ��字符串开头字�W�确�?
* �?1-9'开头的字符�Ԍ��?0�q�制解析�Q?br /> * �?0'开头的字符�Ԍ��?�q�制解析�Q?br /> * �?0x'�?0X'开头的字符�Ԍ��?6�q�制解析�?br /> *
* @param string 要被解析的字�W�串�?br /> * @param radix 表示要解析的数字的基数。该��g��?nbsp;2 ~ 36 之间�?br /> */
parseInt(string, radix)

‘01’�?#8217;07’�Q�按8�q�制�?0�q�制解析会得到相同的�l�果�?�?#8217;08’�Q?#8217;09’�?�q�制解析会得�?#8217;0’�Q�因�?#8217;8’�?#8217;9’�?�q�制中是非法字符�Q�不会被解析。由此导致上�q�的bug�?br />扑ֈ�问题�Ҏ��Q�修复就变得很简单了�Q�显�C�指定radix�?0.
parseInt("08",10);

不高�?/a> 2012-11-08 13:49 发表评论

Eclipse调试Java�?0个技�?�?

Fri, 19 Oct 2012 08:54:00 GMT

在本教程中，我们��看��C��用Eclipse调试Java应用�E�序。调试可以帮助我们识别和解决应用�E�序中的�~�陷。我们将重点攑֜��q�行旉��的问题，而不是编译时错误。有提供像gdb的命令行调试器。在本教�E�中�Q�我们将集中在基于GUI的调试，我们把我们最喜爱的IDE Eclipse来运行，通过本教�E�。虽然我们说的Eclipse�Q�点大多是通用的，适用于调试��用的IDE像NetBeans�?/p>

在看�q�篇文章前，我推荐你看一�?/span>Eclipse 快捷键手�?/span>�Q�你也可以到�q�儿�Q?a style="color: #ff9900; text-decoration: none; ">下蝲PDF文�g我的eclipse版本�?.2 Juno�?/span>

0.三点特别提醒�Q?/h2>

不要使用System.out.println作�ؓ调试工具

启用所有组件的详细的日志记录��?/span>

使用一个日志分析器来阅��L��?/span>

[

�Q�System.out.println()对开发�h员来��_��有时候也许可以是一�U�调试手�D�，但是��目一旦完成他��没有什么用途了�Q�就变成垃圾了，得必��L��释或删除掉，�q�样会比较麻烦。启用所有组件的详细日志记录�U�别�Q�运用日志分析器来记录详�l�系�l�运行状�?�q�对后期�|�站的优化和�l�护会有很多作用。）�q�仅仅是个�h理解�Q�仅供参考！

]

1.条�g断点

惌��一下我们��^时如何添加断点，通常的做法是双击行号的左辏V��在debug视图中，BreakPoint View��所有断炚w��列出来，但是我们可以��d��一个boolean�c�d��的条件来军_��断点是否被蟩�q�。如果条件�ؓ真，在断点处�E�序��停止，否则断点被蟩�q�，�E�序�l�箋执行�?/span>

2.异常断点

在断点view中有一个看��h��像J�Q�的按钮�Q�我们可以��用它��d��一个基于异常的断点�Q�例如我们希望当NullPointerException抛出的时候程序暂停，我们可以�q�样:

3.观察�?/h2>
�q�是一个很好的功能�Q?span style="font-family: 微��Y雅黑, Verdana, sans-serif, 宋体; line-height: 22px; font-size: 14px; ">他允许当一个选定的属性被讉K��或者被更改的时候程序执行暂停，�q�进行debug。最��单的办法是在�c�M��声明成员变量的语句行号左边双击，��可以加入一个观察点�?/span>

4.查看变量

在选中的变量上使用Ctrl+Shift+d 或�?Ctrl+Shift+i可以查看变量��|��另外我们�q�可以在Expressions View中添加监视�?/span>

5.更改变量的�?/h2>
我们可以在Debug的时候改变其中变量的倹{��在Variables View中可以按下图所�C�操作�?/span>

6.在主�Ҏ��停止

在Run/Debug讄��中，我们可以按如下图所�C�的启用�q�个�Ҏ��。程序将会在main�Ҏ��的第一行停�?/span>

7.环境变量

我们可以很方便的在Edit Conriguration对话框中��d��环境变量

8.跛_��函数到选定�?/h2>
�q�个功能非常��P��是我�W�二个非常喜�Ƣ的功能�Q�Drop to frame��是��_��可以重新跛_��当前�Ҏ��的开始处重新执行�Q��ƈ且所有上下文变量的��g��回到那个时候。不一定是当前�Ҏ��Q�可以点��d��前调用栈中的��M��一个frame跛_��那里�Q�除了最开始的那个frame�Q�。主要用途是所有变量状态快速恢复到�Ҏ��开始时候的样子重新执行一遍，卛_��以一遍又一遍地在那个你��x��的上下文中进行多�ơ调试（�l�合改变变量值等其它功能�Q�，而不用重来一遍调试到哪里了。当�Ӟ��原来执行�q�程中��生的副作用是不可逆的�Q�比如你往数据库中插入了一条记录）�?/span>

9.分步�q��o

当我们在调试的时候摁F5��进入方法的内部�Q�但�q�有个缺�Ҏ��的时候可能会�q�入��C��些库的内部（例如JDK�Q�，可能�q�不是我们想要的�Q�我们可以在Preferences中添加一个过滤器�Q�排除指定的包�?/span>

10.跛_��Q�蟩�q�和�q�回

其实�q�个技巧是debug最基本的知识�?/span>

F5-Step Into�Q�移动到下一步，如果当前的行是一个方法调用，��进入这个方法的�W�一行。（可以通过�W�九条来排除�Q?/span>
F6-Step Over�Q�移动到下一行。如果当前行有方法调用，�q�个�Ҏ��被执行完毕�q�回�Q�然后到下一行�?/span>
F7-Step Return�Q��l�执行当前方法，当当前方法执行完毕的时候，控制��{到当前方法被调用的行�?/span>
F8-�U�d��C��一个断点处�?/span>

原文��:http://javapapers.com/core-java/top-10-java-debugging-tips-with-eclipse/

不高�?/a> 2012-10-19 16:54 发表评论

Thu, 26 Jul 2012 02:35:00 GMT

href="itms-services://?action=download-manifest&url=http://test1.gc73.com.cn/hoho.plist">

http://test1.gc73.com.cn/hoho.plist 文�g格式如下

    	items 	 		 			assets 			 				 					kind 					software-package 					url 					http://dlx1.gc73.com/pokerddzV2.1-7.20.iPad.ipa 				 				 					kind 					full-size-image 					needs-shine 					 					url 					http://test1.gc73.com.cn/ipad_tmp.png 				 				 					kind 					display-image 					needs-shine 					 					url 					http://test1.gc73.com.cn/ipad_tmp.png 				 			 			metadata 			 				bundle-identifier 				com.pokercity.fightlordiPad 				kind 				software 				subtitle 				��q�����试 				title 				��q�����试(���狱�?

不高�?/a> 2012-07-26 10:35 发表评论

hg clone abort: error:

Wed, 30 May 2012 14:25:00 GMT

用tortoisehg下蝲google code时报错abort�Q�error
解决�Ҏ��:��https: 换成http 试一�?/div>

不高�?/a> 2012-05-30 22:25 发表评论

visualvm监控jvm及远�E�jvm监控�Ҏ��

Tue, 20 Mar 2012 13:59:00 GMT

VisualVM是Sun的一个OpenJDK��目�Q�其目的在于为Java应用创徏一个整套的问题解决工具。它集成了多个JDK命��o工具的一个可视化工具�Q�它主要用来监控JVM的运行情况，可以用它来查看和��览Heap Dump、Thread Dump、内存对象实例情��c��GC执行情况、CPU消耗以及类的装载情��c�?Java开发�h员可以��?VisualVM创徏必要信息的日志，�pȝ��理人员可用来监控及控制Java应用�E�序在网�l�中的运行状��c�?/span>
下蝲��面 : https://visualvm.dev.java.net/download.html

文档地址 : https://visualvm.dev.java.net/docindex.html

入门文档 : https://visualvm.dev.java.net/zh_CN/gettingstarted.html

安装插�g
通过安装 VisualVM 更新中心提供的插�Ӟ��可以�?VisualVM ��d��功能�?br /> 1. 从主菜单中选择“工具”>“插�g”�?br /> 2. �?#8220;可用插�g”标签中，选中该插件的“安装”复选框。单�?#8220;安装”�?br /> 3. 逐步完成插�g安装�E�序�?br />

功能
1. 概述
查看jvm信息及系�l�配�|?br />

    2. 监视
了解��目�q�动的概�?br />

3. visual gc
可以看到内存gc的详�l�情�?br />

�q�程监控
1. 通过jstatd启动RMI服务
  配置java安全讉K��Q�将如下的代码存为文�?jstatd.all.policy�Q�放到JAVA_HOME/bin中，其内容如下，
  grant codebase "file:${java.home}/../lib/tools.jar" {

permission java.security.AllPermission;

        };

执行命��ojstatd -J-Djava.security.policy=jstatd.all.policy -J-Djava.rmi.server.hostname=192.168.1.8 &(192.168.1.8 ��Z��服务器的ip地址,&表示用守护线�E�的方式�q�行)
jstatd命��o详解 :http://hzl7652.iteye.com/blog/1183182

  打开jvisualvm, 右键Remort,选择 "Add Remort Host..."�Q�在弹出框中输入你的�q�端IP,比如192.168.1.8. �q�接成功.

2. 配置JMX��理tomcat
  打开Tomcat的bin/catalina.bat�Q?span style="color: #ff0000; ">如果为linux或unix�pȝ��Q�则为catalina.sh文�g �?nbsp;
           无限制访�?nbsp;

set JAVA_OPTS=-Dcom.sun.management.jmxremote -Dcom.sun.management.jmxremote.port=9008 -Dcom.sun.management.jmxremote.authenticate=false - Dcom.sun.management.jmxremote.ssl=false

需要用户名和密码访�?/div>

JAVA_OPTS='-Xms128m -Xmx256m -XX:MaxPermSize=128m

-Djava.rmi.server.hostname=192.168.1.8

-Dcom.sun.management.jmxremote.port=8088

-Dcom.sun.management.jmxremote.ssl=false

-Dcom.sun.management.jmxremote.authenticate=true

-Dcom.sun.management.jmxremote.password.file=/usr/java/default/jre/lib/management/jmxremote.password

-Dcom.sun.management.jmxremote.access.file=/usr/java/default/jre/lib/management/jmxremote.access'

(jmxremote.access 在JAVA_HOME\jre\lib\management下有模板)
jmxremote.access 中显�C?br /> monitorRole readonly

controlRole readwrite

jmxremote.password中显�C?br /> monitorRole QED (QED为密�?

controlRole R&D

重新在visualvm中打开�q�程tomcat��可以��用JMX带来的功能了

不高�?/a> 2012-03-20 21:59 发表评论

Eclipse快捷键大�?转蝲)

Wed, 07 Mar 2012 07:52:00 GMT

Eclipse快捷键大�?转蝲)

Ctrl+1 快速修�?最�l�典的快捷键,��׃��用多说了)
Ctrl+D: 删除当前�?nbsp;
Ctrl+Alt+↓ 复制当前行到下一�?复制增加)
Ctrl+Alt+↑ 复制当前行到上一�?复制增加)
Alt+↓ 当前行和下面一行交互位�|?特别实用,可以省去先剪�?再粘贴了)
Alt+↑ 当前行和上面一行交互位�|?同上)
Alt+← 前一个编辑的��面
Alt+→ 下一个编辑的��面(当然是针对上面那条来说了)
Alt+Enter 昄��当前选择资源(工程,or 文�g or文�g)的属�?br />Shift+Enter 在当前行的下一行插入空�?�q�时鼠标可以在当前行的�Q一位置,不一定是最�?
Shift+Ctrl+Enter 在当前行插入�I��(原理同上�?
Ctrl+Q 定位到最后编辑的地方
Ctrl+L 定位在某�?nbsp;(对于�E�序��过100的�h��有��音�?
Ctrl+M 最大化当前的Edit或View (再按则反�?
Ctrl+/ 注释当前�?再按则取消注�?br />Ctrl+O 快速显�C?nbsp;OutLine
Ctrl+T 快速显�C�当前类的��承结�?br />Ctrl+W 关闭当前Editer
Ctrl+K 参照选中的Word快速定位到下一�?br />Ctrl+E 快速显�C�当前Editer的下拉列�?如果当前��面没有昄��的用黑体表示)
Ctrl+/(��键�? 折叠当前�c�M��的所有代�?br />Ctrl+×(��键�? 展开当前�c�M��的所有代�?br />Ctrl+Space 代码助手完成一些代码的插入(但一般和输入法有冲突,可以修改输入法的热键,也可以暂用Alt+/来代�?
Ctrl+Shift+E 昄��理当前打开的所有的View的管理器(可以选择关闭,�Ȁ�zȝ��操作)
Ctrl+J 正向增量查找(按下Ctrl+J�?你所输入的每个字母编辑器都提供快速匹配定位到某个单词,如果没有,则在stutes line中显�C�没有找��C��,查一个单词时,特别实用,�q�个功能Idea两年前就有了)
Ctrl+Shift+J 反向增量查找(和上条相�?只不�q�是从后往前查)
Ctrl+Shift+F4 关闭所有打开的Editer
Ctrl+Shift+X 把当前选中的文本全部变呛_��?br />Ctrl+Shift+Y 把当前选中的文本全部变为小�?br />Ctrl+Shift+F 格式化当前代�?br />Ctrl+Shift+P 定位到对于的匚w��W?譬如{}) (从前面定位后面时,光标要在匚w��W�里�?后面到前�?则反�?

下面的快捷键是重构里面常用的,本�h��p��己喜�Ƣ且常用的整理一�?�?一般重构的快捷键都是Alt+Shift开头的�?
Alt+Shift+R 重命�?nbsp;(是我自己最��q��的一个了,��其是变量和�cȝ��Rename,比手工方法能节省很多力_��?
Alt+Shift+M 抽取�Ҏ�� (�q�是重构里面最常用的方法之一�?��其是对一大堆泥团代码有用)
Alt+Shift+C 修改函数�l�构(比较实用,有N个函数调用了�q�个�Ҏ��,修改一�ơ搞�?
Alt+Shift+L 抽取本地变量( 可以直接把一些魔法数字和字符串抽取成一个变�?��其是多处调用的时�?
Alt+Shift+F 把Class中的local变量变�ؓfield变量 (比较实用的功�?
Alt+Shift+I 合�ƈ变量(可能�q�样说有点不妥Inline)
Alt+Shift+V �U�d��函数和变�?不怎么常用)
Alt+Shift+Z 重构的后悔药(Undo)

�~�辑
作用�?nbsp;功能快捷�?nbsp;
全局查找�q�替�?nbsp;Ctrl+F
文本�~�辑�?nbsp;查找上一�?nbsp;Ctrl+Shift+K
文本�~�辑�?nbsp;查找下一�?nbsp;Ctrl+K
全局撤销 Ctrl+Z
全局复制 Ctrl+C
全局恢复上一个选择 Alt+Shift+↓
全局剪切 Ctrl+X
全局快速修�?nbsp;Ctrl1+1
全局内容辅助 Alt+/
全局全部选中 Ctrl+A
全局删除 Delete
全局上下文信�?nbsp;Alt+�Q?br />Alt+Shift+?
Ctrl+Shift+Space
Java�~�辑�?nbsp;昄��工具提示描述 F2
Java�~�辑�?nbsp;选择��装元素 Alt+Shift+↑
Java�~�辑�?nbsp;选择上一个元�?nbsp;Alt+Shift+←
Java�~�辑�?nbsp;选择下一个元�?nbsp;Alt+Shift+→
文本�~�辑�?nbsp;增量查找 Ctrl+J
文本�~�辑�?nbsp;增量逆向查找 Ctrl+Shift+J
全局 �_�脓 Ctrl+V
全局重做 Ctrl+Y

查看
作用�?nbsp;功能快捷�?nbsp;
全局攑֤� Ctrl+=
全局 �~�小 Ctrl+-

�H�口
作用�?nbsp;功能快捷�?nbsp;
全局 �Ȁ�zȝ��辑器 F12
全局切换�~�辑�?nbsp;Ctrl+Shift+W
全局上一个编辑器 Ctrl+Shift+F6
全局上一个视�?nbsp;Ctrl+Shift+F7
全局上一个透视�?nbsp;Ctrl+Shift+F8
全局下一个编辑器 Ctrl+F6
全局下一个视�?nbsp;Ctrl+F7
全局下一个透视�?nbsp;Ctrl+F8
文本�~�辑�?nbsp;昄��标尺上下文菜�?nbsp;Ctrl+W
全局昄��视图菜单 Ctrl+F10
全局昄��pȝ��菜单 Alt+-

��D��
作用�?nbsp;功能快捷�?nbsp;
Java�~�辑�?nbsp;打开�l�构 Ctrl+F3
全局打开�c�d�� Ctrl+Shift+T
全局打开�c�d��层次�l�构 F4
全局打开声明 F3
全局打开外部javadoc Shift+F2
全局打开资源 Ctrl+Shift+R
全局后退历史记录 Alt+←
全局前进历史记录 Alt+→
全局上一�?nbsp;Ctrl+,
全局下一�?nbsp;Ctrl+.
Java�~�辑�?nbsp;昄��大纲 Ctrl+O
全局在层�ơ结构中打开�c�d�� Ctrl+Shift+H
全局转至匚w��的括�?nbsp;Ctrl+Shift+P
全局转至上一个编辑位�|?nbsp;Ctrl+Q
Java�~�辑�?nbsp;转至上一个成�?nbsp;Ctrl+Shift+↑
Java�~�辑�?nbsp;转至下一个成�?nbsp;Ctrl+Shift+↓
文本�~�辑�?nbsp;转至�?nbsp;Ctrl+L

搜烦
作用�?nbsp;功能快捷�?nbsp;
全局出现在文件中 Ctrl+Shift+U
全局打开搜烦对话�?nbsp;Ctrl+H
全局工作��Z��的声�?nbsp;Ctrl+G
全局工作��Z��的引�?nbsp;Ctrl+Shift+G

文本�~�辑
作用�?nbsp;功能快捷�?nbsp;
文本�~�辑�?nbsp;改写切换 Insert
文本�~�辑�?nbsp;上滚�?nbsp;Ctrl+↑
文本�~�辑�?nbsp;下滚�?nbsp;Ctrl+↓

文�g
作用�?nbsp;功能快捷�?nbsp;
全局保存 Ctrl+X
Ctrl+S
全局打印 Ctrl+P
全局关闭 Ctrl+F4
全局全部保存 Ctrl+Shift+S
全局全部关闭 Ctrl+Shift+F4
全局属�?nbsp;Alt+Enter
全局新徏 Ctrl+N

��目
作用�?nbsp;功能快捷�?nbsp;
全局全部构徏 Ctrl+B

源代�?br />作用�?nbsp;功能快捷�?nbsp;
Java�~�辑�?nbsp;格式�?nbsp;Ctrl+Shift+F
Java�~�辑�?nbsp;取消注释 Ctrl+\
Java�~�辑�?nbsp;注释 Ctrl+/
Java�~�辑�?nbsp;��d��导入 Ctrl+Shift+M
Java�~�辑�?nbsp;�l�织导入 Ctrl+Shift+O
Java�~�辑�?nbsp;使用try/catch块来包围未设�|�，太常用了�Q�所以在�q�里列出,��自己讄��?br />也可以��用Ctrl+1自动修正�?nbsp;

�q�行
作用�?nbsp;功能快捷�?nbsp;
全局单步�q�回 F7
全局单步跌�� F6
全局单步跛_�� F5
全局单步跛_��选择 Ctrl+F5
全局调试上次启动 F11
全局 �l�箋 F8
全局使用�q��o器单步执�?nbsp;Shift+F5
全局 ��d��/去除断点 Ctrl+Shift+B
全局昄�� Ctrl+D
全局 �q�行上次启动 Ctrl+F11
全局 �q�行臌�� Ctrl+R
全局执行 Ctrl+U

重构
作用�?nbsp;功能快捷�?nbsp;
全局撤销重构 Alt+Shift+Z
全局抽取�Ҏ�� Alt+Shift+M
全局抽取局部变�?nbsp;Alt+Shift+L
全局内联 Alt+Shift+I
全局 �U�d�� Alt+Shift+V
全局重命�?nbsp;Alt+Shift+R
全局重做 Alt+Shift+Y

不高�?/a> 2012-03-07 15:52 发表评论

css中className命名规则

Fri, 03 Feb 2012 09:58:00 GMT

以字母或下划�U�开�?
今天找一个css的加载问�?class已经被浏览器加蝲�?但是属性��g��直不昄��出来,几经查找才发现className以数字开头命名的,��D��览器不认可,整一个悲�?img src ="http://www.tkk7.com/titanaly/aggbug/369335.html" width = "1" height = "1" />

不高�?/a> 2012-02-03 17:58 发表评论

Thu, 02 Feb 2012 09:38:00 GMT

BTrace的技术分�?本�h暂没有这个技术能�?大家可以�?nbsp;http://www.iteye.com/topic/1005918,
http://mgoann.iteye.com/blog/1409667
下面是个人写的一些简单实�?不过我一直没办法通过BTrace拿到局部变量的�?不知道哪位牛人帮帮解�{�下
Linux下：
在http://kenai.com/projects/btrace下蝲btrace-bin.tar.gz�Q��ƈ解压�Q�在/etc/profile讄��环境变量�Q?/span>

export BTRACE_HOME=/home/workspace/btrace/
export PATH=$BTRACE_HOME/bin:$PATH

讄��完成�?source /etc/profile
�l�执行文件赋权限 chmod +x btrace

/* BTrace Script Template */

import com.sun.btrace.annotations.*;

import static com.sun.btrace.BTraceUtils.*;

import java.lang.reflect.Field;

@BTrace

public class TracingScript {

/* put your code here */

//打印实例属�?/div>

@OnMethod(clazz = "com.gameplus.action.siteLobby.LobbyAction", method = "/.*bankPage/", location = @Location(value = Kind.ENTRY))

//clazz = "com.gameplus.action.siteLobby.LobbyAction" 表示监控的类,method = "/.*bankPage/"表示监控的方�?,�q�两个参数都可以用正则匹�?/div>

//如果是接口用+号clazz = "+com.gameplus.action.siteLobby.LobbyAction"

public static void bufferMonitor(@Self Object self ){ // @Self 表示监控点实�?nbsp;

print(strcat(strcat(name(probeClass()), "."), probeMethod())); //probeClass()监控的类,probeMethod()监控的方�?/div>

println(self);

println(get(field(classOf(self), "money"))); //只能取值static变量

println(get(field(classOf(self), "money"),self)); //可以取值当前实例变�?static也可以取�?/div>

Field moneyField = field("com.gameplus.action.siteLobby.LobbyAction", "money"); //知道class的名�U�C��可以取�?/div>

get(moneyField,self);

get(field("com.gameplus.action.siteLobby.LobbyAction", "money"), self);

Object montmp =get(field(getSuperclass(classOf(self)), "user"), self); //获取父类变量的方�?/div>

println(str(montmp));

long userId = (Long)get(field(classOf(montmp),"userId"),montmp); //获取superClass.Object.变量�?/div>

println(userId);

}

//打印�q�行时lineNumber

@OnMethod(clazz = "com.gameplus.action.siteLobby.LobbyAction", location=@Location(value=Kind.LINE, line=-1))

public static void online(@ProbeClassName String pcn, @ProbeMethodName String pmn, int line) {

print(Strings.strcat(pcn, ".")); //className

print(Strings.strcat(pmn, ":")); //methodName

println(line); //lineNumber

//�l�果�?com.gameplus.action.siteLobby.LobbyAction.bankPage:161

}

//打印传递的参数�?/div>

import com.sun.btrace.AnyType;

@OnMethod(clazz="com.gameplus.service.operateBankService.OperateBankService",method="/.*/")

public static void anyRead(@ProbeClassName String pcn, @ProbeMethodName String pmn, AnyType[] args) {

println(pcn);

println(pmn);

printArray(args);

}

//打印所有属�?/div>

@OnMethod(clazz = "com.gameplus.action.siteLobby.LobbyAction", method = "/.*bankPage/", location = @Location(value = Kind.RETURN))

public static void bufferMonitor(@Self Object self,@Return Object command ,@Duration long time){

printFields(self);

Object montmp =get(field(getSuperclass(classOf(self)), "user"), self);

printFields(montmp);

//{password=null, newPassword=null, rePassword=, bankPassword=, newBankPassword=, reBankPassword=, operateType=0, operateBankType=0, money=111, integral=0, dateStartQuery=, dateEndQuery=, isDefaultPasswd=0, }

//{userId=10918, username=titanaly11, realname=�Ҏ��1, expTime=1146510, bankMoney=1317886229, bankPasswd=243b6503f2e3e83faccc89830aca1d91, ifAvailable=1, password=1bbd886460827015e5d605ed44252251, money=100000, }

}

//初始化时的变量参�?/div>

//public User(long userId,String playServerId) {

// this.userId = userId;

// this.playServerId = playServerId;

//}

@OnMethod(clazz = "com.gameplus.core.model.oracle.user.User", method="")

public static void bufferMonitor(@Self Object self,long userId,String gameId){

printFields(self);

println(userId);

println(gameId);

//�l�果

//{userId=0, username=null, realname=null, expTime=0, bankMoney=0, bankPasswd=null, ifAvailable=0, password=null, money=0, nickName=null, iconNum=0, tim=null, infullCount=0, userToken=null, onlineTime=0,}

//10918

//222

}

//打印�pȝ��参数

static {

println("System Properties:");

printProperties();

println("VM Flags:");

printVmArguments();

println("OS Enviroment:");

printEnv();

exit(0);

}

//打印�E�序执行关系

//LobbyAction中所有方法执行的执行��序

@OnMethod(clazz="com.gameplus.action.siteLobby.LobbyAction", method="/.*/",

location=@Location(value=Kind.CALL, clazz="/.*/", method="/.*/"))

public static void n(@Self Object self, @ProbeClassName String pcm, @ProbeMethodName String pmn,

@TargetInstance Object instance, @TargetMethodOrField String method){ // all calls to the methods with signature "(String)"

println(Strings.strcat("Context: ", Strings.strcat(pcm, Strings.strcat("#", pmn))));

println(instance); //被调用目标对�?/div>

println(Strings.strcat("",method)); //被调用方�?/div>

//Context: com/gameplus/action/siteLobby/LobbyAction#bankPage

//$Proxy18@807c31

//getBankPage

//Context: com/gameplus/action/siteLobby/LobbyAction#bankPage

//{userEx=10, leverRestriction=6, isDefaultPasswd=0, bankPassEqGamePass=0, moneyTransferMsg=S, isSimplePasswd=0, mobile=null}

//get

//Context: com/gameplus/action/siteLobby/LobbyAction#bankPage

//6

//intValue

//Context: com/gameplus/action/siteLobby/LobbyAction#bankPage

//{userEx=10, leverRestriction=6, isDefaultPasswd=0, bankPassEqGamePass=0, moneyTransferMsg=S, isSimplePasswd=0, mobile=null}

//get

}

不高�?/a> 2012-02-02 17:38 发表评论

亚洲精品高清在线,亚洲av无码一区二区三区人妖,亚洲精品国偷自产在线

Netty 3.1 中文用户手册

parseInt�?8,09bug

Eclipse调试Java�?0个技�?�?

1.条�g断点

2.异常断点

4.查看变量

5.更改变量的�?/h2> 我们可以在Debug的时候改变其中变量的倹{��在Variables View中可以按下图所�C�操作�?/span>

6.在主�Ҏ��停止

7.环境变量

9.分步�q���o

10.跛_���Q�蟩�q�和�q�回

hg clone abort: error:

visualvm监控jvm及远�E�jvm监控�Ҏ��

Eclipse快捷键大�?转蝲)

css中className命名规则

5.更改变量的�?/h2>
我们可以在Debug的时候改变其中变量的倹{��在Variables View中可以按下图所�C�操作�?/span>

9.分步�q��o

10.跛_��Q�蟩�q�和�q�回