1. Overview In Web applications, the generation of some reports may take a long time for the database to calculate; some websites provide weather information, which requires access to a remote server to make a SOAP call to obtain temperature information. All of these are examples of complex information. Adding too much complex information to a Web page may cause the Web server and database server to be overloaded. JSP code block buffering gives developers the freedom to add all kinds of complex information at will.
JSP can encapsulate and run complex Java code in the tag library, which makes JSP page files easier to maintain and makes it more convenient for non-professional developers to use JSP page files. There are already many tag libraries, which are either commercial products or open source products. But most of these products only use tag libraries to implement functions that can be implemented with a simple Java Scriptlet. Few products use custom tags in some creative way, providing almost the same functionality before the emergence of JSP custom tag libraries. Impossible usage.
The OSCache tag library, designed by OpenSymphony, is a groundbreaking JSP custom tag application that provides fast memory caching within existing JSP pages. While there are a few vendors offering caching products in various forms, they are all vendor-specific products. OSCache can run on any JSP 1.1-compliant server, and it can cache existing JSP code blocks not only for all users, but also on a per-user basis. OSCache also includes some advanced features to improve scalability, such as buffering to disk, programmable buffer flushing, exception control, etc. Additionally, like other OpenSymphony products, OSCache's code is freely distributed under an open source license.
This article takes an imaginary auction website design process as an example to introduce the working process of OSCache. This hypothetical Web site would contain:
1: An administrative page reporting recent auction activity;
2: A homepage with complete functions and various promotional information;
3: A special navigation bar that contains all the user’s auction information that has not yet been completed.
2. Management page
The auction website contains a management report, and it takes several seconds for the database server to create such a report. It is important that the report takes a long time to be generated, because we may have multiple administrators monitoring the operation of the system, and we want to avoid regenerating the report every time the administrator visits. To achieve this, we will encapsulate the entire page into an application-level buffer tag that is refreshed every hour. Some products from other vendors have similar functionality, it's just that OSCache does it better than them.
For the sake of simplicity, we will not focus too much on formatting issues. When writing the management page, we first add the tag library declaration to the page:
<%@ taglib uri="cachetags" prefix="cache" %>
Next we have to surround the entire page with cache tags. The default cache time for cache tags is 1 hour.
<cache:cache> .... Complex management reports.... </cache:cache>
The management page is now cached. If the administrator accesses the same page again within an hour after the page is generated, he will see the previously cached page, and there is no need for the database server to generate this report again.
3. Home page The home page of the auction website displays website activities and promotes auctions that are about to end. We want to display the number of ongoing auctions, the number of currently logged in users, a list of auctions that are due to end in the near future, and the current time. These messages have different time accuracy requirements. Auctions on the website usually last for several days, so we can set the time to buffer the number of valid auctions to 6 hours. The number of users will obviously change more frequently, but here we will buffer this value for 15 minutes at a time. Finally, we want the current time displayed on the page to always be the exact time the page was accessed.
After declaring the tag library in the home page, we first output the current date directly without buffering:
now it is: <%=new java.util.Date()%>
Next, we want to display a list of those that will Auctions that end in the short term:
<cache:cache> <ul> <% // Construct an Iterator containing recent auctions Iterator auctions = .... while (auctions.hasMore()) { Auction auction = (Auction) auctions.next(); %><li><%=auction%></li%< } %> </ul> </cache:cache>
Finally, we want to display the number of auctions in progress, this Numbers need to be buffered for 6 hours. Since cache marking requires the number of seconds to buffer data, we convert 6 hours into 21600 seconds:
<cache:cache time="21600"> <% //Query the database to get the total number of auction activities int auctionCount = .... %> There are <%=auctionCount%> ongoing auctions on this website! </cache>
As you can see, we only use a small amount of code to construct a homepage with a complex buffering system. This buffering system buffers each part of the page separately, and the buffering time of each part is fully consistent with the frequency of changes in their respective information. Thanks to buffering, we can now put more content on the homepage; without buffering before, putting too much content on the homepage will cause page access to slow down, and may even cause problems for the database server. Excessive load.
4. Navigation Bar Suppose when planning the website, we decide to display the shopping cart content below the left navigation bar. We will display the number of bids and the current price for each item in the auction by the user, as well as a list of all those items for which the current user has the highest bid.
We use session-level buffering capabilities to construct the above functionality in the navigation bar. Put the following code into the template or include file so that other pages in the website can reference this navigation bar:
<cache:cache key="navbar" scope="session" time="300"> <% //Extract and display the current Bid information%> </cache:cache>
Here we introduce two important attributes, namely key and scope. In the code earlier in this article, since the cache tag can automatically create a unique key for the code block, we do not need to set this key attribute manually. But here, we want to reference this cached block of code from the rest of the site, so we explicitly define the key attribute of the cache tag. Second, the scope attribute is used to tell the cache to mark that the current code block must be buffered on a per-user basis, rather than buffering once for all users.
You should be very careful when using session-level buffering, and it should be clear: although we can make a complex navigation bar reduce the server load by 5x or 10x, it will greatly increase the memory space required per session. It is undoubtedly ideal to increase the number of possible concurrent users in terms of CPU capabilities, but once the number of concurrent users is reduced to the limit of the CPU in terms of memory support capabilities, this solution is no longer ideal.
As mentioned earlier in this article, we want to reference this buffered block of code from the rest of the site. This is because when a user adds an item for auction, or bids for items auctioned by other users, we want to refresh the buffer so that the navigation bar has the latest content the next time it is read. While this data may change due to the activity of other users, it may be very confusing for a user to see that his or her listing remains unchanged after performing an action on the site.
The flush tag provided by the OSCache library can refresh the buffer content. We can add the following code to the page that handles user actions that may affect this area:
<cache:flush key="navbar" scope="session" />
When the user accesses it next time, the navbar buffer block will be refreshed.
So far, the construction of our sample website has been completed and can start running. Let's take a look at OSCache's exception handling capabilities. Even if the buffered content has been invalidated, such as a Java exception occurring within the buffer block, the OSCache tag library still allows us to display the content programmatically. With this exception control feature, we can tear down the connection between the database server and the web server, and the website will still be able to continue running. The JSP 1.2 specification introduced the TryCatchFinally interface, which allows the tag itself to detect and handle Java exceptions. Therefore, markup can be combined with this exception handling code to make JSP pages simpler and more organized.
OpenSymphony is planning to implement additional buffering mechanisms as well as a more manageable main system that will allow us to manage the RAM and disk space used by buffering. Once these features are in place, we will be able to further improve the responsiveness and reliability of the website.
Usage example:
oscache.properties file configuration wizard
cache.memory
The value is true or false. The default is to cache in memory.
If set to false, the cache can only be cached in the database or hard disk, so what is the point of the cache:)
cache.capacity
Number of cache elements
cache.persistence.class
Persistent cache class, if this class is turned on, you must set cache.path information
cache.cluster related to cluster setting information.
like
cache.cluster.multicast.ip is the broadcast IP address
cache.cluster.properties is the cluster properties
3. The basic usage of OSCache
cache1.jsp is as follows
<%@ page import="java.util.*" %>
<%@ taglib uri="oscache" prefix="cache" %>
<html>
<body>
No cached date: <%= new Date() %><p>
<!--Automatic refresh-->
<cache:cache time="30">
Refresh the cached date every 30 seconds: <%= new Date() %>
</cache:cache>
<!--Manual refresh-->
<cache:cache key="testcache">
Manually refresh the cached date: <%= new Date() %> <p>
</cache:cache>
<a href="/cache2.jsp">Manual refresh</a>
</body>
</html>
cache2.jsp performs manual refresh of the page as follows
<%@ taglib uri="oscache" prefix="cache" %>
<html>
<body>
The cache has been flushed...<p>
<cache:flush key="testcache" scope="application"/>
<a href="/cache1.jsp">Return</a>
</body>
</html>
You can also define the effective scope of Cache through the following statement. If you do not define scope, the scope defaults to Applcation.
<cache:cache time="30" scope="session">
...
</cache:cache>
4. Cache filter CacheFilter
You can define a cache filter in web.xml to define the cache of specific resources.
1 <filter>
2 < filter - name > CacheFilter </ filter - name >
3 < filter - class > com.opensymphony.oscache.web.filter.CacheFilter </ filter - class >
4 <init-param>
5 <param-name>time</param-name>
6 < param - value > 60 </ param - value >
7 </init-param>
8 <init-param>
9 <param-name>scope</param-name>
10 <param-value>session</param-value>
11 </init-param>
12 </ filter >
13
14
15 <filter-mapping>
16 < filter - name > CacheFilter </ filter - name >
17 < url - pattern >* .jsp </ url - pattern >
18 </ filter - mapping >
The above definition will cache all .jsp pages, the cache refresh time is 60 seconds, and the cache scope is Session.
Note that CacheFilter only captures page requests with an Http header of 200, that is, only caches requests without errors.
Instead of caching other requests (such as 500, 404, 400)
[Conclusion] OSCache can help us construct a more colorful and higher-performance website. With the help of the OSCache tag library, we can now use it to solve some problems that affect the responsiveness of the website, such as peak traffic periods, overloaded database servers, etc.
Personal tip: If you use Struts or other MVC architecture, it is difficult to enjoy the performance improvement brought by oscache tag, because each request still has to be submitted to action--dao-or othere thing for processing. Therefore, to use caching, you need Other methods, such as method-level caching in spring's interceptor... If all your business processing codes are written in jsp pages, you can use cache tags to cache the page data generated previously to avoid doing Same business operations.