Java Caching Technology

Recently again on the Iteye on the discussion of the Java cache Technology Post more, I do not understand, so the internet probably searched the next, to find an article, temporarily save, if useful to refer to later. This is posted, posts to: Http://cogipard.info/articles/cache-static-files-with-jnotify-and-ehcache

Introduced
jnotify:http://jnotify.sourceforge.net/, through the JNI technology, so that Java code can monitor the development of files in the folder change information, support Linux/windows/macos;
ehcache:http://ehcache.org/, a widely used Java cache module, can do caching work using memory and file completion.
In Java Web projects, in order to improve the responsiveness of Web applications, it is possible to read the usual static files (including Css,js and various other images) into the memory cache in advance, which can reduce the IO operations of many file systems (which is often one of the bottleneck of project performance). However, this often has a disadvantage, that is, when the actual static file changes, the cache does not get a timely refresh, resulting in a certain lag phenomenon. Some projects may not be a problem, but for some projects, this problem must be addressed. There are basically two ways, one is to open a thread, constantly scan the file, and the cached file to make comparisons, determine the file time to modify, and the other is to use the system API to monitor the file changes. The disadvantage of the previous solution is obvious, time-consuming and laborious, the latter method needs to use JNI, and write some of the system's local library functions, fortunately, jnoify for us to prepare the work, directly to use it.

This article will simply give a small example of using jnotify and Ehcache to implement a static file cache.


The preparation of Jnotify
Before using jnotify, you need to "install" the jnotify. Jnotify uses JNI technology to invoke the local library of the system (the DLL file under win and the so file under Linux), which are nearly included in the download package. But if you use jnotify directly, you will often get an error:

1. BASH   
2. java.lang.unsatisfiedlinkerror: no jnotify in  java.library.path   
3.     at java.lang.classloader.loadlibrary ( Unknown source)   
4.     at java.lang.runtime.loadlibrary0 ( Unknown source)   
5.     at java.lang.system.loadlibrary (Unknown  source)   
6.     at net.contentobjects.jnotify.win32.jnotify_ Win32.<clinit> (Unknown source)   
7.     at  Net.contentobjects.jnotify.win32.jnotifyadapterwin32.<init> (Unknown source)   

BASHjava.lang.UnsatisfiedLinkError:no jnotify in Java.library.pathat java.lang.ClassLoader.loadLibrary (Unknown SOURCE) at Java.lang.Runtime.loadLibrary0 (Unknown source) at Java.lang.System.loadLibrary (Unknown source) at Net.contentobjects.jnotify.win32.jnotify_win32.<clinit> (Unknown Source) at Net.contentobjects.jnotify.win32.jnotifyadapterwin32.<init> (Unknown Source)

This is because jnotify cannot find the required DLL or other library files, the solution is to put the Jnotify compressed package library files into the folder Java.library.path points to, generally under Windows can be placed in the [JRE installation directory]/ Under Bin.

The value of Java.library.path can be viewed through System.getproperty ("Java.library.path"), but even if you pass System.setproperty in the program (" Java.library.path "," Some/folder/path/contain/dll ") To change the value of Java.library.path, or can not be loaded into the corresponding DLL library file, because the JVM only read the Java.library.path at the beginning of the program load, and then use the Java.library.path, it is the first load to get that value. Some people think it's just a bug and report it to Sun (http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4280189) but it seems like sun doesn't think it's a bug.
In addition to placing the DLL file in the [JRE installation directory]/bin, you can also manually specify the program's startup parameters:
Java-djava.library.path=some/folder/path/contain/dll method to achieve the goal.

Basic methods of Ehcache use
Ehcache is very easy to use, first we want to get an example of CacheManager. There are two methods of obtaining CacheManager, one is instance mode and one is singleton mode. Here we use the following one:

1. CacheManager manager = new CacheManager ("Src/ehcache.xml"); instance mode
2. Cachemanager.create (); //Singleton mode, default read Ehcache.xml under classpath as configuration file
3. Cache cache = Cachemanager.getinstance (). GetCache ("Staticresourcecache");
4. Staticresourcecache in the Ehcache.xml in advance to define the

CacheManager manager = new CacheManager ("Src/ehcache.xml"); instance mode cachemanager.create ();//Singleton mode, The default reads the Ehcache.xml under the Classpath as the configuration file cache cache = Cachemanager.getinstance (). GetCache ("Staticresourcecache");// Staticresourcecache in the Ehcache.xml in advance to define the

A simple example of ehcache.xml:

2. Ehcache.xml:
4. <?xml version="1.0" encoding="UTF-8"?>
6. <ehcache updatecheck="false" dynamicconfig="false" >
8. <diskstore path="Java.io.tmpdir"/>
10. <cache name="Staticresourcecache"
12. maxelementsinmemory="+"
14. timetoidleseconds="7200"
16. timetoliveseconds="7200" >
18. </cache>
20. </ehcache>

Ehcache.xml: <?xml version= "1.0" encoding= "UTF-8"? ><ehcache updatecheck= "false" dynamicconfig= "false" > <diskstore path= "Java.io.tmpdir"/>    <cache name= "Staticresourcecache" maxelementsinmemory= "1000" timetoidleseconds= "7200" timetoliveseconds= "7200" >    </cache></ehcache>

You can then use the cache instance to manipulate caching, the main way is

1. Cache.get (Object key), Cache.put (new Element (object key, Object value)), Cache.remove (object key).

Cache.get (Object key), Cache.put (new Element (object key, Object value)), Cache.remove (object key).

Caching static files
First you need to scan the folder containing the static files, in order to facilitate our adoption of the Jodd Toolkit:

1. import jodd.io.findfile.filepathscanner;   
2. ...   
3. filepathscanner fs = new  Filepathscanner () {  
4.      @Override    
5.     protected void  onfile (file file)  {  
6.          cachestatic (file); //cache file functions, implementation see &NBSP;&NBSP;
7.     }   
8. };   
9. fs.includedirs (true). Recursive (true). Includefiles (true)   
10. Fs.scan ( Configurations.themes_path); //scan the folder containing the static files   

Import Jodd.io.findfile.FilepathScanner, ..... Filepathscanner fs = new Filepathscanner () {@Overrideprotected void onfile (file file) {cachestatic (file);//functions that cache files, implementation See back}};fs.includedirs (True). Recursive (True). Includefiles (True); Fs.scan (Configurations.themes_path);// Scan folders that contain static files

In general, if the client browser accepts files in gzip format, gzip compression can make the transmitted data significantly less, so consider the gzip compression of some cached static files in advance. Caching the contents of the read static file into the cache, if the static file can be transferred with gzip, the file content needs to be compressed first.

2. Import Java.util.zip.GZIPOutputStream; //JDK Self-brought gzip compression tool
4. Import Jodd.io.FastByteArrayOutputStream; the//gzip output is a byte stream
6. Import Jodd.io.StreamUtil; //jodd's Tool class
10. Private static void cachestatic (file file) {
12. if (!isstaticresource (File.getabsolutepath ()))
14. return;
16. String uri = Touri (File.getabsolutepath ()); //Generate a file ID
18. FileInputStream in = null;
20. StringBuilder builder = new StringBuilder ();
22. try {
24. in = new FileInputStream (file);
26. BufferedReader br = new BufferedReader (
28. new InputStreamReader (in, stringpool.utf_8));
30. String StrLine;
32. While ((StrLine = Br.readline ()) = null) {
34. Builder.append (StrLine);
36. Builder.append ("\ n"); !important
38. }
42. Fastbytearrayoutputstream bao = new Fastbytearrayoutputstream ();
44. Gzipoutputstream go = new Gzipoutputstream (BAO);
46. Go.write (Builder.tostring (). GetBytes ());
48. Go.flush ();
50. Go.close ();
52. Cache.put (new Element (URI, Bao.tobytearray ())); Byte stream of cached files
54. } catch (FileNotFoundException e) {
56. E.printstacktrace ();
58. } catch (Unsupportedencodingexception e) {
60. E.printstacktrace ();
62. } catch (IOException e) {
64. E.printstacktrace ();
66. } finally {
68. Streamutil.close (in);
70. }
72. }

Import JAVA.UTIL.ZIP.GZIPOUTPUTSTREAM;//JDK Self-brought gzip compression tool import jodd.io.fastbytearrayoutputstream;// Gzip output is a byte stream import Jodd.io.streamutil;//jodd tool class private static void Cachestatic (file file) {if (!isstaticresource ( File.getabsolutepath ())) return; String uri = Touri (File.getabsolutepath ());//Generate a file identity fileinputstream in = null; StringBuilder builder = new StringBuilder (); try {in = new FileInputStream (file); BufferedReader br = new BufferedReader (new InputStreamReader (in, stringpool.utf_8)); String strline;while ((strLine = Br.readline ()) = null) {builder.append (strLine); Builder.append ("\ n");//!important} Fastbytearrayoutputstream bao = new Fastbytearrayoutputstream (); Gzipoutputstream go = new Gzipoutputstream (bao); Go.write (Builder.tostring (). GetBytes ()); Go.flush (); Go.close (); Cache.put (New Element (URI, Bao.tobytearray ()));//byte stream of cache file} catch (FileNotFoundException e) {e.printstacktrace ();} catch (Unsupportedencodingexception e) {e.printstacktrace ();} catch (IOException e) {e.printstacktrace ();} finAlly {Streamutil.close (in);}} 

Use Jnotify to change the contents of the cache when the file changes

2. Monitor the folder that Configurations.themes_path points to
4. Jnotify.addwatch (Configurations.themes_path,
6. jnotify.file_created |
8. jnotify.file_deleted |
10. jnotify.file_modified |
12. Jnotify.file_renamed,
14. true, new Jnotifylistener () {
18. @Override
20. public void filecreated (int wd,
22. String RootPath, string name) {
24. Cachestatic (new File (Rootpath+name)); Update Cache
26. }
30. @Override
32. public void filedeleted (int wd,
34. String RootPath, string name) {
36. Cache.remove (Touri (RootPath) +name); //Delete cache entries
38. }
42. @Override
44. public void filemodified (int wd,
46. String RootPath, string name) {
48. Cachestatic (new File (Rootpath+name));
50. }
54. @Override
56. public void filerenamed (int wd,
58. String RootPath, String oldname,
60. String newName) {
62. Cache.remove (Touri (RootPath) +oldname);
64. Cachestatic (new File (Rootpath+newname));
66. }
68. });

Monitor Configurations.themes_path pointing to the folder Jnotify.addwatch (Configurations.themes_path, jnotify.file_created  | jnotify.file_deleted  | jnotify.file_modified | Jnotify.file_renamed, True,  new Jnotifylistener () {@Overridepublic void filecreated (int wd,string rootpath, String Name) {cachestatic (rootpath+name));//update cache} @Overridepublic void filedeleted (int wd,string rootpath, String Name) {Cache.remove (Touri (RootPath) +name);//delete cache entry} @Overridepublic void filemodified (int wd,string rootpath, String Name) {cachestatic (rootpath+name)), @Overridepublic void filerenamed (int wd,string rootpath, String oldname, String newName) {cache.remove (Touri (RootPath) +oldname); Cachestatic (new File (Rootpath+newname));}});

Java Caching Technology