ssm中使用redis缓存

没有采用maven

先搭建好ssm框架和引用对应的jar包
在xml文件中 ，以applicationContext-jdbc为例：
添加上：

	<!-- 添加  jedis 对象  -->
	<bean id="jedis" class="redis.clients.jedis.Jedis">
		<constructor-arg name="host" value="redis的ip地址"></constructor-arg>
		<constructor-arg name="port" value="redis端口号 "></constructor-arg>
	</bean>
	<!--添加json对象  -->
	<bean id="json" class="com.zrgk.util.JsonUtil">

然后需要写好两个类 一个是用户 json数据类型转换的util类：

JsonUtil

其中定义好了方法：
1.将对象转换成json字符串
2.将json结果集转化为对象
3.将json数据转换成pojo对象list

package com.zrgk.util;

import java.util.List;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JsonUtil{

    // 定义jackson对象
    private static final ObjectMapper MAPPER = new ObjectMapper();

    /**
     * 将对象转换成json字符串。
     * <p>Title: pojoToJson</p>
     * <p>Description: </p>
     * @param data
     * @return
     */
    public static String objectToJson(Object data) {
    	try {
			String string = MAPPER.writeValueAsString(data);
			return string;
		} catch (JsonProcessingException e) {
			e.printStackTrace();
		}
    	return null;
    }
    
    /**
     * 将json结果集转化为对象
     * @param jsonData json数据
     * @param clazz 对象中的object类型
     * @return{key:value,key:value}
     */
    public static <T> T jsonToPojo(String jsonData, Class<T> beanType) {
        try {
            T t = MAPPER.readValue(jsonData, beanType);
            return t;
        } catch (Exception e) {
        	e.printStackTrace();
        }
        return null;
    }
    
    /**
     * 将json数据转换成pojo对象list
     * <p>Title: jsonToList</p>
     * <p>Description: </p>
     * @param jsonData
     * @param beanType
     * @return[{},{}]
     */
    public static <T>List<T> jsonToList(String jsonData, Class<T> beanType) {
    	JavaType javaType = MAPPER.getTypeFactory().constructParametricType(List.class, beanType);
    	try {
    		List<T> list = MAPPER.readValue(jsonData, javaType);
    		return list;
		} catch (Exception e) {
			e.printStackTrace();
		}
    	
    	return null;
    }
    
}

然后在定义一个redis的包
写一个接口：

JedisDao

package com.zrgk.redis;

// 处理 操作  
// 想对 redis 数据库进行哪些操作 定义哪些方法
public interface JedisDao {

	
	// 存储数据  操作  kye value
	public String set(String key,String value);
	// 设置 存活时间 
	public String set(String key,String value,int time);
	// 获取数据  操作 key  value
	public String get(String key);
	
	// hash 
	// 对 hash 数据的存储
	public long hset(String hkey,String key,String value);
	// 对 hash 数据的获取
	public String hget(String hkey,String key);
	// 删除方法 根据 key 删除 value   数据类型 key value
	public long del(String key);
	public long hdel(String hkey,String key);
	// 一个数据的存活时间 
	
}

在写一个实现类：

JedisDaoImpl

package com.zrgk.redis;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import redis.clients.jedis.Jedis;

@Component
public class JedisDaoImpl implements JedisDao {
	
	@Autowired
	public Jedis jedis;// 注入 jedis 对象  
	public Jedis getJedis() {
		return jedis;
	}

	public void setJedis(Jedis jedis) {
		this.jedis = jedis;
	}

	public String set(String key, String value) {
		return jedis.set(key, value);
	}
	public String set(String key, String value,int time) {
		String s =jedis.set(key, value);
		jedis.expire(key, time);
		return s;
	}

	public String get(String key) {
		return jedis.get(key);
	}

	public long hset(String hkey, String key, String value) {
		return jedis.hset(hkey, key,value);
	}

	public String hget(String hkey, String key) {
		return jedis.hget(hkey,key);
	}

	public long del(String key) {
		return jedis.del(key);
	}

	public long hdel(String hkey, String key) {
		return jedis.hdel(hkey, key);
	}

}

最后就可以在service层进行引用
以查询所有用户为例:

LoginServiceImpl

package com.zrgk.service;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.zrgk.bean.UserBean;
import com.zrgk.dao.LoginDao;
import com.zrgk.redis.JedisDao;
import com.zrgk.util.JsonUtil;

@Service
public class LoginServiceImpl implements LoginService {

	@Autowired
	LoginDao ld;// 自动注入
	public LoginDao getLd() {
		return ld;
	}
	public void setLd(LoginDao ld) {
		this.ld = ld;
	}
	@Autowired
	public JedisDao jd;
	public JedisDao getJd() {
		return jd;
	}
	public void setJd(JedisDao jd) {
		this.jd = jd;
	}
	
	@Autowired
	public JsonUtil json;
	public JsonUtil getJson() {
		return json;
	}
	public void setJson(JsonUtil json) {
		this.json = json;
	}
	
	// 获取所有的用户
	public List<UserBean> getAllUser() {
		
		// 注意 redis 操作不能 影响主程序执行   try catch
		try {
			// 去 redis 数据库中 查询 是否存在  此集合 数据  jedis 对象 
			String s =jd.get("ublist");
			if(s != null && !"".equals(s)){
				// redis 数据库中查到了 数据  走缓存
				List<UserBean> ubList =json.jsonToList(s, UserBean.class);
				System.out.println("数据查询 走的是缓存。。。。。");
				return ubList;
			}
		} catch (Exception e) {
			System.out.println("redis 操作发生了异常  取");
			e.printStackTrace();
		}
		
		
		// 没有查询 去 mysql 数据库查询
		List<UserBean> ubList =ld.getAllUser();
		
		try {
			// 把查询到的 数据 存储到 redis 数据库中
			jd.set("ublist", json.objectToJson(ubList),100);
			System.out.println("数据查询 走的是 查询 mysql 数据库  ");
		} catch (Exception e) {
			System.out.println("redis 操作发生了异常  存  ");
			e.printStackTrace();
		}
		
		return ubList;
	}
	public int deleteOneUser(int uid) {
		// 对 数据做了 操作  删除这个 数据在 redis 中存储的
		try {
			jd.del("ublist");
		} catch (Exception e) {
			e.printStackTrace();
		}
		
		return ld.deleteOneUser(uid);
	}
}

核心思想就是：
查数据库之前先查看redis缓存中是否存在要查的数据有的话，直接将redis中的数据返回给前台，没有的话再去数据库里面进行查询，将查询的结果存到redis中并且返回给前台。
如果对在数据进行了操作的话需要在操作成功后将redis中的数据删除掉，这样就会在下一次查询的时候会去数据库中查询，保证了数据的真实性和准确性。
也可以设置数据在 redis中的生命周期，以保证数据的真实性和准确性。
所以redis缓存适用于不经常变换的数据，比如地区列表，菜单列表。