先去缓存中查,如果没有存到缓存中
简单的map 缓存(缓存就是键值对)
package com.kaishengit.utils.cache;
import org.springframework.stereotype.Repository;
import java.util.HashMap;
import java.util.Map;
/**
* @author Wgs
* @version 1.0
* @create：2017/10/24
*/
@Repository
public class SimpleCache {
private static Map<String, Object> cacheMap = new HashMap<>();
/**
* 获取对象
*
* @param key
* @return
*/
public static Object get(String key) {
if (cacheMap.containsKey(key)) {
return cacheMap.get(key);
}
return null;
}
/**
* 设置缓存
* @param key
*
*/
public static void set(String key,Object value) {
cacheMap.put(key, value);
}
/**
* 删除
*
* @param key
*/
public static void remove(String key) {
cacheMap.remove(key);
}
}
测试
测试
/**
* 根据id查找对象
*
* @param userid
* @return
*/
@Override
public User findById(Integer userid) {
User user = (User) simpleCache.get("user:" + String.valueOf(userid));
if (user == null) {
user = userMapper.findById(userid);
simpleCache.set("user" + userid, user);
}else {
logger.debug("load user from cache.........................");
}
return user;
}
cache(注意insert update delete 需要删除缓存)
测试
package test.java.com.kaishengit.service.impl;
import org.junit.Test;
import net.sf.ehcache.CacheManager;
import net.sf.ehcache.Ehcache;
import net.sf.ehcache.Element;
import org.junit.Test;
/**
* @author Wgs
* @version 1.0
* @create：2017/10/24
*/
public class cacheTest {
@Test
public void testCache() {
CacheManager cacheManager = new CacheManager();
Ehcache ehcache = cacheManager.getEhcache("user");
//添加
Element element = new Element("user:1", "jack");
ehcache.put(element);
//删除
//ehcache.removeAll();
//ehcache.remove("user:1");
//取值
Element e = ehcache.get("user:1");
System.out.println(e.getObjectValue());
}
}
Ehcache的使用
<dependency>
<groupId>org.ehcache</groupId>
<artifactId>ehcache</artifactId>
<version>3.4.0</version>
</dependency>
配置文件
<?xml version="1.0" encoding="UTF-8" ?>
<ehcahe>
<!--
java.io.tmpdir 获取当前操作系统登录用户的临时文件夹路径
-->
<diskStore path="java.io.tmpdir"/>
<cache name="user"
maxElementsInMemory="100"
eternal="false"
timeToIdleSeconds="30"
timeToLiveSeconds="30"
overflowToDisk="true"
/>
<cache name="book"
maxElementsInMemory="1000"
eternal="false"
timeToIdleSeconds="300"
timeToLiveSeconds="300"
overflowToDisk="false"
/>
</ehcahe>
image.png
工具类
package com.kaishengit.util;
import net.sf.ehcache.CacheManager;
import net.sf.ehcache.Ehcache;
import net.sf.ehcache.Element;
import java.io.Serializable;
/**
* Ehcache工具类
*/
public class EhCacheUtil {
private static CacheManager cacheManager = new CacheManager();
public Ehcache getEhCache(String cacheName) {
return cacheManager.getCache(cacheName);
}
public void set(Ehcache ehcache,Serializable key,Serializable value) {
Element element = new Element(key,value);
ehcache.put(element);
}
public void set(String cacheName,Serializable key,Serializable value) {
Element element = new Element(key,value);
getEhCache(cacheName).put(element);
}
public void set(String cacheName,Object key,Object value) {
Element element = new Element(key,value);
getEhCache(cacheName).put(element);
}
public Object get(String cacheName,Serializable key) {
Element element = getEhCache(cacheName).get(key);
return element == null ? null : element.getObjectValue();
}
public Object get(Ehcache ehcache,Serializable key) {
Element element = ehcache.get(key);
return element == null ? null : element.getObjectValue();
}
public void removeAll(String cacheName) {
getEhCache(cacheName).removeAll();
}
public void removeAll(Ehcache ehcache) {
ehcache.removeAll();
}
public void remove(String cacheName,Serializable key) {
getEhCache(cacheName).remove(key);
}
public void remove(Ehcache ehcache,Serializable key) {
ehcache.remove(key);
}
}
Guava
// 发送激活用户账号的邮件,写进去时间,如果没人访问就过期,有人访问就延期时间
private static Cache<String, String> cache = CacheBuilder
.newBuilder()
.expireAfterWrite(6, TimeUnit.HOURS)
.build();
// 找回密码token
private static Cache<String, String> passwordCache = CacheBuilder.newBuilder()
.expireAfterWrite(30, TimeUnit.MINUTES)
.build();
// 限制操作pinlv
private static Cache<String, String> activeCache = CacheBuilder.newBuilder()
.expireAfterWrite(30, TimeUnit.SECONDS)
.build();
package com.kaishengit.service;
import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import com.kaishengit.dao.UserDao;
import com.kaishengit.entity.User;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
public class UserServiceWithGuava {
private UserDao userDao = new UserDao();
private static Cache<String,User> cache = CacheBuilder.newBuilder()
.maximumSize(100)
.expireAfterAccess(10,TimeUnit.MINUTES)
.build();
public User findById(Integer id) {
User user = null;
try {
user = cache.get("user:" + id, new Callable<User>() {
@Override
public User call() {
return userDao.findById(id);
}
});
} catch (ExecutionException e) {
e.printStackTrace();
}
return user;
}
/*private static LoadingCache<String,User> cache = CacheBuilder
.newBuilder()
.maximumSize(100)
.expireAfterAccess(50, TimeUnit.SECONDS)
.build(new CacheLoader<String, User>() {
@Override
public User load(String key) {
UserDao userDao = new UserDao();
return userDao.findById(Integer.valueOf(key));
}
});
public User findById(Integer id) {
User user = cache.getUnchecked(id.toString()); //cache.get("user:"+id);
return user;
}*/
}
测试
// 发送激活用户账号的邮件,写进去时间,如果没人访问就过期,有人访问就延期时间
private static Cache<String, String> cache = CacheBuilder
.newBuilder()
.expireAfterWrite(6, TimeUnit.HOURS)
.build();
// 找回密码token
private static Cache<String, String> passwordCache = CacheBuilder.newBuilder()
.expireAfterWrite(30, TimeUnit.MINUTES)
.build();
// 限制操作pinlv
private static Cache<String, String> activeCache = CacheBuilder.newBuilder()
.expireAfterWrite(30, TimeUnit.SECONDS)
.build();
@Override
public User findByName(String username) {
return userMapper.findByUsername(username);
}
@Override
public User findByEmail(String email) {
return userMapper.finByEmail(email);
}
/**
* 注册用户
*
* @param user
* @throws UserExistException
*/
@Override
public void saveNewUser(User user) throws UserExistException {
User u = userMapper.findByUsername(user.getUsername());
if (u != null) {
throw new UserExistException("用户名已经存在");
}
user.setPassword(DigestUtils.md5Hex(user.getPassword() + salt));
user.setState(User.USERSTATE_UNACTIVE);
user.setAvatar(User.DEFAULT_AVATAR_NAME);
logger.info("盐值:{}" + salt);
logger.info("加密后密码是: {}", user.getPassword());
userMapper.saveNewUser(user);
// 创建线程发激活邮件
getThread(user);
}
/**
* 使用线程发送激活邮件
*
* @param user
*/
private void getThread(User user) {
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
// 发送激活邮件
String uuid = UUID.randomUUID().toString().replace("-", "");
String url = "http://localhost/user/active?_=" + uuid;
// 放入缓存等待6小时
cache.put(uuid, user.getUsername());
String html = "<h3>Dear " + user.getUsername() + ":</h3>请点击<a href='" + url + "'>该链接</a>去激活你的账号. <br> 凯盛软件";
Email email = getEmail(smpt, port, username, password, formmail);
logger.info("邮箱:{}" + email);
EmailUtil.sendHtmlEmail(email, user.getEmail(), "用户激活邮件", html);
}
});
thread.start();
}
/**
* 验证token
*
* @param token
*/
@Override
public void activeUser(String token) throws ServiceException {
String userName = cache.getIfPresent(token);
logger.info("token: {}" + token);
if (token == null) {
throw new ServiceException("token无效或者过期");
} else {
User user = userMapper.findByUsername(userName);
if (user == null) {
throw new ServiceException("账号不存在");
} else {
// 设置激活
user.setState(Statu.Active.getValue());
// 更新用户
userMapper.update(user);
// 删除缓存中的键对应的值
cache.invalidate(token);
}
}
}
/**
* 用户找回密码
*
* @param sessionId 客户端的sessionID,限制客户端的操作频率
* @param type 找回密码方式 email | phone
* @param value 电子邮件地址 | 手机号码
*/
@Override
public void funndpassword(String sessionId, String type, String value) {
if (activeCache.getIfPresent(sessionId) == null) {
if ("phone".equals(type)) {
// TODO 根据手机号找
}
if ("email".equals(type)) {
// 根据邮箱找
User user = userMapper.finByEmail(value);
if (user != null) {
// 开启线程发邮件
getThread(value, user);
}
}
activeCache.put(sessionId, "xxxx");
} else {
throw new ServiceException("操作频率过快，稍后再试");
}
}
/**
* 使用线程发送找回密码
*
* @param value
* @param user
*/
private void getThread(String value, User user) {
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
String uuid = UUID.randomUUID().toString().replace("-", "");
passwordCache.put(uuid, user.getUsername());
String url = "http://localhost/foundpassword/newpassword?token=" + uuid;
String html = user.getUsername() + "<<br>请点击该<a href='" + url + "'>链接</a>进行找回密码操作，链接在30分钟内有效";
Email email = getEmail(smpt, port, username, password, formmail);
logger.info("邮箱:{}" + email);
EmailUtil.sendHtmlEmail(email, value, "密码找回邮件", html);
}
});
thread.start();
}
