J2EE编码性能优化

日期:2015-10-23点击次数:4847

内容:应用J2EE平台开发的系统的性能是系统使用者和开发者都关注的问题,本文从服务器端编程时应注意的几个方面讨论代码对性能的影响,并总结一些解决的建议。

一、      概要
      Java 2 Platform, Enterprise Edition (J2EE)是当前很多商业应用系统使用的开发平台,该技术提供了一个基于组件的方法来设计、开发、装配和部署企业级应用程序。J2EE平台提供了一个多层结构的分布式的应用程序模型,可以更快地开发和发布的新的应用解决方案。 
      作为网络上的商业应用系统,同时访问的人数是很多的,在大量访问的情况下,过多的资源请求和有限的服务器资源(内存、CPU时间、网络带宽等)之间就会出现矛盾,应用系统的性能就显得很重要了,有时正确的代码并不能保证项目的成功,性能往往是最后决定一个项目是否成功关键。
本文主要从性能的角度出发,讨论J2EE服务器端的代码性能优化和提升。 

二、      常用的Java代码问题对应用系统的性能影响.
下面讨论了一些在开发时应该注意方面:
1.    使用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();

 

2.    生成对象时,分配合理的空间和大小
  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);

 

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

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;
 }
}

 

所以,当有较大的循环时,应该检查循环内是否有效率不高的地方,寻找更优的方案加以改进。
4.    对象的创建
  尽量少用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之类的方法改变对象的变量达到重用的目的。
5.    变量的注意事项
尽量使用局部变量,调用方法时传递的参数以及在调用中创建的临时变量都保存在栈(Stack) 中,速度较快。其他变量,如静态变量、实例变量等,都在堆(Heap)中创建,速度较慢。
  尽量使用静态变量,即加修饰符static,如果类中的变量不会随他的实例而变化,就可以定义为静态变量,从而使他所有的实例都共享这个变量
6.    方法(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关键字有利于编译器的优化。
7.    慎用异常处理
      异常是Java的一种错误处理机制,对程序来说是非常有用的,但是异常对性能不利。抛出异常首先要创建一个新的对象,并进行相关的处理,造成系统的开销,所以异常应该用在错误处理的情况,不应该用来控制程序流程,流程尽量用while,if等处理。在不是很影响代码健壮性的前提下,可以把几个try/catch块合成一个。
8.    同步
同步主要出现在多线程的情况,为多线程同时运行时提供对象数据安全的机制,多线程是比较复杂话题,应用多线程也是为了获得性能的提升,应该尽可能减少同步。
  另外,如果需要同步的地方,可以减少同步的代码段,如只同步某个方法或函数,而不是整个代码。
9.    使用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操作。
1.    合理控制日志输出
        日志对于大多时候是有用的,特别是系统调试的时候,但也会产生大量的信息出现在控制台和日志上,同时输出时,有序列化和同步的过程,造成了开销。
  特别是在发行版中,要合理的控制日志输出、输出的级别,根据不同的情况进行不同的输出的控制。
2.    使用缓存
  读写内存要比读写文件要快很多,应尽可能使用缓冲,尽可能使用带有Buffer的类代替没有Buffer的类,如可以用BufferedReader 代替Reader,用BufferedWriter代替Writer来进行处理I/O操作同样可以用BufferedInputStream代替InputStream都可以获得性能的提高。 

四、      数据库访问
  在Java技术的应用体系中,应用程序是通过JDBC(Java Database Connectivity)实现的接口来访问数据库的,JDBC支持“建立连接、SQL语句查询、处理结果”等基本功能。在应用JDBC接口访问数据库的过程中,只要根据规范来实现,就可以达到要求的功能。
  但是,有些时候进行数据查询的效率着实让开发人员不如所愿,明明根据规范编写的程序,运行效果却很差,造成整个系统的执行效率不高。
1.     使用连接池
      为了提高访问数据库的性能,我们还可以使用JDBC 2.0的一些规范和特性,JDBC是占用资源的,在使用数据库连接时可以使用连接池Connection Pooling,避免频繁打开、关闭Connection。而我们知道,获取Connection是比较消耗系统资源的。
  Connection缓冲池是这样工作的:当一个应用程序关闭一个数据库连接时,这个连接并不真正释放而是被循环利用,建立连接是消耗较大的操作,循环利用连接可以显著的提高性能,因为可以减少新连接的建立。
  一个通过DataSource获取缓冲池获得连接,并连接到一个CustomerDB数据源的代码演示如下:

Context ctx = new InitialContext();
DataSource dataSource = (DataSource) ctx.lookup("jdbc/CustomerDB");
Connection conn = dataSource.getConnection("password","username");

 

 
2.     缓存DataSource
      一个DataSource对象代表一个实际的数据源。这个数据源可以是从关系数据库到表格形式的文件,完全依赖于它是怎样实现的,一个数据源对象注册到JNDI名字服务后,应用程序就可以从JNDI服务器上取得该对象,并使用之和数据源建立连接。
  通过上面的例子,我们知道DataSource是从连接池获得连接的一种方式,通过JNDI方式获得,是占用资源的。
  为了避免再次的JNDI调用,可以系统中缓存要使用的DataSource。
3.     关闭所有使用的资源
      系统一般是并发的系统,在每次申请和使用完资源后,应该释放供别人使用,数据库资源每个模式的含义可以参考SUN JDBC的文档,不同是比较宝贵的,使用完成后应该保证彻底的释放。
请看下面的代码段:

Connection conn = null;
Statement stmt = null;
ResultSet rs = null;
try {
 DataSource dataSource = getDataSource();
 // 取的DataSource的方法,实现略。
 conn = datasource.getConnection();
 stmt = conn.createStatement();
 rs = stmt.executeQuery("SELECT * FROM ...");
 ... // 其他处理
 rs.close();
 stmt.close();
 conn.close();
}catch (SQLException ex) {
 ... // 错误处理
}

 

  粗看似乎没有什么问题,也有关闭相关如Connection等系统资源的代码,但当出现异常后,关闭资源的代码可能并不被执行,为保证资源的确实已被关闭,应该把资源关闭的代码放到finally块:

Connection conn = null;
Statement stmt = null;
ResultSet rs = null;
try {
 DataSource dataSource = getDataSource();
 // 取的DataSource的方法,实现略。
 conn = datasource.getConnection();
 stmt = conn.createStatement();
 rs = stmt.executeQuery("SELECT * FROM ...");
 ... // 其他处理
}catch (SQLException ex) {
 ... // 错误处理

}finally{
 if (rs!=null) {
  try {
   rs.close(); // 关闭ResultSet}
  catch (SQLException ex) {
   ... // 错误处理
  }
 }
 if (stmt!=null){
  try {
   stmt.close(); // 关闭Statement}
  catch (SQLException ex) {
   ... // 错误处理
  }
 }
 if (conn!=null){
  try {
   conn.close(); // 关闭Connection}
  catch (SQLException ex) {
   ... // 错误处理
  }
 }
}

 

 
4.     缓存经常使用的数据
  对于构建的业务系统,如果有些数据要经常要从数据库中读取,同时,这些数据又不经常变化,这些数据就可以在系统中缓存起来,使用时直接读取缓存,而不用频繁的访问数据库读取数据。
  缓存工作可以在系统初始化时一次性读取数据,特别是一些只读的数据,当数据更新时更新数据库内容,同时更新缓存的数据值。

总结
           一般意义上说,参与系统运行的代码都会对性能产生影响,实际应用中应该养成良好的编程规范、编写高质量的代码,当系统性能出现问题时,要找到主要影响性能的瓶颈所在,然后集中精力优化这些代码,能达到事半功倍的效果。
            J2EE性能的优化包括很多方面的,要达到一个性能优良的系统,除了关注代码之外,还应该根据系统实际的运行情况,从服务器软硬件环境、集群技术、系统构架设计、系统部署环境、数据结构、算法设计等方面综合考虑。


 

软件部        张毅 

姓名:
性别:
电话:
E-mail
问题:
问题描述:
版权所有 金名计算机系统集成股份有限公司 备案号:京ICP备13027063号