CMS系统学习（六）

Yuncoco

于 2019-06-01 15:27:40 发布

阅读量306

点赞数

本文链接：https://blog.csdn.net/Yuncoco/article/details/90729628

版权

一、缓存

1、什么是缓存:
缓存就是数据交换的缓冲区（称作Cache）
2、缓存作用
(1)提升性能
(2)缓解数据库压力
3、缓存实现方式
==(1)EhCache ==：是一个纯Java的进程内缓存框架，具有快速、精干等特点，是Hibernate(JPA)中默认CacheProvider。Ehcache是一种广泛使用的开源Java分布式缓存.
(2)Memcached:只支持简单的key/value数据结构,协议简单、内置内存存储方式,不会对数据进行持久化，重启memcached、重启操作系统会导致全部数据消失。
(3)Redis:（nosql 数据库中央缓存 --大数据）支持多种数据结构，如string,list,map,set 支持持久化操作，可以进行数据持久化到磁盘，从而进行数据备份或数据恢复等操作，较好的防止数据丢失的手段。
4、缓存实现步骤
(1)导入jar包
(2).引入xml配置文件:ehcache.xml

<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../config/ehcache.xsd">

	<!-- 放在硬盘的位置  -->
    <diskStore path="C:/ehcache"/>

	<!-- 
		name:这个缓存的名称(随便取)
		maxElementsInMemory:内存中最多放多少个对象
		eternal:是否永久保存
		timeToIdleSeconds:缓存数据的钝化时间
		timeToLiveSeconds：缓存数据的生存时间
		overflowToDisk：是否把缓存的对象放到硬盘中
		maxElementsOnDisk：硬盘中最多放多少个对象
		memoryStoreEvictionPolicy:缓存的策略
		缓存满了之后的淘汰算法。LRU和FIFO算法这里就不做介绍.
		LFU算法直接淘汰使用比较少的对象，在内存保留的都是一些经常访问的对象。
	 -->
	<cache
			name="cacheDemo"
            maxElementsInMemory="10000"
            eternal="false"
            timeToIdleSeconds="120"
            timeToLiveSeconds="120"
            overflowToDisk="true"
            maxElementsOnDisk="10000000"
            diskPersistent="false"
            diskExpiryThreadIntervalSeconds="120"
            memoryStoreEvictionPolicy="LRU"
            />
</ehcache>

(3)spring 配置：applicationContext.xml

factory-method:这个方法返回的对象就会变成一个Bean
<bean id="cacheManager" class="net.sf.ehcache.CacheManager" factory-method="create"></bean>

(4)创建一个缓存管理器:

package cn.itsource.cms.cache;

import java.util.List;

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;

import cn.itsource.cms.domain.Images;
import cn.itsource.cms.service.IImagesService;
import net.sf.ehcache.Cache;
import net.sf.ehcache.CacheManager;
import net.sf.ehcache.Element;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class CacheTest {
	@Autowired
	private CacheManager cm;//spring方式创建缓存管理对象
	@Autowired
	private IImagesService imageService;
	
	
	@Test
	public void testCache(){
		List<Images> list = imageService.finalAll();
		System.out.println(list);
		//要是用缓存，必须要创建缓存管理对象
//		CacheManager cm = CacheManager.create();
		//通过管理对象拿到相应缓存对象
		Cache cache = cm.getCache("cacheDemo");
		//准备一个Element对象
		Element element = new Element("list",list );
		//向缓存中存东西
		cache.put(element);
		//获取数据
		Element element2 = cache.get("list");
		System.out.println(element2.getObjectValue());
		
	}
}

5.缓存的使用场景:
1.经常读取,很少修改
2.允许出现无效数据(敏感数据不能用缓存,财务,银行)
3.缓存数据不能大于内存(钝化)

cms系统缓存使用：
1.创建一个CacheUtils类

package cn.itsource.cms.util;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import net.sf.ehcache.Cache;
import net.sf.ehcache.CacheManager;
import net.sf.ehcache.Element;

/**
 * 操作缓存的一个工具类
 * @author Administrator
 *
 */
@Component
public class CacheUtils {
	
	@Autowired
	private CacheManager cm;

	/**
	 * 存一个东西
	 * @param key
	 * @param value
	 */
	public void put(String key,Object value){
		//拿到缓存对象
		Cache cache = cm.getCache("cacheDemo");
		//创建一个Element对象
		Element ele = new Element(key, value);
		//把对象放到缓存中去
		cache.put(ele);
	}
	
	/**
	 * <T>T:返回值是什么类型，这个泛型就是什么类型
	 */
	public <T>T get(String key){
		//拿到缓存对象
		Cache cache = cm.getCache("cacheDemo");
		Element ele = cache.get(key);
		//返回相应数据
		if(ele==null){
			return null;
		}
		return (T)ele.getObjectValue();
	}
	
	/**
	 * 移除缓存
	 */
	public void remove(){
		Cache cache = cm.getCache("cacheDemo");
		cache.removeAll();
	}
}

2.JobsServiceImpl

package cn.itsource.cms.service.impl;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import cn.itsource.cms.dao.IJobsDao;
import cn.itsource.cms.domain.Jobs;
import cn.itsource.cms.page.PageList;
import cn.itsource.cms.query.SqlCondition;
import cn.itsource.cms.service.IJobsService;
import cn.itsource.cms.util.CacheUtils;
@Service
public class JobsServiceImpl implements IJobsService {
	@Autowired
	private IJobsDao dao;

	@Autowired
	private CacheUtils cacheUtils;

	@Override
	public void save(Jobs jobs) {
		dao.save(jobs);
		cacheUtils.remove();
	}

	@Override
	public void update(Jobs jobs) {
		dao.update(jobs);
		cacheUtils.remove();
	}

	@Override
	public void delete(Integer id) {
		dao.delete(id);
		cacheUtils.remove();
	}

	@Override
	public Jobs finalId(Integer id) {
		return dao.finalId(id);
	}

	@Override
	public List<Jobs> finalAll() {
		return dao.finalAll();
	}
	
	/**
	 * 每一页都应该有自己的特殊的名称
	 *  第1页: jobs_1
	 *  第2页: jobs_2
	 *  第n页: jobs_n
	 */
	@Override
	public PageList<Jobs> queryAll(SqlCondition condition) {
	Integer currentPage = condition.getCurrentPage();
		String key = "jobs" +currentPage;
		//从缓存中获到相应的数据
		PageList<Jobs> pageList = cacheUtils.get(key);
		//如果这个数据不存在，从数据库中去查询，并且把它放到缓存中
			if (pageList==null) {
			 pageList = dao.queryAll(condition);
				cacheUtils.put(key, pageList);
			}
			//把值传回去
		return pageList;
	}

}

异常：java.io.NotSerializableException：
创建的pojo类未实现Serializable接口，启动服务器会报此异常，对代码功能没影响，或者说暂时未发现有什么影响。要解决此异常，可通过实现该接口解决。
pojo:简单的Java对象，实际就是普通JavaBeans