/* * Copyright 2002-2014 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * *      http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */package org.springframework.cache;import java.util.Collection;import org.springframework.lang.Nullable;/** * Spring's central cache manager SPI. * Allows for retrieving named {@link Cache} regions. * * @author Costin Leau * @since 3.1 */public interface CacheManager {    /**     * Return the cache associated with the given name.     * @param name the cache identifier (must not be {@code null})     * @return the associated cache, or {@code null} if None found     */    @Nullable    Cache getCache(String name);    /**     * Return a collection of the cache names known by this manager.     * @return the names of all caches known by the cache manager     */    Collection<String> getCacheNames();}

/* * Copyright 2002-2017 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * *      http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */package org.springframework.cache;import java.util.concurrent.Callable;import org.springframework.lang.Nullable;/** * Interface that defines common cache operations. * * <b>Note:</b> Due to the generic use of caching, it is recommended that * implementations allow storage of <tt>null</tt> values (for example to * cache methods that return {@code null}). * * @author Costin Leau * @author Juergen Hoeller * @author Stephane Nicoll * @since 3.1 */public interface Cache {    /**     * Return the cache name.     */    String getName();    /**     * Return the underlying native cache provider.     */    Object getNativeCache();    /**     * Return the value to which this cache maps the specified key.     * <p>Returns {@code null} if the cache contains no mapping for this key;     * otherwise, the cached value (which may be {@code null} itself) will     * be returned in a {@link ValueWrapper}.     * @param key the key whose associated value is to be returned     * @return the value to which this cache maps the specified key,     * contained within a {@link ValueWrapper} which may also hold     * a cached {@code null} value. A straight {@code null} being     * returned means that the cache contains no mapping for this key.     * @see #get(Object, Class)     */    @Nullable    ValueWrapper get(Object key);    /**     * Return the value to which this cache maps the specified key,     * generically specifying a type that return value will be cast to.     * <p>Note: This variant of {@code get} does not allow for differentiating     * between a cached {@code null} value and no cache entry found at all.     * Use the standard {@link #get(Object)} variant for that purpose instead.     * @param key the key whose associated value is to be returned     * @param type the required type of the returned value (may be     * {@code null} to bypass a type check; in case of a {@code null}     * value found in the cache, the specified type is irrelevant)     * @return the value to which this cache maps the specified key     * (which may be {@code null} itself), or also {@code null} if     * the cache contains no mapping for this key     * @throws IllegalStateException if a cache entry has been found     * but failed to match the specified type     * @since 4.0     * @see #get(Object)     */    @Nullable    <T> T get(Object key, @Nullable Class<T> type);    /**     * Return the value to which this cache maps the specified key, obtaining     * that value from {@code valueLoader} if necessary. This method provides     * a simple substitute for the conventional "if cached, return; otherwise     * create, cache and return" pattern.     * <p>If possible, implementations should ensure that the loading operation     * is synchronized so that the specified {@code valueLoader} is only called     * once in case of concurrent access on the same key.     * <p>If the {@code valueLoader} throws an exception, it is wrapped in     * a {@link ValueRetrievalException}     * @param key the key whose associated value is to be returned     * @return the value to which this cache maps the specified key     * @throws ValueRetrievalException if the {@code valueLoader} throws an exception     * @since 4.3     */    @Nullable    <T> T get(Object key, Callable<T> valueLoader);    /**     * Associate the specified value with the specified key in this cache.     * <p>If the cache previously contained a mapping for this key, the old     * value is replaced by the specified value.     * @param key the key with which the specified value is to be associated     * @param value the value to be associated with the specified key     */    void put(Object key, @Nullable Object value);    /**     * Atomically associate the specified value with the specified key in this cache     * if it is not set already.     * <p>This is equivalent to:     * <pre><code>     * Object existingValue = cache.get(key);     * if (existingValue == null) {     *     cache.put(key, value);     *     return null;     * } else {     *     return existingValue;     * }     * </code></pre>     * except that the action is performed atomically. While all out-of-the-box     * {@link CacheManager} implementations are able to perform the put atomically,     * the operation may also be implemented in two steps, e.g. with a check for     * presence and a subsequent put, in a non-atomic way. Check the documentation     * of the native cache implementation that you are using for more details.     * @param key the key with which the specified value is to be associated     * @param value the value to be associated with the specified key     * @return the value to which this cache maps the specified key (which may be     * {@code null} itself), or also {@code null} if the cache did not contain any     * mapping for that key prior to this call. Returning {@code null} is therefore     * an indicator that the given {@code value} has been associated with the key.     * @since 4.1     */    @Nullable    ValueWrapper putIfAbsent(Object key, @Nullable Object value);    /**     * Evict the mapping for this key from this cache if it is present.     * @param key the key whose mapping is to be removed from the cache     */    void evict(Object key);    /**     * Remove all mappings from the cache.     */    void clear();    /**     * A (wrapper) object representing a cache value.     */    @FunctionalInterface    interface ValueWrapper {        /**         * Return the actual value in the cache.         */        @Nullable        Object get();    }    /**     * Wrapper exception to be thrown from {@link #get(Object, Callable)}     * in case of the value loader callback failing with an exception.     * @since 4.3     */    @SuppressWarnings("serial")    class ValueRetrievalException extends RuntimeException {        @Nullable        private final Object key;        public ValueRetrievalException(@Nullable Object key, Callable<?> loader, Throwable ex) {            super(String.format("Value for key '%s' could not be loaded using '%s'", key, loader), ex);            this.key = key;        }        @Nullable        public Object getKey() {            return this.key;        }    }}

@Cacheable(cacheNames="books", key="#isbn")public Book findBook(ISBN isbn, boolean checkWarehouse, boolean includeUsed)@Cacheable(cacheNames="books", key="#isbn.rawNumber")public Book findBook(ISBN isbn, boolean checkWarehouse, boolean includeUsed)@Cacheable(cacheNames="books", key="T(someType).hash(#isbn)")public Book findBook(ISBN isbn, boolean checkWarehouse, boolean includeUsed)

@Cacheable(cacheNames="book", condition="#name.length() < 32", unless="#result.hardback")public Book findBook(String name)

@CacheEvict(cacheNames="books", allEntries=true,beforeInvocation=true)public void loadBooks(InputStream batch)

@CachePut(cacheNames="book", key="#isbn")public Book updateBook(ISBN isbn, BookDescriptor descriptor)

compile 'org.springframework.data:spring-data-redis:2.0.6.RELEASE'    // https://mvnrepository.com/artifact/redis.clients/jedis    compile group: 'redis.clients', name: 'jedis', version: '2.9.0'// https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-core    compile group: 'com.fasterxml.jackson.core', name: 'jackson-core', version: '2.9.5'// https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind    compile group: 'com.fasterxml.jackson.core', name: 'jackson-databind', version: '2.9.5'

package com.bdqn.lyrk.ssh.study.config;import org.springframework.cache.annotation.EnableCaching;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;import org.springframework.data.redis.cache.RedisCacheConfiguration;import org.springframework.data.redis.cache.RedisCacheManager;import org.springframework.data.redis.connection.RedisConnectionFactory;import org.springframework.data.redis.connection.RedisStandaloneConfiguration;import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;import org.springframework.data.redis.core.StringRedisTemplate;import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;import org.springframework.data.redis.serializer.RedisSerializationContext;@Configuration@EnableCachingpublic class RedisConfig {    /**     * 创建redisConnectionFactory     * @return     */    @Bean    public RedisConnectionFactory redisConnectionFactory() {        /*            设置相关配置         */        RedisStandaloneConfiguration configuration = new RedisStandaloneConfiguration();        configuration.setPort(6379);        configuration.setHostName("localhost");        configuration.setDatabase(0);        JedisConnectionFactory jedisConnectionFactory =                new JedisConnectionFactory(configuration);        return jedisConnectionFactory;    }    @Bean    public StringRedisTemplate stringRedisTemplate() {        StringRedisTemplate stringRedisTemplate = new StringRedisTemplate();        stringRedisTemplate.setConnectionFactory(redisConnectionFactory());        return stringRedisTemplate;    }    @Bean    public RedisCacheManager cacheManager() {        /*            配置json序列化方式         */        RedisCacheConfiguration cacheConfiguration = RedisCacheConfiguration.defaultCacheConfig().                serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(                        new GenericJackson2JsonRedisSerializer()));        return RedisCacheManager.builder(redisConnectionFactory()).                transactionAware().cacheDefaults(cacheConfiguration).build();    }}

package com.bdqn.lyrk.ssh.study.service;import com.bdqn.lyrk.ssh.study.entity.StudentEntity;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.cache.annotation.CacheEvict;import org.springframework.cache.annotation.CachePut;import org.springframework.cache.annotation.Cacheable;import org.springframework.orm.hibernate5.HibernateTemplate;import org.springframework.stereotype.Service;import org.springframework.transaction.annotation.Transactional;@Servicepublic class StudentService {    @Autowired    private HibernateTemplate hibernateTemplate;    @Transactional    public int save(StudentEntity studentEntity) {        hibernateTemplate.save(studentEntity);        return studentEntity.getId();    }    @Cacheable(key = "#id", cacheNames = "student", cacheManager = "cacheManager", condition = "#id==1")    public StudentEntity listStudents(Integer id) {        return hibernateTemplate.get(StudentEntity.class, id);    }    @Transactional    @CachePut(key = "#id", cacheNames = "student", cacheManager = "cacheManager")    public StudentEntity updateStudent(Integer id) {        StudentEntity studentEntity = new StudentEntity();        studentEntity.setId(id);        studentEntity.setStuName("tests");        studentEntity.setPassword("password");        hibernateTemplate.update(studentEntity);        return studentEntity;    }    @CacheEvict(key = "#id", cacheNames = "student")    @Transactional    public StudentEntity deleteStudent(Integer id) {        StudentEntity studentEntity = hibernateTemplate.load(StudentEntity.class, id);        hibernateTemplate.delete(studentEntity);        return studentEntity;    }}

package com.bdqn.lyrk.ssh.study;import com.bdqn.lyrk.ssh.study.config.AppConfig;import com.bdqn.lyrk.ssh.study.service.StudentService;import org.springframework.context.annotation.AnnotationConfigApplicationContext;import java.io.IOException;public class Main {    public static void main(String[] args) throws IOException {        AnnotationConfigApplicationContext applicationContext =                new AnnotationConfigApplicationContext(AppConfig.class);        StudentService studentService =                applicationContext.getBean(StudentService.class);        studentService.updateStudent(1);        System.out.println(studentService.listStudents(1).getStuName());        studentService.deleteStudent(1);    }}