使用Spring3.1.1的緩存示例

定義數據訪問接口：

package org.kevin.cache.dao;

import java.util.Collection;

import org.kevin.cache.domain.Data;

public interface DataDAO {

    public void add(Data data);

    public void update(Data data);

    public Data find(Integer id);

    public void delete(Integer id);

    public Collection<Data> getAll();
}

對接口方法進行實現，使用Map模擬數據庫的表進行存儲數據：

package org.kevin.cache.dao;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;

import org.kevin.cache.domain.Data;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;

public class DataDAOImpl implements DataDAO {

    private Map<Integer, Data> dataMap = new HashMap<>();

    @Override
    @CacheEvict(value = "data", allEntries = true)
    public void add(Data data) {
        System.out.println("Execute：public void add(Data data)");
        dataMap.put(data.getId(), data);
    }

    @Override
    @CacheEvict(value = "data", allEntries = true)
    public void update(Data data) {
        System.out.println("Execute：public void update(Data data) ");
        dataMap.put(data.getId(), data);
    }

    @Override
    @Cacheable(value = "data")
    public Data find(Integer id) {
        System.out.println("Execute：public Data find(Integer id)");
        return dataMap.get(id);
    }

    @Override
    @CacheEvict(value = "data", allEntries = true)
    public void delete(Integer id) {
        System.out.println("Execute：public void delete(Integer id)");
        dataMap.remove(id);
    }

    @Override
    @Cacheable(value = "data")
    public Collection<Data> getAll() {
        System.out.println("Execute：public Collection<Data> getAll()");
        return dataMap.values();
    }
}

如上，對數據進行增刪改的時候清空緩存，查詢時使用緩存。其中value為緩存區，allEntries表示清空緩存區中的所有數據。為了稍后驗證緩存是否生效，打印出執行的方法簽名。

定義領域模型：

package org.kevin.cache.domain;

public class Data {

    private Integer id;
    private String first;
    private String second;

    public Data(Integer id, String first, String second) {
        this.id = id;
        this.first = first;
        this.second = second;
    }

    public String getFirst() {
        return first;
    }

    public void setFirst(String first) {
        this.first = first;
    }

    public String getSecond() {
        return second;
    }

    public void setSecond(String second) {
        this.second = second;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public Integer getId() {
        return id;
    }
}

接下來編寫spring配置文件：

<beans xmlns="http://www.springframework.org/schema/beans" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" 
     xmlns:cache="http://www.springframework.org/schema/cache" 
    xsi:schemaLocation=" 
            http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd 
            http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache-3.1.xsd"> 

    <cache:annotation-driven />

    <bean id="cacheManager" class="org.springframework.cache.support.SimpleCacheManager">
        <property name="caches">
            <set>
                <bean class="org.springframework.cache.concurrent.ConcurrentMapCacheFactoryBean" p:name="default" />
                <bean class="org.springframework.cache.concurrent.ConcurrentMapCacheFactoryBean" p:name="data" />
            </set>
        </property>
    </bean>

    <bean id="dataDao" class="org.kevin.cache.dao.DataDAOImpl" />
</beans>

最后編寫main方法驗證緩存是否生效：

package org.kevin.cache;

import java.util.Collection;

import org.kevin.cache.dao.DataDAO;
import org.kevin.cache.domain.Data;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class CacheMain {

    public static void main(String[] args) {

        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring-cache-demo.xml");
        DataDAO dataDAO = context.getBean("dataDao", DataDAO.class);

        dataDAO.add(new Data(1, "li", "wenkai"));
        Collection<Data> dataCollection = dataDAO.getAll();
        System.out.println(dataCollection.size());

        System.out.println("=================================");

        dataDAO.add(new Data(2, "jack", "lee"));
        dataCollection = dataDAO.getAll();
        System.out.println(dataCollection.size());;
        Data data = dataDAO.find(1);
        System.out.println(data.getFirst());
        data = dataDAO.find(2);
        System.out.println(data.getFirst());
        data = dataDAO.find(2);
        System.out.println(data.getFirst());;

        System.out.println("====================================");
        dataDAO.add(new Data(3, "kevin", "lee"));
        data = dataDAO.find(2);
        System.out.println(data.getFirst());
        data = dataDAO.find(3);
        System.out.println(data.getFirst());
        data = dataDAO.find(2);
        System.out.println(data.getFirst());
    }
}

打印接過如下，表示已經生效：

Execute：public void add(Data data)
Execute：public Collection<Data> getAll()
1
=================================
Execute：public void add(Data data)
Execute：public Collection<Data> getAll()
2
Execute：public Data find(Integer id)
li
Execute：public Data find(Integer id)
jack
jack
====================================
Execute：public void add(Data data)
Execute：public Data find(Integer id)
jack
Execute：public Data find(Integer id)
kevin
jack

最后，spring支持的緩存機制，是方法級的緩存，而不關注底層是否使用了數據庫以及通過什么方式訪問的數據庫；因此這種緩存不止可以放到DAO層，也可以放置到Service層，甚至可以對各種代碼數據進行緩存。

如果應用中同時使用了Hibernate和Ibatis，或者這種方式是一種好的緩存解決方案。

  轉自：http://blog.csdn.net/scorpio3k/article/details/7628894