JAVA缓存
? 1 Cache类
? 2 CacheManager类
JAVA缓存有两种:
一、文件缓存,是指把数据存储在磁盘上，可以XML格式，也可以序列化文件DAT格式还是
其它文件格式。
二、内存缓存，也就是实现一个类中静态Map,对这个Map进行常规的增删查。
public class Cache {
private String key;//缓存ID
private Object value;//缓存数据
private long timeOut;//更新时间
private boolean expired; //是否终止
public Cache() {
super();
}
public Cache(String key, Object value, long timeOut, boolean expired) {
this.key = key;
this.value = value;
this.timeOut = timeOut;
this.expired = expired;
}
public String getKey() {
return key;
}
public long getTimeOut() {
return timeOut;
}
public Object getValue() {
return value;
}
public void setKey(String string) {
key = string;
}
public void setTimeOut(long l) {
timeOut = l;
}
public void setValue(Object object) {
value = object;
}
public booleanisExpired() {
return expired;
}
public void setExpired(boolean b) {
expired = b;
}
}
//测试类，
class Test {
public static void main(String[] args) {
System.out.println(CacheManager.getSimpleFlag("alksd"));
// CacheManager.putCache("abc", new Cache());
// CacheManager.putCache("def", new Cache());
// CacheManager.putCache("ccc", new Cache());
// CacheManager.clearOnly("");
// Cache c = new Cache();
// for (int i = 0; i < 10; i++) {
// CacheManager.putCache("" + i, c);
// }
// CacheManager.putCache("aaaaaaaa", c);
// CacheManager.putCache("abchcy;alskd", c);
// CacheManager.putCache("cccccccc", c);
// CacheManager.putCache("abcoqiwhcy", c);
// System.out.println("删除前的大小："+CacheManager.getCacheSize()); // CacheManager.getCacheAllkey();
// CacheManager.clearAll("aaaa");
// System.out.println("删除后的大小："+CacheManager.getCacheSize()); // CacheManager.getCacheAllkey();
}
public class CacheManager {
private static HashMapcacheMap = new HashMap();
//单实例构造方法
private CacheManager() {
super();
}
//获取布尔值的缓存
public static booleangetSimpleFlag(String key){
try{
return (Boolean) cacheMap.get(key);
}catch(NullPointerException e){
return false;
}
}
public static long getServerStartdt(String key){
try {
return (Long)cacheMap.get(key);
} catch (Exception ex) {
return 0;
}
}
//设置布尔值的缓存
public synchronized static booleansetSimpleFlag(String key,boolean flag){
if (flag &&getSimpleFlag(key)) {//假如为真不允许被覆盖
return false;
}else{
cacheMap.put(key, flag);
return true;
}
}
public synchronized static booleansetSimpleFlag(String key,longserverbegrundt){ if (cacheMap.get(key) == null) {
cacheMap.put(key,serverbegrundt);
return true;
}else{
return false;
}
//得到缓存。同步静态方法
private synchronized static Cache getCache(String key) {
return (Cache) cacheMap.get(key);
}
//判断是否存在一个缓存
private synchronized static booleanhasCache(String key) {
return cacheMap.containsKey(key);
}
//清除所有缓存
public synchronized static void clearAll() {
cacheMap.clear();
}
//清除某一类特定缓存,通过遍历HASHMAP下的所有对象，来判断它的KEY与传入的TYPE 是否匹配
public synchronized static void clearAll(String type) {
Iterator i = cacheMap.entrySet().iterator();
String key;
ArrayListarr = new ArrayList();
try {
while (i.hasNext()) {
java.util.Map.Entry entry = (java.util.Map.Entry) i.next();
key = (String) entry.getKey();
if (key.startsWith(type)) { //如果匹配则删除掉
arr.add(key);
}
}
for (int k = 0; k clearOnly(arr.get(k)); } } catch (Exception ex) { ex.printStackTrace(); } } //清除指定的缓存 public synchronized static void clearOnly(String key) { cacheMap.remove(key); //载入缓存 public synchronized static void putCache(String key, Cache obj) { cacheMap.put(key, obj); } //获取缓存信息 public static Cache getCacheInfo(String key) { if (hasCache(key)) { Cache cache = getCache(key); if (cacheExpired(cache)) { //调用判断是否终止方法 cache.setExpired(true); } return cache; }else return null; } //载入缓存信息 public static void putCacheInfo(String key, Cache obj, long dt,boolean expired) { Cache cache = new Cache(); cache.setKey(key); cache.setTimeOut(dt + System.currentTimeMillis()); //设置多久后更新缓存 cache.setValue(obj); cache.setExpired(expired); //缓存默认载入时，终止状态为FALSE cacheMap.put(key, cache); } //重写载入缓存信息方法 public static void putCacheInfo(String key,Cacheobj,longdt){ Cache cache = new Cache(); cache.setKey(key); cache.setTimeOut(dt+System.currentTimeMillis()); cache.setValue(obj); cache.setExpired(false); cacheMap.put(key,cache); } //判断缓存是否终止 public static booleancacheExpired(Cache cache) { if (null == cache) { //传入的缓存不存在 return false; } long nowDt = System.currentTimeMillis(); //系统当前的毫秒数 long cacheDt = cache.getTimeOut(); //缓存内的过期毫秒数 if (cacheDt<= 0||cacheDt>nowDt) { //过期时间小于等于零时,或者过期时间大于当前时间时，则为FALSE return false; } else { //大于过期时间即过期 return true; } } //获取缓存中的大小 public static intgetCacheSize() { return cacheMap.size(); } //获取指定的类型的大小 public static intgetCacheSize(String type) { int k = 0; Iterator i = cacheMap.entrySet().iterator(); String key; try { while (i.hasNext()) { java.util.Map.Entry entry = (java.util.Map.Entry) i.next(); key = (String) entry.getKey(); if (key.indexOf(type) != -1) { //如果匹配则删除掉 k++; } } } catch (Exception ex) { ex.printStackTrace(); } return k; } //获取缓存对象中的所有键值名称 public static ArrayListgetCacheAllkey() { ArrayList a = new ArrayList(); try { Iterator i = cacheMap.entrySet().iterator(); while (i.hasNext()) { java.util.Map.Entry entry = (java.util.Map.Entry) i.next(); a.add((String) entry.getKey()); } } catch (Exception ex) {} finally { return a; } } //获取缓存对象中指定类型的键值名称 public static ArrayListgetCacheListkey(String type) { ArrayList a = new ArrayList(); String key; try { Iterator i = cacheMap.entrySet().iterator(); while (i.hasNext()) { java.util.Map.Entry entry = (java.util.Map.Entry) i.next(); key = (String) entry.getKey(); if (key.indexOf(type) != -1) { a.add(key); } } } catch (Exception ex) {} finally { return a; } } } 2007-09-29 简单LRU算法实现缓存 最简单的LRU算法实现，就是利用jdk的LinkedHashMap，覆写其中的removeEldestEntry(Map.Entry)方法即可，如下所示： java 代码 1.import java.util.ArrayList; 2.import java.util.Collection; 3.import java.util.LinkedHashMap; 4.import java.util.concurrent.locks.Lock; 5.import java.util.concurrent.locks.ReentrantLock; 6.import java.util.Map; 7. 8. 9./** 10. * 类说明：利用LinkedHashMap实现简单的缓存，必须实现removeEldestEntry方法， 具体参见JDK文档 11. * 12. * @author dennis 13. * 14. * @param 15. * @param 16. */ 17.public class LRULinkedHashMap 18. private final int maxCapacity; 19. 20. private static final float DEFAULT_LOAD_FACTOR = 0.75f; 21. 22. private final Lock lock = new ReentrantLock(); 23. 24. public LRULinkedHashMap(int maxCapacity) { 25. super(maxCapacity, DEFAULT_LOAD_FACTOR, true); 26. this.maxCapacity = maxCapacity; 27. } 28. 29. @Override 30. protected boolean removeEldestEntry(java.util.Map.Entry 31. return size() > maxCapacity; 32. } 33. @Override 34. public boolean containsKey(Object key) { 35. try { 36. lock.lock(); 37. return super.containsKey(key); 38. } finally { 39. lock.unlock(); 40. } 41. } 42. 43. 44. @Override 45. public V get(Object key) { 46. try { 47. lock.lock(); 48. return super.get(key); 49. } finally { 50. lock.unlock(); 51. } 52. } 53. 54. @Override 55. public V put(K key, V value) { 56. try { 57. lock.lock(); 58. return super.put(key, value); 59. } finally { 60. lock.unlock(); 61. } 62. } 63. 64. public int size() { 65. try { 66. lock.lock(); 67. return super.size(); 68. } finally { 69. lock.unlock(); 70. } 71. } 72. 73. public void clear() { 74. try { 75. lock.lock(); 76. super.clear(); 77. } finally { 78. lock.unlock(); 79. } 80. } 81. 82. public Collection 83. try { 84. lock.lock(); 85. return new ArrayList 86. } finally { 87. lock.unlock(); 88. } 89. } 90.} 91. 如果你去看LinkedHashMap的源码可知，LRU算法是通过双向链表来实现，当某个位置被命中，通过调整链表的指向将该位置调整到头位置，新加入的内容直接放在链表头，如此一来，最近被命中的内容就向链表头移动，需要替换时，链表最后的位置就是最近最少使用的位置。 LRU算法还可以通过计数来实现，缓存存储的位置附带一个计数器，当命中时将计数器加1，替换时就查找计数最小的位置并替换，结合访问时间戳来实现。这种算法比较适合缓存数据量较小的场景，显然，遍历查找计数最小位置的时间复杂度为O(n)。我实现了一个，结合了访问时间戳，当最小计数大于MINI_ACESS时，就移除最久没有被访问的项： java 代码 1.import java.io.Serializable; 2.import java.util.ArrayList; 3.import java.util.Collection; 4.import java.util.HashMap; 5.import java.util.Iterator; 6.import java.util.Map; 7.import java.util.Set; 8.import java.util.concurrent.atomic.AtomicInteger; 9.import java.util.concurrent.atomic.AtomicLong; 10.import java.util.concurrent.locks.Lock; 11.import java.util.concurrent.locks.ReentrantLock; 12. 13./** 14. * 15. * @author dennis 16. * 类说明：当缓存数目不多时，才用缓存计数的传统LRU算法 17. * @param 18. * @param 19. */ 20.public class LRUCache 21. 22. private static final int DEFAULT_CAPACITY = 100; 23. 24. protected Map 25. 26. private final Lock lock = new ReentrantLock(); 27. 28. private final transient int maxCapacity; 29. 30. private static int MINI_ACCESS = 10; 31. 32. public LRUCache() { 33. this(DEFAULT_CAPACITY); 34. } 35. 36. public LRUCache(int capacity) { 37. if (capacity <= 0) 38. throw new RuntimeException("缓存容量不得小于0"); 39. this.maxCapacity = capacity; 40. this.map = new HashMap 41. } 42. 43. public boolean ContainsKey(K key) { 44. try { 45. lock.lock(); 46. return this.map.containsKey(key); 47. } finally { 48. lock.unlock(); 49. } 50. } 51. 52. public V put(K key, V value) { 53. try { 54. lock.lock(); 55. if ((map.size() > maxCapacity - 1) && !map.containsKey(key)) { 56. // System.out.println("开始"); 57. Set 58. removeRencentlyLeastAccess(entries); 59. } 60. ValueEntry valueEntry = map.put(key, new ValueEntry(value)); 61. if (valueEntry != null) 62. return valueEntry.value; 63. else 64. return null; 65. } finally { 66. lock.unlock(); 67. } 68. } 69. 70. /** 71. * 移除最近最少访问 72. */ 73. protected void removeRencentlyLeastAccess( 74. Set 75. // 最小使用次数 76. int least = 0; 77. // 最久没有被访问 78. long earliest = 0; 79. K toBeRemovedByCount = null; 80. K toBeRemovedByTime = null; 81. Iterator 82. if (it.hasNext()) { 83. Map.Entry 84. least = valueEntry.getValue().count.get(); 85. toBeRemovedByCount = valueEntry.getKey(); 86. earliest = valueEntry.getValue().lastAccess.get(); 87. toBeRemovedByTime = valueEntry.getKey(); 88. } 89. while (it.hasNext()) { 90. Map.Entry 91. if (valueEntry.getValue().count.get() < least) { 92. least = valueEntry.getValue().count.get(); 93. toBeRemovedByCount = valueEntry.getKey(); 94. } 95. if (valueEntry.getValue().lastAccess.get() < earliest) { 96. earliest = valueEntry.getValue().count.get(); 97. toBeRemovedByTime = valueEntry.getKey(); 98. } 99. } 100. // System.out.println("remove:" + toBeRemoved); 101. // 如果最少使用次数大于MINI_ACCESS，那么移除访问时间最早的项(也就是最久没有被访问的项） 102. if (least > MINI_ACCESS) { 103. map.remove(toBeRemovedByTime); 104. } else { 105. map.remove(toBeRemovedByCount); 106. } 107. } 108. 109. public V get(K key) { 110. try { 111. lock.lock(); 112. V value = null; 113. ValueEntry valueEntry = map.get(key); 114. if (valueEntry != null) { 115. // 更新访问时间戳 116. valueEntry.updateLastAccess(); 117. // 更新访问次数 118. valueEntry.count.incrementAndGet(); 119. value = valueEntry.value; 120. } 121. return value; 122. } finally { 123. lock.unlock(); 124. } 125. } 126. 127. public void clear() { 128. try { 129. lock.lock(); 130. map.clear(); 131. } finally { 132. lock.unlock(); 133. } 134. } 135. 136. public int size() { 137. try { 138. lock.lock(); 139. return map.size(); 140. } finally { 141. lock.unlock(); 142. } 143. } 144. 145. public Collection 146. try { 147. lock.lock(); 148. Set 149. Map 150. for (K key : keys) { 151. tmp.put(key, map.get(key).value); 152. } 153. return new ArrayList 155. lock.unlock(); 156. } 157. } 158. 159. class ValueEntry implements Serializable { 160. private V value; 161. 162. private AtomicInteger count; 163. 164. private AtomicLong lastAccess; 165. 166. public ValueEntry(V value) { 167. this.value = value; 168. this.count = new AtomicInteger(0); 169. lastAccess = new AtomicLong(System.nanoTime()); 170. } 171. 172. public void updateLastAccess() { 173. https://www.doczj.com/doc/bc159125.html,stAccess.set(System.nanoTime()); 174. } 175. 176. } 177.} 2008-04-07 LRU Cache 看了下RU(Least Recently Used ,最近最少使用)，可以使用LinkedHashMap实现，到是蛮简单的.LinkedHashMap会将get或是put的数据置于底端. 重写removeEldestEntry()可以设定根据size来调整cache的数量. Java代码 1.import java.util.Collection; 2.import java.util.LinkedHashMap; 3.import java.util.Map; 4. 5./** 6. * This class uses the LinkedHashMap to build LRU cache. 7. * User can define the cache size. 8. */ 9.public class LRUCache 10.{ 11. int cacheSize = 0; 12. float loadFactor = 0.75f; //default 13. LinkedHashMap map; 14. 15. public LRUCache(int cacheSize) 16. { 17. this.cacheSize = cacheSize; 18. map = new LinkedHashMap(cacheSize, loadFactor, true) 19. { 20. protected boolean removeEldestEntry(Map.Entry eldest) 21. { 22. return size() > LRUCache.this.cacheSize; 23. //return false; 24. } 25. }; 26. } 27. 28. public synchronized void clear() 29. { 30. map.clear(); 31. } 32. 33. public synchronized Object get(Object key) 34. { 35. return map.get(key); 36. } 37. 38. public synchronized void put(Object key, Object value) 39. { 40. map.put( 41. key, 42. value); 43. } 44. 45. public synchronized Object remove(Object key) 46. { 47. return map.remove(key); 48. } 49. 50. public synchronized int size() 51. { 52. return map.size(); 53. } 54. 55. public synchronized Collection values() 56. { 57. return map.values(); 58. } 59. 60. public static void main(String []args) 61. { 62. // testing 63. int size = 3; 64. LRUCache cache = new LRUCache(size); 65. cache.put(new Integer("1"), "1"); 66. cache.put(new Integer("2"), "2"); 67. cache.put(new Integer("3"), "3"); 68. 69. String value = (String)cache.get(new Integer(1)); 70. System.out.println(value); 71. System.out.println("Testing ..."); 72. 73. Object[] values = cache.values().toArray(); 74. for (int i = 0; i < values.length; i++) 75. { 76. value = (String)values[i]; 77. System.out.println(value); 78. } 79. } 80.} LRU缓存应用一例 首先，来看看LRU的定义：Least recently used. 可以理解为，最少使用的被淘汰。在网上发现了这个LRUCache 类及文章 《基于双链表实现缓存策略之LRU实现》，正好站内有一个搜索 《ACM AND JAVA》https://www.doczj.com/doc/bc159125.html,/cwbwebhome/acm.jsp 需要缓存，应用了一把，这样就不需要每次搜索POJID都查询数据库。先凑合着用了。 package com.db; import java.util.Hashtable; importjava.sql.*; public class LRUCache { private intcacheSize; private Hashtable nodes;//缓存容器 private intcurrentSize; private CacheNode first;//链表头 private CacheNode last;//链表尾 private static LRUCache instance=new LRUCache(1000); /** * 链表节点 * @author Administrator * */ class CacheNode { CacheNodeprev;//前一节点 CacheNode next;//后一节点 Object value;//值 Object key;//键 CacheNode() { } } private LRUCache(int i) { currentSize = 0; cacheSize = i; nodes = new Hashtable(i);//缓存容器 ResultSetRst=null; DbTransdb=new DbTrans(); try{ Rst=db.executeQuery("select File_name,Article_type from Article where type_id=17"); String f_name=null; String a_type=null; while(Rst.next()){//将数据库中的记录全部取出，缓存。 a_type=Rst.getString("Article_type"); f_name=Rst.getString("File_name"); put(a_type,f_name); } if(Rst!=null) Rst.close(); if(db!=null) db.close(); }catch(SQLException e){ System.out.println(e.toString()); } } public static LRUCachegetInstance(){ return instance; } /** * 获取缓存中对象 * @param key * @return */ public Object get(Object key) { CacheNode node = (CacheNode) nodes.get(key); if (node != null) { moveToHead(node); return node.value; } else { return null; } } /** * 添加缓存 * @param key * @param value */ public void put(Object key, Object value) { CacheNode node = (CacheNode) nodes.get(key); if (node == null) { //缓存容器是否已经超过大小. if (currentSize>= cacheSize) { if (last != null)//将最少使用的删除nodes.remove(last.key); removeLast(); } else { currentSize++; } node = new CacheNode(); } node.value = value; node.key = key; //将最新使用的节点放到链表头，表示最新使用的. moveToHead(node); nodes.put(key, node); } /** * 将缓存删除 * @param key * @return */ public Object remove(Object key) { CacheNode node = (CacheNode) nodes.get(key); if (node != null) { if (node.prev != null) { node.prev.next = node.next; } if (node.next != null) { node.next.prev = node.prev; } if (last == node) last = node.prev; if (first == node) first = node.next; } return node; } public void clear() { first = null; last = null; } /** * 删除链表尾部节点 * 表示删除最少使用的缓存对象 */ private void removeLast() { //链表尾不为空,则将链表尾指向null. 删除连表尾（删除最少使用的缓存对象） if (last != null) { if (last.prev != null) last.prev.next = null; else first = null; last = last.prev; } } /** * 移动到链表头，表示这个节点是最新使用过的 * @param node */ private void moveToHead(CacheNode node) { if (node == first) return; if (node.prev != null) node.prev.next = node.next; if (node.next != null) node.next.prev = node.prev; if (last == node) last = node.prev; if (first != null) { node.next = first; first.prev = node; } first = node; node.prev = null; if (last == null) last = first; } } 有些不满意之处，主要是缓存大小不好确定，暂定为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" %> <% String s=request.getParameter("s"); String toPage="nothing.jsp"; String pattern = "\\d{1,5}"; out.println(s); if(s==null||s.length()==0) { toPage="nothing.jsp"; }else { Pattern p = https://www.doczj.com/doc/bc159125.html,pile(pattern); Matcher m = p.matcher(s); boolean b = m.matches(); out.println(b); if(!b){ toPage="nothing.jsp"; 求职意向：java软件工程师 工作经验：2年 到岗时间：一周之内 期望薪资：面议 个人信息 年龄：25岁邮箱： 手机: 现居地：北京通州 专业技能 ?熟悉掌握JavaScript，Ajax，jQuery，JSON等前台技术并能够熟练使用EasyUI，zTree，ECharts等插件 ?熟悉掌握Servlet，Cookie，Session，JDBC，JavaBean，EL表达式，JSTL 等技术，深入了解MVC开发模式 ?熟悉使用Struts2框架，包括拦截器，OGNL表达式，Ajax并熟悉Struts2的工作流程 ?熟悉使用Spring框架，包括IOC和DI，AOP编程，声明式事务处理以及代理模式 ?熟悉使用Hibernate框架，包括一对多，多对多的对象关系映射，HQL，对象状态转换，数据缓存等 ?熟练运用SpringMVC，Mybatis 进行项目开发，掌握shiro 安全框架 ?熟悉使用MySQL和oracle数据库，使用其编写复杂的SQL语句，具有Mysql数据库的优化经验；掌握redis数据缓存技术 ?熟悉使用MyEclipse、HBilder，PLSQLDevelopment等开发工具，熟悉使用maven 项目管理工具，以及SVN 服务器的使用 ?熟悉Tomcat服务器的应用部署和集群配置 工作经历 毗邻智慧软件开发科技有限公司 担任职位：java软件开发师 ●初期主要实现项目的维护和个性化需求的搜集整理 ●完成项目模块的编码和测试工作 项目经验 项目名称：泉翼达商城 框架构建：Spring + SpringMVC + Mybatis + Mysql + zTree +PageHelper+ + EasyUI +CKeditor+Nginx+Redis 项目描述：此系统主要实现的功能是用户网上预订果蔬功能，包括交易系统和后台管理系统、会员系统、积分系统、支付系统、物流系统、单点登录系统 功能模块：商品信息展示、购物车管理、订单管理、用户管理、商品管理、积分管理、支付管理等功能模块 项目职责： ?负责了此系统的商品信息模块和商品管理模块的用户需求分析，完成了文档的设计与编写 ?前台交易系统负责了商品信息模块和购物车管理模块的代码编写，实现了商品基本信息（如商品预览、商品明细、分类检索）的功能，以及购物车管理模块（实现添 加商品、删除列表、数量修改、清空购物车、结算功能） ?后台管理系统负责商品管理（实现商品列表、商品发布、商品删除、商品修改功能）和用户管理模块（实现登入/登出、用户注册、信息修改功能） 多层技术架构 本系统构建于J2EE平台，采用分层提供服务支持的设计思想，将系统划分为数据库层、中间件层、EMALL基础服务层、业务表现层和系统接口层。系统对每一层定义明确的功能接口，同时在层次内实现组件化的接口实现。层次化、模块组件化的实现，使系统具备了最大程度的灵活度，从而能对业务需求的变化作出快速的反应，使系统具有很好的扩展性。 首先我们来看一个系统技术架构图： 上图可以清晰的了解到整个系统的层次划分，系统从最底部的数据库层开始，一层一层的向上提供接口服务，最终实现用户按业务要求的可见操作界面和其他系统接口。各层次专著于自身功能的接口实现，整个层次保持相对的稳定。系统通过不改变接口，各个层次、各个组件进行优化的策略，能在不影响整个业务的前提下，不断的完善和改进。 一、数据库层 对于平台中的所有应用，都存在着各种各样的配置信息、业务数据、系统运行状态等信息。数据库层对这些数据信息本身进行归档，提供快速查询的底层接口，并保证数据的完整性、可靠性。 在数据库方面，我们采用Oracle或者是MySQL。这两种数据库分别有不同的适用环境。 1、Oracle ◆适合大型的电子商务应用。 ◆能使用所有的网客通平台功能。如访问量排行榜、降价排行榜、销售排行榜、访问量统计等等，就以往的经验来看，这些功能每天要处理的数据都会超过一千万。这种数据量如果使用传统的统计方法，统计一次的时间就可能会以天来计算了。如果使用Oracle，再配合我们专门对Oracle进行优化的高效率的统计程序，那么只需十数秒便可完成。 ◆此外，如果只用一台数据库无法应付日益增长的服务器访问量，可以使用Oracle RAC（真正应用集群），通过增加数据库服务器进行集群。 2、MySQL ◆适合中小型的电子商务应用。 ◆无法使用网客通平台一些高级应用，如排行榜、统计分析、MIS系统对接等。这是由于MySQL设计上强调访问速度，牺牲了一些数据库的高级功能，虽然用程序也可以实现这些功能，但是在性能上无法满足需求。 ◆不支持数据库集群。 爱奇艺的Java缓存之路，你应该知道的缓存进化史！ 本文是上周去技术沙龙听了一下爱奇艺的Java缓存之路有感写出来的。先简单介绍一下爱奇艺的java缓存道路的发展吧。 可以看见图中分为几个阶段: 第一阶段:数据同步加redis 通过消息队列进行数据同步至redis，然后Java应用直接去取缓存这个阶段优点是:由于是使用的分布式缓存，所以数据更新快。缺点也比较明显:依赖Redis的稳定性，一旦redis 挂了，整个缓存系统不可用，造成缓存雪崩，所有请求打到DB。 第二、三阶段:JavaMap到Guava cache 这个阶段使用进程内缓存作为一级缓存，redis作为二级。优点:不受外部系统影响，其他系统挂了，依然能使用。缺点:进程内缓存无法像分布式缓存那样做到实时更新。由于java内存有限，必定缓存得设置大小，然后有些缓存会被淘汰，就会有命中率的问题。 第四阶段: Guava Cache刷新 为了解决上面的问题，利用Guava Cache可以设置写后刷新时间，进行刷新。解决了一直不更新的问题，但是依然没有解决实时刷新。 第五阶段: 外部缓存异步刷新 这个阶段扩展了Guava Cache,利用redis作为消息队列通知机制，通知其他java应用程序进行刷新。 这里简单介绍一下爱奇艺缓存发展的五个阶段，当然还有一些其他的优化，比如GC调优，缓存穿透，缓存覆盖的一些优化等等。有兴趣的同学可以关注公众号，联系我进行交流。上面说的是爱奇艺的一个进化线路，但是在大家的一般开发过程中，第一步一般都没有redis，而是直接查库。 在流量不大的时候，查数据库或者读取文件是最为方便，也能完全满足我们的业务要求。当我们应用有一定流量之后或者查询数据库特别频繁，这个时候就可以祭出我们的java中自带的HashMap或者ConcurrentHashMap。我们可以在代码中这么写: 但是这样做就有个问题HashMap无法进行数据淘汰，内存会无限制的增长，所以hashMap 很快也被淘汰了。当然并不是说他完全就没用，就像我们古代社会也不是所有的东西都是过时的，比如我们中华名族的传统美德是永不过时的，就像这个hashMap一样的可以在某些 Ehcache是现在最流行的纯Java开源缓存框架 2014-12-22 13:28 37723人阅读评论(0) 收藏举报分类： java（405） c:\t _blank Ehcache是现在最流行的纯Java开源缓存框架，配置简单、结构清晰、功能强大，最初知道它，是从hibernate的缓存开始的。网上中文的EhCache材料以简单介绍和配置方法居多，如果你有这方面的问题，请自行google；对于API，官网上介绍已经非常清楚，请参见官网；但是很少见到特性说明和对实现原理的分析，因此在这篇文章里面，我会详细介绍和分析EhCache的特性，加上一些自己的理解和思考，希望对缓存感兴趣的朋友有所收获。 一、特性一览，来自官网，简单翻译一下： 1、快速轻量 过去几年，诸多测试表明Ehcache是最快的Java缓存之一。 Ehcache的线程机制是为大型高并发系统设计的。 大量性能测试用例保证Ehcache在不同版本间性能表现得一致性。 很多用户都不知道他们正在用Ehcache，因为不需要什么特别的配置。 API易于使用，这就很容易部署上线和运行。 很小的jar包，Ehcache 2.2.3才668kb。 最小的依赖：唯一的依赖就是SLF4J了。 2、伸缩性 缓存在内存和磁盘存储可以伸缩到数G，Ehcache为大数据存储做过优化。 大内存的情况下，所有进程可以支持数百G的吞吐。 为高并发和大型多CPU服务器做优化。 线程安全和性能总是一对矛盾，Ehcache的线程机制设计采用了Doug Lea的想法来获得较高的性能。 单台虚拟机上支持多缓存管理器。 通过Terracotta服务器矩阵，可以伸缩到数百个节点。 3、灵活性 Ehcache 1.2具备对象API接口和可序列化API接口。 不能序列化的对象可以使用除磁盘存储外Ehcache的所有功能。 除了元素的返回方法以外，API都是统一的。只有这两个方法不一致：getObjectValue和getKeyValue。这就使得缓存对象、序列化对象来获取新的特性这个过程很简单。 支持基于Cache和基于Element的过期策略，每个Cache的存活时间都是可以设置和控制的。 提供了LRU、LFU和FIFO缓存淘汰算法，Ehcache 1.2引入了最少使用和先进先出缓存淘汰算法，构成了完整的缓存淘汰算法。 提供内存和磁盘存储，Ehcache和大多数缓存解决方案一样，提供高性能的内存和磁盘存储。 动态、运行时缓存配置，存活时间、空闲时间、内存和磁盘存放缓存的最大数目都是可以在运行时修改的。 4、标准支持 Ehcache提供了对JSR107 JCACHE API最完整的实现。因为JCACHE在发布以前，Ehcache的实现（如net.sf.jsr107cache）已经发布了。 实现JCACHE API有利于到未来其他缓存解决方案的可移植性。 Ehcache的维护者Greg Luck，正是JSR107的专家委员会委员。 5、可扩展性 监听器可以插件化。Ehcache 1.2提供了CacheManagerEventListener和CacheEventListener接口，实现可以插件化，并且可以在ehcache.xml里配置。 节点发现，冗余器和监听器都可以插件化。 分布式缓存，从Ehcache 1.2开始引入，包含了一些权衡的选项。Ehcache的团队相信没有什么是万能的配置。 实现者可以使用内建的机制或者完全自己实现，因为有完整的插件开发指南。 缓存的可扩展性可以插件化。创建你自己的缓存扩展，它可以持有一个缓存的引用，并且绑定在缓存的生命周期内。 缓存加载器可以插件化。创建你自己的缓存加载器，可以使用一些异步方法来加载数据到缓存里面。 缓存异常处理器可以插件化。创建一个异常处理器，在异常发生的时候，可以执行某些特定操作。 缓存管理功能需求说明 缓存管理开发背景 缓存管理功能的开发，意在减少系统对数据库的过多访问，通过减少对数据库的访问次数，改用访问内存的方式，提升系统的性能。直接从内存获取数据，较之从数据库获取数据，效率可以得到显著的提升。 系统由于多次查询数据库，消耗大量系统资源，且查询效率可能因为开发者的个人能力导致查询效率不高，或占用过多资源影响系统性能。使用缓存管理，系统只有第一次查询访问数据库，而后皆通过访问内存取得数据，不需要在计较这次查询的SQL是否过于复杂，是否效率低下，直接取得数据返回即可。 第一部分、缓存管理 缓存管理提供了缓存工具类CacheUtils以供开发者对缓存进行自定义开发。如果开发者需要自己开发某功能需要涉及缓存管理则可以借助使用CacheUtils工具类来完成。本地缓存管理和redis 缓存管理的区分在于redis是否正确连接且启动。注意，是正确连接并且启动redis服务器。 关于开发者需要自行开发某功能的缓存管理需要了解CacheUtils怎么使用可以查看《缓存管理开发说明》 本地缓存管理 本地缓存管理是在redis没有正常启动运行的时候系统提供的缓存管理方式。本地缓存管理暂无任何持久化操作。对于缓存中的所有数据，在应用重启后一律清空，需要重新载入缓存。本地缓存 管理采用的是标准的key-value形式保存，于Java中采用的结构形式为HashMap结构，HashMap 有利于快速的存取，因而采用该结构保存本地缓存。其中key的类型为string，value的类型为object。本地缓存管理对于类型的限制基本没有。Value可以置入任何Java支持的对象。 本地缓存管理中，保存进入缓存只需要使用CacheUtils中的save方法进行保存即可，保存的数据在本地缓存中不做多余的处理，直接置入缓存中。由于采用的是以Object类型的形式保存，并不会对保存的数据进行转换，获取保存的缓存数据时直接使用CacheUtils中的get方法即可取得保存的数据，达到怎么存就怎么取，存什么取什么。无需更多的变换数据结构，更不会导致因为存储导致类型的变换或者数据的丢失。 由于存什么取得的就是什么，因而直接修改取得的数据对象有可能导致缓存数据也被修改。Redis缓存管理 Redis缓存管理需要开启redis服务器并正确配置连接信息，系统会在启动的时候检测redis是否可以正常连接启用，如果没有正常连接启用则使用本地缓存管理。 Redis缓存管理对于类型具有特别的要求，对于不同的数据类型需要使用对应的类型进行保存。且不允许使用复杂的对象类型进行保存，如list-object是不被允许的，需要转换为list-string的类型再进行保存，同理Map类型也不被允许使用Object，但是单个JavaBean是允许进行存取的。即redis 缓存管理不支持三维结构存储，仅支持二维结构存储。 Redis缓存管理的数据会有简易的持久化。即当redis停止后或者系统停止后，再次启动时redis 依然存有数据提供，不需要再次载入缓存。如果缓存设置了失效则可能会被清除。 Redis缓存管理保存、修改 由于redis数据类型的特殊性，所以所有Java中复杂的对象存储都需要进行相应的转换后才可 Java编程提高性能时需注意的地方 最近的机器内存又爆满了，出了新增机器内存外，还应该好好review一下我们的代码，有很多代码编写过于随意化，这些不好的习惯或对程序语言的不了解是应该好好打压打压了。 下面是参考网络资源和总结一些在java编程中尽可能做到的一些地方 1.尽量在合适的场合使用单例 使用单例可以减轻加载的负担，缩短加载的时间，提高加载的效率，但并不是所有地方都适用于单例，简单来说，单例主要适用于以下三个方面 第一，控制资源的使用，通过线程同步来控制资源的并发访问 第二，控制实例的产生，以达到节约资源的目的 第三，控制数据共享，在不建立直接关联的条件下，让多个不相关的进程或线程之间实现通信 2.尽量避免随意使用静态变量 要知道，当某个对象被定义为stataic变量所引用，那么gc通常是不会回收这个对象所占有的内存，如 1 2 3 public class A{ static B b = new B(); } 此时静态变量b的生命周期与A类同步，如果A类不会卸载，那么b对象会常驻内存， 直到程序终止。 3.尽量避免过多过常的创建java对象 尽量避免在经常调用的方法，循环中new对象，由于系统不仅要花费时间来创建对象，而且还要花时间对这些对象进行垃圾回收和处理，在我们可以控制的范围内，最大限度的重用对象，最好能用基本的数据类型或数组来替代对象。 4.尽量使用final修饰符 带有final修饰符的类是不可派生的。在Java核心API中，有许多应用final的例子，例如https://www.doczj.com/doc/bc159125.html,ng.String。为String类指定final防止了使用者覆盖length()方法。另外，如果一个类是final的，则该类所有方法都是final的。java编译器会寻找机会内联(inline)所有的final方法(这和具体的编译器实现有关)。此举能够使性能平均提高50%。 5.尽量使用局部变量 调用方法时传递的参数以及在调用中创建的临时变量都保存在栈(Stack)中，速度较快。其他变量，如静态变量，实例变量等，都在堆(Heap)中创建，速度较慢。 6.尽量处理好包装类型和基本类型两者的使用场所 虽然包装类型和基本类型在使用过程中是可以相互转换，但它们两者所产生的内存区域是完全不同的，基本类型数据产生和处理都在栈中处理，包装类型是对象，是在堆中产生实例。 在集合类对象，有对象方面需要的处理适用包装类型，其他的处理提倡使用基本类型。 8种流行的java缓存框架介绍 OSCache OSCache是个一个广泛采用的高性能的J2EE缓存框架，OSCache能用于任何Java应用程序的普通的缓存解决方案。OSCache有以下特点：缓存任何对象，你可以不受限制的缓存部分jsp页面或HTTP请求，任何java对象都可以缓存。拥有全面的API--OSCache API给你全面的程序来控制所有的OSCache特性。永久缓存--缓存能随意的写入硬盘，因此允许昂贵的创建(expensive-to-create)数据来保持缓存，甚至能让应用重启。支持集群--集群缓存数据能被单个的进行参数配置，不需要修改代码。缓存记录的过期--你可以有最大限度的控制缓存对象的过期，包括可插入式的刷新策略(如果默认性能不需要时)。 Java Caching system JSC(Java Caching system)是一个用分布式的缓存系统，是基于服务器的java应用程序。它是通过提供管理各种动态缓存数据来加速动态web应用。JCS和其他缓存系统一样，也是一个用于高速读取，低速写入的应用程序。动态内容和报表系统能够获得更好的性能。如果一个网站，有重复的网站结构，使用间歇性更新方式的数据库(而不是连续不断的更新数据库)，被重复搜索出相同结果的，就能够通过执行缓存方式改进其性能和伸缩性。 EHCache EHCache 是一个纯java的在进程中的缓存，它具有以下特性：快速，简单，为Hibernate2.1充当可插入的缓存，最小的依赖性，全面的文档和测试。 JCache JCache是个开源程序，正在努力成为JSR-107开源规范，JSR-107规范已经很多年没改变了。这个版本仍然是构建在最初的功能定义上。 ShiftOne ShiftOne Java Object Cache是一个执行一系列严格的对象缓存策略的Java lib，就像一个轻量级的配置缓存工作状态的框架。 SwarmCache SwarmCache是一个简单且有效的分布式缓存，它使用IP multicast与同一个局域网的其他主机进行通讯，是特别为集群和数据驱动web应用程序而设计的。SwarmCache能够让典型的读操作大大超过写操作的这类应用提供更好的性能支持。SwarmCache使用JavaGroups 来管理从属关系和分布式缓存的通讯。 TreeCache / JBossCache Java 对文件进行读写操作的例子很多，让初学者感到十分困惑，我觉得有必要将各种方法进行 一次分析，归类，理清不同方法之间的异同点。 一．在JDK 1.0 中，通常是用InputStream & OutputStream 这两个基类来进行读写操作的。InputStream 中的FileInputStream 类似一个文件句柄，通过它来对文件进行操作，类似的，在 OutputStream 中我们有FileOutputStream 这个对象。 用FileInputStream 来读取数据的常用方法是： FileInputStream fstream = new FileInputStream(args[0]); DataInputStream in = new DataInputStream(fstream); 用in.readLine() 来得到数据，然后用in.close() 关闭输入流。 完整代码见Example 1。 用FileOutputStream 来写入数据的常用方法是： FileOutputStream out out = new FileOutputStream("myfile.txt"); PrintStream p = new PrintStream( out ); 用p.println() 来写入数据，然后用p.close() 关闭输入。 完整代码见Example 2。 二．在JDK 1.1中，支持两个新的对象Reader & Writer，它们只能用来对文本文件进行操作，而 JDK1.1中的InputStream & OutputStream 可以对文本文件或二进制文件进行操作。 用FileReader 来读取文件的常用方法是： FileReader fr = new FileReader("mydata.txt"); BufferedReader br = new BufferedReader(fr); 用br.readLing() 来读出数据，然后用br.close() 关闭缓存，用fr.close() 关闭文件。 完整代码见Example 3。 用FileWriter 来写入文件的常用方法是： FileWriter fw = new FileWriter("mydata.txt"); PrintWriter out = new PrintWriter(fw); 在用out.print 或out.println 来往文件中写入数据，out.print 和out.println的唯一区别是后者写 入数据或会自动开一新行。写完后要记得用out.close() 关闭输出，用fw.close() 关闭文件。完整代码见Example 4。 -------------------------------------------------------------- following is the source code of examples------------------------------------------------------ Example 1: Java分页原理及常用分页方法 什么是分页技术 分页,是一种将所有数据分段展示给用户的技术.用户每次看到的不是全部数据,而是其中的一部分。如果在其中没有找到自习自己想要的内容,用户可以通过制定页码或是翻页的方式转换可见内容,直到找到自己想要的内容为止.其实这和我们阅读书籍很类似，我们不能把整本书的全部内容写在一页纸上。 为什么要分页？ 1、加载少量数据，减少客户的和服务器数据交互，降低服务器压力。 2、增强用户体验，每次加载数据量少，加载速度自然就快，用户体验就好。 常见分页样式： 1、传统分页（分页工具栏），如百度的分页： 2、自动加载：如QQ空间下拉自动加载数据 传统分页与下拉式分页对比 传统分页可以明确数据信息，数量等； 下拉式无法明确数据量等信息，分页后之前从信息还在页面上。 常见分页实现方式 1.Java程序分页的实现主要是用List接口中的subList(intstartIndex,intendIndex)方法， 这种方式也称为程序内存分页。 2.使用数据库的SQL语句实现数据分页。适用于数据量较大，访问频度较低的操作。如 果数据量大，访问频度又高，可以参考大数据分页。 关于内存分页 当数据量较小时推荐使用。使用subList进行分页时，如果数据量比较大是一个非常耗费系统资源的方案。 目前web项目有许多分布式系统，可能有多个系统访问同一个数据库，那么对数据库的开销就比较大了，这时可以考虑对内存分页进行优化，例如利用程序缓存处理机制等。 其实真正的内存分页不是那么简单的事情，要实现一个完整的通用的机制，不是一两个小时就能搞定的。首先有一个数据记录的服务器缓存问题，然后才是数据记录分页问题，这个相对好解决一点，但第一个问题就不太好组织。因为缓存问题涉及到数据的缓存位置，缓存时间，删除时间和利于查询的数据组织问题。 数据库分页： 概要设计 1．引言 1.1编写的目的。 本文档的阅读对象为软件开发组成员。 1.2背景 随着信息检索技术的高速发展，做为信息检索代表的搜索引擎被广泛引用，如google，百度等，在中国Internet高速发展过程中，越来越受关注，特别是google，百度在美国上市后，搜索引擎备受关注。 a.系统的名称 简易搜索引擎 c.该系统同其他系统或其他机构的基本的相互来往关系。 Lucene ，apache 1.3定义 spider (基于一个树型spider改写而成) Index (lucene) Search 实现搜索(JSP , lucene ) Analyzer 实现分词(CJKAnalyzer) Eclipse (JDK开发平台(IDE) ) 1.4参考资料 中文分词https://www.doczj.com/doc/bc159125.html,/windshow/category/70837.aspx?PageNumber=3 < lucene in action >(index 和search ) < thinking in java >（JNI）< java核心技术第2卷> （JNI） 正则表达式 https://www.doczj.com/doc/bc159125.html,/myweb/disp.asp?idd=312&room=10 https://www.doczj.com/doc/bc159125.html,/myweb/disp.asp?idd=314&room=10 https://www.doczj.com/doc/bc159125.html,/myweb/disp.asp?idd=315&room=10 https://www.doczj.com/doc/bc159125.html,/developer/tech/story/0,2000081602,39077620,00.htm https://www.doczj.com/doc/bc159125.html,/develop/Read_Article.asp?Id=8254 https://www.doczj.com/doc/bc159125.html,/develop/Read_Article.asp?Id=8255 https://www.doczj.com/doc/bc159125.html,/develop/Read_Article.asp?Id=17735 https://www.doczj.com/doc/bc159125.html,/develop/Read_Article.asp?Id=17739 https://www.doczj.com/doc/bc159125.html,/develop/Read_Article.asp?Id=17781 2．总体设计 2.1需求规定 Java 软件高级工程师笔试题 【智力部分】（30分） 1.烧一根不均匀的绳要用一个小时，如何用它来判断半个小时？（5分） 2.4，4，10，10，加减乘除，怎么出24点？（5分） 3.如果你有无穷多的水，一个容积为3L的和5L的提桶，你如何准确称出 4L的水？（5分） 4.一只蜗牛从井底爬到井口，每天白天蜗牛要睡觉，晚上才出来活动，一个晚上蜗牛可以向上爬3尺，但是白天 睡觉的时候会往下滑2尺，井深10尺，问蜗牛几天可以爬出来？（5分） 5.有一种细菌，经过一分钟分裂为2个，再过一分钟，分裂为4个，这样，将一个细菌放在一个瓶子里面，一个 小时后瓶子被细菌充满了。现在假设一开始放入瓶中的为两个细菌，那么到充满瓶子要多长的时间？（10分） 【专业部分】（70分） 6.简述一下面向对象的特征，并举例说明你对面向对象的理解？（5分） 7.ArrayList和HsahSet的区别,HashMap和Hashtable的区别?（5分） 8.线程同步的关键字是什么？sleep() 和wait() 有什么区别?怎么唤醒wait()停止的线程?（5分） 9.列举你在项目中常用的设计模式（伪代码或类图），并说明每种设计模式的具体应用场景。（5分） 10.Spring中事务管理支持哪几种方式以及每种方式的具体使用方法。（5分） 11.Hibernate的缓存等级及其特点（5分） 12.至少写出一种11位手机号码的正则表达式。（5分） 13.用简短的代码实现字符串“s tr in g”到“s tr in g”转换。即将多个空格转换为一个空 格（5分） 14.使用Socket编写一个程序，客户端向服务器端发送请求（发送字符串即可），服务端接收后发送反馈信息.（10 分） 15.用SQL语句实现Oracle分页查询。（10分） 16.aa，bb表都有20个字段，且记录数量都很大，aa，bb表的X字段（非空）上有索引，请用SQL列出aa 表里面存在的X在bb表不存在的X的值，请写出认为最快的语句，并解译原因。（10分） 本文由我司收集整编，推荐下载，如有疑问，请与我司联系Redis缓存Mysql模拟用户登录Java实现实例2016/03/18 1 这段时间在研究Redis，作为缓存界的新宠，现在使用它的公司越来越多。本文使用的是最新稳定版Redis3.0.实现的具体逻辑是： 1. 用户登录首先判断是否在redis缓存中，如果在redis缓存中，直接登录成功； 2. 若用户未在redis缓存，则访问Mysql，判断用户是否存在，如果不存在，则提示用户注册；如果存在，则登录成功； 3. 在mysql存在并登录成功的同时，将改条数据用Redis Hash类型进行缓存，并设置过期时间为30分钟； 4. 设置redis最大内存，若超出内存范围，则使用FIFO方式进行清除。 ?本文实现方式为最简单的模拟方式，有的代码有进一步封装得必要。 ?一、首先创建两个类，一个类连接Mysql，一个类连接Redis，并复写相关方法：?public class Mysql {public Connection conn;{try {Class.forName( com.mysql.jdbc.Driver conn=DriverManager.getConnection( jdbc:mysql://localhost/spring , root , root } catch (ClassNotFoundException e) {e.printStackTrace();} catch (SQLException e) {e.printStackTrace();}}} ?public class Redis extends Jedis {public Jedis redis;{redis = new Jedis( 192.168.217.128 , 6379);redis.auth( root }// public static void main(String[] args) {// System.out.println(redis.get( name ));// System.out.println(redis.keys( * ));// // redis.sinter(keys);// }public String get(String key) {return redis.get( name }public String set(String key, String value) {return redis.set(key, value);}public Long del(String... keys) {return redis.del(keys);}// 键值增加字符public Long append(String key, String str) {return redis.append(key, str);}public Boolean exists(String key) {return redis.exists(key);}// Need researchpublic Long setnx(String key, String value) {return redis.setnx(key, value);}public String setex(String key, String value, int seconds) {return redis.setex(key, seconds, value);}public Long setrange(String key, String str, int offset) Cache 所谓缓存，就是将程序或系统经常要调用的对象存在内存中，一遍其使用时可以快速调用，不必再去创建新的重复的实例。这样做可以减少系统开销，提高系统效率。 缓存主要可分为二大类: 一、通过文件缓存,顾名思义文件缓存是指把数据存储在磁盘上，不管你是以XML格式，序列化文件DAT格式还是其它文件格式； 二、内存缓存，也就是实现一个类中静态Map,对这个Map进行常规的增删查. 代码如下： package lhm.hcy.guge.frameset.cache; import java.util.*; //Description: 管理缓存 //可扩展的功能：当chche到内存溢出时必须清除掉最早期的一些缓存对象，这就要求对每个缓存对象保存创建时间 public class CacheManager { private static HashMap cacheMap = new HashMap(); //单实例构造方法 private CacheManager() { super(); } //获取布尔值的缓存 public static boolean getSimpleFlag(String key){ try{ return (Boolean) cacheMap.get(key); }catch(NullPointerException e){ return false; } public static long getServerStartdt(String key){ try { return (Long)cacheMap.get(key); } catch (Exception ex) { return 0; } } //设置布尔值的缓存 public synchronized static boolean setSimpleFlag(String key,boolean flag){ if (flag && getSimpleFlag(key)) {//假如为真不允许被覆盖 return false; }else{ cacheMap.put(key, flag); return true; } } public synchronized static boolean setSimpleFlag(String key,long serverbegrundt){ if (cacheMap.get(key) == null) { cacheMap.put(key,serverbegrundt); return true; }else{ return false; } } //得到缓存。同步静态方法 private synchronized static Cache getCache(String key) { return (Cache) cacheMap.get(key); } //判断是否存在一个缓存 private synchronized static boolean hasCache(String key) { return cacheMap.containsKey(key); } //清除所有缓存 public synchronized static void clearAll() { cacheMap.clear(); } //清除某一类特定缓存,通过遍历HASHMAP下的所有对象，来判断它的KEY与传入的 关于java基础 1.String,StringBuilder,StringBuffer区别是什么？底层数据结构是什么？分别是如何实现的？ 2.HashSet的底层实现是什么？它与HashMap有什么关系？ 3.Java 的并发包里面有那些知识点？ 4.HashCode与HashMap的关系？ 5.哈希函数的理解？ 6.map在put()的做了哪些事？ 7.如果发生hash碰撞，有什么方法可以解决？ 8.各种类型的锁？ 9.synchronize和lock？ 10.hashTable的数据结构？ 11.线程安全的map即HashTable和CurrentHashMap，底层的线程安全是如何实现的？ 12.hashCode的原理？ 13.什么情况下需要重写类的hashCode()方法？什么时候需要重写equals()方法？ 14.hashmap添加元素，如果通过hash值得到的位置如果有元素，哪一种情况会取代所在的元素？ 15.HashMap添加元素，如果是所得的桶数组的位置有值。该值则被添加到链表尾端，为什么会是 尾端？ 16.ArrayList和hashmap底层结构，以及CurrentHashMap解决了什么问题； 17.Hashmap的是否线程安全？为什么是安全或者不安全？ 18.HashMap、HashTable以及ConcurrentHashMap的区别； 19.volatile关键字的理解；用在哪些场景? 20.线程的理解以及其实现方式； 21.线程池的参数有哪些？实现原理； 22.线程同步方法有哪些？ 23.缓存的原理？为什么要用缓存？为什么会比数据库查询快？ 24.反射机制的理解； 25.Object中的方法； 26.String的toString()方法的实现？底层原理？ 27.NIO与IO的异同； 28.垃圾回收机制的理解； 29.java8的新特性有哪些？如何使用？ 30.static关键字的场景和意义；（拓展：final） 31.如何理解事务？ 32.虚拟机的内存结构； 33.动态代理的两种实现方式； 34.悲观锁和乐观锁的区别 35.如何解决跨域问题？ 36.xml文件解析方式有几种 37.synchronize的锁的类型 38.秒杀系统的设计 39.分库分表 40.Spring底层是如何实现的； 41.Tomcat容器启动的时候，spring的启动流程； 高级JAVA工程师需要掌握哪些技术 我把它分为了五大专题 工程化专题 工程化专题 git git安装使用 git日常使用：fetch/pull/push/revert/rebase git分支管理git flow Jenkins多套环境（test/pre/production）系统自动化发布 Jenkins自动发布到远程主机 MavenMaven私服搭建setting.xml文件剖析pom.xml详解Maven实用插件教学（静态代码检查、生成可执行jar包）profile使用 源码分析 源码分析 Spring源码分析 Spring IOC的实现原理Spring BeanFactory 源码分析Spring AOP的实现原理及配置文件详解 Spring AOP的各种应用场景分析 Spring MVC与Struts对比Spring HandlerMapping详解手写实现SpringMVC框架Spring与各种框架集成原理 Spring JDBC操作原理基于Spring JDBC手写ORM框架 MyBatis源码分析 MyBatis3简介 MyBatis3 SqlMap那些事儿 数据库连接池到底是什么 MyBatis3 SessionFactory实现原理 MyBatis3 配置文件详解 MyBatis3 事务管理与集成 浅谈Hibernate MyBatis3与Hibernate框架对比Netty源码分析 NIO通信原理剖析深入了解NIO缓冲区Buffer NIO Selector原理 AIO编程 Netty产生的背景以及基础入门 Netty高性能之道 Netty的HTTP与Socket通信原理 利用Netty搭建高性能的WebSocket聊天室 Netty聊天室客户端架构实现 Netty的编码解码Netty的拆包粘包操作 MsgPack原理讲解及各种序列化框架对比 MsgPack与Netty整合Netty HTTP通信与Spring整合 Netty RPC架构 Netty与各种架构整合以及Netty源码分析 性能调优 性能调优 JVMJVM内存模型JVM运行时数据区垃圾回收机制GC日志详解 根据GC日志调优系统，调优不靠碰运气！Mysql数据库优化 数据库底层数据结构索引数据存储结构 innodb详解SQL调优及原理分库、分表实现Nginx调优动静资源分离 nginx参数详解nginx + lua使用应用：ip过滤，扛DDOSTomcat调优 Tomcat源码、架构分析Tomcat具体调优参数设置Tomcat压力基准测试Tomcat NIO 配置 双十一技术架构专题-九阳真经 九阳真经技术专题秒杀系统实战 分享6个国内优秀Java后台管理框架的开源项目,建议收藏！ 后台管理系统是内容管理系统Content Manage System(简称CMS)的一个子集。CMS是Content Management System的缩写，意为'内容管理系统'。内容管理系统是企业信息化建设和电子政务的新宠，也是一个相对较新的市场。我自己也一直在搭建一个即好用，又美观的后台管理系统的手动架，可以即拿的即用的项目。不用要重复的去造轮子，把有限的时间用去一些有意思的事。下面分享一下开源中国中有哪些优秀的Java开源后台管理系统。所有项目在https://www.doczj.com/doc/bc159125.html,中输入项目都可以搜索的到。ThinkGem / JeeSite(开发人员/项目名称)watch 2100 star 4000 fork 2600JeeSite是基于多个优秀的开源项目，高度整合封装而成的高效，高性能，强安全性的开源Java EE快速开发平台。JeeSite是您快速完成项目的最佳基础平台解决方案，JeeSite是您想学习Java平台的最佳学习案例，JeeSite还是接私活的最佳助手。JeeSite是在Spring Framework基础上搭建的一个Java基础开发平台，以Spring MVC为模型视图控制器，MyBatis为数据访问层，Apache Shiro为权限授权层，Ehcahe对常用数据进行缓存，Activit为工作流引擎。是JavaEE界的最佳整合。JeeSite 主要定位于企业信息化领域，已内置企业信息化系统的基础 功能和高效的代码生成工具，包括：系统权限组件、数据 权限组件、数据字典组件、核心工具组件、视图操作组件、工作流组件、代码生成等。前端界面风格采用了结构简单、性能优良、页面美观大气的Twitter Bootstrap页面展示框架。采用分层设计、双重验证、提交数据安全编码、密码加密、访问验证、数据权限验证。使用Maven做项目管理，提高项目的易开发性、扩展性。JeeSite目前包括以下四大模块，系统管理(SYS)模块、内容管理(CMS)模块、在线办公(OA)模块、代码生成(GEN)模块。系统管理模块，包括企业组织架构(用户管理、机构管理、区域管理)、菜单管理、角色权限管理、字典管理等功能; 内容管理模块，包括内容管理(文章、链接)，栏目管理、站点管理、公共留言、文件管理、前端网站展示等功能; 在线办公模块，提供简单的请假流程实例;代码生成模块，完成重复的工作。JeeSite 提供了常 用工具进行封装，包括日志工具、缓存工具、服务器端验证、数据字典、当前组织机构数据(用户、机构、区域)以及其它常用小工具等。另外还提供一个强大的在线代码生成工具，此工具提供简单的单表、一对多、树结构功能的生成，如果对外观要求不是很高，生成的功能就可以用了。如果你使 用了JeeSite基础框架，就可以很高效的快速开发出，优秀的信息管理系统。技术选型：1、后端核心框架：Spring Framework 4.1安全框架：Apache Shiro 1.2视图框架：java开发工程师简历
多层技术架构JAVA
爱奇艺的Java缓存之路,你应该知道的缓存进化史!
Ehcache是现在最流行纯Java开源缓存框架
缓存管理需求说明
Java编程提高性能时需注意的地方
8种缓存框架介绍
Java 对文件读写操作
java分页原理及实现方式
javajava概要设计
JAVA高级工程师笔试题(技术部分)
【IT专家】Redis缓存Mysql模拟用户登录Java实现实例
Java 中常用缓存Cache机制的实现
(完整版)java开发工作经验面试题集锦
高级JAVA工程师需要掌握哪些技术
分享6个国内优秀Java后台管理框架的开源项目,建议收藏!
相关主题
文本预览