“快”在细节 J2EE程序的性能优化技巧

　　Java 2 Platform, Enterprise Edition (J2EE)是当前很多商业应用系统使用的开发平台，该技术提供了一个基于组件的方法来设计、开发、装配和部署企业级应用程序。J2EE平台提供了一个多层结构的分布式的应用程序模型，可以更快地开发和发布的新的应用解决方案。

　　J2EE是一种技术规范，定义了整个标准的应用开发体系结构和一个部署环境，应用开发者开发时只要专注于具体商业逻辑和商业业务规则的实现上，而其他的诸如事务、持久化、安全等系统开发问题可以由应用程序容器或者服务器处理，开发完成后，就可以方便地部署到实现规范的应用服务器中。

　　作为网络上的商业应用系统，同时访问的人数是很多的，在大量访问的情况下，过多的资源请求和有限的服务器资源(内存、CPU时间、网络带宽等)之间就会出现矛盾，应用系统的性能就显得很重要了，有时正确的代码并不能保证项目的成功，性能往往是最后决定一个项目是否成功关键。

　　本文主要从性能的角度出发，讨论J2EE服务器端的代码性能优化和提升。

　　二、常见的Java 编程

　　J2EE语言基础是Java，常用的Java代码问题对应用系统的性能影响，下面讨论了一些应该注意方面。

　　·使用StringBuffer代替String

　　当处理字符串的相加时，常见的写法是:..

String str1 = "Hello";
String str2 = "welcome to world";
String str3 = str1 + ", " + str2 +"!";
System.out.println(str3);

　　很多人都知道，这样的代码效率是很低的，因为String是用来存储字符串常量的，如果要执行“+”的操作，系统会生成一些临时的对象，并对这些对象进行管理，造成不必要的开销。

　　如果字符串有连接的操作，替代的做法是用StringBuffer类的append方法，它的缺省构造函数和append的实现是:

public StringBuffer() { // 构造函数
this(16); // 缺省容量16}

public synchronized StringBuffer append(String str) {
　if (str == null) {
　　str = String.valueOf(str);
　}

　int len =str.length();
　int newcount = count + len;
　if(newcount > value.length)

　expandCapacity(newcount);

　// 扩充容量
　str.getChars(0, len, value, count);
　count = newcount;
　return this;
}

　　当字符串的大小超过缺省16时，代码实现了容量的扩充，为了避免对象的重新扩展其容量，更好的写法为:

StringBuffer buffer = new StringBuffer(30);
// 分配指定的大小。
buffer.append("hello");
buffer.append(",");
buffer.append("welcometo world!");
String str = buffer.toString();

·生成对象时，分配合理的空间和大小

　　Java中的很多类都有它的默认的空间分配大小，对于一些有大小的对象的初始化，应该预计对象的大小，然后使用进行初始化，上面的例子也说明了这个问题，StringBuffer创建时，我们指定了它的大小。

　　另外的一个例子是Vector，当声明Vector vect=new Vector()时，系统调用:

public Vector() {// 缺省构造函数
　this(10); // 容量是 10;
}

　　缺省分配10个对象大小容量。当执行add方法时，可以看到具体实现为:..

public synchronized boolean add(Object o) {
　modCount++;
　ensureCapacityHelper(elementCount+1);
　elementData[elementCount++] =o;

　return true;
}

private void ensureCapacityHelper(int minCapacity) {
　int oldCapacity = elementData.length;
　if (minCapacity > oldCapacity) {
　　Object oldData[] = elementData;
　　int newCapacity = (capacityIncrement > 0) ? (oldCapacity + capacityIncrement) :
(oldCapacity * 2);
　　if (newCapacity < minCapacity) {
　　　newCapacity = minCapacity;
　　}
　　elementData = new Object[newCapacity];
　　System.arraycopy(oldData, 0, elementData, 0, elementCount);
　}
}

　　我们可以看到，当Vector大小超过原来的大小时，一些代码的目的就是为了做容量的扩充，在预先知道该Vector大小的话，可以指定其大小，避免容量扩充的开销，如知道Vector大小为100时，初始化是就可以象这样。

Vector vect =.. new Vector(100);

　　·优化循环体

　　循环是比较重复运行的地方，如果循环次数很大，循环体内不好的代码对效率的影响就会被放大而变的突出。考虑下面的代码片:..

Vector vect = new Vector(1000);
...
for( inti=0; i<vect.size(); i++){
　...
}

　　for循环部分改写成:

int size = vect.size();
for( int i=0; i>size; i++){
　...
}

　　如果size=1000，就可以减少1000次size()的系统调用开销，避免了循环体重复调用。

　　再看如下的代码片:..

for (int i = 0;i <100000;i++)
if (i%10 == 9) {
　... // 每十次执行一次
}

　　改写成也可以提高效率:..

for(inti =0,j =10; i<100000; i++,j--){
　if(j == 0){
　　... // 每十次执行一次
　　j = 10;
　}
}

　　所以，当有较大的循环时，应该检查循环内是否有效率不高的地方，寻找更优的方案加以改进

·对象的创建

　　尽量少用new来初始化一个类的实例，当一个对象是用new进行初始化时，其构造函数链的所有构造函数都被调用到，所以new操作符是很消耗系统资源的，new一个对象耗时往往是局部变量赋值耗时的上千倍。同时，当生成对象后，系统还要花时间进行垃圾回收和处理。

　　当new创建对象不可避免时，注意避免多次的使用new初始化一个对象。

　　尽量在使用时再创建该对象。如:

NewObject object = new NewObject();
int value;
if(i>0 )
{
　value =object.getValue();
}

　　可以修改为:

int value;
if(i>0 )
{
　NewObject object = new NewObject();
　Value =object.getValue();
}

　　另外，应该尽量重复使用一个对象，而不是声明新的同类对象。一个重用对象的方法是改变对象的值，如可以通过setValue之类的方法改变对象的变量达到重用的目的。

　　·变量的注意事项

　　尽量使用局部变量，调用方法时传递的参数以及在调用中创建的临时变量都保存在栈(Stack) 中，速度较快。其他变量，如静态变量、实例变量等，都在堆(Heap)中创建，速度较慢。

　　尽量使用静态变量，即加修饰符static，如果类中的变量不会随他的实例而变化，就可以定义为静态变量，从而使他所有的实例都共享这个变量。

　　·方法(Method)调用

　　在Java中，一切都是对象，如果有方法(Method)调用，处理器先要检查该方法是属于哪个对象，该对象是否有效，对象属于什么类型，然后选择合适的方法并调用。

　　可以减少方法的调用，同样一个方法:

public void CallMethod(int i ){
　if( i ==0 ){
　　return;
　}
　... // 其他处理
}

　　如果直接调用，

int i = 0;
...
CallMethod(i);

　　就不如写成:

int i = 0;
...

if( i ==0 ){
　CallMethod(i);
}

　　不影响可读性等情况下，可以把几个小的方法合成一个大的方法。

　　另外，在方法前加上final，private关键字有利于编译器的优化。·慎用异常处理

　　异常是Java的一种错误处理机制，对程序来说是非常有用的，但是异常对性能不利。抛出异常首先要创建一个新的对象，并进行相关的处理，造成系统的开销，所以异常应该用在错误处理的情况，不应该用来控制程序流程，流程尽量用while，if等处理。

　　在不是很影响代码健壮性的前提下，可以把几个try/catch块合成一个。

　　·同步

　　同步主要出现在多线程的情况，为多线程同时运行时提供对象数据安全的机制，多线程是比较复杂话题，应用多线程也是为了获得性能的提升，应该尽可能减少同步。

　　另外，如果需要同步的地方，可以减少同步的代码段，如只同步某个方法或函数，而不是整个代码。

　　·使用Java系统API

　　Java的API一般都做了性能的考虑，如果完成相同的功能，优先使用API而不是自己写的代码，如数组复制通常的代码如下:

int size = 1000;
String[] strArray1 = new String[size];
String[] strArray2 = new String[size];
for(inti=0;i<size;i++){ // 赋值
　strArray1[i] = (new String("Array: " + i));
}

for(inti=0;i<size;i++){ // 复制
　strArray2[i]=(new String((String)a[i]));
}

　　如果使用Java提供的API，就可以提高性能:

int size = 1000;
String[] strArray1 = new String[size];
String[] strArray2 = new String[size];
for(inti=0;i<size;i++){ // 赋值
strArray1[i] = (new String("Array: " + i));
}

System.arraycopy(strArray1,0,strArray2,0,size); // 复制

　　同样的一个规则是，当有大量数据的复制时，应该使用System.arraycopy()。

　　三、I/O 性能

　　输入/输出(I/O)包括很多方面，我们知道，进行I/O操作是很费系统资源的。程序中应该尽量少用I/O操作。使用时可以注意: . 合理控制输出函数System.out.println()对于大多时候是有用的，特别是系统调试的时候，但也会产生大量的信息出现在控制台和日志上，同时输出时，有序列化和同步的过程，造成了开销。

　　特别是在发行版中，要合理的控制输出，可以在项目开发时，设计好一个Debug的工具类，在该类中可以实现输出开关，输出的级别，根据不同的情况进行不同的输出的控制。

　　·使用缓存

　　读写内存要比读写文件要快很多，应尽可能使用缓冲。

　　尽可能使用带有Buffer的类代替没有Buffer的类，如可以用BufferedReader 代替Reader，用BufferedWriter代替Writer来进行处理I/O操作。

　　同样可以用BufferedInputStream代替InputStream都可以获得性能的提高。

　　四、Servlet

　　Servlet采用请求——响应模式提供Web服务，通过ServletResponse以及ServletRequest这两个对象来输出和接收用户传递的参数，在服务器端处理用户的请求，根据请求访问数据库、访问别的Servlet方法、调用EJB等等，然后将处理结果返回给客户端。

　　·尽量不使用同步

　　Servlet是多线程的，以处理不同的请求，基于前面同步的分析，如果有太多的同步就失去了多线程的优势了。

　　·不用保存太多的信息在HttpSession中

　　很多时候，存储一些对象在HttpSession中是有必要的，可以加快系统的开发，如网上商店系统会把购物车信息保存在该用户的Session中，但当存储大量的信息或是大的对象在会话中是有害的，特别是当系统中用户的访问量很大，对内存的需求就会很高。

　　具体开发时，在这两者之间应作好权衡。