import org.ehcache.xml.XmlConfiguration; //导入依赖的package包/类
public static void main(String[] args) {
  LOGGER.info("Creating cache manager via XML resource");
  Configuration xmlConfig = new XmlConfiguration(BasicXML.class.getResource("/ehcache.xml"));
  try (CacheManager cacheManager = newCacheManager(xmlConfig)) {
    cacheManager.init();

    Cache<Long, String> basicCache = cacheManager.getCache("basicCache", Long.class, String.class);

    LOGGER.info("Putting to cache");
    basicCache.put(1L, "da one!");
    String value = basicCache.get(1L);
    LOGGER.info("Retrieved '{}'", value);

    LOGGER.info("Closing cache manager");
  }

  LOGGER.info("Exiting");
}
 

import org.ehcache.xml.XmlConfiguration; //导入依赖的package包/类
public static void main(String[] args) {
  LOGGER.info("Creating clustered cache manager from XML");
  final URL myUrl = ClusteredXML.class.getResource("/ehcache.xml");
  Configuration xmlConfig = new XmlConfiguration(myUrl);
  try (CacheManager cacheManager = newCacheManager(xmlConfig)) {
    cacheManager.init();
    
    Cache<Long, String> basicCache = cacheManager.getCache("basicCache", Long.class, String.class);
    
    LOGGER.info("Getting from cache");
    String value = basicCache.get(1L);
    LOGGER.info("Retrieved '{}'", value);

    LOGGER.info("Closing cache manager");
  }

  LOGGER.info("Exiting");
}
 

import org.ehcache.xml.XmlConfiguration; //导入依赖的package包/类
CacheManager createCacheManager() throws IOException {
    CacheManager manager;

    if (cacheManager != null) {
        manager = cacheManager;
    } else if (configUri != null) {
        manager = CacheManagerBuilder.newCacheManager(new XmlConfiguration(getConfigUriAsUrl()));
    } else {
        CacheManagerBuilder builder = CacheManagerBuilder.newCacheManagerBuilder();
        if (configuration != null) {
            builder.withCache(cacheName, configuration);
        }

        manager = builder.build();
    }

    return manager;
}
 

import org.ehcache.xml.XmlConfiguration; //导入依赖的package包/类
@Test
public void jsr107DefaultEh107IdentityCopierForImmutableTypesWithCMLevelDefaults() {
  XmlConfiguration xmlConfiguration = new XmlConfiguration(getClass().getResource("/ehcache-107-immutable-types-cm-level-copiers.xml"));
  final DefaultJsr107Service jsr107Service = new DefaultJsr107Service(ServiceUtils.findSingletonAmongst(Jsr107Configuration.class, xmlConfiguration.getServiceCreationConfigurations().toArray()));
  merger = new ConfigurationMerger(xmlConfiguration, jsr107Service, mock(Eh107CacheLoaderWriterProvider.class));

  MutableConfiguration<Long, String> stringCacheConfiguration  = new MutableConfiguration<>();
  stringCacheConfiguration.setTypes(Long.class, String.class);
  ConfigurationMerger.ConfigHolder<Long, String> configHolder1 = merger.mergeConfigurations("stringCache", stringCacheConfiguration);

  assertThat(configHolder1.cacheConfiguration.getServiceConfigurations().isEmpty(), is(true));

  for (ServiceCreationConfiguration<?> serviceCreationConfiguration : xmlConfiguration.getServiceCreationConfigurations()) {
    if (serviceCreationConfiguration instanceof DefaultCopyProviderConfiguration) {
      DefaultCopyProviderConfiguration copierConfig = (DefaultCopyProviderConfiguration)serviceCreationConfiguration;
      assertThat(copierConfig.getDefaults().size(), is(6));
      assertThat(copierConfig.getDefaults().get(Long.class).getClazz().isAssignableFrom(IdentityCopier.class), is(true));
      assertThat(copierConfig.getDefaults().get(String.class).getClazz().isAssignableFrom(Eh107IdentityCopier.class), is(true));
      assertThat(copierConfig.getDefaults().get(Float.class).getClazz().isAssignableFrom(Eh107IdentityCopier.class), is(true));
      assertThat(copierConfig.getDefaults().get(Double.class).getClazz().isAssignableFrom(Eh107IdentityCopier.class), is(true));
      assertThat(copierConfig.getDefaults().get(Character.class).getClazz().isAssignableFrom(Eh107IdentityCopier.class), is(true));
      assertThat(copierConfig.getDefaults().get(Integer.class).getClazz().isAssignableFrom(Eh107IdentityCopier.class), is(true));
    }
  }
}
 

import org.ehcache.xml.XmlConfiguration; //导入依赖的package包/类
@Override
protected void doPreSetup() throws Exception {
    final URL url = this.getClass().getResource(EHCACHE_CONFIG);
    final Configuration xmlConfig = new XmlConfiguration(url);

    cacheManager = CacheManagerBuilder.newCacheManager(xmlConfig);
    cacheManager.init();
}
 

import org.ehcache.xml.XmlConfiguration; //导入依赖的package包/类
@Test
public void test_config_loaded() throws Exception {
  CacheManager myCacheManager = CacheManagerBuilder.newCacheManager(new XmlConfiguration(getClass().getClassLoader().getResource(xml)));
  myCacheManager.init();
  try {
    DefaultManagementRegistryConfiguration registryConfiguration = null;

    for (ServiceCreationConfiguration<?> configuration : myCacheManager.getRuntimeConfiguration().getServiceCreationConfigurations()) {
      if (configuration instanceof DefaultManagementRegistryConfiguration) {
        registryConfiguration = (DefaultManagementRegistryConfiguration) configuration;
        break;
      }
    }

    assertThat(registryConfiguration, is(not(nullValue())));

    // 1st test: CM alia not set, so generated
    if (xml.endsWith("-1.xml")) {
      expectedConfiguration.setCacheManagerAlias(registryConfiguration.getContext().get("cacheManagerName"));
    }

    assertThat(registryConfiguration, equalTo(expectedConfiguration));

  } finally {
    myCacheManager.close();
  }
}
 

import org.ehcache.xml.XmlConfiguration; //导入依赖的package包/类
@Test
public void xmlConfigSample() throws Exception {
  // tag::xmlConfig[]
  final URL myUrl = getClass().getResource("/configs/docs/getting-started.xml"); // <1>
  XmlConfiguration xmlConfig = new XmlConfiguration(myUrl); // <2>
  CacheManager myCacheManager = CacheManagerBuilder.newCacheManager(xmlConfig); // <3>
  myCacheManager.init();  // <4>
  // end::xmlConfig[]
}
 

import org.ehcache.xml.XmlConfiguration; //导入依赖的package包/类
@Test
public void xmlTemplateSample() throws Exception {
  // tag::xmlTemplate[]
  XmlConfiguration xmlConfiguration = new XmlConfiguration(getClass().getResource("/configs/docs/template-sample.xml"));
  CacheConfigurationBuilder<Long, String> configurationBuilder = xmlConfiguration.newCacheConfigurationBuilderFromTemplate("example", Long.class, String.class); // <1>
  configurationBuilder = configurationBuilder.withResourcePools(ResourcePoolsBuilder.heap(1000)); // <2>
  // end::xmlTemplate[]
}
 

import org.ehcache.xml.XmlConfiguration; //导入依赖的package包/类
ConfigurationMerger(org.ehcache.config.Configuration ehConfig, Jsr107Service jsr107Service, Eh107CacheLoaderWriterProvider cacheLoaderWriterFactory) {
  if (ehConfig instanceof XmlConfiguration) {
    xmlConfiguration = (XmlConfiguration) ehConfig;
  } else {
    xmlConfiguration = null;
  }
  this.jsr107Service = jsr107Service;
  this.cacheLoaderWriterFactory = cacheLoaderWriterFactory;
}
 

import org.ehcache.xml.XmlConfiguration; //导入依赖的package包/类
@Test
public void testConfigParse() throws ClassNotFoundException, SAXException, InstantiationException, IllegalAccessException, IOException {
  final XmlConfiguration configuration = new XmlConfiguration(this.getClass().getResource("/ehcache-107.xml"));
  final DefaultJsr107Service jsr107Service = new DefaultJsr107Service(ServiceUtils.findSingletonAmongst(Jsr107Configuration.class, configuration.getServiceCreationConfigurations().toArray()));

  final CacheManager cacheManager = new EhcacheManager(configuration, Collections.<Service>singletonList(jsr107Service));
  cacheManager.init();

  assertThat(jsr107Service.getTemplateNameForCache("foos"), equalTo("stringCache"));
  assertThat(jsr107Service.getTemplateNameForCache("bars"), equalTo("tinyCache"));
}
 

import org.ehcache.xml.XmlConfiguration; //导入依赖的package包/类
@Before
public void setUp() {
  xmlConfiguration = mock(XmlConfiguration.class);
  jsr107Service = mock(Jsr107Service.class);
  cacheLoaderWriterFactory = mock(Eh107CacheLoaderWriterProvider.class);
  merger = new ConfigurationMerger(xmlConfiguration, jsr107Service, cacheLoaderWriterFactory);
}
 

import org.ehcache.xml.XmlConfiguration; //导入依赖的package包/类
@Test
public void jsr107DefaultEh107IdentityCopierForImmutableTypes() {
  XmlConfiguration xmlConfiguration = new XmlConfiguration(getClass().getResource("/ehcache-107-copiers-immutable-types.xml"));
  final DefaultJsr107Service jsr107Service = new DefaultJsr107Service(ServiceUtils.findSingletonAmongst(Jsr107Configuration.class, xmlConfiguration.getServiceCreationConfigurations().toArray()));
  merger = new ConfigurationMerger(xmlConfiguration, jsr107Service, mock(Eh107CacheLoaderWriterProvider.class));

  MutableConfiguration<Long, String> stringCacheConfiguration  = new MutableConfiguration<>();
  stringCacheConfiguration.setTypes(Long.class, String.class);
  ConfigurationMerger.ConfigHolder<Long, String> configHolder1 = merger.mergeConfigurations("stringCache", stringCacheConfiguration);

  assertDefaultCopier(configHolder1.cacheConfiguration.getServiceConfigurations());

  MutableConfiguration<Long, Double> doubleCacheConfiguration  = new MutableConfiguration<>();
  doubleCacheConfiguration.setTypes(Long.class, Double.class);
  ConfigurationMerger.ConfigHolder<Long, Double> configHolder2 = merger.mergeConfigurations("doubleCache", doubleCacheConfiguration);

  assertDefaultCopier(configHolder2.cacheConfiguration.getServiceConfigurations());

  MutableConfiguration<Long, Character> charCacheConfiguration  = new MutableConfiguration<>();
  charCacheConfiguration.setTypes(Long.class, Character.class);
  ConfigurationMerger.ConfigHolder<Long, Character> configHolder3 = merger.mergeConfigurations("charCache", charCacheConfiguration);

  assertDefaultCopier(configHolder3.cacheConfiguration.getServiceConfigurations());

  MutableConfiguration<Long, Float> floatCacheConfiguration  = new MutableConfiguration<>();
  floatCacheConfiguration.setTypes(Long.class, Float.class);
  ConfigurationMerger.ConfigHolder<Long, Float> configHolder4 = merger.mergeConfigurations("floatCache", floatCacheConfiguration);

  assertDefaultCopier(configHolder4.cacheConfiguration.getServiceConfigurations());

  MutableConfiguration<Long, Integer> integerCacheConfiguration  = new MutableConfiguration<>();
  integerCacheConfiguration.setTypes(Long.class, Integer.class);
  ConfigurationMerger.ConfigHolder<Long, Integer> configHolder5 = merger.mergeConfigurations("integerCache", integerCacheConfiguration);

  assertDefaultCopier(configHolder5.cacheConfiguration.getServiceConfigurations());

}
 

import org.ehcache.xml.XmlConfiguration; //导入依赖的package包/类
@Test
public void testXACacheWithXMLConfig() throws Exception {
  // tag::testXACacheWithXMLConfig[]
  BitronixTransactionManager transactionManager =
      TransactionManagerServices.getTransactionManager(); // <1>

  URL myUrl = this.getClass().getResource("/docs/configs/xa-getting-started.xml"); // <2>
  Configuration xmlConfig = new XmlConfiguration(myUrl); // <3>
  CacheManager myCacheManager = CacheManagerBuilder.newCacheManager(xmlConfig); // <4>
  myCacheManager.init();

  myCacheManager.close();
  transactionManager.shutdown();
  // end::testXACacheWithXMLConfig[]
}
 

import org.ehcache.xml.XmlConfiguration; //导入依赖的package包/类
@Test
public void testSimpleConfig() throws Exception {
  TransactionManagerServices.getConfiguration().setJournal("null").setServerId("XmlConfigTest");
  BitronixTransactionManager transactionManager = TransactionManagerServices.getTransactionManager();

  final URL myUrl = this.getClass().getResource("/configs/simple-xa.xml");
  Configuration xmlConfig = new XmlConfiguration(myUrl);
  CacheManager myCacheManager = CacheManagerBuilder.newCacheManager(xmlConfig);
  myCacheManager.init();

  myCacheManager.close();
  transactionManager.shutdown();
}
 

import org.ehcache.xml.XmlConfiguration; //导入依赖的package包/类
@Test
public void testTemplateConfigOverride() throws Exception {
  final URL myUrl = this.getClass().getResource("/configs/template-xa.xml");
  Configuration xmlConfig = new XmlConfiguration(myUrl);
  CacheConfiguration<?, ?> cacheConfiguration = xmlConfig.getCacheConfigurations().get("xaCache1");
  XAStoreConfiguration xaStoreConfiguration = ServiceUtils.findSingletonAmongst(XAStoreConfiguration.class, cacheConfiguration
      .getServiceConfigurations());

  assertThat(xaStoreConfiguration.getUniqueXAResourceId(), is("xaCache1"));
}
 

import org.ehcache.xml.XmlConfiguration; //导入依赖的package包/类
@Test
public void testCanLoadXmlConfigValidForHA() {
  XmlConfiguration xmlConfiguration = new XmlConfiguration(getClass().getResource("/configs/cluster-ha.xml"));
  ClusteringServiceConfiguration config = ServiceUtils.findSingletonAmongst(ClusteringServiceConfiguration.class, xmlConfiguration
    .getServiceCreationConfigurations());
  assertThat(config.getClusterUri().toString(), containsString("example.com:9540,example.com:9640"));
}
 

import org.ehcache.xml.XmlConfiguration; //导入依赖的package包/类
@Test
public void testFailsWithInvalidClusterUri() {
  try {
    new XmlConfiguration(getClass().getResource("/configs/cluster-invalid-uri.xml"));
  } catch (XmlConfigurationException e) {
    assertThat(e.getCause().getMessage(), containsString("not facet-valid with respect to pattern"));
  }
}
 

import org.ehcache.xml.XmlConfiguration; //导入依赖的package包/类
@Test
public void testViaXml() throws Exception {
  final Configuration configuration = new XmlConfiguration(this.getClass().getResource(SIMPLE_CLUSTER_XML));
  final CacheManager cacheManager = CacheManagerBuilder.newCacheManager(configuration);

  assertThat(cacheManager, is(instanceOf(PersistentCacheManager.class)));

  cacheManager.init();

  final Cache<Long, String> cache = cacheManager.getCache("simple-cache", Long.class, String.class);
  assertThat(cache, is(not(nullValue())));

  cacheManager.close();
}
 

import org.ehcache.xml.XmlConfiguration; //导入依赖的package包/类
@Test
public void testGetUnknownCacheInvalidAttribute() {
  try {
    new XmlConfiguration(this.getClass().getResource("/configs/unknown-cluster-cache-invalid-attribute.xml"));
    fail("Expected XmlConfigurationException");
  } catch(XmlConfigurationException xce) {
    Assert.assertThat(xce.getCause().getMessage(), endsWith("Attribute 'unit' is not allowed to appear in element 'tc:clustered'."));
  }
}
 

import org.ehcache.xml.XmlConfiguration; //导入依赖的package包/类
@Test
public void testGetUnknownCacheInvalidElement() {
  try {
    new XmlConfiguration(this.getClass().getResource("/configs/unknown-cluster-cache-invalid-element.xml"));
    fail("Expected XmlConfigurationException");
  } catch(XmlConfigurationException xce) {
    Assert.assertThat(xce.getCause().getMessage(), endsWith("Element 'tc:clustered' must have no character or element information item [children], because the type's content type is empty."));
  }
}