import javax.cache.annotation.CacheResult; //导入依赖的package包/类
/**
 * Return the {@link JavaMailSender} built from the given node.
 * 
 * @param node
 *            The node holding the SMTP configuration.
 * @return the {@link JavaMailSender} built from the given node.
 */
@CacheResult(cacheName = "plugin-data")
public JavaMailSender getMailSender(@CacheKey final String node) {
	final JavaMailSenderImpl mail = new JavaMailSenderImpl();
	final Map<String, String> parameters = pvResource.getNodeParameters(node);
	mail.setUsername(parameters.get(PARAMETER_USER));
	mail.setPassword(parameters.get(PARAMETER_PASSWORD));
	mail.setHost(parameters.get(PARAMETER_HOST));
	mail.setPort(Optional.ofNullable(parameters.get(PARAMETER_PORT)).map(Integer::valueOf).orElse(125));
	mail.setDefaultEncoding("UTF-8");

	final Properties properties = new Properties();
	properties.put("mail.smtp.auth", Boolean.TRUE);
	properties.put("mail.smtp.starttls.enable", Boolean.TRUE);
	properties.put("mail.smtp.quitwait", Boolean.FALSE);
	properties.put("mail.smtp.socketFactory.fallback", Boolean.FALSE);

	mail.setJavaMailProperties(properties);
	return mail;
}
 

import javax.cache.annotation.CacheResult; //导入依赖的package包/类
/**
 * Reset the database cache with the LDAP data.
 */
@CacheResult(cacheName = "ldap")
public Map<LdapData, Map<String, ? extends ResourceOrg>> getLdapData() {
	final Map<LdapData, Map<String, ? extends ResourceOrg>> result = new EnumMap<>(LdapData.class);

	// Fetch LDAP data
	log.info("Fetching LDAP data ...");
	final Map<String, CompanyOrg> companies = getCompany().findAllNoCache();
	final Map<String, GroupOrg> groups = getGroup().findAllNoCache();
	final Map<String, UserOrg> users = getUser().findAllNoCache(groups);
	result.put(LdapData.COMPANY, companies);
	result.put(LdapData.GROUP, groups);
	result.put(LdapData.USER, users);
	ldapCacheDao.reset(companies, groups, users);
	return result;
}
 

import javax.cache.annotation.CacheResult; //导入依赖的package包/类
protected CacheResultOperation createCacheResultOperation(Method method, CacheDefaults defaults, CacheResult ann) {
	String cacheName = determineCacheName(method, defaults, ann.cacheName());
	CacheResolverFactory cacheResolverFactory =
			determineCacheResolverFactory(defaults, ann.cacheResolverFactory());
	KeyGenerator keyGenerator = determineKeyGenerator(defaults, ann.cacheKeyGenerator());

	CacheMethodDetails<CacheResult> methodDetails = createMethodDetails(method, ann, cacheName);

	CacheResolver cacheResolver = getCacheResolver(cacheResolverFactory, methodDetails);
	CacheResolver exceptionCacheResolver = null;
	final String exceptionCacheName = ann.exceptionCacheName();
	if (StringUtils.hasText(exceptionCacheName)) {
		exceptionCacheResolver = getExceptionCacheResolver(cacheResolverFactory, methodDetails);
	}

	return new CacheResultOperation(methodDetails, cacheResolver, keyGenerator, exceptionCacheResolver);
}
 

import javax.cache.annotation.CacheResult; //导入依赖的package包/类
/**
 * Build a user LDAP repository from the given node.
 * 
 * @param node
 *            The node, also used as cache key.
 * @return The {@link UserLdapRepository} instance. Cache is involved.
 */
@CacheResult(cacheName = "ldap-user-repository")
public UserLdapRepository getUserLdapRepository(@CacheKey final String node) {
	log.info("Build ldap template for node {}", node);
	final Map<String, String> parameters = pvResource.getNodeParameters(node);
	final LdapContextSource contextSource = new LdapContextSource();
	contextSource.setReferral(parameters.get(PARAMETER_REFERRAL));
	contextSource.setPassword(parameters.get(PARAMETER_PASSWORD));
	contextSource.setUrl(parameters.get(PARAMETER_URL));
	contextSource.setUserDn(parameters.get(PARAMETER_USER));
	contextSource.setBase(parameters.get(PARAMETER_BASE_BN));
	contextSource.afterPropertiesSet();
	final LdapTemplate template = new LdapTemplate();
	template.setContextSource(contextSource);
	template.setIgnorePartialResultException(true);

	// A new repository instance
	final UserLdapRepository repository = new UserLdapRepository();
	repository.setTemplate(template);
	repository.setPeopleBaseDn(StringUtils.trimToEmpty(parameters.get(PARAMETER_PEOPLE_DN)));
	repository.setPeopleInternalBaseDn(parameters.get(PARAMETER_PEOPLE_INTERNAL_DN));
	repository.setQuarantineBaseDn(StringUtils.trimToEmpty(parameters.get(PARAMETER_QUARANTINE_DN)));
	repository.setDepartmentAttribute(parameters.get(PARAMETER_DEPARTMENT_ATTRIBUTE));
	repository.setLocalIdAttribute(parameters.get(PARAMETER_LOCAL_ID_ATTRIBUTE));
	repository.setUidAttribute(parameters.get(PARAMETER_UID_ATTRIBUTE));
	repository.setLockedAttribute(parameters.get(PARAMETER_LOCKED_ATTRIBUTE));
	repository.setLockedValue(parameters.get(PARAMETER_LOCKED_VALUE));
	repository.setPeopleClass(parameters.get(PARAMETER_PEOPLE_CLASS));
	repository.setCompanyPattern(StringUtils.trimToEmpty(parameters.get(PARAMETER_COMPANY_PATTERN)));

	// Complete the bean
	SpringUtils.getApplicationContext().getAutowireCapableBeanFactory().autowireBean(repository);

	return repository;
}
 

import javax.cache.annotation.CacheResult; //导入依赖的package包/类
@Override
@CacheResult(cacheName = "iam-node-configuration")
public IamConfiguration getConfiguration() {
	final String primary = getPrimary();
	return servicePluginLocator.getResourceExpected(primary, IamConfigurationProvider.class)
			.getConfiguration(primary);
}
 

import javax.cache.annotation.CacheResult; //导入依赖的package包/类
/**
 * Return a specific configuration. System properties overrides the value from the database. Configuration values
 * are
 * always encrypted.
 * 
 * @param name
 *            The requested parameter name.
 * @return a specific configuration. May be <code>null</code>.
 */
@GET
@CacheResult(cacheName = "configuration")
public String get(@CacheKey final String name) {
	String value = System.getProperty(name);
	if (value == null) {
		value = Optional.ofNullable(repository.findByName(name)).map(SystemConfiguration::getValue).orElse(null);
	}
	return Optional.ofNullable(value).map(cryptoHelper::decryptAsNeeded).orElse(null);
}
 

import javax.cache.annotation.CacheResult; //导入依赖的package包/类
@Override
protected JCacheOperation<?> findCacheOperation(Method method, Class<?> targetType) {
	CacheResult cacheResult = method.getAnnotation(CacheResult.class);
	CachePut cachePut = method.getAnnotation(CachePut.class);
	CacheRemove cacheRemove = method.getAnnotation(CacheRemove.class);
	CacheRemoveAll cacheRemoveAll = method.getAnnotation(CacheRemoveAll.class);

	int found = countNonNull(cacheResult, cachePut, cacheRemove, cacheRemoveAll);
	if (found == 0) {
		return null;
	}
	if (found > 1) {
		throw new IllegalStateException("More than one cache annotation found on '" + method + "'");
	}

	CacheDefaults defaults = getCacheDefaults(method, targetType);
	if (cacheResult != null) {
		return createCacheResultOperation(method, defaults, cacheResult);
	}
	else if (cachePut != null) {
		return createCachePutOperation(method, defaults, cachePut);
	}
	else if (cacheRemove != null) {
		return createCacheRemoveOperation(method, defaults, cacheRemove);
	}
	else {
		return createCacheRemoveAllOperation(method, defaults, cacheRemoveAll);
	}
}
 

import javax.cache.annotation.CacheResult; //导入依赖的package包/类
protected CacheResolver getExceptionCacheResolver(CacheResolverFactory factory,
		CacheMethodDetails<CacheResult> details) {

	if (factory != null) {
		javax.cache.annotation.CacheResolver cacheResolver = factory.getExceptionCacheResolver(details);
		return new CacheResolverAdapter(cacheResolver);
	}
	else {
		return getDefaultExceptionCacheResolver();
	}
}
 

import javax.cache.annotation.CacheResult; //导入依赖的package包/类
public CacheResultOperation(CacheMethodDetails<CacheResult> methodDetails, CacheResolver cacheResolver,
		KeyGenerator keyGenerator, CacheResolver exceptionCacheResolver) {

	super(methodDetails, cacheResolver, keyGenerator);
	CacheResult ann = methodDetails.getCacheAnnotation();
	this.exceptionTypeFilter = createExceptionTypeFilter(ann.cachedExceptions(), ann.nonCachedExceptions());
	this.exceptionCacheResolver = exceptionCacheResolver;
	this.exceptionCacheName = (StringUtils.hasText(ann.exceptionCacheName()) ? ann.exceptionCacheName() : null);
}
 

import javax.cache.annotation.CacheResult; //导入依赖的package包/类
@Override
protected CacheResultOperation createSimpleOperation() {
	CacheMethodDetails<CacheResult> methodDetails = create(CacheResult.class,
			SampleObject.class, "simpleGet", Long.class);

	return new CacheResultOperation(methodDetails, defaultCacheResolver, defaultKeyGenerator,
			defaultExceptionCacheResolver);
}
 

import javax.cache.annotation.CacheResult; //导入依赖的package包/类
@Test
public void multiParameterKey() {
	CacheMethodDetails<CacheResult> methodDetails = create(CacheResult.class,
			SampleObject.class, "multiKeysGet", Long.class, Boolean.class, String.class);
	CacheResultOperation operation = createDefaultOperation(methodDetails);

	CacheInvocationParameter[] keyParameters = operation.getKeyParameters(3L, Boolean.TRUE, "Foo");
	assertEquals(2, keyParameters.length);
	assertCacheInvocationParameter(keyParameters[0], Long.class, 3L, 0);
	assertCacheInvocationParameter(keyParameters[1], String.class, "Foo", 2);
}
 

import javax.cache.annotation.CacheResult; //导入依赖的package包/类
@Test
public void invokeWithWrongParameters() {
	CacheMethodDetails<CacheResult> methodDetails = create(CacheResult.class,
			SampleObject.class, "anotherSimpleGet", String.class, Long.class);
	CacheResultOperation operation = createDefaultOperation(methodDetails);

	thrown.expect(IllegalStateException.class);
	operation.getAllParameters("bar"); // missing one argument
}
 

import javax.cache.annotation.CacheResult; //导入依赖的package包/类
@Test
public void tooManyKeyValues() {
	CacheMethodDetails<CacheResult> methodDetails = create(CacheResult.class,
			SampleObject.class, "anotherSimpleGet", String.class, Long.class);
	CacheResultOperation operation = createDefaultOperation(methodDetails);

	thrown.expect(IllegalStateException.class);
	operation.getKeyParameters("bar"); // missing one argument
}
 

import javax.cache.annotation.CacheResult; //导入依赖的package包/类
@Test
public void annotatedGet() {
	CacheMethodDetails<CacheResult> methodDetails = create(CacheResult.class,
			SampleObject.class, "annotatedGet", Long.class, String.class);
	CacheResultOperation operation = createDefaultOperation(methodDetails);
	CacheInvocationParameter[] parameters = operation.getAllParameters(2L, "foo");

	Set<Annotation> firstParameterAnnotations = parameters[0].getAnnotations();
	assertEquals(1, firstParameterAnnotations.size());
	assertEquals(CacheKey.class, firstParameterAnnotations.iterator().next().annotationType());

	Set<Annotation> secondParameterAnnotations = parameters[1].getAnnotations();
	assertEquals(1, secondParameterAnnotations.size());
	assertEquals(Value.class, secondParameterAnnotations.iterator().next().annotationType());
}
 

import javax.cache.annotation.CacheResult; //导入依赖的package包/类
@Test
public void fullGetConfig() {
	CacheMethodDetails<CacheResult> methodDetails = create(CacheResult.class,
			SampleObject.class, "fullGetConfig", Long.class);
	CacheResultOperation operation = createDefaultOperation(methodDetails);
	assertTrue(operation.isAlwaysInvoked());
	assertNotNull(operation.getExceptionTypeFilter());
	assertTrue(operation.getExceptionTypeFilter().match(IOException.class));
	assertFalse(operation.getExceptionTypeFilter().match(NullPointerException.class));
}
 

import javax.cache.annotation.CacheResult; //导入依赖的package包/类
protected DefaultCacheInvocationContext<?> createDummyContext() {
	Method method = ReflectionUtils.findMethod(Sample.class, "get", String.class);
	Assert.notNull(method);
	CacheResult cacheAnnotation = method.getAnnotation(CacheResult.class);
	CacheMethodDetails<CacheResult> methodDetails =
			new DefaultCacheMethodDetails<>(method, cacheAnnotation, "test");
	CacheResultOperation operation = new CacheResultOperation(methodDetails,
			defaultCacheResolver, defaultKeyGenerator, defaultExceptionCacheResolver);
	return new DefaultCacheInvocationContext<CacheResult>(operation, new Sample(), new Object[] {"id"});
}
 

import javax.cache.annotation.CacheResult; //导入依赖的package包/类
@CacheResult( cacheName = CACHE_NAME )
public double sqrt(int a) {
	final double b = Math.sqrt(a);
	if (LOG.isDebugEnabled()) {
		LOG.debug("[CALCULATED] sqrt({}) = {}", a, b);
	}
	return b;
}
 

import javax.cache.annotation.CacheResult; //导入依赖的package包/类
@CacheResult(cacheName = "Di18n")
// All parameters will be used as cache keys
public String find(String key, String baseBundle, String language) {

  Iterable<Di18n> iterator = queryIterable(false, 0,
      1, null,
      Di18nMapper.Field.KEY.getFieldName(), false,
      null, false,
      Filter.equalsFilter(Di18nMapper.Field.KEY.getFieldName(), key),
      Filter.equalsFilter(Di18nMapper.Field.BASEBUNDLE.getFieldName(), baseBundle),
      Filter.equalsFilter(Di18nMapper.Field.LOCALE.getFieldName(), language));

  return iterator.iterator().hasNext() ? iterator.iterator().next().getLocalizedMessage() : null;

}
 

import javax.cache.annotation.CacheResult; //导入依赖的package包/类
@CacheResult
public int add(int a, int b) {
    try {
        TimeUnit.SECONDS.sleep(3L);
    } catch (InterruptedException e) {
    }

    return a + b;
}
 

import javax.cache.annotation.CacheResult; //导入依赖的package包/类
@GET
@Path("add")
@Produces(MediaType.TEXT_PLAIN)
@CacheResult(cacheName = "calcCache")
public int add(@QueryParam("a") int a, @QueryParam("b") int b) throws InterruptedException {
    TimeUnit.SECONDS.sleep(3);

    return a + b;
}