Ehcache源码解析——配置文件解析

最新推荐文章于 2018-04-24 09:52:15 发布
原创 最新推荐文章于 2018-04-24 09:52:15 发布 · 1.1k 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#ehcache #sax

本文介绍了Ehcache如何通过BeanHandler将ehcache.xml配置文件解析为Configuration对象的过程。BeanHandler利用反射机制，根据XML标签名查找对应的set或add方法，并实例化对象。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

首先，我们来看看Ehcache的初始化时序图。
这里写图片描述

从时序图可以看出，Ehcache内部是使用SAX来解析配置文件的。

一般来说，XML文件的解析就是将配置文件解析成配置对象，下面是Ehcache的配置文件和配置类。

ehcache.xml

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="ehcache.xsd"
         updateCheck="true" monitoring="autodetect"
         dynamicConfig="true">
    <cacheManagerEventListenerFactory class="" properties=""/>

    <cache name="userCache"
           maxElementsInMemory="400"
           overflowToDisk="false"
           eternal="false"
           timeToIdleSeconds="0"
           timeToLiveSeconds="0"
           memoryStoreEvictionPolicy="LRU">
     </cache>
</ehcache>
public final class Configuration {
    private String cacheManagerName;
    private boolean updateCheck = true;
    private int defaultTransactionTimeoutInSeconds = 15;
    private Monitoring monitoring = Monitoring.AUTODETECT;

    //缓存配置
    private CacheConfiguration defaultCacheConfiguration;
    private final Map<String, CacheConfiguration> cacheConfigurations;

    //分布式缓存的一些配置
    private FactoryConfiguration cacheManagerEventListenerFactoryConfiguration;
    private TerracottaClientConfiguration terracottaConfigConfiguration;
    private ManagementRESTServiceConfiguration managementRESTService;
    private final List<FactoryConfiguration> cacheManagerPeerProviderFactoryConfiguration;
    private final List<FactoryConfiguration> cacheManagerPeerListenerFactoryConfiguration;
    private SizeOfPolicyConfiguration sizeOfPolicyConfiguration;
    private FactoryConfiguration transactionManagerLookupConfiguration;

    private ConfigurationSource configurationSource;
    private boolean dynamicConfig = true;
    private Long maxBytesLocalHeap;
    private String maxBytesLocalHeapInput;
    private Long maxBytesLocalOffHeap;
    private String maxBytesLocalOffHeapInput;
    private Long maxBytesLocalDisk;
    private String maxBytesLocalDiskInput;
}

那么，ehcache是如何将ehcache.xml转换为Configuration对象的呢？

这个是通过BeanHandler来完成的，BeanHandler主要采用做了下面几件事情：

  1. 逐行解析标签，通过标签名称找到该标签在Configuration对象中的set或者add方法，然后根据方法的第一个参数使用反射实例化一个对象
  2. 通过反射，将标签的属性添加到具体的对象中
final class BeanHandler extends DefaultHandler {

    private static final Logger LOG = LoggerFactory.getLogger(BeanHandler.class.getName());
    private final Object bean;
    private ElementInfo element;
    private Locator locator;

    public BeanHandler(final Object bean) {
        this.bean = bean;
    }

    @Override
    public final void startElement(final String uri,final String localName,final String qName,final Attributes attributes)throws SAXException {
        if (extractingSubtree() || startExtractingSubtree(getTagPart(qName))) {
            //……
        } else {
            //每次遇到新的起始标签时，创建新的ElementInfo对象，并关联它的父标签对象
            if (element == null) {
                element = new ElementInfo(qName, bean);
            } else {
                //通过标签名称，找到Configuration类中的set或者add方法，然后通过该方法的第一个参数实例化一个对象，最后调用set或者add方法。
                final Object child = createChild(element, qName);
                element = new ElementInfo(element, qName, child);
            }

            // 为新的ElementInfo对象添加属性
            for (int i = 0; i < attributes.getLength(); i++) {
                final String attrName = attributes.getQName(i);
                final String attrValue = attributes.getValue(i);
                setAttribute(element, attrName, attrValue);
            }
        }
    }


    @Override
    public final void endElement(final String uri,final String localName,final String qName)throws SAXException {
        if (element.parent != null) {
            if (extractingSubtree()) {
                //……
            } else {
                addChild(element.parent.bean, element.bean, qName);
            }
        }
        element = element.parent;
    }

    @Override
    public void characters(char[] ch, int start, int length)
            throws SAXException {
        if (extractingSubtree()) {
            appendToSubtree(ch, start, length);
        }
    }

    private Object createChild(final ElementInfo parent, final String name) throws SAXException {
        try {
            // Look for a create<name> method
            final Class parentClass = parent.bean.getClass();
            Method method = findCreateMethod(parentClass, name);
            if (method != null) {
                return method.invoke(parent.bean, new Object[] {});
            }

            // Look for an add<name> method
            method = findSetMethod(parentClass, "add", name);
            if (method != null) {
                return createInstance(parent.bean, method.getParameterTypes()[0]);
            }
        } catch (final Exception e) {
            throw new SAXException(getLocation() + ": Could not create nested element <" + name + ">.", e);
        }
    }


    private static Object createInstance(Object parent, Class childClass)
            throws Exception {
        final Constructor[] constructors = childClass.getDeclaredConstructors();
        ArrayList candidates = new ArrayList();
        for (final Constructor constructor : constructors) {
            final Class[] params = constructor.getParameterTypes();
            if (params.length == 0) {
                candidates.add(constructor);
            } else if (params.length == 1 && params[0].isInstance(parent)) {
                candidates.add(constructor);
            }
        }
        switch (candidates.size()) {
            case 0:
                throw new Exception("No constructor for class " + childClass.getName());
            case 1:
                break;
            default:
                throw new Exception("Multiple constructors for class " + childClass.getName());
        }

        final Constructor constructor = (Constructor) candidates.remove(0);
        constructor.setAccessible(true);
        if (constructor.getParameterTypes().length == 0) {
            return constructor.newInstance(new Object[] {});
        } else {
            return constructor.newInstance(new Object[]{parent});
        }
    }

    private static Method findCreateMethod(Class objClass, String name) {
        final String methodName = makeMethodName("create", name);
        final Method[] methods = objClass.getMethods();
        for (final Method method : methods) {
            if (!method.getName().equals(methodName)) {
                continue;
            }
            if (Modifier.isStatic(method.getModifiers())) {
                continue;
            }
            if (method.getParameterTypes().length != 0) {
                continue;
            }
            if (method.getReturnType().isPrimitive() || method.getReturnType().isArray()) {
                continue;
            }
            return method;
        }
        return null;
    }

    private void setAttribute(final ElementInfo element,final String attrName,final String attrValue) throws SAXException {
        try {
            final Class objClass = element.bean.getClass();
            final Method method = chooseSetMethod(objClass, "set", attrName, String.class);
            if (method != null) {
                final Object realValue = convert(attrName, method.getParameterTypes()[0], attrValue);
                method.invoke(element.bean, new Object[]{realValue});
                return;
            } else {
                if (element.elementName.equals("ehcache")) {
                    LOG.debug("Ignoring ehcache attribute {}", attrName);
                    return;
                }
            }
        } catch (final InvocationTargetException e) {
            //……
        } catch (final Exception e) {
            //……
        }
         //……
    }

    private Method findSetMethod(final Class objClass,final String prefix,final String name)throws Exception {
        final String methodName = makeMethodName(prefix, name);
        final Method[] methods = objClass.getMethods();
        Method candidate = null;
        for (final Method method : methods) {
            if (!method.getName().equals(methodName)) {
                continue;
            }
            if (Modifier.isStatic(method.getModifiers())) {
                continue;
            }
            if (method.getParameterTypes().length != 1) {
                continue;
            }
            if (!method.getReturnType().equals(Void.TYPE)) {
                continue;
            }
            if (candidate != null) {
                throw new Exception("Multiple " + methodName + "() methods in class " + objClass.getName() + ".");
            }
            candidate = method;
        }

        return candidate;
    }

    private void addChild(final Object parent,final Object child,final String name)throws SAXException {
        try {
            // Look for an add<name> method on the parent
            final Method method = findSetMethod(parent.getClass(), "add", name);
            if (method != null) {
                method.invoke(parent, new Object[]{child});
            }
        } catch (final InvocationTargetException e) {
            final SAXException exc = new SAXException(getLocation() + ": Could not finish element <" + name + ">." +
                    " Message was: " + e.getTargetException());
            throw exc;
        } catch (final Exception e) {
            throw new SAXException(getLocation() + ": Could not finish element <" + name + ">.");
        }
    }

    private static final class ElementInfo {
        private final ElementInfo parent;
        private final String elementName;
        private final Object bean;

        public ElementInfo(final String elementName, final Object bean) {
            parent = null;
            this.elementName = elementName;
            this.bean = bean;
        }

        public ElementInfo(final ElementInfo parent, final String elementName, final Object bean) {
            this.parent = parent;
            this.elementName = elementName;
            this.bean = bean;
        }
    }
}

BeanHandler有下面几点值得我们学习：

  1. 解析过程全部使用反射，无须关心具体的标签
  2. Configuration需要提供set或add方法
Spring Cloud 微服务开发：入门、进阶与源码剖析 —— 7.2 技术实战
极客挖掘机
02-04 1942
7.2 技术实战 7.2.1 数据访问层 工程ch7_1_data_service，项目依赖pom.xml如下： 代码清单：ch7_1/ch7_1_data_service/pom.xml <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xml...
ehcache(Java缓存框架 EhCache)源码
05-15
ehcache(Java缓存框架 EhCache)源码
Ehcache注解核心逻辑源码学习
iteye_4143的博客
10-31 341
Ehcache支持方法注解方式管理缓存，使代码的侵入性很小。最常用的Ehcache注解是@Cacheable、@CacheEvict、@CachePut 本文通过分析源码整理了这几个注解的实现逻辑和关系，并指出一些组合使用时的限制   1注解类源码 1.1@Cacheable /** * Cacheable注解缓存方法（或类的所有方法）返回值，缓存Key是方法本身和参数的组合签名...
ehcache学习源码
07-13
ehcache学习源码
RMI方式Ehcache集群的源码分析
热门推荐
西代零零发
09-21 1万+
Ehcache不仅支持基本的内存缓存，还支持多种方式将本地内存中的缓存同步到其他使用Ehcache的服务器中，形成集群。如下图所示： Ehcache支持多种集群方式，下面以RMI通信方式为例，来具体分析一下Ehcache集群的源码。 1服务Provider Ehcache支持两种服务发现方式：一种是通过广播的方式，服务间自动发现，动态更新存活服务的列表；另一种就是
ehcache2.4源码分析 ---- 持久化
slqprrx的专栏
12-15 219
参数： overflowToDisk="true" 当为true时会持久化到硬盘，并非超出内存最大数时才会 diskPersistent="true" 当为false时，manager.shutdown()时会清空硬盘文件，下次启动时不会读取。为true时，manager.shutdown()时会保留硬盘文件，下次启动会读取。 当缓存为可持久化时，会用到这个工具 net.sf.eh...
深入探讨ehcache缓存机制-MethodCacheInterceptor实例解析
在本文中，我们将详细探讨Ehcache中一个特定的缓存实现机制——MethodCacheInterceptor，该机制允许开发者通过拦截器的形式缓存方法的返回结果。 ### Ehcache的基本概念 在深入分析MethodCacheInterceptor之前，...
ehcache缓存对象
07-26
3. **缓存配置**：Ehcache支持XML配置文件和编程式配置。配置包括缓存的大小、内存和磁盘存储策略、缓存的存活时间和过期时间等。 4. **API使用**：Ehcache提供了简单的API，如`put()`用于添加缓存项，`get()`用于...
memcached完全剖析ehcache memcached redis 缓存技术总结
06-01
8. **源码分析** - 针对开发人员，可能有对这些缓存系统关键组件的源码解析，帮助理解其内部运作机制。 9. **安全性与管理** - 讨论如何确保缓存的安全性，以及监控和管理缓存的方法。 10. **最佳实践** - 提供...
Mybatis-Plus源码深度解析：揭秘Bound Statement的幕后创建者
[Mybatis-Plus源码深度解析：揭秘Bound Statement的幕后创建者](https://opengraph.githubassets.com/734804c02550655776622e38204c60bbd20cde388ac316d1473c62fa136fd66a/baomidou/mybatis-plus) # 摘要 Mybatis-...
ehcache.jar及源码
02-28
ehcache所需的ehcache-core-2.5.2.jar及其源码ehcache-core-2.5.2-sources.jar
ehcache2-7-3 源码
08-10
ehcache-2.7.3-distribution.tar.gz
Spring+EhCache实例源码
01-12
Spring+EhCache实例源码，本实例的环境 eclipse + maven + spring + ehcache + junit，实例详解请访问博主博客：http://blog.youkuaiyun.com/u013142781
ehcache技术详解
11-28
ehcache技术详解,包括ehcache安装部署，已经常见的用法
ehcache配置文件
01-19
配置SSH框架是有关于ehcahe文件
Ehcache BlockingCache 源码分析
weixin_34055910的博客
02-13 123
BlockingCache是对Ehcache进行的扩展,BlockingCache内置了读写锁，不需要用户显示调用。 要彻底分析BlockingCache的原理，需要首先来看一下它内部用到的一些类。 //锁的管理器接口 public interface CacheLockProvider { /** * 根据key获取锁 * 这个实现需要保证给定相同的k...
Ehcache源代码阅读
theking
10-23 657
1. 配置文件解析 由标准的SAX方式解析ehcache.xml到一个Configuration对象。关键类是BeanHandler+Configuration。BeanHandler的技巧在于xml tag/property与java bean的名称约定，找到一个tag就直接用tag名找到对应的add/extract/set方法call进去。类写的短小精悍，坏处是每个java类的写法都要受到限制...
ehcache3-源码简析三
weixin_30517001的博客
08-24 288
ehcache3的evict策略是怎样的呢？从put操作可以一窥，这里以单层heap cache为例。 ehcache3的evict策略不可设置，只能通过eviction-advisor建议evict，但这种建议得不到保证且低效。ehcache3的evict策略其实是一种基于样本的LRU算法，即在全量数据中采集一定数量样本（默认为8），在样本集中选取lastAccessTime最小的进行evic...
Ehcache源码解析——存储组件
根号三
04-24 989
Ehcache存储组件类依赖关系如下：
Ehcache 2.5.2核心包配置文件与结构解析
在ehcache.xml配置文件中，可以看到一个超链接配置，这个超链接实际上指向ehcache.xsd文件，它允许开发人员或配置管理员通过编辑ehcache.xml文件来自定义缓存的行为。比如，用户可以配置缓存的生命周期管理策略、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值