Skip to content
体验新版
项目
组织
正在加载...
登录
切换导航
打开侧边栏
爱吃血肠
spring-framework
提交
3699a037
S
spring-framework
项目概览
爱吃血肠
/
spring-framework
通知
1
Star
0
Fork
0
代码
文件
提交
分支
Tags
贡献者
分支图
Diff
Issue
0
列表
看板
标记
里程碑
合并请求
0
Wiki
0
Wiki
分析
仓库
DevOps
项目成员
Pages
S
spring-framework
项目概览
项目概览
详情
发布
仓库
仓库
文件
提交
分支
标签
贡献者
分支图
比较
Issue
0
Issue
0
列表
看板
标记
里程碑
合并请求
0
合并请求
0
Pages
分析
分析
仓库分析
DevOps
Wiki
0
Wiki
成员
成员
收起侧边栏
关闭侧边栏
动态
分支图
创建新Issue
提交
Issue看板
体验新版 GitCode,发现更多精彩内容 >>
提交
3699a037
编写于
5月 17, 2011
作者:
C
Costin Leau
浏览文件
操作
浏览文件
下载
电子邮件补丁
差异文件
revise cache API
+ add missing files (remember to check "show unversioned files")
上级
0b917e3f
变更
10
隐藏空白更改
内联
并排
Showing
10 changed file
with
809 addition
and
0 deletion
+809
-0
org.springframework.context/src/main/java/org/springframework/cache/annotation/AnnotationCacheOperationSource.java
...work/cache/annotation/AnnotationCacheOperationSource.java
+123
-0
org.springframework.context/src/main/java/org/springframework/cache/interceptor/AbstractFallbackCacheOperationSource.java
...che/interceptor/AbstractFallbackCacheOperationSource.java
+218
-0
org.springframework.context/src/main/java/org/springframework/cache/interceptor/BeanFactoryCacheOperationSourceAdvisor.java
...e/interceptor/BeanFactoryCacheOperationSourceAdvisor.java
+62
-0
org.springframework.context/src/main/java/org/springframework/cache/interceptor/CacheEvictOperation.java
...pringframework/cache/interceptor/CacheEvictOperation.java
+43
-0
org.springframework.context/src/main/java/org/springframework/cache/interceptor/CacheOperation.java
...org/springframework/cache/interceptor/CacheOperation.java
+128
-0
org.springframework.context/src/main/java/org/springframework/cache/interceptor/CacheOperationSource.java
...ringframework/cache/interceptor/CacheOperationSource.java
+41
-0
org.springframework.context/src/main/java/org/springframework/cache/interceptor/CacheOperationSourcePointcut.java
...ework/cache/interceptor/CacheOperationSourcePointcut.java
+68
-0
org.springframework.context/src/main/java/org/springframework/cache/interceptor/CacheUpdateOperation.java
...ringframework/cache/interceptor/CacheUpdateOperation.java
+26
-0
org.springframework.context/src/main/java/org/springframework/cache/interceptor/CompositeCacheOperationSource.java
...work/cache/interceptor/CompositeCacheOperationSource.java
+63
-0
org.springframework.context/src/main/java/org/springframework/cache/interceptor/DefaultValue.java
...a/org/springframework/cache/interceptor/DefaultValue.java
+37
-0
未找到文件。
org.springframework.context/src/main/java/org/springframework/cache/annotation/AnnotationCacheOperationSource.java
0 → 100644
浏览文件 @
3699a037
/*
* Copyright 2010-2011 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.annotation
;
import
java.io.Serializable
;
import
java.lang.reflect.AnnotatedElement
;
import
java.lang.reflect.Method
;
import
java.util.Collections
;
import
java.util.LinkedHashSet
;
import
java.util.Set
;
import
org.springframework.cache.interceptor.AbstractFallbackCacheOperationSource
;
import
org.springframework.cache.interceptor.CacheOperation
;
import
org.springframework.util.Assert
;
/**
*
* Implementation of the {@link org.springframework.cache.interceptor.CacheOperationSource}
* interface for working with caching metadata in JDK 1.5+ annotation format.
*
* <p>This class reads Spring's JDK 1.5+ {@link Cacheable} and {@link CacheEvict}
* annotations and exposes corresponding caching operation definition to Spring's cache infrastructure.
* This class may also serve as base class for a custom CacheOperationSource.
*
* @author Costin Leau
*/
@SuppressWarnings
(
"serial"
)
public
class
AnnotationCacheOperationSource
extends
AbstractFallbackCacheOperationSource
implements
Serializable
{
private
final
boolean
publicMethodsOnly
;
private
final
Set
<
CacheAnnotationParser
>
annotationParsers
;
/**
* Create a default AnnotationCacheOperationSource, supporting
* public methods that carry the <code>Cacheable</code> and <code>CacheEvict</code>
* annotations.
*/
public
AnnotationCacheOperationSource
()
{
this
(
true
);
}
/**
* Create a custom AnnotationCacheOperationSource, supporting
* public methods that carry the <code>Cacheable</code> and
* <code>CacheEvict</code> annotations.
*
* @param publicMethodsOnly whether to support only annotated public methods
* typically for use with proxy-based AOP), or protected/private methods as well
* (typically used with AspectJ class weaving)
*/
public
AnnotationCacheOperationSource
(
boolean
publicMethodsOnly
)
{
this
.
publicMethodsOnly
=
publicMethodsOnly
;
this
.
annotationParsers
=
new
LinkedHashSet
<
CacheAnnotationParser
>(
1
);
this
.
annotationParsers
.
add
(
new
SpringCachingAnnotationParser
());
}
/**
* Create a custom AnnotationCacheOperationSource.
* @param annotationParsers the CacheAnnotationParser to use
*/
public
AnnotationCacheOperationSource
(
CacheAnnotationParser
...
annotationParsers
)
{
this
.
publicMethodsOnly
=
true
;
Assert
.
notEmpty
(
annotationParsers
,
"At least one CacheAnnotationParser needs to be specified"
);
Set
<
CacheAnnotationParser
>
parsers
=
new
LinkedHashSet
<
CacheAnnotationParser
>(
annotationParsers
.
length
);
Collections
.
addAll
(
parsers
,
annotationParsers
);
this
.
annotationParsers
=
parsers
;
}
@Override
protected
CacheOperation
findCacheOperation
(
Class
<?>
clazz
)
{
return
determineCacheOperation
(
clazz
);
}
@Override
protected
CacheOperation
findCacheOperation
(
Method
method
)
{
return
determineCacheOperation
(
method
);
}
/**
* Determine the cache operation definition for the given method or class.
* <p>This implementation delegates to configured
* {@link CacheAnnotationParser CacheAnnotationParsers}
* for parsing known annotations into Spring's metadata attribute class.
* Returns <code>null</code> if it's not cacheable.
* <p>Can be overridden to support custom annotations that carry caching metadata.
* @param ae the annotated method or class
* @return CacheOperation the configured caching operation,
* or <code>null</code> if none was found
*/
protected
CacheOperation
determineCacheOperation
(
AnnotatedElement
ae
)
{
for
(
CacheAnnotationParser
annotationParser
:
this
.
annotationParsers
)
{
CacheOperation
attr
=
annotationParser
.
parseCacheAnnotation
(
ae
);
if
(
attr
!=
null
)
{
return
attr
;
}
}
return
null
;
}
/**
* By default, only public methods can be made cacheable.
*/
@Override
protected
boolean
allowPublicMethodsOnly
()
{
return
this
.
publicMethodsOnly
;
}
}
\ No newline at end of file
org.springframework.context/src/main/java/org/springframework/cache/interceptor/AbstractFallbackCacheOperationSource.java
0 → 100644
浏览文件 @
3699a037
/*
* Copyright 2010-2011 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.interceptor
;
import
java.lang.reflect.Method
;
import
java.lang.reflect.Modifier
;
import
java.util.Map
;
import
java.util.concurrent.ConcurrentHashMap
;
import
org.apache.commons.logging.Log
;
import
org.apache.commons.logging.LogFactory
;
import
org.springframework.core.BridgeMethodResolver
;
import
org.springframework.util.ClassUtils
;
import
org.springframework.util.ObjectUtils
;
/**
* Abstract implementation of {@link CacheOperation} that caches
* attributes for methods and implements a fallback policy: 1. specific target
* method; 2. target class; 3. declaring method; 4. declaring class/interface.
*
* <p>Defaults to using the target class's caching attribute if none is
* associated with the target method. Any caching attribute associated with
* the target method completely overrides a class caching attribute.
* If none found on the target class, the interface that the invoked method
* has been called through (in case of a JDK proxy) will be checked.
*
* <p>This implementation caches attributes by method after they are first used.
* If it is ever desirable to allow dynamic changing of cacheable attributes
* (which is very unlikely), caching could be made configurable.
* @author Costin Leau
* @see org.springframework.transaction.interceptor.AbstractFallbackTransactionAttributeSource
*/
public
abstract
class
AbstractFallbackCacheOperationSource
implements
CacheOperationSource
{
/**
* Canonical value held in cache to indicate no caching attribute was
* found for this method and we don't need to look again.
*/
private
final
static
CacheOperation
NULL_CACHING_ATTRIBUTE
=
new
CacheUpdateOperation
();
/**
* Logger available to subclasses.
* <p>As this base class is not marked Serializable, the logger will be recreated
* after serialization - provided that the concrete subclass is Serializable.
*/
protected
final
Log
logger
=
LogFactory
.
getLog
(
getClass
());
/**
* Cache of CacheOperationDefinitions, keyed by DefaultCacheKey (Method + target Class).
* <p>As this base class is not marked Serializable, the cache will be recreated
* after serialization - provided that the concrete subclass is Serializable.
*/
final
Map
<
Object
,
CacheOperation
>
attributeCache
=
new
ConcurrentHashMap
<
Object
,
CacheOperation
>();
/**
* Determine the caching attribute for this method invocation.
* <p>Defaults to the class's caching attribute if no method attribute is found.
* @param method the method for the current invocation (never <code>null</code>)
* @param targetClass the target class for this invocation (may be <code>null</code>)
* @return {@link CacheOperation} for this method, or <code>null</code> if the method
* is not cacheable
*/
public
CacheOperation
getCacheOperation
(
Method
method
,
Class
<?>
targetClass
)
{
// First, see if we have a cached value.
Object
cacheKey
=
getCacheKey
(
method
,
targetClass
);
CacheOperation
cached
=
this
.
attributeCache
.
get
(
cacheKey
);
if
(
cached
!=
null
)
{
if
(
cached
==
NULL_CACHING_ATTRIBUTE
)
{
return
null
;
}
// Value will either be canonical value indicating there is no caching attribute,
// or an actual caching attribute.
return
cached
;
}
else
{
// We need to work it out.
CacheOperation
cacheDef
=
computeCacheOperationDefinition
(
method
,
targetClass
);
// Put it in the cache.
if
(
cacheDef
==
null
)
{
this
.
attributeCache
.
put
(
cacheKey
,
NULL_CACHING_ATTRIBUTE
);
}
else
{
if
(
logger
.
isDebugEnabled
())
{
logger
.
debug
(
"Adding cacheable method '"
+
method
.
getName
()
+
"' with attribute: "
+
cacheDef
);
}
this
.
attributeCache
.
put
(
cacheKey
,
cacheDef
);
}
return
cacheDef
;
}
}
/**
* Determine a cache key for the given method and target class.
* <p>Must not produce same key for overloaded methods.
* Must produce same key for different instances of the same method.
* @param method the method (never <code>null</code>)
* @param targetClass the target class (may be <code>null</code>)
* @return the cache key (never <code>null</code>)
*/
protected
Object
getCacheKey
(
Method
method
,
Class
<?>
targetClass
)
{
return
new
DefaultCacheKey
(
method
,
targetClass
);
}
/**
* Same signature as {@link #getTransactionAttribute}, but doesn't cache the result.
* {@link #getTransactionAttribute} is effectively a caching decorator for this method.
* @see #getTransactionAttribute
*/
private
CacheOperation
computeCacheOperationDefinition
(
Method
method
,
Class
<?>
targetClass
)
{
// Don't allow no-public methods as required.
if
(
allowPublicMethodsOnly
()
&&
!
Modifier
.
isPublic
(
method
.
getModifiers
()))
{
return
null
;
}
// The method may be on an interface, but we need attributes from the target class.
// If the target class is null, the method will be unchanged.
Method
specificMethod
=
ClassUtils
.
getMostSpecificMethod
(
method
,
targetClass
);
// If we are dealing with method with generic parameters, find the original method.
specificMethod
=
BridgeMethodResolver
.
findBridgedMethod
(
specificMethod
);
// First try is the method in the target class.
CacheOperation
opDef
=
findCacheOperation
(
specificMethod
);
if
(
opDef
!=
null
)
{
return
opDef
;
}
// Second try is the caching operation on the target class.
opDef
=
findCacheOperation
(
specificMethod
.
getDeclaringClass
());
if
(
opDef
!=
null
)
{
return
opDef
;
}
if
(
specificMethod
!=
method
)
{
// Fall back is to look at the original method.
opDef
=
findCacheOperation
(
method
);
if
(
opDef
!=
null
)
{
return
opDef
;
}
// Last fall back is the class of the original method.
return
findCacheOperation
(
method
.
getDeclaringClass
());
}
return
null
;
}
/**
* Subclasses need to implement this to return the caching attribute
* for the given method, if any.
* @param method the method to retrieve the attribute for
* @return all caching attribute associated with this method
* (or <code>null</code> if none)
*/
protected
abstract
CacheOperation
findCacheOperation
(
Method
method
);
/**
* Subclasses need to implement this to return the caching attribute
* for the given class, if any.
* @param clazz the class to retrieve the attribute for
* @return all caching attribute associated with this class
* (or <code>null</code> if none)
*/
protected
abstract
CacheOperation
findCacheOperation
(
Class
<?>
clazz
);
/**
* Should only public methods be allowed to have caching semantics?
* <p>The default implementation returns <code>false</code>.
*/
protected
boolean
allowPublicMethodsOnly
()
{
return
false
;
}
/**
* Default cache key for the CacheOperationDefinition cache.
*/
private
static
class
DefaultCacheKey
{
private
final
Method
method
;
private
final
Class
<?>
targetClass
;
public
DefaultCacheKey
(
Method
method
,
Class
<?>
targetClass
)
{
this
.
method
=
method
;
this
.
targetClass
=
targetClass
;
}
@Override
public
boolean
equals
(
Object
other
)
{
if
(
this
==
other
)
{
return
true
;
}
if
(!(
other
instanceof
DefaultCacheKey
))
{
return
false
;
}
DefaultCacheKey
otherKey
=
(
DefaultCacheKey
)
other
;
return
(
this
.
method
.
equals
(
otherKey
.
method
)
&&
ObjectUtils
.
nullSafeEquals
(
this
.
targetClass
,
otherKey
.
targetClass
));
}
@Override
public
int
hashCode
()
{
return
this
.
method
.
hashCode
()
*
29
+
(
this
.
targetClass
!=
null
?
this
.
targetClass
.
hashCode
()
:
0
);
}
}
}
\ No newline at end of file
org.springframework.context/src/main/java/org/springframework/cache/interceptor/BeanFactoryCacheOperationSourceAdvisor.java
0 → 100644
浏览文件 @
3699a037
/*
* Copyright 2010-2011 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.interceptor
;
import
org.springframework.aop.ClassFilter
;
import
org.springframework.aop.Pointcut
;
import
org.springframework.aop.support.AbstractBeanFactoryPointcutAdvisor
;
/**
* Advisor driven by a {@link CacheOperationSource}, used to include a
* cache advice bean for methods that are cacheable.
*
* @author Costin Leau
*/
@SuppressWarnings
(
"serial"
)
public
class
BeanFactoryCacheOperationSourceAdvisor
extends
AbstractBeanFactoryPointcutAdvisor
{
private
CacheOperationSource
cacheDefinitionSource
;
private
final
CacheOperationSourcePointcut
pointcut
=
new
CacheOperationSourcePointcut
()
{
@Override
protected
CacheOperationSource
getCacheOperationSource
()
{
return
cacheDefinitionSource
;
}
};
/**
* Set the cache operation attribute source which is used to find cache
* attributes. This should usually be identical to the source reference
* set on the cache interceptor itself.
* @see CacheInterceptor#setCacheAttributeSource
*/
public
void
setCacheDefinitionSource
(
CacheOperationSource
cacheDefinitionSource
)
{
this
.
cacheDefinitionSource
=
cacheDefinitionSource
;
}
/**
* Set the {@link ClassFilter} to use for this pointcut.
* Default is {@link ClassFilter#TRUE}.
*/
public
void
setClassFilter
(
ClassFilter
classFilter
)
{
this
.
pointcut
.
setClassFilter
(
classFilter
);
}
public
Pointcut
getPointcut
()
{
return
this
.
pointcut
;
}
}
\ No newline at end of file
org.springframework.context/src/main/java/org/springframework/cache/interceptor/CacheEvictOperation.java
0 → 100644
浏览文件 @
3699a037
/*
* Copyright 2010-2011 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.interceptor
;
/**
* Class describing an 'evict' operation.
*
* @author Costin Leau
*/
public
class
CacheEvictOperation
extends
CacheOperation
{
private
boolean
cacheWide
=
false
;
public
boolean
isCacheWide
()
{
return
cacheWide
;
}
public
void
setCacheWide
(
boolean
cacheWide
)
{
this
.
cacheWide
=
cacheWide
;
}
@Override
protected
StringBuilder
getOperationDescription
()
{
StringBuilder
sb
=
super
.
getOperationDescription
();
sb
.
append
(
","
);
sb
.
append
(
cacheWide
);
return
sb
;
}
}
org.springframework.context/src/main/java/org/springframework/cache/interceptor/CacheOperation.java
0 → 100644
浏览文件 @
3699a037
/*
* Copyright 2010-2011 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.interceptor
;
import
java.util.Collections
;
import
java.util.LinkedHashSet
;
import
java.util.Set
;
import
org.springframework.util.Assert
;
/**
* Base class implementing {@link CacheOperation}.
*
* @author Costin Leau
*/
public
abstract
class
CacheOperation
{
private
Set
<
String
>
cacheNames
=
Collections
.
emptySet
();
private
String
condition
=
""
;
private
String
key
=
""
;
private
String
name
=
""
;
public
Set
<
String
>
getCacheNames
()
{
return
cacheNames
;
}
public
String
getCondition
()
{
return
condition
;
}
public
String
getKey
()
{
return
key
;
}
public
String
getName
()
{
return
name
;
}
public
void
setCacheName
(
String
cacheName
)
{
Assert
.
hasText
(
cacheName
);
this
.
cacheNames
=
Collections
.
singleton
(
cacheName
);
}
public
void
setCacheNames
(
String
[]
cacheNames
)
{
Assert
.
notEmpty
(
cacheNames
);
this
.
cacheNames
=
new
LinkedHashSet
<
String
>(
cacheNames
.
length
);
for
(
String
string
:
cacheNames
)
{
this
.
cacheNames
.
add
(
string
);
}
}
public
void
setCondition
(
String
condition
)
{
Assert
.
notNull
(
condition
);
this
.
condition
=
condition
;
}
public
void
setKey
(
String
key
)
{
Assert
.
notNull
(
key
);
this
.
key
=
key
;
}
public
void
setName
(
String
name
)
{
Assert
.
hasText
(
name
);
this
.
name
=
name
;
}
/**
* This implementation compares the <code>toString()</code> results.
* @see #toString()
*/
@Override
public
boolean
equals
(
Object
other
)
{
return
(
other
instanceof
CacheOperation
&&
toString
().
equals
(
other
.
toString
()));
}
/**
* This implementation returns <code>toString()</code>'s hash code.
* @see #toString()
*/
@Override
public
int
hashCode
()
{
return
toString
().
hashCode
();
}
/**
* Return an identifying description for this cache operation.
* <p>Has to be overridden in subclasses for correct <code>equals</code>
* and <code>hashCode</code> behavior. Alternatively, {@link #equals}
* and {@link #hashCode} can be overridden themselves.
*/
@Override
public
String
toString
()
{
return
getOperationDescription
().
toString
();
}
/**
* Return an identifying description for this caching operation.
* <p>Available to subclasses, for inclusion in their <code>toString()</code> result.
*/
protected
StringBuilder
getOperationDescription
()
{
StringBuilder
result
=
new
StringBuilder
();
result
.
append
(
"CacheDefinition["
);
result
.
append
(
name
);
result
.
append
(
"] caches="
);
result
.
append
(
cacheNames
);
result
.
append
(
" | condition='"
);
result
.
append
(
condition
);
result
.
append
(
"' | key='"
);
result
.
append
(
key
);
result
.
append
(
"'"
);
return
result
;
}
}
\ No newline at end of file
org.springframework.context/src/main/java/org/springframework/cache/interceptor/CacheOperationSource.java
0 → 100644
浏览文件 @
3699a037
/*
* Copyright 2010-2011 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.interceptor
;
import
java.lang.reflect.Method
;
/**
* Interface used by CacheInterceptor. Implementations know
* how to source cache operation attributes, whether from configuration,
* metadata attributes at source level, or anywhere else.
*
* @author Costin Leau
*/
public
interface
CacheOperationSource
{
/**
* Return the cache operation definition for this method.
* Return null if the method is not cacheable.
* @param method method
* @param targetClass target class. May be <code>null</code>, in which
* case the declaring class of the method must be used.
* @return {@link CacheOperation} the matching cache operation,
* or <code>null</code> if none found
*/
CacheOperation
getCacheOperation
(
Method
method
,
Class
<?>
targetClass
);
}
org.springframework.context/src/main/java/org/springframework/cache/interceptor/CacheOperationSourcePointcut.java
0 → 100644
浏览文件 @
3699a037
/*
* Copyright 2010-2011 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.interceptor
;
import
java.io.Serializable
;
import
java.lang.reflect.Method
;
import
org.springframework.aop.support.StaticMethodMatcherPointcut
;
import
org.springframework.util.ObjectUtils
;
/**
* Inner class that implements a Pointcut that matches if the underlying
* {@link CacheOperationSource} has an attribute for a given method.
*
* @author Costin Leau
*/
@SuppressWarnings
(
"serial"
)
abstract
class
CacheOperationSourcePointcut
extends
StaticMethodMatcherPointcut
implements
Serializable
{
public
boolean
matches
(
Method
method
,
Class
<?>
targetClass
)
{
CacheOperationSource
cas
=
getCacheOperationSource
();
return
(
cas
==
null
||
cas
.
getCacheOperation
(
method
,
targetClass
)
!=
null
);
}
@Override
public
boolean
equals
(
Object
other
)
{
if
(
this
==
other
)
{
return
true
;
}
if
(!(
other
instanceof
CacheOperationSourcePointcut
))
{
return
false
;
}
CacheOperationSourcePointcut
otherPc
=
(
CacheOperationSourcePointcut
)
other
;
return
ObjectUtils
.
nullSafeEquals
(
getCacheOperationSource
(),
otherPc
.
getCacheOperationSource
());
}
@Override
public
int
hashCode
()
{
return
CacheOperationSourcePointcut
.
class
.
hashCode
();
}
@Override
public
String
toString
()
{
return
getClass
().
getName
()
+
": "
+
getCacheOperationSource
();
}
/**
* Obtain the underlying CacheOperationDefinitionSource (may be <code>null</code>).
* To be implemented by subclasses.
*/
protected
abstract
CacheOperationSource
getCacheOperationSource
();
}
\ No newline at end of file
org.springframework.context/src/main/java/org/springframework/cache/interceptor/CacheUpdateOperation.java
0 → 100644
浏览文件 @
3699a037
/*
* Copyright 2010-2011 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.interceptor
;
/**
* Class describing an 'update' operation.
*
* @author Costin Leau
*/
public
class
CacheUpdateOperation
extends
CacheOperation
{
}
org.springframework.context/src/main/java/org/springframework/cache/interceptor/CompositeCacheOperationSource.java
0 → 100644
浏览文件 @
3699a037
/*
* Copyright 2010-2011 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.interceptor
;
import
java.io.Serializable
;
import
java.lang.reflect.Method
;
import
org.springframework.util.Assert
;
/**
* Composite {@link CacheOperationSource} implementation that iterates
* over a given array of {@link CacheOperationSource} instances.
*
* @author Costin Leau
*/
@SuppressWarnings
(
"serial"
)
public
class
CompositeCacheOperationSource
implements
CacheOperationSource
,
Serializable
{
private
final
CacheOperationSource
[]
cacheDefinitionSources
;
/**
* Create a new CompositeCachingDefinitionSource for the given sources.
* @param cacheDefinitionSourcess the CacheDefinitionSource instances to combine
*/
public
CompositeCacheOperationSource
(
CacheOperationSource
[]
cacheDefinitionSources
)
{
Assert
.
notNull
(
cacheDefinitionSources
,
"cacheDefinitionSource array must not be null"
);
this
.
cacheDefinitionSources
=
cacheDefinitionSources
;
}
/**
* Return the CacheDefinitionSource instances that this
* CompositeCachingDefinitionSource combines.
*/
public
final
CacheOperationSource
[]
getCacheDefinitionSources
()
{
return
this
.
cacheDefinitionSources
;
}
public
CacheOperation
getCacheOperation
(
Method
method
,
Class
<?>
targetClass
)
{
for
(
CacheOperationSource
source
:
cacheDefinitionSources
)
{
CacheOperation
definition
=
source
.
getCacheOperation
(
method
,
targetClass
);
if
(
definition
!=
null
)
{
return
definition
;
}
}
return
null
;
}
}
\ No newline at end of file
org.springframework.context/src/main/java/org/springframework/cache/interceptor/DefaultValue.java
0 → 100644
浏览文件 @
3699a037
/*
* Copyright 2011 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.interceptor
;
import
org.springframework.cache.Cache.ValueWrapper
;
/**
* Default implementation for {@link org.springframework.cache.Cache.ValueWrapper}.
*
* @author Costin Leau
*/
public
class
DefaultValue
<
V
>
implements
ValueWrapper
<
V
>
{
private
final
V
value
;
public
DefaultValue
(
V
value
)
{
this
.
value
=
value
;
}
public
V
get
()
{
return
value
;
}
}
编辑
预览
Markdown
is supported
0%
请重试
或
添加新附件
.
添加附件
取消
You are about to add
0
people
to the discussion. Proceed with caution.
先完成此消息的编辑!
取消
想要评论请
注册
或
登录