大型运输行业实战_day08_1_memcache缓存生产应用

1.memcache使用环境搭建

       1.安装memcached服务器

        

         安装方法 以管理员身份打开cmd,在cmd中执行如下命令:

        

          注意:在执行该命令时必须在memcached.exe文件下执行.

       2.开启服务

         注意:要重新打开cmd控制台,再执行开启服务命令

        

      3.查看是否启动成功

       

     4.关闭memcache缓存服务器

     

    到此安装启动查看是否启动成功关闭服务完成!

2.memcached与spring整合并使用

      1.拷贝jar包

        

       注意:如果项目中没有日志包必须拷贝日志包

      2.编写与spring整合的配置文件: spring-memcached.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!-- XMemcachedClientFactoryBean工厂配置-->
    <bean id="memcachedClient" class="net.rubyeye.xmemcached.utils.XMemcachedClientFactoryBean">
        <property name="servers" value="${memcache.servers}"/>
        <property name="weights" value="${memcache.servers.weight}"/>
        <property name="sessionLocator">
            <bean class="net.rubyeye.xmemcached.impl.KetamaMemcachedSessionLocator"/>
        </property>
        <property name="transcoder">
            <bean class="net.rubyeye.xmemcached.transcoders.SerializingTranscoder"/>
        </property>
        <property name="bufferAllocator">
            <bean class="net.rubyeye.xmemcached.buffer.SimpleBufferAllocator"/>
        </property>
    </bean>
    <!--自己封装的api类-->
    <bean class="com.day02.sation.map.MemcachedAccess">
        <property name="memcachedClient" ref="memcachedClient"/>
    </bean>

</beans>

  使用到的服务器参数配置:

  memcache.servers=127.0.0.1:11211
  memcache.servers.weight=1

3.编写封装的API类  MemcachedAccess.java

package com.day02.sation.map;

import net.rubyeye.xmemcached.MemcachedClient;
import net.rubyeye.xmemcached.exception.MemcachedException;
import java.util.concurrent.TimeoutException;

/**
 * Created by Administrator on 1/4.
 */
public class MemcachedAccess {
    private MemcachedClient memcachedClient;

    /**
     * 缓存时间
     * @param key
     * @param time
     * @param value
     * @return
     */
    public boolean put(String key,Integer time,String value){
        try {
            boolean add = memcachedClient.add(key, time, value);
            return add;
        } catch (TimeoutException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (MemcachedException e) {
            e.printStackTrace();
        }
        return false;
    }

    /**
     *添加
     * @param key
     * @param value
     * @return
     */
    public boolean put(String key,String value){
        try {
            boolean add = memcachedClient.add(key, 1*24*60, value);
            return add;
        } catch (TimeoutException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (MemcachedException e) {
            e.printStackTrace();
        }
        return false;
    }

    /**
     * 获取
     * @param key
     * @return
     */
    public String get(String key){
        try {
            String value= (String)memcachedClient.get(key);
            return value;
        } catch (TimeoutException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (MemcachedException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 清除缓存
     */
    public void flushAll(){
        try {
            memcachedClient.flushAll();
        } catch (TimeoutException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (MemcachedException e) {
            e.printStackTrace();
        }
    }

    public MemcachedClient getMemcachedClient() {
        return memcachedClient;
    }

    public void setMemcachedClient(MemcachedClient memcachedClient) {
        this.memcachedClient = memcachedClient;
    }
}

 4.将spring-memcached.xml于spring主配置文件进行关联

  <!--引入memcached.xml文件-->
<import resource="classpath:spring/spring-memcached.xml"/>

5..测试MemcachedAccess.java是否可用

package com.day02.sation.test;

import com.day02.sation.map.MemcachedAccess;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/**
 * Created by Administrator on 12/27.
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:spring-config.xml")
public class TestMemcache {
    @Autowired
    private MemcachedAccess memcachedAccess;

    @Test
    public void testGetList() {
        //添加一对值
        memcachedAccess.put("name", "wuji");
        //取出缓存中的值
        String name = memcachedAccess.get("name");
        System.out.println("name=  " + name);
        //清除所有缓存
        memcachedAccess.flushAll();
        //再次获取值,检查是否已经清除
        String name2 = memcachedAccess.get("name");
        System.out.println("name2=  " + name2);
    }
}

 6.memcache在实际生产中做数据字典缓存使用案例

package com.day02.sation.map;

import com.day02.sation.dao.IDicDao;
import com.day02.sation.model.Dic;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.util.List;

/**
 * Created by Administrator on 1/3.
 */

public class DicMemcache {
    private static IDicDao dicDao;
    private static MemcachedAccess memcachedAccess;
    static {
        //获取应用上下文对象
        ApplicationContext ctx = new ClassPathXmlApplicationContext("spring-config.xml");
        //获取dicDao实例
        dicDao = ctx.getBean(IDicDao.class);
        //获取MemcachedAccess实例
        memcachedAccess = ctx.getBean(MemcachedAccess.class);
        //调用方法初始化字典
        addMapValue();
    }

    public static String getFieldDetail(String tableName, String fieldName, String filedValue) {
        String key = tableName + "_" + fieldName + "_" + filedValue;
        String value = memcachedAccess.get(key);
        if (value == null) { //如果 value 为空 重新查询数据库
            Dic dicQuery = new Dic();
            dicQuery.setTableName(tableName);
            dicQuery.setFieldName(fieldName);
            dicQuery.setFieldValue(filedValue);

            Dic dic = dicDao.getDic(dicQuery);
            if (dic != null) {//数据有该值
                String fieldDescribe = dic.getFieldDescribe();
                memcachedAccess.put(key, fieldDescribe);
                return fieldDescribe;
            }
            value = "暂无";
        }
        return value;
    }

    /**
     * 初始化字典数据
     */
    private static void addMapValue() {
        List<Dic> list = dicDao.getList();
        for (int i = 0; i < list.size(); i++) {
            Dic dic = list.get(i);
            String tableName = dic.getTableName();
            String fieldName = dic.getFieldName();
            String fieldValue = dic.getFieldValue();
            String key = tableName + "_" + fieldName + "_" + fieldValue;
            String fieldDescribe = dic.getFieldDescribe();
            memcachedAccess.put(key, fieldDescribe);
        }

    }
}

 7.调用获取值

 

  到此memcache的使用到此结束!