java 线程实时更新缓存
废话不多说，直接上代码
spring+jdbc框架
第一步：配置spring文件，当web程序运行时，初始化一个类（为了让实习生能更好地理解，我就通俗点说：意思就是当程序运行时，便执行一个类里面的所有方法，大神们别喷，我也是新手）
<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans
<span style="white-space:pre"> </span>http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
<span style="white-space:pre"> </span>http://www.springframework.org/schema/context
<span style="white-space:pre"> </span>http://www.springframework.org/schema/context/spring-context-2.5.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-2.5.xsd"
xmlns:tx="http://www.springframework.org/schema/tx" xmlns:aop="http://www.springframework.org/schema/aop">
<!-- 初始化系统参数 -->
<bean id="initialization" class="com.xtown.smartcity.Initialization"
scope="singleton" init-method="init">
</bean>
</beans>
第二步：初始化的
Initialization类，此类继承了ServletContextAware是为了能获得里面的一些接口方法，至于有什么用，请实习生们详细查询ServletContext是什么，有什么作用，或者看spring文档，当程序运行，便会通过spring配置文件初始化Initialization类里面的方法，通常是需要实现一些程序一开始运行便要实现的一些功能，例如实时更新，线程之类的。
/**
*
* 项目名称：SEAutoBizshow <br />
* 类名称：InitializationService <br />
* 类描述： 初始化系统参数 <br />
* 创建人：panpan <br />
* 创建时间：2013-7-24 下午07:42:58 <br />
* 修改人：panpan <br />
* 修改时间：2013-7-24 下午07:42:58 <br />
* 修改备注： <br />
*
* @version
*/
public class Initialization implements ServletContextAware {
ServletContext context;
@Resource
AdminUserService adminUserService;
public void setServletContext(ServletContext context) {
this.context = context;
}
public void init() { //大家着重看这里，这里就是程序开始就必须要初始化的一些方法，方法体可以直接写在本类，或者自己封装类来调用。
initContentPath();
initRes();
initAdminUser();
CacheManager.RunTask();//这个便是本人封装的类，也是本人需要程序一开始便要执行的方法，里面有一些静态方法供本人调用的，下面会贴出来给大家看的。
}
/**
* 初始化项目路径
*/
public void initContentPath() {
/** 设置项目名 */
String contextPath = context.getContextPath().replace('\\', '/');
context.setAttribute("path", contextPath);
context.setAttribute("webpath", Global.WebPath);
}
/**
*
* 方法名: initRes <br />
* 描述: 初始化菜单资源<br />
* 参数：<br />
* <br />
*
* @return void <br />
* @throws
*/
public void initRes() {
ResXmlParser.getInstance().getUriResources();
}
/**
* 创建后台超级管理员
*/
public void initAdminUser() {
adminUserService.doInitUser();
}
}
第三步：这是本人封装的缓存类，里面封装了一些处理缓存的方法，也是第一步的spring配置文件初始化、第二步的类里面调、第三步的封装类的方法。
package com.xtown.web.util.cache;
import java.util.HashMap;
public class CacheManager {
public static HashMap cacheMap = new HashMap();
//得到缓存。同步静态方法
public static Object getCache(String key) {
return (Object) cacheMap.get(key);
}
//载入json缓存
public static void putCache(String key, Object obj) {
cacheMap.put(key, obj);
}
//判断是否存在一个缓存
public synchronized static boolean hasCache(String key) {
return cacheMap.containsKey(key);
}
//清除所有缓存
public synchronized static void clearAll() {
cacheMap.clear();
}
//清除指定的缓存
public synchronized static void clearOnly(String key) {
cacheMap.remove(key);
}
//获取缓存中的大小
public static int getCacheSize() {
return cacheMap.size();
}
public static void RunTask(){//这就是第二步初始化的类要调用的方法。
new ClearCacheTask().start();
}
} 第四步：这是第三步调用另一个类里面的方法，这个类就是线程类，当程序运行后，这个线程便会执行，而且一直执行下去，设置好时间就可以实现实时更新缓存了。
package com.xtown.web.util.cache;
public class ClearCacheTask extends Thread{//继承线程类<span style="font-family: Arial, Helvetica, sans-serif;">Thread</span>
<span style="white-space:pre"> </span> //重写线程类run方法
@Override
public void run() {
try {
while (true) {//循环，当为true是便会执行下面的代码块
System.out.println("********************cacheMap*******************");
Thread.sleep(5*60*1000);//设置时间，这里是设置5分钟，格式是：24*60*60*1000（时*分*秒*毫秒）
CacheManager.cacheMap.clear();//这个就是调用封装类里面的清理缓存的方法
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}第五步：就是要实现的逻辑功能，当用户输入参数，就会执行下面方法。
package com.xtown.smartcity.controller.mobile;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import com.google.gson.JsonArray;
import com.google.gson.JsonObject;
import com.xtown.smartcity.DataTypes;
import com.xtown.smartcity.DeviceInfo;
import com.xtown.smartcity.Globals;
import com.xtown.smartcity.XpsActionParams;
import com.xtown.smartcity.info.App;
import com.xtown.smartcity.info.City;
import com.xtown.smartcity.info.Content;
import com.xtown.smartcity.info.Favorites;
import com.xtown.smartcity.info.Msgready;
import com.xtown.smartcity.info.Service;
import com.xtown.smartcity.info.Topics;
import com.xtown.smartcity.info.Topicstyle;
import com.xtown.smartcity.info.UserInfo;
import com.xtown.smartcity.info.Usermsg;
import com.xtown.smartcity.service.MobileApiService;
import com.xtown.smartcity.service.MobileSsoService;
import com.xtown.web.util.DateTimeUtil;
import com.xtown.web.util.NumberUtil;
import com.xtown.web.util.StringUtil;
import com.xtown.web.util.cache.CacheManager;
/**
* 接口
* @author liangli
*
*/
@Controller
@RequestMapping("/mobile/city/*")
public class CityController extends BaseMobileController {
@Resource
MobileApiService service;
@Resource
MobileSsoService sso;
/**
* 城市公共信息
* @param request
* @param response
* @return
*/
@RequestMapping("public")
public void publicInfos(HttpServletRequest request, HttpServletResponse response) throws Exception {
//判断是否存在缓存
if(!CacheManager.hasCache(key)){
//这里就是你要实现逻辑的地方，你需要缓存什么数据，就去查，查出来的数据，就调用CacheManager封装类里面的方法，把数据缓存起来，缓存里面没有数据，就会执行这里CacheManager.putCache(key, jo.toString());//封装类里面的载入需要缓存起来的json数据。
}else{
//这里就是如果缓存里面有数据，就会一直从缓存里面拿数据，至于怎么写，就看你自己了，一般都是先从缓存里面拿出json数据，然后再输出到客户端去。outputJson((String)CacheManager.getCache(key), response)//这句代码就是输入json数据，里面的第一个参数就是从缓存里面get出你之前缓存起来的数据，第二个参数就不用说，意思很明显，就是响应，这是新手中的新手都会的一个参数，我就不多说了，不懂就去找度娘查HttpServletResponse}
}
}
整体实现一个java 实时更新缓存数据的问题就是这样了，我为那些实习生，还有刚毕业出来工作的程序员，重新整理下思路，当初本人做的不是这样，本人做的有够复杂的，就是在spring配置文件里面配一大堆，然后又写一大堆代码才能实现，结果到最后还是给经理劈头盖脑地狠骂一顿，然后对我说出用线程方法，一步一步实现，到最后，我才明白，简单，很简单，只需要自己写的不到30句代码就搞定，比我配置spring文件配生配死，然后写一大堆代码才能实现的好得多，有开发经验的经理就是不同，放的屁都香过人的。好了，废话说多了，下面我整理下：
第一步配置spring文件，初始化Initialization，第二步创建一个Initialization实现ServletContextAware，调用第三步的封装类里面的方法。第三步封装一个缓存类，里面写一些载入缓存，清除缓存的方法，供调用。第四步建一个ClearCacheTask类 继承Thread类，重写run方法，run方法里面实现一些需要实现的功能，例如需要清除缓存，就在里面调用第三步缓存类里面的方法就可以了。第五步，也是最后一步，实现逻辑，出自己需要查的数据，然后调用封装缓存类里面的方法。
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
