ehcache 自定义缓存监听（event listeners）

小咪咪 2023-01-22 12:53 7阅读 0赞

--------------------

### ehcache 自定义缓存监听（event listeners） ###

### \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* ###

**使用说明**

**缓存监听事件在对应的缓存事件发生时触发**

Cache listeners allow implementers to register callback methods 
    that will be executed when a cache event occurs

**缓存监听器注册在缓存上**

Listeners are registered at the cache level - and therefore 
    only receive events for caches that they have been registered with

### \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* ###

**相关类与接口**

**CacheEventListener**

public interface CacheEventListener<K, V> {
        void onEvent(CacheEvent<? extends K, ? extends V> var1);
    }

**CacheEventAdapter**

public abstract class CacheEventAdapter<K, V> implements CacheEventListener<K, V> {
        public CacheEventAdapter() {
        }
    
        public final void onEvent(CacheEvent<? extends K, ? extends V> event) {
            switch(event.getType()) {
            case CREATED:
                this.onCreation(event.getKey(), event.getNewValue());
                break;
            case UPDATED:
                this.onUpdate(event.getKey(), event.getOldValue(), event.getNewValue());
                break;
            case REMOVED:
                this.onRemoval(event.getKey(), event.getOldValue());
                break;
            case EXPIRED:
                this.onExpiry(event.getKey(), event.getOldValue());
                break;
            case EVICTED:
                this.onEviction(event.getKey(), event.getOldValue());
                break;
            default:
                throw new AssertionError("Unsupported event type " + event.getType());
            }
    
        }
    
        protected void onEviction(K key, V evictedValue) {
        }
    
        protected void onExpiry(K key, V expiredValue) {
        }
    
        protected void onRemoval(K key, V removedValue) {
        }
    
        protected void onUpdate(K key, V oldValue, V newValue) {
        }
    
        protected void onCreation(K key, V newValue) {
        }
    }

**CacheEvent**

public interface CacheEvent<K, V> {
        EventType getType();
    
        K getKey();
    
        V getNewValue();
    
        V getOldValue();
    
        /** @deprecated */
        @Deprecated
        Cache<K, V> getSource();
    }

**EventType**

@XmlType(
        name = "event-type"
    )
    @XmlEnum
    public enum EventType {
        EVICTED,
        EXPIRED,
        REMOVED,
        CREATED,
        UPDATED;
    
        private EventType() {
        }
    
        public String value() {
            return this.name();
        }
    
        public static EventType fromValue(String v) {
            return valueOf(v);
        }
    }

**CacheEventListenerConfiguration**

public interface CacheEventListenerConfiguration<R> extends ServiceConfiguration<CacheEventListenerProvider, R> {
    
        EventFiring firingMode();
        EventOrdering orderingMode();
        EnumSet<EventType> fireOn();
    }

**DefaultCacheEventListenerConfiguration**

public class DefaultCacheEventListenerConfiguration extends ClassInstanceConfiguration<CacheEventListener<?, ?>> implements CacheEventListenerConfiguration<Void> {
        private final EnumSet<EventType> eventsToFireOn;
        private EventFiring eventFiringMode;       //同步异步设置，默认异步
        private EventOrdering eventOrderingMode;   //有序设置，默认无序
    
        public DefaultCacheEventListenerConfiguration(Set<EventType> fireOn, Class<? extends CacheEventListener<?, ?>> clazz, Object... arguments) {
            super(clazz, arguments);
            this.eventFiringMode = EventFiring.ASYNCHRONOUS;     //默认异步
            this.eventOrderingMode = EventOrdering.UNORDERED;    //默认无序
            if (fireOn.isEmpty()) {
                throw new IllegalArgumentException("Set of event types to fire on must not be empty");
            } else {
                this.eventsToFireOn = EnumSet.copyOf(fireOn);
            }
        }
    
        public DefaultCacheEventListenerConfiguration(Set<EventType> fireOn, CacheEventListener<?, ?> listener) {
            super(listener);
            this.eventFiringMode = EventFiring.ASYNCHRONOUS;
            this.eventOrderingMode = EventOrdering.UNORDERED;
            if (fireOn.isEmpty()) {
                throw new IllegalArgumentException("Set of event types to fire on must not be empty");
            } else {
                this.eventsToFireOn = EnumSet.copyOf(fireOn);
            }
        }
    
        public Class<CacheEventListenerProvider> getServiceType() {
    
        public void setEventFiringMode(EventFiring firingMode) {
        public void setEventOrderingMode(EventOrdering orderingMode) {
    
        public EventFiring firingMode() {
        public EventOrdering orderingMode() {
    
        public EnumSet<EventType> fireOn() {
        public boolean compatibleWith(ServiceConfiguration<?, ?> other) {

**CacheEventListenerConfigurationBuilder**

public class CacheEventListenerConfigurationBuilder implements Builder<CacheEventListenerConfiguration<?>> {
        private EventOrdering eventOrdering;          //有序设置
        private EventFiring eventFiringMode;          //同步异步设置
        private Object[] listenerArguments = new Object[0];
        private final EnumSet<EventType> eventsToFireOn;
        private final Class<? extends CacheEventListener<?, ?>> listenerClass;
        private final CacheEventListener<?, ?> listenerInstance;
    
        private CacheEventListenerConfigurationBuilder(EnumSet<EventType> eventsToFireOn, Class<? extends CacheEventListener<?, ?>> listenerClass) {
        private CacheEventListenerConfigurationBuilder(EnumSet<EventType> eventsToFireOn, CacheEventListener<?, ?> listenerInstance) {
        private CacheEventListenerConfigurationBuilder(CacheEventListenerConfigurationBuilder other) {
    
    
        public static CacheEventListenerConfigurationBuilder newEventListenerConfiguration(Class<? extends CacheEventListener<?, ?>> listenerClass, EventType eventType, EventType... eventTypes) {
        public static CacheEventListenerConfigurationBuilder newEventListenerConfiguration(CacheEventListener<?, ?> listener, EventType eventType, EventType... eventTypes) {
        public static CacheEventListenerConfigurationBuilder newEventListenerConfiguration(Class<? extends CacheEventListener<?, ?>> listenerClass, Set<EventType> eventSetToFireOn) throws IllegalArgumentException {
        public static CacheEventListenerConfigurationBuilder newEventListenerConfiguration(CacheEventListener<?, ?> listener, Set<EventType> eventSetToFireOn) throws IllegalArgumentException {
    
    
        public CacheEventListenerConfigurationBuilder constructedWith(Object... arguments) {
    
        public CacheEventListenerConfigurationBuilder eventOrdering(EventOrdering eventOrdering) {
        public CacheEventListenerConfigurationBuilder ordered() {
        public CacheEventListenerConfigurationBuilder unordered() {
    
        public CacheEventListenerConfigurationBuilder firingMode(EventFiring eventFiringMode) {
        public CacheEventListenerConfigurationBuilder synchronous() {
        public CacheEventListenerConfigurationBuilder asynchronous() {
    
        public DefaultCacheEventListenerConfiguration build() {

**EventOrdering**

public enum EventOrdering {
        UNORDERED(false),        //不排序
        ORDERED(true);           //排序
    
        private final boolean ordered;
    
        private EventOrdering(boolean ordered) {
            this.ordered = ordered;
        }
    
        public boolean isOrdered() {
            return this.ordered;
        }
    }

**EventFiring**

public enum EventFiring {
        ASYNCHRONOUS,         //异步
        SYNCHRONOUS;          //同步
    
        private EventFiring() {
        }
    }

### \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* ###

**示例**

class CustomEventListener extends CacheEventAdapter<Integer,String> {
    
        @Override
        protected void onCreation(Integer key, String newValue) {
            System.out.println("添加了缓存：key ==> "+key+" 、value ==> "+newValue);
        }
    
        @Override
        protected void onUpdate(Integer key, String oldValue, String newValue) {
            System.out.println("更新了缓存：key ==> "+key+"  、oldValue ==> "+oldValue+" 、newValue ==> "+newValue);
        }
    }
    
    public class Test6 {
    
        public static void main(String[] args){
            CacheEventListenerConfiguration<?> eventListenerConfiguration=CacheEventListenerConfigurationBuilder
                    .newEventListenerConfiguration(new CustomEventListener(),EventType.CREATED,EventType.UPDATED)
                    .asynchronous().unordered()
                    .build();
    
            CacheManager cacheManager= CacheManagerBuilder.newCacheManagerBuilder()
                    .using(PooledExecutionServiceConfigurationBuilder.newPooledExecutionServiceConfigurationBuilder()
                            .defaultPool("default",5,10)
                            .pool("pool",2,4)
                            .build())
                    .withDefaultEventListenersThreadPool("pool")
                    .withCache("custom", CacheConfigurationBuilder.newCacheConfigurationBuilder(Integer.class,String.class,
                            ResourcePoolsBuilder.newResourcePoolsBuilder()
                            .heap(10, MemoryUnit.MB).build())
                            .withService(eventListenerConfiguration)
                    ).build(true);
    
            Cache<Integer,String> cache=cacheManager.getCache("custom",Integer.class,String.class);
            cache.put(1,"瓜田李下");
            cache.put(1,"瓜田李下 2");
            System.out.println(cache.get(1));
        }
    }

**\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\***

**控制台输出**

23:06:26.923 [main] DEBUG org.ehcache.core.spi.ServiceLocator - Starting 17 Services...
    23:06:26.932 [main] DEBUG org.ehcache.core.internal.statistics.DefaultStatisticsService - Starting service
    23:06:26.949 [main] DEBUG org.ehcache.core.spi.ServiceLocator - All Services successfully started, 17 Services in 29ms
    23:06:26.951 [main] DEBUG org.ehcache.core.EhcacheManager - Creating Cache 'custom' in EhcacheManager.
    23:06:26.962 [main] DEBUG org.ehcache.impl.internal.spi.serialization.DefaultSerializationProvider - Serializer for <java.lang.Integer> : org.ehcache.impl.serialization.IntegerSerializer@13eb8acf
    23:06:26.965 [main] DEBUG org.ehcache.impl.internal.spi.serialization.DefaultSerializationProvider - Serializer for <java.lang.String> : org.ehcache.impl.serialization.StringSerializer@396e2f39
    23:06:26.986 [main] DEBUG org.ehcache.impl.internal.spi.copy.DefaultCopyProvider - Copier for <java.lang.Integer> : org.ehcache.impl.copy.IdentityCopier@4516af24
    23:06:26.987 [main] DEBUG org.ehcache.impl.internal.spi.copy.DefaultCopyProvider - Copier for <java.lang.String> : org.ehcache.impl.copy.IdentityCopier@4ae82894
    23:06:27.001 [main] INFO org.ehcache.sizeof.filters.AnnotationSizeOfFilter - Using regular expression provided through VM argument org.ehcache.sizeof.filters.AnnotationSizeOfFilter.pattern for IgnoreSizeOf annotation : ^.*cache\..*IgnoreSizeOf$
    23:06:27.159 [main] INFO org.ehcache.sizeof.impl.JvmInformation - Detected JVM data model settings of: 64-Bit HotSpot JVM with Compressed OOPs
    23:06:27.237 [main] INFO org.ehcache.sizeof.impl.AgentLoader - Failed to attach to VM and load the agent: class java.io.IOException: Can not attach to current VM
    23:06:27.276 [main] DEBUG org.ehcache.impl.internal.store.heap.OnHeapStore - No expiration strategy detected
    23:06:27.361 [main] DEBUG class org.ehcache.core.Ehcache-custom - Initialize successful.
    23:06:27.361 [main] INFO org.ehcache.core.EhcacheManager - Cache 'custom' created in EhcacheManager.
    23:06:27.361 [main] DEBUG org.ehcache.core.internal.statistics.DefaultStatisticsService - Moving from UNINITIALIZED to AVAILABLE
    23:06:27.361 [main] DEBUG org.ehcache.core.internal.statistics.DefaultStatisticsService - Cache added custom
    23:06:27.393 [main] DEBUG org.ehcache.core.EhcacheManager - Initialize successful.
    23:06:27.400 [main] DEBUG org.ehcache.sizeof.filters.AnnotationSizeOfFilter - org.ehcache.sizeof.annotations.IgnoreSizeOf matched IgnoreSizeOf annotation pattern ^.*cache\..*IgnoreSizeOf$
    添加了缓存：key ==> 1 、value ==> 瓜田李下
    瓜田李下 2
    更新了缓存：key ==> 1  、oldValue ==> 瓜田李下 、newValue ==> 瓜田李下 2