一、前言

  关于EnableCaching最简单使用,个人感觉只需提供一个CacheManager的一个实例就好了。springboot为我们提供了cache相关的自动配置。引入cache模块,如下。

二、maven依赖

<dependency>

    <groupId>org.springframework.boot</groupId>

    <artifactId>spring-boot-starter-cache</artifactId>

</dependency>

<dependency>

    <groupId>org.springframework.boot</groupId>

    <artifactId>spring-boot-starter-data-redis</artifactId>

</dependency>

<dependency>

    <groupId>org.springframework.integration</groupId>

    <artifactId>spring-integration-redis</artifactId>

</dependency>

<dependency>

    <groupId>redis.clients</groupId>

    <artifactId>jedis</artifactId>

</dependency>

三、缓存类型

  本人也仅仅使用了redis、guava、ehcache。更多详情请参考 spring cache官方文档。

https://docs.spring.io/spring-boot/docs/current/reference/html/boot-features-caching.html

四、常用注解

  @Cacheable    触发缓存填充

  @CacheEvict    触发缓存驱逐

  @CachePut    更新缓存而不会干扰方法执行

  @Caching    重新组合要在方法上应用的多个缓存操作

  @CacheConfig    在类级别共享一些常见的缓存相关设置

五、Spring Cache提供的SpEL上下文数据

  下表直接摘自Spring官方文档:

名字
位置
描述
示例
methodName
root对象
当前被调用的方法名
#root.methodName
method
root对象
当前被调用的方法
#root.method.name
target
root对象
当前被调用的目标对象
#root.target
targetClass
root对象
当前被调用的目标对象类
#root.targetClass
args
root对象
当前被调用的方法的参数列表
#root.args[0]
caches
root对象
当前方法调用使用的缓存列表(如@Cacheable(value={"cache1", "cache2"})),则有两个cache
#root.caches[0].name
argument name
执行上下文
当前被调用的方法的参数,如findById(Long id),我们可以通过#id拿到参数
#user.id
result
执行上下文
方法执行后的返回值(仅当方法执行之后的判断有效,如‘unless’,'cache evict'的beforeInvocation=false)
#result

六、RedisCacheManager配置

  基于jedis

@Configuration
@EnableCaching
public class RedisCacheConfig extends CachingConfigurerSupport {
@Autowired
private RedisProperties redisProperties;
@Bean
public JedisConnectionFactory jedisConnectionFactory() {
// 获取服务器数组(这里要相信自己的输入,所以没有考虑空指针问题)
String[] serverArray = redisProperties.getClusterNodes().split(",");
RedisClusterConfiguration redisClusterConfiguration = new
RedisClusterConfiguration(Arrays.asList(serverArray));
JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
// 最大空闲连接数, 默认8个
jedisPoolConfig.setMaxIdle(100);
// 最大连接数, 默认8个
jedisPoolConfig.setMaxTotal(500);
// 最小空闲连接数, 默认0
jedisPoolConfig.setMinIdle(0);
// 获取连接时的最大等待毫秒数(如果设置为阻塞时BlockWhenExhausted),如果超时就抛异常, 小于零:阻塞不确定的时间,
// 默认-1
jedisPoolConfig.setMaxWaitMillis(2000); // 设置2秒
// 对拿到的connection进行validateObject校验
jedisPoolConfig.setTestOnBorrow(true);
return new JedisConnectionFactory(redisClusterConfiguration
,jedisPoolConfig);
}
/** * 注入redis template * * @return */
@Bean
@Qualifier("redisTemplate")
public RedisTemplate redisTemplate(
JedisConnectionFactoryjedisConnectionFactory
, Jackson2JsonRedisSerializer jackson2JsonRedisSerializer) {
RedisTemplate template = new RedisTemplate();
template.setConnectionFactory(jedisConnectionFactory);
template.setKeySerializer(new JdkSerializationRedisSerializer());
template.setValueSerializer(jackson2JsonRedisSerializer);
template.afterPropertiesSet();
return template;
}
/** * redis cache manager * * @return */
@Bean
@Primary
public RedisCacheManager redisCacheManager(
JedisConnectionFactory jedisConnectionFactory
, ObjectProvider<List<RedisCacheConfigurationProvider>>
configurationProvider) {
Map<String, RedisCacheConfiguration> redisCacheConfigurationMap =
Maps.newHashMap();
List<RedisCacheConfigurationProvider> configurations
= configurationProvider.getIfAvailable();
if (!CollectionUtils.isEmpty(configurations)) {
for (RedisCacheConfigurationProvider configuration : configurations) {
redisCacheConfigurationMap.putAll(configuration.resolve());
}
}
RedisCacheManager cacheManager = RedisCacheManager.
RedisCacheManagerBuilder.fromConnectionFactory(jedisConnectionFactory)
.cacheDefaults(resovleRedisCacheConfiguration(Duration.
ofSeconds(300), JacksonHelper.genJavaType(Object.class)))
.withInitialCacheConfigurations(redisCacheConfigurationMap)
.build();
return cacheManager;
}
private static RedisCacheConfiguration resovleRedisCacheConfiguration(Duration duration, JavaType javaType) {
return RedisCacheConfiguration.defaultCacheConfig()
.serializeKeysWith(RedisSerializationContext
.SerializationPair
.fromSerializer(new StringRedisSerializer()))
.serializeValuesWith(RedisSerializationContext
.SerializationPair.fromSerializer(
new Jackson2JsonRedisSerializer<>(javaType)))
.entryTtl(duration);
}
/** * 配置一个序列器, 将对象序列化为字符串存储, 和将对象反序列化为对象 */
@Bean
public Jackson2JsonRedisSerializer jackson2JsonRedisSerializer() {
Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
ObjectMapper om = new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jackson2JsonRedisSerializer.setObjectMapper(om);
return jackson2JsonRedisSerializer;
}
public static abstract class RedisCacheConfigurationProvider {
// key = 缓存名称, value = 缓存时间 和 缓存类型
protected Map<String, Pair<Duration, JavaType>> configs;
protected abstract void initConfigs();
public Map<String, RedisCacheConfiguration> resolve() {
initConfigs();
Assert.notEmpty(configs, "RedisCacheConfigurationProvider 配置不能为空...");
Map<String, RedisCacheConfiguration> result = Maps.newHashMap();
configs.forEach((cacheName, pair) -> result.put(cacheName,
resovleRedisCacheConfiguration(pair.getKey(), pair.getValue())));
return result;
}
} }

  基于Lettuce

@Configuration
@EnableCaching
public class RedisCacheConfig extends CachingConfigurerSupport {   @Autowired
private RedisProperties redisProperties;
@Bean
public LettuceConnectionFactory lettuceConnectionFactory() {
String[] serverArray = redisProperties.getClusterNodes().split(",");// 获取服务器数组(这里要相信自己的输入,所以没有考虑空指针问题)
RedisClusterConfiguration redisClusterConfiguration = new RedisClusterConfiguration(Arrays.asList(serverArray));
GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
// 最大空闲连接数, 默认8个
poolConfig.setMaxIdle(100);
// 最大连接数, 默认8个
poolConfig.setMaxTotal(500);
// 最小空闲连接数, 默认0
poolConfig.setMinIdle(0);
LettuceClientConfiguration lettuceClientConfiguration = LettucePoolingClientConfiguration.builder()
.commandTimeout(Duration.ofSeconds(15))
.poolConfig(poolConfig)
.shutdownTimeout(Duration.ZERO)
.build();
return new LettuceConnectionFactory(redisClusterConfiguration, lettuceClientConfiguration);
}
/** * 注入redis template * * @return */
@Bean
@Qualifier("redisTemplate")
public RedisTemplate redisTemplate(LettuceConnectionFactory lettuceConnectionFactory, Jackson2JsonRedisSerializer jackson2JsonRedisSerializer) {
RedisTemplate template = new RedisTemplate();
template.setConnectionFactory(lettuceConnectionFactory);
template.setKeySerializer(new JdkSerializationRedisSerializer());
template.setValueSerializer(jackson2JsonRedisSerializer);
template.afterPropertiesSet();
return template;
}
/** * redis cache manager * * @return */
@Bean
@Primary
public RedisCacheManager redisCacheManager(LettuceConnectionFactory lettuceConnectionFactory, ObjectProvider<List<RedisCacheConfigurationProvider>> configurationProvider) {
Map<String, RedisCacheConfiguration> redisCacheConfigurationMap = Maps.newHashMap();
List<RedisCacheConfigurationProvider> configurations = configurationProvider.getIfAvailable();
if (!CollectionUtils.isEmpty(configurations)) {
for (RedisCacheConfigurationProvider configuration : configurations) {
redisCacheConfigurationMap.putAll(configuration.resolve());
}
}
RedisCacheManager cacheManager = RedisCacheManager.RedisCacheManagerBuilder.fromConnectionFactory(lettuceConnectionFactory)
.cacheDefaults(resovleRedisCacheConfiguration(Duration.ofSeconds(300), JacksonHelper.genJavaType(Object.class)))
.withInitialCacheConfigurations(redisCacheConfigurationMap)
.build();
return cacheManager;
}
private static RedisCacheConfiguration resovleRedisCacheConfiguration(Duration duration, JavaType javaType) {
return RedisCacheConfiguration.defaultCacheConfig()
.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new Jackson2JsonRedisSerializer<>(javaType)))
.entryTtl(duration);
}
@Bean
public RedisLockRegistry redisLockRegistry(LettuceConnectionFactory lettuceConnectionFactory) {
return new RedisLockRegistry(lettuceConnectionFactory, "recharge-plateform", 60000 * 20);
}
/** * 配置一个序列器, 将对象序列化为字符串存储, 和将对象反序列化为对象 */
@Bean
public Jackson2JsonRedisSerializer jackson2JsonRedisSerializer() {
Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
ObjectMapper om = new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jackson2JsonRedisSerializer.setObjectMapper(om);
return jackson2JsonRedisSerializer;
}
public static abstract class RedisCacheConfigurationProvider {
// key = 缓存名称, value = 缓存时间 和 缓存类型
protected Map<String, Pair<Duration, JavaType>> configs;
protected abstract void initConfigs();
public Map<String, RedisCacheConfiguration> resolve() {
initConfigs();
Assert.notEmpty(configs, "RedisCacheConfigurationProvider 配置不能为空...");
Map<String, RedisCacheConfiguration> result = Maps.newHashMap();
configs.forEach((cacheName, pair) -> result.put(cacheName, resovleRedisCacheConfiguration(pair.getKey(), pair.getValue())));
return result;
}
} }

  Jedis和Lettuce比较

  Jedis 是直连模式,在多个线程间共享一个 Jedis 实例时是线程不安全的,如果想要在多线程环境下使用 Jedis,需要使用连接池,

  每个线程都去拿自己的 Jedis 实例,当连接数量增多时,物理连接成本就较高了。

  Lettuce的连接是基于Netty的,连接实例可以在多个线程间共享,

  所以,一个多线程的应用可以使用同一个连接实例,而不用担心并发线程的数量。当然这个也是可伸缩的设计,一个连接实例不够的情况也可以按需增加连接实例。通过异步的方式可以让我们更好的利用系统资源,而不用浪费线程等待网络或磁盘I/O。

  

  只在基于Lettuce的配置中,加入了RedisLockRegistry对应bean的配置,由于在集群的模式下,基于Jedis的配置下,通过RedisLockRegistry 获取分布式锁的时候报错:

EvalSha is not supported in cluster environment

  具体的解决方案就是切换至基于Lettuce的配置,请参考

https://stackoverflow.com/questions/47092475/spring-boot-redistemplate-execute-sc

  

  RedisCacheConfigurationProvider 作用为不同的cache提供特定的缓存时间以及key、value序列化和反序列化的方式。具体使用方式如下。

@Component

public class CouponRedisCacheConfigurationProvider extends RedisCacheConfig.RedisCacheConfigurationProvider {

@Override
protected void initConfigs() {
this.configs = Maps.newHashMap();
this.configs.put(CouponConstants.COUPON_ALL_CACHE, new Pair<>(Duration.ofHours(1), JacksonHelper.genMapType(HashMap.class, Integer.class, Coupon.class)));
this.configs.put(CouponConstants.COUPON_GOOD_CACHE, new Pair<>(Duration.ofHours(1), JacksonHelper.genCollectionType(List.class, String.class))); this.configs.put(CouponConstants.COUPON_HANDLE_TELEPHONE_STATUS_CACHE, new Pair<>(Duration.ofMinutes(10), JacksonHelper.genCollectionType(List.class, CouponHandle.class)));
this.configs.put(CouponConstants.COUPON_HANDLE_TELEPHONE_GOOD_CACHE, new Pair<>(Duration.ofMinutes(10), JacksonHelper.genCollectionType(List.class, CouponHandle.class)));
} }

  JacksonHelper 作用是根据不同的类型的对象获取对应的JavaType对象,在构造RedisTempalte序列化和反序列化器Jackson2JsonRedisSerializer对象需要。具体代码如下。

public class JacksonHelper {
private static Logger LOGGER = LoggerFactory.getLogger(JacksonHelper.class); private static final SimpleModule module = initModule();
private static final ObjectMapper objectMapper;
private static final ObjectMapper prettyMapper; public JacksonHelper() {
} private static SimpleModule initModule() {
return (new SimpleModule()).addSerializer(BigDecimal.class, new BigDecimalSerializer())
.addSerializer(LocalTime.class, new LocalTimeSerializer())
.addDeserializer(LocalTime.class, new LocalTimeDeserializer())
.addSerializer(LocalDate.class, new LocalDateSerializer())
.addDeserializer(LocalDate.class, new LocalDateDeserializer())
.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer())
.addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer())
.addSerializer(Date.class, new DateSerializer())
.addDeserializer(Date.class, new DateDeserializer());
} public static JavaType genJavaType(TypeReference<?> typeReference) {
return getObjectMapper().getTypeFactory().constructType(typeReference.getType());
} public static JavaType genJavaType(Class<?> clazz) {
return getObjectMapper().getTypeFactory().constructType(clazz);
} public static JavaType genCollectionType(Class<? extends Collection> collectionClazz, Class<?> javaClazz) {
return getObjectMapper().getTypeFactory().constructCollectionType(collectionClazz, javaClazz);
} public static JavaType genMapType(Class<? extends Map> mapClazz, Class<?> keyClass, Class<?> valueClazz) {
return getObjectMapper().getTypeFactory().constructMapType(mapClazz, keyClass, valueClazz);
} public static ObjectMapper getObjectMapper() {
return objectMapper;
} public static ObjectMapper getPrettyMapper() {
return prettyMapper;
} static {
objectMapper = (new ObjectMapper()).registerModule(module).configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false).configure(DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_AS_NULL, true).configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
prettyMapper = objectMapper.copy().configure(SerializationFeature.INDENT_OUTPUT, true);
} } class LocalDateDeserializer extends JsonDeserializer<LocalDate> { public LocalDateDeserializer() {
} public LocalDate deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException {
String dateString = ((JsonNode) jp.getCodec().readTree(jp)).asText();
return LocalDate.parse(dateString, DateTimeFormatter.ISO_LOCAL_DATE);
} } class DateDeserializer extends JsonDeserializer<Date> { public DateDeserializer() {
} public Date deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException {
String dateTimeStr = ((JsonNode) jp.getCodec().readTree(jp)).asText();
SimpleDateFormat sdf = new SimpleDateFormat(CouponConstants.DATE_TIME_FORMATER);
ParsePosition pos = new ParsePosition(0);
return sdf.parse(dateTimeStr, pos);
} } class LocalDateTimeDeserializer extends JsonDeserializer<LocalDateTime> { public LocalDateTimeDeserializer() {
} public LocalDateTime deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException {
String dateTimeStr = ((JsonNode) jp.getCodec().readTree(jp)).asText();
return LocalDateTime.parse(dateTimeStr, DateTimeFormatter.ISO_LOCAL_DATE_TIME);
} } class LocalTimeDeserializer extends JsonDeserializer<LocalTime> { public LocalTimeDeserializer() {
} public LocalTime deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException {
String dateString = ((JsonNode) jp.getCodec().readTree(jp)).asText();
return LocalTime.parse(dateString, DateTimeFormatter.ISO_LOCAL_TIME);
} } class BigDecimalSerializer extends JsonSerializer<BigDecimal> { public BigDecimalSerializer() {
} public void serialize(BigDecimal value, JsonGenerator jgen, SerializerProvider provider) throws IOException {
jgen.writeString(value.toString());
} } class LocalDateSerializer extends JsonSerializer<LocalDate> { public LocalDateSerializer() {
} public void serialize(LocalDate value, JsonGenerator jgen, SerializerProvider provider) throws IOException {
jgen.writeString(DateTimeFormatter.ISO_LOCAL_DATE.format(value));
} } class LocalDateTimeSerializer extends JsonSerializer<LocalDateTime> { public LocalDateTimeSerializer() {
} public void serialize(LocalDateTime value, JsonGenerator jgen, SerializerProvider provider) throws IOException {
jgen.writeString(DateTimeFormatter.ISO_LOCAL_DATE_TIME.format(value));
} } class DateSerializer extends JsonSerializer<Date> { public DateSerializer() {
} public void serialize(Date value, JsonGenerator jgen, SerializerProvider provider) throws IOException {
SimpleDateFormat sdf = new SimpleDateFormat(CouponConstants.DATE_TIME_FORMATER);
jgen.writeString(sdf.format(value));
} } class LocalTimeSerializer extends JsonSerializer<LocalTime> { public LocalTimeSerializer() {
} public void serialize(LocalTime value, JsonGenerator jgen, SerializerProvider provider) throws IOException {
jgen.writeString(DateTimeFormatter.ISO_LOCAL_TIME.format(value));
} }

  业务代码

@Component
public class ServiceImpl {    @Override
@CacheEvict(cacheNames = CouponConstants.COUPON_HANDLE_TELEPHONE_STATUS_CACHE, key = "#telephone+'#'+#status", beforeInvocation = true)
public void evictCouponHandles(String telephone, Integer status) { } @Override
@Cacheable(cacheNames = CouponConstants.COUPON_HANDLE_TELEPHONE_STATUS_CACHE, key = "#telephone+'#'+#status", sync = true)
public List<CouponHandle> searchCouponHandles(String telephone, Integer status) {
} }

  不同的缓存对应不同的存储类型,不同的存储类型对应着不同的序列化和反序列化器,这就保证了再调用注有@Cacheable注解的代码时获取到的对象不会发生类型转换错误。关于设置不同的cache下过期时间以及序列化和反序列器,请参考下面更直接明了的例子。

@Configuration

public class RedisCacheConfig {

@Bean
public KeyGenerator simpleKeyGenerator() {
return (o, method, objects) -> {
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.append(o.getClass().getSimpleName());
stringBuilder.append(".");
stringBuilder.append(method.getName());
stringBuilder.append("[");
for (Object obj : objects) {
stringBuilder.append(obj.toString());
}
stringBuilder.append("]"); return stringBuilder.toString();
};
} @Bean
public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
return new RedisCacheManager(
RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory),
this.getRedisCacheConfigurationWithTtl(600), // 默认策略,未配置的 cache 会使用这个
this.getRedisCacheConfigurationMap() // 指定 cache 策略
);
} private Map<String, RedisCacheConfiguration> getRedisCacheConfigurationMap() {
Map<String, RedisCacheConfiguration> redisCacheConfigurationMap = new HashMap<>();
redisCacheConfigurationMap.put("UserInfoList", this.getRedisCacheConfigurationWithTtl(3000));
redisCacheConfigurationMap.put("UserInfoListAnother", this.getRedisCacheConfigurationWithTtl(18000)); return redisCacheConfigurationMap;
} private RedisCacheConfiguration getRedisCacheConfigurationWithTtl(Integer seconds) {
Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
ObjectMapper om = new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jackson2JsonRedisSerializer.setObjectMapper(om); RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig();
redisCacheConfiguration = redisCacheConfiguration.serializeValuesWith(
RedisSerializationContext
.SerializationPair
.fromSerializer(jackson2JsonRedisSerializer)
).entryTtl(Duration.ofSeconds(seconds)); return redisCacheConfiguration;
} }
@Cacheable(value = "UserInfoList", keyGenerator = "simpleKeyGenerator") // 3000秒
@Cacheable(value = "UserInfoListAnother", keyGenerator = "simpleKeyGenerator") // 18000秒
@Cacheable(value = "DefaultKeyTest", keyGenerator = "simpleKeyGenerator") // 600秒,未指定的cache,使用默认策略

springboot2.0 redis EnableCaching的配置和使用的更多相关文章

  1. springBoot2.0+redis+fastJson+自定义注解实现方法上添加过期时间

    springBoot2.0集成redis实例 一.首先引入项目依赖的maven jar包,主要包括 spring-boot-starter-data-redis包,这个再springBoot2.0之前 ...

  2. springboot2.0+redis实现消息队列+redis做缓存+mysql

    本博客仅供参考,本人实现没有问题. 1.环境 先安装redis.mysql 2.springboot2.0的项目搭建(请自行完成),本人是maven项目,因此只需配置,获取相应的jar包,配置贴出. ...

  3. SpringBoot2.0之六 多环境配置

    开发过程中面对不同的环境,例如数据库.redis服务器等的不同,可能会面临一直需要修改配置的麻烦中,在以前的项目中,曾通过Tomcat的配置来实现,有的项目甚至需要手动修改相关配置,这种方式费时费力, ...

  4. SpringBoot2.0之八 多数据源配置

     在开发的过程中我们可能都会遇到对接公司其他系统等需求,对于外部的系统可以采用接口对接的方式,对于一个公司开发的两个系统,并且知道相关数据库结构的情况下,就可以考虑使用多数据源来解决这个问题.Spri ...

  5. SpringBoot2.0 redis生成组建和读写配置文件

    @Component 生成组建 @ConfigurationProperties(prefix="redis") 读写redis配置文件 application.propertie ...

  6. springboot2.0和Druid整合配置数据源

    1. idea使用spring 初始化工具初始化springboot项目(要选中web) 下一步,下一步 2. 在pom.xml中,引入Druid连接池依赖: <dependency> & ...

  7. IntelliJ IDEA 2017版 spring-boot2.0.4的yml配置使用

    一.必须配置字端两个 server: port: 8080 servlet: context-path: /demo 二.两种mvc转换springboot,一种是注解,一种就是.yml或proper ...

  8. IntellJ IDEA2017 springboot2.0.2中读取配置

    IDEA 路径 src\main\resources\application.properties 配置文件名称为 application.properties 默认的位置在classpath根目录下 ...

  9. springboot2.0最精简的配置yml

    https://blog.csdn.net/yu_hongrun/article/details/81708762

随机推荐

  1. Confluence 6 开始使用

    欢迎来到 Confluence 的开始使用指南文档.在这个稳定中,你将会找到有关对 Confluence 进行评估的指南和其他的一些有用的内容.当你开始使用 Confluence 的时候,这些信息能够 ...

  2. Confluence 6 针对大数据量备份

    XML 站点备份的方式只针对 Confluence 包含有几千页面的情况,XML 备份所需要的时间随着数据量的变化而增加.另外的一个问题是 XML 站点的备份将会包含上 G 的附件数据,随着数据量的增 ...

  3. OC Swift中检查代码行数

    1 打开终端  cd 进去当前项目 2 总行数查看命令     find . -name "*.m" -or -name "*.h" | xargs wc -l ...

  4. Java的家庭记账本程序(E)

    日期:2019.2.9 博客期:032 星期二 今天是把程序的相关Bug补一补,嗯`: 1.添加了跳转说明 生成了一个对于成员的权限声明内容,用户再登陆界面点击Go按钮后,切换至说明页面,再次点击Go ...

  5. Executor多线程框架使用

    在我们的JDK1.5的时候JAVA推出一款为了更加方便开发的多线程应用而封装的框架(Executor),相比传统的Thread类,Executor更加的方便,性能好,更易于管理,而且支持线程池.一般在 ...

  6. 【深度学习】吴恩达网易公开课练习(class1 week3)

    知识点梳理 python工具使用: sklearn: 数据挖掘,数据分析工具,内置logistic回归 matplotlib: 做图工具,可绘制等高线等 绘制散点图: plt.scatter(X[0, ...

  7. Visual Studio UML

    1 .类图设计 2.动态图设计,业务工作流程说明了业务为所想服务的业务助教提供了所需要的价值而必须完成的工作,业务用例由一系列的活动组成,它们共同为业务主角生成某些工件,工作流程通常包括一个基本的工作 ...

  8. django配置一个网站建设

    第一步: 安装数据库MySQL,也可以使用pycharm自带的数据库sqllite,大项目要使用数据库.安装请参考上篇. 数据库在pycharm中驱动设置,setting文件中修改驱动文件密码等信息. ...

  9. mybatis 遍历map;

    mybatis 遍历map; 参考http://blog.csdn.net/hj7jay/article/details/78652050 ps: ${m[key]}这是显示 打印的key读value ...

  10. jquery实现全选 反选 取消

    <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8&quo ...