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方法里面实现一些需要实现的功能，例如需要清除缓存，就在里面调用第三步缓存类里面的方法就可以了。第五步，也是最后一步，实现逻辑，出自己需要查的数据，然后调用封装缓存类里面的方法。
说明：此文章供实习生和刚出来工作的程序员遇到这方面的功能而无从下手的，来参考！大神们的，看了也不要喷，我不是误人子弟，我也是刚毕业的工作者，只是把自己的独立见解写出来，供实习生和刚出来工作的程序员参考而已，有错误，欢迎指出，让我也能学习，谢谢！！！
2988
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
