`
renjie120
  • 浏览: 237933 次
  • 性别: Icon_minigender_1
  • 来自: 上海
博客专栏
D11bba82-ec4a-3d31-a3c0-c51130c62f1c
Java应用集锦
浏览量:22942
社区版块
存档分类
最新评论

java应用集锦5:缓存管理 单例模式 ThreadLocal

    博客分类:
  • java
阅读更多

转载请注明出处: http://renjie120.iteye.com/

 

在项目中经常需要使用缓存下拉菜单的值,可以使用一个map进行缓存管理;单例模式在项目中经常要使用,是很有用的一个设计模式;ThreadLocal在自己的一个框架中使用了,其本身也是被spring框架所使用来管理例如事务等,很有用的一个java类!

1.提供一个改造的简单的缓存管理类CacheManager

2.单例模式的简单实现

3.ThreadLocal的使用举例

1.CacheManager类,从名字看是管理Cache的管理器,主要有两个类:

package com.lsframe.cache;


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 boolean isExpired() {
		return expired;
	}

	public void setExpired(boolean b) {
		expired = b;
	}
}

 

package com.lsframe.cache;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;

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与传入的TYPE是否匹配
	public synchronized static void clearAll(String type) {
		Iterator i = cacheMap.entrySet().iterator();
		String key;
		ArrayList<String> arr = 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 < arr.size(); 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);
	}

	/**
	 * 获取缓存信息.
	 * @param key
	 * @return
	 */
	public static Cache getCacheInfo(String key) {
		if (hasCache(key)) {
			Cache cache = getCache(key);
			if (cacheExpired(cache)) { // 调用判断是否终止方法
				cache.setExpired(true);
			}
			return cache;
		} else
			return null;
	}

	/**
	 * 载入缓存信息.
	 * @param key
	 * @param obj
	 * @param dt
	 * @param expired
	 */
	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);
	}

	/**
	 * 重写载入缓存信息方法.
	 * @param key
	 * @param obj
	 * @param dt
	 */
	public static void putCacheInfo(String key, Cache obj, long dt) {
		Cache cache = new Cache();
		cache.setKey(key);
		cache.setTimeOut(dt + System.currentTimeMillis());
		cache.setValue(obj);
		cache.setExpired(false);
		cacheMap.put(key, cache);
	}
	
	/**	
	 * 判断缓存是否终止.
	 * @param cache
	 * @return
	 */
	public static boolean cacheExpired(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;
		}
	}

	/**
	 * 获取缓存中的大小.
	 * @return
	 */
	public static int getCacheSize() {
		return cacheMap.size();
	}

	/**
	 * 获取指定的类型的大小
	 * @param type
	 * @return
	 */
	public static int getCacheSize(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;
	}

	/**
	 * 获取缓存对象中的所有键值名称.
	 * @return
	 */
	public static ArrayList getCacheAllkey() {
		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;
		}
	}

	/**
	 * 获取缓存对象中指定类型的键值名称.
	 * @param type
	 * @return
	 */
	public static ArrayList getCacheListkey(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;
		}
	}
}

 

使用举例:

public List getAllTallyTypes(){
		List allTallyTypes = null;
		TallyTypeDao tallyTypeDao = new TallyTypeDao();
		//从缓存中取列表,对于这里类似是取字典表的数据,所以可以使用缓存。
		if(CacheManager.getCacheInfo("tallyTypes")==null){
			allTallyTypes = tallyTypeDao.doGetAllTallyTypes(
				"from tallyBook.pojo.TallyType");
			Cache c = new Cache();
			c.setKey("tallyTypes");
			c.setValue(allTallyTypes);
			CacheManager.putCache("tallyTypes",c);
		}else{
			allTallyTypes = (List)CacheManager.getCacheInfo("tallyTypes").getValue();
		}
		return allTallyTypes;
	}

 

2.关于单例类的举例,截取代码自改造的一个简单的数据库连接池代码:

public class DBPoolManager {
/**
	 * 返回连接池管理对象的实例
	 * @return
	 */
	public static DBPoolManager getInstance() {
		if(dbManager==null){
			dbManager = new DBPoolManager();
		}
		//创建了一次就计数累加一次。
		clientCount++;
		return dbManager;
	}
     private DBPoolManager() {
		//构造函数中进行初始化操作
		init();
	}

	private void init() {
		try {
			pros = new Properties();
			pros.load(this.getClass().getResourceAsStream("/db.properties"));
		} catch (Exception ex) {
			log.error("没有找到连接池配置文件", ex);
		}
		loadDriver();
		createPool();
	}
}

 

单例模式的典型特征之一,就是私有的构造函数!然后有一个init()这样的方法返回对象的实例.

3.使用本地线程变量的实例,代码来自改造的一个MVC框架片段,用于设置了request变量之后,再方便取出request变量:

package com.lsframe.mvc;

import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class ActionContext {
	private static ThreadLocal<ActionContext> actionContext = new ThreadLocal<ActionContext>();

	/**
	 * 取得上下文的内容.
	 * @return
	 */
	public static ActionContext getContext() {
		return (ActionContext) actionContext.get();
	}

	/**
	 * 设置上下文.
	 * @param context
	 */
	public static void setContext(ActionContext context) {
		actionContext.set(context);
	}

	private Map<String, Object> context = null;

	/**
	 * 初始化上下文环境.
	 * @param context
	 */
	public ActionContext(Map<String, Object> context) {
		this.context = context;
	}

	/**
	 * 得到上下文.
	 * @return
	 */
	public Map<String, Object> getContextMap() {
		return context;
	}

	/**
	 * 取得上下文中的值.
	 * @param key
	 * @return
	 */
	public Object get(String key) {
		return context.get(key);
	}

	/**
	 * 取得上下文中的HttpServletRequest对象.
	 * @return
	 */
	public HttpServletRequest getHttpServletRequest() {
		return (HttpServletRequest) context.get("HttpServletRequest");
	}

	/**
	 * 取得上下文中的HttpServletResponse.
	 * @return
	 */
	public HttpServletResponse getHttpServletResponse() {
		return (HttpServletResponse) context.get("HttpServletResponse");
	}
}

 设置request的时候,只需要使用:

 

Map context = new HashMap();
   context.put("HttpServletRequest", request);
   context.put("HttpServletResponse", response);
   ActionContext actionContext = new ActionContext(context);
   ActionContext.setContext(actionContext);

 如此简单!!多谢这个方便的本地线程变量,然后就可以在一个请求的任意位置得到request了...是不是和session很相似的机制,好像session就是用这个实现的...

 

分享到:
评论

相关推荐

    43丨单例模式(下):如何设计实现一个集群环境下的分布式单例模式?1

    单例模式是一种设计模式,旨在确保一个类只有一个实例,并提供全局访问点。在单例模式中,类的构造函数是私有的,防止外部直接创建对象,而是通过静态方法获取该类的唯一实例。单例模式的唯一性通常是在进程范围内,...

    线程相关的单例模式

    这种模式在处理资源管理、控制并发以及提高性能等方面有着广泛的应用。当涉及到线程相关的问题时,单例模式的作用尤为重要,因为它可以确保在多线程环境下,类的实例只有一个,从而避免了多个线程同时创建多个对象...

    Java 单例模式线程安全问题

    Java 单例模式线程安全问题详解 Java 单例模式线程安全问题是指在 Java 中实现单例模式时,如何确保线程安全的问题。单例模式是指在整个应用程序生命周期中,只有一个实例存在的设计模式。这种模式可以提高性能,...

    java设计模式之单例模式

    以上就是8种常见的Java单例模式实现方式,每种方式都有其适用场景和优缺点,开发者应根据实际需求选择合适的设计模式。在实际开发中,理解并熟练运用这些模式,有助于提高代码质量,降低维护成本。

    这可能是最全的单例模式了

    ThreadLocal实现单例模式如何破坏单例如何防止单例被破坏参考文章 单例模式有以下特点:  1、单例类只能有一个实例。  2、单例类必须自己创建自己的唯一实例。  3、单例类必须给所有其他对象提供这一实例。

    设计模式及ThreadLocal资料

    总结一下,这份资料涵盖了设计模式中的单例模式、工厂模式和代理模式,以及Java中的ThreadLocal特性。理解并熟练应用这些概念和技术,对于提升Java开发者的技能水平,优化代码的可读性和可维护性具有重要作用。在...

    ThreadLocal应用示例及理解

    以上就是关于ThreadLocal的基本概念、使用方法、生命周期管理和实际应用示例的详细解释。了解并熟练掌握ThreadLocal可以帮助我们编写出更高效、更安全的多线程代码。在Java并发编程中,ThreadLocal是一个不可或缺的...

    Java并发编程:设计原则与模式(Concurrent.Programming.in.Java)(中英版)

    通过学习这些设计原则和模式,开发者能够更好地应对Java并发编程的挑战,编写出高效、可靠的并发应用程序。阅读《Java并发编程:设计原则与模式》(中英版),将有助于提升你在这方面的专业技能。

    java单例模式看这一篇就够了

    Java中的单例模式是一种设计模式,它用于保证一个类在整个应用程序中只能有一个实例存在。这样做的目的是为了控制实例化过程,避免多个实例间的资源冲突,同时提供全局访问点。单例模式属于创建型设计模式,它在软件...

    JAVA ThreadLocal类深入

    【JAVA ThreadLocal类深入】 Java中的ThreadLocal类是一种线程绑定机制,用于在多线程环境中为每个线程提供独立的变量副本,避免了线程间的数据共享带来的并发访问问题。ThreadLocal并不是一个线程对象,而是线程...

    threadlocal:java.lang.ThreadLocal 的实验性无等待并发实现

    【标题】:“线程本地(ThreadLocal):Java.lang.ThreadLocal 的实验性无等待并发实现” 在Java编程中,`ThreadLocal`是一个非常重要的工具类,它提供了线程局部变量的功能。线程局部变量是局限于单个线程的变量,...

    Java ThreadLocal详解_动力节点Java学院整理

    3. 缓存管理:在多线程环境中,使用ThreadLocal可以在每个线程中创建一个缓存副本,这样可以避免多个线程之间的缓存竞争问题。 ThreadLocal的实现原理: ThreadLocal的实现原理是基于Java的类加载机制。在每个...

    Java并发编程:设计原则与模式(第二版).rar

    6. **线程池**:Java的`ExecutorService`和`ThreadPoolExecutor`提供了线程池的实现,通过线程池可以有效地管理和调度线程,避免资源浪费。书中会详细介绍线程池的工作原理和最佳实践。 7. **死锁、活锁与饥饿**:...

    Java避坑指南:Java高手笔记代码篇.rar

    7. **设计模式**:Java中的常见设计模式如工厂模式、单例模式、观察者模式等,是解决特定问题的模板。熟悉并能灵活运用这些模式,能写出更优雅、可维护的代码。 8. **并发工具类**:如Semaphore、CyclicBarrier、...

    java事务 - threadlocal

    Java事务和ThreadLocal是两种在Java编程中至关重要的概念,它们分别用于处理多线程环境下的数据一致性问题和提供线程局部变量。 首先,我们来深入理解Java事务。在数据库操作中,事务是一系列操作的集合,这些操作...

    Java并发编程:设计原则与模式(第二版)-3PDF

    《Java并发编程:设计原则与模式(第二版)》是一本深入...以上知识点构成了《Java并发编程:设计原则与模式(第二版)》的主要内容,通过学习和实践这些知识,开发者可以更好地设计和实现高并发、高性能的Java应用。

    Java单例模式、饥饿模式代码实例

    单例模式常用于配置管理、缓存管理等场景,因为它确保了在整个应用中只有一个共享的、可访问的对象。 在上述代码中,`MyThreadScopeData` 类实现了单例模式,但采用了稍微不同的实现方式,即线程局部(Thread Local...

    java 简单的ThreadLocal示例

    Java中的ThreadLocal是一个非常重要的工具类,它在多线程编程中扮演着独特角色,尤其在处理线程间数据隔离和共享时。ThreadLocal不是线程本身,而是为每个线程提供一个独立的变量副本,使得每个线程都可以独立地改变...

    入研究java.lang.ThreadLocal类.docx

    ### 知识点详解:Java.lang.ThreadLocal 类 #### 一、概述 **ThreadLocal** 并非线程的一种特殊实现形式,而是一种为每个线程提供独立副本的机制,通常被称为“线程局部变量”。这种机制使得每个线程都可以独立...

Global site tag (gtag.js) - Google Analytics