[外门弟子]JAVA-10|2017年07月31日的日报-技能树.IT修真院

发表于： 2017-07-31 23:47:54

4 878

今天完成的事:

复习了一下SpringMVC的配置

添加MemCacheUtil类,思路是通过key查询缓存如果缓存存在则输出,如果缓存里不存在则查询数据库,如果结果为null,返回null,如果有数据就添加到缓存

实现是在service层,需要重写service接口

package com.fanchen.service;

import java.util.List;

import com.fanchen.pojo.Category;

public interface CategoryService {

    int add(Category category);

    void delete(int id);

    Category get(Category category);

    int update(Category category);

    List<Category> list();

}

   @Override
    public Category get(Category category) {
        System.out.println("在缓存中寻找");
        Category c=new Category();
//        设置key
        String key = "category_id(" + category.getId() + ")";
//        通过key获取Category对象
        c = (Category) MemcachedUtil.get(key);
//            在缓存中寻找key
        if (c == null) {
//             如果没找到
            c = categoryMapper.get(category);
//            在数据库里找
            if (c != null) {
                System.out.println("在数据库中找到并添加到缓存");
//            如果在数据库中找到,就放人缓存里
                MemcachedUtil.set(key, c,new Date(1000*64*10));
            }
        }
        return c;
    }

然后是MemcacheUtil类,从散修大师兄哪里抄来的,我只用了add方法

package com.fanchen.util;

import java.util.Date;

import org.apache.log4j.Logger;

import com.whalin.MemCached.MemCachedClient;

/**
 * @author
 * @ClassName: MemcachedUtil
 * @Description: Memcached工具类
 * @date 2015-8-6
 */
public class MemcachedUtil {
    private static final Logger logger = Logger.getLogger(MemcachedUtil.class);

    private static MemCachedClient cachedClient;

    static {
        if (cachedClient == null)
            //括号中的名称要和配置文件memcached-context.xml中的名称一致
            cachedClient = new MemCachedClient("memcachedPool");
    }

    private MemcachedUtil() {
    }

    /**
     * 向缓存添加新的键值对。如果键已经存在，则之前的值将被替换。
     *
     * @param key   键
     * @param value 值
     * @return
     */

    public static boolean set(String key, Object value) {
        return setExp(key, value, null);
    }

    /**
     * 向缓存添加新的键值对。如果键已经存在，则之前的值将被替换。
     *
     * @param key    键
     * @param value  值
     * @param expire 过期时间 New Date(1000*10)：十秒后过期
     * @return
     */
    public static boolean set(String key, Object value, Date expire) {
        return setExp(key, value, expire);
    }

    /**
     * 向缓存添加新的键值对。如果键已经存在，则之前的值将被替换。
     *
     * @param key    键
     * @param value  值
     * @param expire 过期时间 New Date(1000*10)：十秒后过期
     * @return
     */
    private static boolean setExp(String key, Object value, Date expire) {
        boolean flag = false;
        try {
            flag = cachedClient.set(key, value, expire);
        } catch (Exception e) {
            // 记录Memcached日志
            logger.error("Memcached set方法报错，key值：" + key + "\r\n");
        }
        return flag;
    }

    /**
     * 仅当缓存中不存在键时，add 命令才会向缓存中添加一个键值对。
     *
     * @param key   键
     * @param value 值
     * @return
     */
    public static boolean add(String key, Object value) {
        return addExp(key, value, null);
    }

    /**
     * 仅当缓存中不存在键时，add 命令才会向缓存中添加一个键值对。
     *
     * @param key    键
     * @param value  值
     * @param expire 过期时间 New Date(1000*10)：十秒后过期
     * @return
     */
    public static boolean add(String key, Object value, Date expire) {
        return addExp(key, value, expire);
    }

    /**
     * 仅当缓存中不存在键时，add 命令才会向缓存中添加一个键值对。
     *
     * @param key    键
     * @param value  值
     * @param expire 过期时间 New Date(1000*10)：十秒后过期
     * @return
     */

    private static boolean addExp(String key, Object value, Date expire) {
        boolean flag = false;
        try {
            flag = cachedClient.add(key, value, expire);
        } catch (Exception e) {
            // 记录Memcached日志
            logger.error("Memcached add方法报错，key值：" + key + "\r\n");
        }
        return flag;
    }

    /**
     * 仅当键已经存在时，replace 命令才会替换缓存中的键。
     *
     * @param key   键
     * @param value 值
     * @return
     */
    public static boolean replace(String key, Object value) {
        return replaceExp(key, value, null);
    }

    /**
     * 仅当键已经存在时，replace 命令才会替换缓存中的键。
     *
     * @param key    键
     * @param value  值
     * @param expire 过期时间 New Date(1000*10)：十秒后过期
     * @return
     */
    public static boolean replace(String key, Object value, Date expire) {
        return replaceExp(key, value, expire);
    }

    /**
     * 仅当键已经存在时，replace 命令才会替换缓存中的键。
     *
     * @param key    键
     * @param value  值
     * @param expire 过期时间 New Date(1000*10)：十秒后过期
     * @return
     */
    private static boolean replaceExp(String key, Object value, Date expire) {
        boolean flag = false;
        try {
            flag = cachedClient.replace(key, value, expire);
        } catch (Exception e) {
            logger.error("Memcached replace方法报错，key值：" + key + "\r\n");
        }
        return flag;
    }

    /**
     * get 命令用于检索与之前添加的键值对相关的值。
     *
     * @param key 键
     * @return
     */
    public static Object get(String key) {
        Object obj = null;
        try {
            obj = cachedClient.get(key);
        } catch (Exception e) {
            logger.error("Memcached get方法报错，key值：" + key + "\r\n");
        }
        return obj;
    }

    /**
     * 删除 memcached 中的任何现有值。
     *
     * @param key 键
     * @return
     */
    public static boolean delete(String key) {
        return deleteExp(key, null);
    }

    /**
     * 删除 memcached 中的任何现有值。
     *
     * @param key    键
     * @param expire 过期时间 New Date(1000*10)：十秒后过期
     * @return
     */
    public static boolean delete(String key, Date expire) {
        return deleteExp(key, expire);
    }

    /**
     * 删除 memcached 中的任何现有值。
     *
     * @param key    键
     * @param expire 过期时间 New Date(1000*10)：十秒后过期
     * @return
     */
    private static boolean deleteExp(String key, Date expire) {
        boolean flag = false;
        try {
            flag = cachedClient.delete(key, expire);
        } catch (Exception e) {
            logger.error("Memcached delete方法报错，key值：" + key + "\r\n");
        }
        return flag;
    }

    /**
     * 清理缓存中的所有键/值对
     *
     * @return
     */
    public static boolean flashAll() {
        boolean flag = false;
        try {
            flag = cachedClient.flushAll();
        } catch (Exception e) {
            logger.error("Memcached flashAll方法报错\r\n");
        }
        return flag;
    }
}

还需要相应的实体类

然后就是

这两个文件随便一百度多得是,就不贴了

需要在applicationContext.xml添加配置文件所在路径

<!--memcached配置文件位置-->
<import resource="classpath:memcached-content.xml"/>
<!--memcached的配置文件的配置文件路径-->
<bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
    <property name="locations">
        <list>
            <value>classpath*:memcache.properties</value>
        </list>
    </property>
</bean>

最后是依赖

<dependency>
  <groupId>com.whalin</groupId>
  <artifactId>Memcached-Java-Client</artifactId>
  <version>3.0.0</version>
</dependency>

差不多就是这些吧,希望可以帮到后来者

然后是测试,CategoryMapper是不加缓存的CategoryService是加缓存的

@Controller
   public class FindController {

    @Autowired
    CategoryMapper categoryMapper;
    @Autowired
    CategoryServiceImpl categoryService;
    @RequestMapping(value = "user/get",method = RequestMethod.POST)
       public String get(Category category,HttpServletRequest request){
   request.setAttribute("c",categoryService.get(category));
        return "getList";
    }
}