Go语言视频零基础入门到精通

javalearner

首先，来看看LRU的定义： Least recently used. 可以理解为， 最少使用的被淘汰。在网上发现了这个LRUCache 类及文章
《基于双链表实现缓存策略之LRU实现》，正好站内有一个搜索

《ACM AND java》http://www.java3z.com/cwbwebhome/acm.jsp

需要缓存，应用了一把，这样就不需要每次搜索POJID都查询数据库。先凑合着用了。

1. package com.db;
   
2. import java.util.Hashtable;
   
3. import java.sql.*;
   
4. public class LRUCache {   
   
5.     private int cacheSize;   
   
6.     private Hashtable nodes;//缓存容器   
   
7.     private int currentSize;   
   
8.     private CacheNode first;//链表头   
   
9.     private CacheNode last;//链表尾   
   
10.     private static LRUCache instance=new LRUCache(1000);
    
11.     /**  
    
12.      * 链表节点  
    
13.      * @author Administrator  
    
14.      *  
    
15.      */  
    
16.     class CacheNode {   
    
17.         CacheNode prev;//前一节点   
    
18.         CacheNode next;//后一节点   
    
19.         Object value;//值   
    
20.         Object key;//键   
    
21.         CacheNode() {   
    
22.         }   
    
23.     }   
    
24.   
    
25.     private LRUCache(int i) {   
    
26.         currentSize = 0;   
    
27.         cacheSize = i;   
    
28.         nodes = new Hashtable(i);//缓存容器   
    
29.          ResultSet Rst=null;
    
30.          DbTrans db=new DbTrans();
    
31.          try{
    
32.             Rst=db.executeQuery("select File_name,Article_type  from Article where type_id=17");
    
33.             String f_name=null;
    
34.             String a_type=null;
    
35.             while(Rst.next()){//将数据库中的记录全部取出，缓存。
    
36.                a_type=Rst.getString("Article_type");
    
37.                f_name=Rst.getString("File_name");
    
38.                put(a_type,f_name);
    
39.             }
    
40.               if(Rst!=null) Rst.close();
    
41.               if(db!=null) db.close();   
    
42.          }catch(SQLException e){
    
43.             System.out.println(e.toString());
    
44.          }
    
45.         
    
46.     }   
    
47.   public static LRUCache getInstance(){
    
48.        return instance;
    
49.    }
    
50.       
    
51.     /**  
    
52.      * 获取缓存中对象  
    
53.      * @param key  
    
54.      * @return  
    
55.      */  
    
56.     public Object get(Object key) {   
    
57.         CacheNode node = (CacheNode) nodes.get(key);   
    
58.         if (node != null) {   
    
59.             moveToHead(node);   
    
60.             return node.value;   
    
61.         } else {   
    
62.             return null;   
    
63.         }   
    
64.     }   
    
65.       
    
66.     /**  
    
67.      * 添加缓存  
    
68.      * @param key  
    
69.      * @param value  
    
70.      */  
    
71.     public void put(Object key, Object value) {   
    
72.         CacheNode node = (CacheNode) nodes.get(key);   
    
73.            
    
74.         if (node == null) {   
    
75.             //缓存容器是否已经超过大小.   
    
76.             if (currentSize >= cacheSize) {   
    
77.                 if (last != null)//将最少使用的删除   
    
78.                     nodes.remove(last.key);   
    
79.                 removeLast();   
    
80.             } else {   
    
81.                 currentSize++;   
    
82.             }   
    
83.                
    
84.             node = new CacheNode();   
    
85.         }   
    
86.         node.value = value;   
    
87.         node.key = key;   
    
88.         //将最新使用的节点放到链表头，表示最新使用的.   
    
89.         moveToHead(node);   
    
90.         nodes.put(key, node);   
    
91.     }   
    
92.   
    
93.     /**  
    
94.      * 将缓存删除  
    
95.      * @param key  
    
96.      * @return  
    
97.      */  
    
98.     public Object remove(Object key) {   
    
99.         CacheNode node = (CacheNode) nodes.get(key);   
    
100.         if (node != null) {   
     
101.             if (node.prev != null) {   
     
102.                 node.prev.next = node.next;   
     
103.             }   
     
104.             if (node.next != null) {   
     
105.                 node.next.prev = node.prev;   
     
106.             }   
     
107.             if (last == node)   
     
108.                 last = node.prev;   
     
109.             if (first == node)   
     
110.                 first = node.next;   
     
111.         }   
     
112.         return node;   
     
113.     }   
     
114.   
     
115.     public void clear() {   
     
116.         first = null;   
     
117.         last = null;   
     
118.     }   
     
119.   
     
120.     /**  
     
121.      * 删除链表尾部节点  
     
122.      *  表示 删除最少使用的缓存对象  
     
123.      */  
     
124.     private void removeLast() {   
     
125.         //链表尾不为空,则将链表尾指向null. 删除连表尾（删除最少使用的缓存对象）   
     
126.         if (last != null) {   
     
127.             if (last.prev != null)   
     
128.                 last.prev.next = null;   
     
129.             else  
     
130.                 first = null;   
     
131.             last = last.prev;   
     
132.         }   
     
133.     }   
     
134.       
     
135.     /**  
     
136.      * 移动到链表头，表示这个节点是最新使用过的  
     
137.      * @param node  
     
138.      */  
     
139.     private void moveToHead(CacheNode node) {   
     
140.         if (node == first)   
     
141.             return;   
     
142.         if (node.prev != null)   
     
143.             node.prev.next = node.next;   
     
144.         if (node.next != null)   
     
145.             node.next.prev = node.prev;   
     
146.         if (last == node)   
     
147.             last = node.prev;   
     
148.         if (first != null) {   
     
149.             node.next = first;   
     
150.             first.prev = node;   
     
151.         }   
     
152.         first = node;   
     
153.         node.prev = null;   
     
154.         if (last == null)   
     
155.             last = first;   
     
156.     }   
     
157.    
     
158. }  
     

复制代码

有些不满意之处，主要是缓存大小不好确定，暂定为1000, 以后题目多了，要重新编译源文件。（缓存大小最好写在一个配置
文件中）

最后看一下JSP文件：POJsearch.jsp，从提交页面获取POJID，从缓存中取数据。
<%@ page import="com.db.LRUCache" %>
<%@ page import="java.util.regex.Matcher" %>
<%@ page import="java.util.regex.Pattern" %>
<%@ page import="com.db.LRUCache" %> <%

1. String s=request.getParameter("s");
   
2.   String toPage="nothing.jsp";
   
3.    String pattern = "\d{1,5}";
   
4.   
   
5.    out.println(s);
   
6.   
   
7. if(s==null||s.length()==0) {
   
8.      toPage="nothing.jsp";
   
9.   }else {
   
10.     Pattern p = Pattern.compile(pattern);
    
11.     Matcher m = p.matcher(s);
    
12.     boolean b = m.matches();
    
13.     out.println(b);
    
14.      if(!b){
    
15.         toPage="nothing.jsp";
    
16.      }else{
    
17.       
    
18.       LRUCache cache=LRUCache.getInstance();
    
19.       String f_name=(String)cache.get(s);
    
20.       if(f_name!=null)
    
21. 
    
22.        toPage=f_name;
    
23.       else
    
24.       toPage="nothing.jsp";
    
25.       }
    
26.     }
    
27.    
    
28. response.sendRedirect(toPage);
    

复制代码

%>