A small site, such as personal website, you can use the most simple HTML static page implementation, achieve beautification effect, cooperate with some pictures of all the pages are stored in a directory, such sites on the system architecture, performance requirements are very simple, with the enrichment of Internet business, website related technology after years of development, Has been subdivided into very fine aspects, especially for large websites, the use of technology is very wide, from hardware to software, programming language, database, WebServer, firewall and other fields have very high requirements, has not been the original simple HTML static site can match.
Large websites, such as portals. In the case of high user access and high concurrent requests, the basic solution is to use a high performance server, a high performance database, an efficient programming language, and a high performance Web container. But in addition to these aspects, it can not fundamentally solve the problem of high load and high concurrency faced by large websites.
The solutions provided above also mean greater investment to a certain extent, and such solutions have bottlenecks and do not have good expansibility. Below, I will talk about some of my experience from the perspective of low cost, high performance and high expansibility.
1. Static HTML
In fact, we all know that the highest efficiency, consumption of the least is pure static HTML pages, so we try to make our website pages using static pages to achieve, the simplest method is actually the most effective method. However, for websites with a large number of contents and frequent updates, we cannot implement them one by one manually, so the common information publishing system CMS emerged. For example, the news channels of various portal sites we often visit, even their other channels, are managed and implemented through the information publishing system. Information publishing system can achieve the simplest information input automatically generate static pages, but also with channel management, authority management, automatic capture and other functions, for a large website, have a set of efficient, manageable CMS is essential.
In addition to the portal and information release type of site, for interactive website demanding community type, as static as possible is the essential means to improve performance and real-time of the post within the community, the article is static, when there are updates to static is also extensive use of the strategy, like the hodgepodge of Mop is the use of the strategy, Netease community and so on.
At the same time, the HTML static is an efficient way of some caching strategies use, for frequent use in the system database query but content update small applications, consider using HTML static, such as BBS BBS in public Settings information, the information management background and the current mainstream BBS can be stored to the database, In fact, a lot of these information is called by the foreground program, but the update frequency is very small, you can consider this part of the content of the background update when static, so as to avoid a large number of database access requests.
2. Image server separation
As you know, for Web servers, whether it’s Apache, IIS, or any other container, images are the most resource consuming, so it’s necessary to separate images from the page, which is basically the strategy of large sites, they all have a separate image server, or many image servers. This architecture can reduce the pressure on the server system to provide page access requests, and can ensure that the system will not crash due to image problems. On the application server and image server, different configuration optimization can be carried out, for example, Apache can configure the ContentType as little as possible. As few loadModules as possible to ensure higher system consumption and execution efficiency.
3, database cluster and library table hash
Large sites have complex applications, these applications must use the database, so in the face of a large number of access, the bottleneck of the database will soon appear, then a database will soon be unable to meet the application, so we need to use database cluster or library table hash.
In terms of database cluster, many databases have their own solutions, Oracle, Sybase, etc., have good solutions, and the Master/Slave provided by MySQL is similar. What KIND of DB you use, refer to the corresponding solutions to implement.
The database cluster mentioned above is limited by the DB type in terms of architecture, cost and scalability, so we need to consider improving the system architecture from an application perspective. Library table hashing is the common and most effective solution. We installed in the application and application or function module database, different modules for different database or table, and then according to certain strategy on a page or smaller database hash function, such as user table, carried out in accordance with the user ID hash table, so that it can improve system performance in low cost and good extensibility. Sohu BBS is adopted such architecture, set the BBS user, separation and post information database, and then to post, the user shall be carried out in accordance with the plate and the ID hash database and table, finally can be simple configuration in the configuration file can let the system adds a low-cost added database in system performance.
4, caching,
Caching is a term that everyone in technology has seen, and it’s used a lot of times. Caching in website architecture and website development is also very important. Here are the two basic types of caches. Advanced and distributed caching is described later. The architecture of the cache, familiar with Apache can know that Apache provides its own cache module, Squid module can also be used to cache, these two ways can effectively improve the access response ability of Apache. For web program development, The MemoryCache provided by Linux is a common Cache interface that can be used in Web development. For example, when Java is used, MemoryCache can be called to Cache and communicate with some data. Some large communities use such architecture. In addition, in the use of Web language development, various languages basically have their own Cache module and method, PHP has Pear Cache module, Java is more,.NET is not very familiar with, I believe there must be.
5, mirror
Mirror is large sites often adopt the way of improving performance and data security, image technology can solve different web portal and regional users access speed difference, the difference between such as ChinaNet and EduNet causes a lot of sites within the education network structures, mirror sites, the data is regularly updated or updated in real time. Without going into the technical details of mirroring, there are many specialized off-the-shelf solutions and products to choose from. There are also inexpensive ideas that can be implemented through software, such as tools like Rsync on Linux.
6. Load balancing
Load balancing will be the ultimate solution for large websites to deal with heavy load and large number of concurrent requests.
Load balancing technology has developed over the years, and there are many professional service providers and products to choose from. I personally have been exposed to some solutions, and there are two architectures for you to refer to.
1) Hardware layer 4 switching
Layer 4 switching uses the header information of Layer 3 and Layer 4 packets to identify service flows based on application intervals and allocate the entire service flows to appropriate application servers for processing. Layer 4 switching functions are like virtual IP addresses that point to physical servers. It transmits services that are subject to a variety of protocols, such as HTTP, FTP, NFS, Telnet, or others. These services require complex load balancing algorithms based on physical servers. In the IP world, the service type is determined by the TCP or UDP port address of the terminal. In layer 4 switching, the application range is determined by the IP address of the source end and the terminal, as well as the TCP and UDP ports.
In the hardware 4 layer switching product space, there are some well-known products to choose from, such as Alteon, F5, etc., which are expensive but good value for money, offering excellent performance and flexible management capabilities. Yahoo China had nearly 2,000 servers and it took three or four Alteon to do it.
2) Software four-layer exchange
After we know the principle of the hardware four-layer switch, the software four-layer switch based on the OSI model came into being. Such a solution achieves the same principle, but the performance is slightly worse. But to meet a certain amount of pressure is still easy, some people say that software implementation is actually more flexible, the ability to deal with completely depends on your configuration of the familiar ability.
LVS is Linux Virtual Server, which provides real-time disaster response solutions based on heartbeat, improves the robustness of the system, and provides flexible Virtual VIP configuration and management functions. It can meet multiple application requirements at the same time, which is essential for distributed systems.
A typical strategy to use load balancing is to build SQUID cluster based on software or hardware four layer switching. This idea is adopted in many large websites including search engines. Such architecture is low cost, high performance and strong expansion, and it is very easy to add or remove nodes into the architecture at any time. I plan to sort out such a structure in detail and discuss it with you in my spare time.
A: high concurrency high load type of site concerns database
Yes, the database is the first SPOF that most applications face. Especially for Web2.0 applications, database response is the first thing to be solved. In general, MySQL is the most commonly used, probably starting as a MySQL host, but as data increases to more than 1 million, MySQL’s performance drops dramatically. The most commonly used optimization method is m-S (master-slave) synchronous replication, in which the query and operation are performed on different servers. I recommend the method of M-M-Slaves, two Master Mysql and multiple Slaves. It should be noted that although there are two masters, only one is Active at the same time, we can switch at a certain time. The reason for using two M is to ensure that M does not become SPOF the system again. Slaves can further load balance and can be combined with LVS to properly balance the SELECT operation to different Slaves. The above architecture can handle a certain amount of load, but as you add more users and your user table exceeds 10 million, that M becomes SPOF. You cannot expand Slaves, otherwise the cost of replication synchronization will skyrocket, what to do? My approach is table partitioning, which is done at the business level. The simplest example is user data. Shard to different database clusters according to certain shard methods, such as ID.
The global database is used for querying meta data. The disadvantage is that each query will increase one time. For example, if you want to query a user nightsailer, you first need to find the cluster ID corresponding to nightsailer in the global database group, and then go to the specified cluster to find the actual data of nightsailer. Each cluster can be m-M or M-M-Slaves. This is a scalable structure that you can simply add new mysql clusters to as the load increases.
Note that: 1) Disable all auto_INCREMENT fields; 2) Use a universal algorithm to allocate IDS in a centralized manner; 3) Use a good method to monitor the load and running status of mysql host services. If you have 30 or more mysql databases running you know what I mean. 4. Don’t use persistent links (don’t use PConnect), instead use a third-party database link pool like SQLRelay, or do it yourself, as mysql link pools often fail in PHP4. Two: high concurrency high load website system architecture HTML static
Actually we all know, efficiency is the highest, the consumption of the smallest is pure static www.ablanxue.com/shtml/20120… HTML pages, so we try to make the pages on our site use static pages, the simplest method is actually the most effective method. However, for websites with a large number of contents and frequent updates, we cannot implement them one by one manually, so the common information publishing system CMS emerged. For example, the news channels of various portal sites we often visit, even their other channels, are managed and implemented through the information publishing system. Information publishing system can achieve the simplest information input automatically generate static pages, but also with channel management, authority management, automatic capture and other functions, for a large website, have a set of efficient, manageable CMS is essential. In addition to the portal and information release type of site, for interactive website demanding community type, as static as possible is the essential means to improve performance and real-time of the post within the community, the article is static, when there are updates to static is also extensive use of the strategy, like the hodgepodge of Mop is the use of the strategy, Netease community and so on. At the same time, the HTML static is an efficient way of some caching strategies use, for frequent use in the system database query but content update small applications, consider using HTML static, such as BBS BBS in public Settings information, the information management background and the current mainstream BBS can be stored to the database, In fact, a large number of these information is called by the foreground program, but the update frequency is very small, you can consider this part of the content of the background update when static, so as to avoid a large number of database access requests high concurrency.
When a Servlet resource request arrives at the WEB server, we fill the specified JSP page in response to the request:
HTTP request –Web server –Servlet– business logic processing — access data — Populate JSPS — respond to requests
After the HTML is static:
HTTP request -Web server -Servlet- HTML- response request
Static requests are as follows
Servlet:
public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { if(request.getParameter("chapterId") ! = null){ String chapterFileName = "bookChapterRead_"+request.getParameter("chapterId")+".html"; String chapterFilePath = getServletContext().getRealPath("/") + chapterFileName; File chapterFile = new File(chapterFilePath); if(chapterFile.exists()){response.sendRedirect(chapterFileName); return; }// If you have this file, tell the browser to go to INovelChapterBiz novelChapterBiz = new NovelChapterBizImpl(); NovelChapter novelChapter = novelChapterBiz.searchNovelChapterById(Integer.parseInt(request.getParameter("chapterId"))); / / section information int lastPageId = novelChapterBiz. SearchLastCHapterId (novelChapter. GetNovelId () getId (), novelChapter. GetId ()); int nextPageId = novelChapterBiz.searchNextChapterId(novelChapter.getNovelId().getId(), novelChapter.getId()); request.setAttribute("novelChapter", novelChapter); request.setAttribute("lastPageId", lastPageId); request.setAttribute("nextPageId", nextPageId); new CreateStaticHTMLPage().createStaticHTMLPage(request, response, getServletContext(), chapterFileName, chapterFilePath, "/bookRead.jsp"); }}Copy the codeClasses that generate STATIC HTML pages:
package com.jb.y2t034.thefifth.web.servlet; import java.io.ByteArrayOutputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.OutputStreamWriter; import java.io.PrintWriter; import javax.servlet.RequestDispatcher; import javax.servlet.ServletContext; import javax.servlet.ServletException; import javax.servlet.ServletOutputStream; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import javax.servlet.http.HttpServletResponseWrapper; /** * Create HTML static page * Feature: Create HTML static page * Time: 1011, 2009 * Location: Home * @author mavk ** / public class CreateStaticHTMLPage {/** ** Method of generating static HTML pages * @param Request request object * @param Response Response object * @param servletContext Servlet context * @param fileName fileName * @param fileFullPath full file path * @param jspPath Generate static file JSP path (relative) * @throws IOException * @throws ServletException */ public void createStaticHTMLPage(HttpServletRequest request, HttpServletResponse response,ServletContext servletContext,String fileName,String fileFullPath,String jspPath) throws ServletException, IOException{ response.setContentType("text/html; charset=gb2312"); / / set the HTML results flow (i.e., HTML file) RequestDispatcher rd = servletContext. GetRequestDispatcher (jspPath); Final ByteArrayOutputStream ByteArrayOutputStream = new ByteArrayOutputStream(); ServletOutputStream Final ServletOutputStream servletOuputStream = new ServletOutputStream(){// For receiving resources from HttpServletResponse public void write(byte[] b, int off,int len){ byteArrayOutputStream.write(b, off, len); } public void write(int b){ byteArrayOutputStream.write(b); }}; final PrintWriter printWriter = new PrintWriter(new OutputStreamWriter(byteArrayOutputStream)); // Convert the byte stream to a character stream HttpServletResponse HttpServletResponse = new HttpServletResponseWrapper (response) {/ / used to get the result from the response flow resources (rewrite the two methods) public ServletOutputStream getOutputStream () {return servletOuputStream; } public PrintWriter getWriter(){ return printWriter; }}; rd.include(request, httpServletResponse); Printwriter.flush (); FileOutputStream FileOutputStream = new FileOutputStream(fileFullPath); byteArrayOutputStream.writeTo(fileOutputStream); Fileoutputstream.close (); // Write all resources in byteArrayOuputStream to fileOuputStream. // Close the output stream and release the related resource response.sendredirect (fileName); // Send the specified file stream to the client}}Copy the codeThree: high concurrency and high load of the site concerns of the cache, load balancing, storage
Caching is another big issue, and I use memcached for my cache cluster, usually deploying 10 or so (10GB pool). Do not use swap. It is best to turn off Linux swap.
Load balancing/acceleration When it comes to caching, the first thing people think about is page static, so called static HTML, which I think is common sense and not important. With static pages comes load balancing and acceleration of static services. I think Lighttped+Squid is the best way. LVS <——->lighttped====>squid(s) ====lighttpd
This is the one I use a lot. Note that I do not use Apache, and I do not deploy Apache unless there is a specific need, because I generally use PHp-FastCGI with Lighttpd, which is much better than Apache + mod_PHP.
Squid can be used to solve problems such as file synchronization, but you need to be careful to monitor the cache hit ratio and try to increase it to 90% or more. Squid and Lighttped also have many topics to discuss, which will not be covered here.
Storage Storage is also a big problem, one is the storage of small files, such as images. The other is the storage of large files, such as search engine indexes, generally more than 2 gigabytes per file. The simplest way to store small files is to distribute them with Lighttpd. Or use Redhat GFS, which has the advantage of transparent application and the disadvantage of high cost. I mean the problem with your purchase of disk array. In my project, the storage capacity is 2-10TB, and I use distributed storage. File duplication and redundancy are addressed here. So that each file has different redundancy, see Google’s GFS paper on this. The storage of large files, as described in Nutch, is now a separate hadoop subproject. (You can Google it.)
Others: Passport and so on are also considered, but these are relatively simple ones. Four: High concurrency and high load website image server of the system architecture of separation As we all know, for the Web server, Apache, IIS or other containers, image is the consumption of resources, so it is necessary to separate the images with the page, this is basically will adopt the strategy of large website, they have independent image server, Even a lot of image servers. This architecture can reduce the pressure on the server system to provide page access requests, and can ensure that the system will not crash due to image problems. On the application server and image server, different configuration optimization can be carried out, for example, Apache can configure the ContentType as little as possible. As few loadModules as possible to ensure higher system consumption and execution efficiency.
Use Apache to achieve the image server separation reason: the initial stage of the application, may be deployed on a server (cost reasons), the first priority separation, must be the database and the application server. What would be the second separation? Each has its own considerations. The project team I am in focuses on saving bandwidth. No matter how good the server performance is, no matter how high the bandwidth is, it is easy to fail to support concurrent services. Therefore, this is the focus of my article. WEB application Server: 4CPU dual-core 2G, 4G memory Deployment: Win2003/Apache Http Server 2.1/Tomcat6 Database Server: Step 1: Add two common servers with 2 cpus, 2 cores, and 2 memory to deploy resource servers. Tomcat6, which runs a simple application for image uploading, (remember to specify <distributable/> of web.xml), and specify the domain name res1.*** com,res2.***.com, using the AJP protocol step 2: /fileupload. HTML /otherupload. HTML Add the following configuration to the httpd.conf file
<VirtualHost *:80> ServerAdmin webmaster@***.com ProxyPass /fileupload.html balancer://rescluster/fileupload lbmethod=byrequests stickysession=JSESSIONID nofailover=Off timeout=5 maxattempts=3 ProxyPass /otherupload.html balancer://rescluster/otherupload.html lbmethod=byrequests stickysession=JSESSIONID nofailover=Off timeout=5 maxattempts=3 #<! — Proxy balancer://rescluster/> BalancerMember ajp://res1.***.com:8009 smax=5 Max =500 TTL =120 retry=300 loadfactor=100 route=tomcat1 BalancerMember ajp://res2.***.com:8009 smax=5 max=500 ttl=120 retry=300 loadfactor=100 Run the following command: route=tomcat2 </Proxy> </ VirtualHost> Step 3 modify the service logic. All uploaded files are saved in the database using the full URL mode, for example, product image path: http://res1.***.com/upload/20090101/product120302005.jpg
Now, you can rest easy, when the bandwidth is low, add dozens of image servers, just need to modify the Apache configuration file, can be.
Five: database cluster and library table hashing for the system architecture of high concurrency and high load web sites
Large sites have complex applications, these applications must use the database, so in the face of a large number of access, the bottleneck of the database will soon appear, then a database will soon be unable to meet the application, so we need to use database cluster or library table hash. In terms of database cluster, many databases have their own solutions, Oracle, Sybase, etc., have good solutions, and the Master/Slave provided by MySQL is similar. What KIND of DB you use, refer to the corresponding solutions to implement. The database cluster mentioned above is limited by the DB type in terms of architecture, cost and scalability, so we need to consider improving the system architecture from an application perspective. Library table hashing is the most common and effective solution. We installed in the application and application or function module database, different modules for different database or table, and then according to certain strategy on a page or smaller database hash function, such as user table, carried out in accordance with the user ID hash table, so that it can improve system performance in low cost and good extensibility. Sohu BBS is adopted such architecture, set the BBS user, separation and post information database, and then to post, the user shall be carried out in accordance with the plate and the ID hash database and table, finally can be simple configuration in the configuration file can let the system adds a low-cost added database in system performance.
Classification of cluster software: Generally speaking, cluster software can be divided into three categories according to the direction of focus and the problems it tries to solve: High Performance Cluster (HPC), Load Balance Cluster (LBC), and High Availability Cluster (HAC). High Performance Cluster (HPC) uses multiple machines in a cluster to complete the same task, making the task faster and more reliable than that of a single machine. Make up for the lack of single performance. The cluster is widely used in the environment with large data volume and complex computation, such as weather forecast and environmental monitoring. Load balance cluster (LBC), it is the use of a cluster in a number of stand-alone, complete many parallel small work. In general, if an application USES many, so user request response time will increase, the performance of the machine would also be affected, if using the load balancing cluster, so any one machine in a cluster can respond to user request, this cluster will be after the user service requests, select the minimum load at that time, The machine that can provide the best service accepts the request and responds, so that clustering can be used to increase the availability and stability of the system. This type of clustering is often used in web sites; High Availability Cluster (HAC) takes advantage of system redundancy in the cluster. When a machine is damaged, other backup machines can quickly replace it to start services and wait for the repair and return of the faulty machine. Maximize the availability of services in the cluster. Such systems are widely used in banking and telecommunication services, which require high system reliability. 2 the current situation of the database cluster database cluster is the computer cluster technology is introduced into the database, although the manufacturers claim to the architecture of how to perfect, but still can not change the Oracle should, everyone pursuit of facts, the cluster on the solution of Oracle RAC is ahead of other database vendors, including Microsoft, It can meet customers’ requirements of high availability, high performance, database load balancing and convenient expansion. Oracle Real Application Cluster(RAC) Microsoft SQL Cluster Server (MSCS) IBM DB2 UDB High Availability Cluster(UDB) Sybase ASE High Availability Cluster (ASE) MySQL High Availability Cluster (MySQL CS) Third-party High Availability (HA) Cluster based on IO At present, there are six main types of database cluster technology, some of which are developed by database manufacturers themselves. There are also third-party cluster companies developed; There are database manufacturers and third-party cluster companies to develop cooperation, all types of cluster to achieve the function and architecture are not the same. Real Application Cluster (RAC) is a new technology used in Oracle9i database, and also the core technology of Oracle database to support grid computing environment. It solves an important problem in traditional database applications: the contradiction between high performance, high scalability and low price. For a long time, Oracle has dominated the clustered database market with Real Application Cluster (RAC) technology
Six: high concurrency and high load site system architecture caching
Caching is a term that everyone in technology has seen, and it’s used a lot of times. Caching in website architecture and website development is also very important. Here are the two basic types of caches. Advanced and distributed caching is described later. The architecture of the cache, familiar with Apache can know that Apache provides its own cache module, Squid module can also be used to cache, these two ways can effectively improve the access response ability of Apache. For website program development, The MemoryCache provided by Linux is a common Cache interface, which can be used in Web development. For example, MemoryCache can be called for caching and communication sharing of some data when Java is used for development. Some large communities use such architecture. In addition, in the use of Web language development, various languages basically have their own Cache module and method, PHP has Pear Cache module, Java is more,.NET is not very familiar with, I believe there must be.
JBossCache is a replicated transaction cache that allows you to cache enterprise application data for better performance. Cached data is automatically replicated, making clustering between Jboss servers easy. JBossCache can run an Mbean service through the Jboss application service or another J2EE container, or it can run on its own. JBossCache consists of two modules: TreeCache and TreeCacheAOP. TreeCache – is a transaction cache for tree structure replication. TreeCacheAOP — an “object-oriented” cache that uses AOP to dynamically manage pojos OSCache the OSCache tag library, designed by OpenSymphony, is a pioneering JSP custom tag application that provides fast memory caching within existing JSP pages. OSCache is a widely adopted high-performance J2EE caching framework that can be used as a common caching solution for any Java application. OSCache has the following features: Cache any object, you can cache portions of JSP pages or HTTP requests without limitation, and any Java object can be cached. Full API- The OSCache API gives you a full program to control all OSCache features. Permanent cache – The cache can be written to the hard disk at will, thus allowing expensive to-create data to keep the cache and even restart the application. Support for clustering – cluster cache data can be configured individually without code modification. Expiration of cached records – You can have maximum control over expiration of cached objects, including a pluggable refresh strategy (if not required by default performance). JCACHE JCACHE is a soon-to-be-published standard specification (JSR 107) that describes a way to temporarily cache Java objects in memory, including object creation, shared access, spooling, invalidation, consistency across JVMS, and more. It can be used to cache the most frequently read data within JSPS, such as product catalogs and price lists. With JCACHE, the response time for most queries is increased by having cached data (internal tests show response times to be about 15 times faster). Ehcache Ehcache comes from Hibernate and is used in Hibernate as a data caching solution. The Java Caching System JCS is a sub-project of Project Turbine in Jakarta. It is a compound buffer tool. Objects can be buffered to memory or hard disk. Has buffer object time expiration Settings. It is also possible to build a distributed architecture with buffering through JCS for high-performance applications. Some objects that require frequent access and consume a lot of resources each time they are accessed can be temporarily stored in buffers to improve service performance. JCS is a great buffer tool. The buffering tool improves performance significantly for applications where read operations are far greater than write operations. SwarmCache SwarmCache is a simple and powerful distributed caching mechanism. It uses IP multicast to effectively communicate between cached instances. It is ideal for quickly improving the performance of clustered Web applications. ShiftOne ShiftOne Object Cache This Java library provides basic Object caching capabilities. The policies implemented are first-in, first-out (FIFO), most recently used (LRU), and least frequently used (LFU). All strategies can maximize the size of an element and maximize its lifetime. WhirlyCache WhirlyCache is a fast, configurable cache of objects that exist in memory. It can speed up a web site or application by caching objects that would otherwise have to be built by querying databases or other expensive handlers. Jofti Can index and search objects in the cache layer (EHCache, JBossCache, and OSCache) or in storage structures that support Map interfaces. The framework also provides transparency for adding and deleting objects in the index as well as easy-to-use query capabilities for searching. Cache4j Cache4J is a Java object cache with a simple API and fast implementation. Its features include: in-memory caching, designed for multithreaded environments, two implementations: synchronization and blocking, a variety of cache clearing strategies: LFU, LRU, FIFO, can use strong reference and soft reference to store objects. Open Terracotta is a JVM-level Open source clustering framework that provides: HTTP Session replication, distributed caching, POJO clustering, and JVMS across clusters for distributed application coordination (code injection, so you don’t need to modify anything). Object caching system used by sccache SHOP.COM. Sccache is an in-process cache and a second-level, shared cache. It stores cached objects to disk. Supports association of keys, keys of any size, and data of any size. Automatic garbage collection. Shoal Shoal is a Java extensible dynamic clustering framework that provides infrastructure support for building fault-tolerant, reliable, and usable Java applications. The framework can also be integrated into any Java product that does not want to be tied to a specific communication protocol, but requires clustering and distributed system support. Shoal is the clustering engine for GlassFish and JonAS application servers. Simple-spring-memcached, which encapsulates calls to Memcached, makes Memcached client development incredibly Simple.