Upgrade the JSP application of the seven cheats trick

Js| program you are often complained of by customers JSP page response speed is very slow? Do you think your Web application can withstand ever-increasing amounts of traffic when the number of customer visits is soaring? This article describes some of the most useful ways to adjust the JSP and servlet to make your servlet and JSP pages respond faster and more scalable. And in the case of increasing the number of users, the system load will show a trend of smooth and long. In this article, I'll use some examples and configuration methods to make your application's performance unexpectedly elevated.

Some of these tuning techniques are implemented in your programming work. Other technologies are related to the configuration of the application server. In this article, we will describe in detail how to improve the overall performance of your application by adjusting the servlet and JSP pages. Before reading this article, let's say you have basic servlet and JSP knowledge.

Method One: Caching data in the Init () method of the Servlet

After the application server initializes the servlet instance, it invokes the Init () method of the servlet before servicing the client request. In the lifecycle of a servlet, the init () method is invoked only once. System performance can be greatly improved by caching some static data in the Init () method or by completing some time-consuming operations that need to be performed only once.

For example, creating a JDBC Connection pool in the init () method is a good example, assuming that we are using the jdbc2.0 DataSource interface to get a database connection, and that, in general, we need to get a specific data source through Jndi. We can imagine that in a specific application, if a jndi query is executed every time a SQL request is performed, the performance of the system will drop dramatically. The workaround is the following code, which is cached datasource, making it possible for the next SQL call to continue to take advantage of it:

public class Controllerservlet extends HttpServlet
{
Private Javax.sql.DataSource Testds = null;
public void init (ServletConfig config) throws Servletexception
{
Super.init (config);
Context ctx = null;
Try
{
CTX = new InitialContext ();
Testds = (Javax.sql.DataSource) ctx.lookup ("Jdbc/testds");
}
catch (Namingexception ne)
{
Ne.printstacktrace ();
}
catch (Exception e)
{
E.printstacktrace ();
}
}

Public Javax.sql.DataSource Gettestds ()
{
return Testds;
}
...
...
}

Method 2: Disable servlet and JSP automatic overloading (auto-reloading)

SERVLET/JSP provides a practical technology, automatic overload technology, which provides developers with a good development environment, when you change the servlet and JSP pages without restarting the application server. However, this technology is a great drain on the resources of the system during the operation of the product, because it will bring a great burden to the JSP engine class loader (ClassLoader). Therefore, turning off the automatic overload feature is a great help to improve system performance.

Method 3: Do not abuse httpsession

In many applications, our programs need to maintain the state of the client so that the pages can be interconnected. Unfortunately, because HTTP is inherently stateless, the state of the client cannot be saved. Therefore, the general application Server provides a session to save the state of the customer. In the JSP application server, it is through the httpsession to realize the function of the session, but at the same time, it also brings a small burden to the system. Because every time you get or update the session, the system needs to serialize it in a time-consuming process. You can improve the performance of the system by following several processing methods for httpsession.

If not necessary, you should close the default settings for HttpSession in the JSP page. If you do not explicitly specify, each JSP page will default to create a httpsession. If you do not need to use session in your JSP, you can disable it by using the following JSP page designator:

<%@ page session= "false"%>

Do not store large data pairs in HttpSession: If you store large data pairs in HttpSession, the application server will serialize it whenever you read and write to it, increasing the extra burden on the system. The larger the data you store in the HttpSession, the faster the performance of the system will fall.

When you don't need to httpsession, release it as quickly as possible: when you no longer need a session, you can release it by calling the Httpsession.invalidate () method. Try to set the timeout for the session short: there is a default timeout for the session in the JSP application server. When the customer has not done anything after this time, the related session is automatically freed from memory. The larger the timeout time, the lower the performance of the system, so the best way is to keep its value at a lower level as much as possible.

Method 4: Compress the page output

Compression is a good way to solve data redundancy, especially in the network bandwidth is not developed today. Some browsers support gzip (GNU Zip) to compress HTML files, which dramatically reduces the time to download HTML files. So, if you compress the HTML page generated by the servlet or JSP page, the user will feel the page is browsing very quickly. Unfortunately, not all browsers support gzip compression, but you can check to see if the client's browser supports it in your program. Here is a snippet of the implementation of this method:

public void doget (HttpServletRequest request,
HttpServletResponse response)
Throws IOException, Servletexception
{
OutputStream out = null
String encoding = Request.getheader ("accept-encoding");
if (encoding!= null && encoding.indexof ("gzip")!=-1)
{
Request.setheader ("content-encoding", "gzip");
out = new Gzipoutputstream (Request.getoutputstream ());
}
else if (encoding!= null && encoding.indexof ("compress")!=-1)
{
Request.setheader ("content-encoding", "compress");
out = new Zipoutputstream (Request.getoutputstream ());
}
Else
{
out = Request.getoutputstream ();
}
...
...
}

Method 5: Use the thread pool

The application server defaults to creating a thread for each of the different client requests and assigns a service () method to them, and the corresponding thread is undone when the service () method call completes. Because creating and undoing threads consumes a certain amount of system resources, this default mode reduces the performance of the system. But fortunately, we can change this by creating a thread pool.

In addition, we will also set a minimum number of threads and a maximum number of threads for this thread pool. When the application server starts, it creates a thread pool that is equal to the minimum number of threads, which, when requested by the client, is handled from the pool, and then, when the processing is complete, the thread is put back into the pool. If the threads in the pool are not sufficient, the system automatically increases the number of threads in the pool, but the total amount cannot exceed the maximum thread count. By using a thread pool, the system's load will be rendered a smooth upward curve when client requests increase dramatically, thereby increasing the system's scalability.

Method 6: Select the correct page inclusion mechanism

There are two ways to include another page in a JSP:

1. Use the Include indicator

<%@ Includee file= "test.jsp"%>

2. Use JSP indicator

In practice, it is found that if the first method is used, the system performance can be higher.

Method 7: Correctly determine the life cycle of the JavaBean

A powerful place for JSP is the support of JavaBean. By using the label in a JSP page, you can insert JavaBean directly into a JSP page. It is used in the following ways:

"Package.classname" type= "TypeName"

The scope attribute indicates the life cycle of the bean. The default life cycle is page. If you don't choose your bean's lifecycle correctly, it will affect your system's performance.

For example, if you only want to use a bean in one request, but you set the life cycle of the bean to session, the bean will remain in memory when the request is finished, unless it is timed out or the user closes the browser. This consumes a certain amount of memory and needlessly increases the workload of the JVM garbage collector. So setting the correct lifecycle for the bean and cleaning it up as quickly as possible after the Bean's mission is over, using system performance to improve.

A few other useful methods

1, in string concatenation operation as far as possible not to use the "+" operator: In Java programming, we often use the "+" operator to connect a few strings, but you may never think of it can actually affect the system performance? Because strings are constants, the JVM produces some temporary pairs of pixels. The more "+" you use, the more temporary the image will be generated, which will also have some impact on system performance. The workaround is to replace the "+" operator with StringBuffer.

2, avoid using the System.out.println () method: Because System.out.println () is a synchronous call, that is, when it is invoked, disk I/O operations must wait for it to complete, so we should try to avoid calls to it. But when we debug the program it is an essential convenience tool, in order to solve this contradiction, I suggest you better use the Log4j tool (http://Jakarta.apache.org ), it can be easily debugged, It does not produce a method like System.out.println ().

3, Servletoutputstream and PrintWriter tradeoff: the use of printwriter may bring some small overhead, because it converts all the original output into a character stream to output, so if you use it as a page output, The system has to bear a conversion process. The use of Servletoutputstream as a page output does not have a problem, but it is in binary output. Therefore, in practical application to weigh the pros and cons of both.

Summarize

The purpose of this article is to greatly improve the performance of your application through some of the tuning techniques of the servlet and JSP, and thus enhance the performance of the entire Java EE application. With these tuning techniques, you can see that it's not a technology platform (like Java EE and. NET contention) that determines the performance of your application, it's important that you have a deeper understanding of the platform so that you can fundamentally optimize your application