2. 程式人生 > >springboot2.0 redis EnableCaching的配置和使用

springboot2.0 redis EnableCaching的配置和使用

阿新 • • 發佈：2018-12-10

一、前言

　　關於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

@[email protected]
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的配置和使用

一、前言 　　關於EnableCaching最簡單使用，個人感覺只需提供一個CacheManager的一個例項就好了。springboot為我們提供了cache相關的自動配置。引入cache模組，如下。 二、maven依賴 <dependency> <groupI

springboot2.0.3使用jpa和hibernate的方式配置多數據源(sqlite和mysql)

自動 username urn ini sqli tps www 不同的 sqlite數據庫 application.properties配置: #數據庫配置 mysql.spring.datasource.jdbc-url =jdbc:mysql://127.0.0.1

springboot2.0 快速專案搭建和專案的配置(start.spring.io)

訪問 https://start.spring.io/ 輸入專案先關資訊  通過 Search for dependencies 搜尋先關模組並新增 然後點選Generate Project 生成專案的程式碼 會生成一個壓縮吧將壓縮包進行解壓&n

springboot2.0 快速專案搭建和專案的配置(Spring Tool Suite (STS))

之前寫了一篇關於如何通過 IntellJ IDEA 快速建立spirngboot ，今天我們來介紹一下如何使用Spring Tool Suite (STS) 進行spirngboot 快速建立。關於spirngboot的介紹我們不在進行介紹。 先通過Spring Tool Suit

安裝MongoDB最新版4.0、及配置和啟動實例

logs 默認端口 info mkdir -p 其他 gem nosql數據庫 eml pytho MongoDB簡介： 1.MongoDB是一款基於分布式文件存儲的開源的文檔數據庫，並且是業內領先的NoSQL數據庫，用C++編寫而成。2.在高負載的情況下，添加更多的節點，

springboot2.0+redis實現消息隊列+redis做緩存+mysql

ins 取數 pathvaria fastjson getc lan arr 創建 ride 本博客僅供參考，本人實現沒有問題。 1、環境 　　先安裝redis、mysql 2、springboot2.0的項目搭建(請自行完成)，本人是maven項目，因此只需配置，

springboot2.0雙資料來源配置

題記：由於專案中不只是用一個數據庫，所以記下以免忘記。 1、首先展示目錄結構   2、pom配置檔案 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/PO

springboot2.0.5 freemarker配置檔案

# FREEMARKER (FreeMarkerProperties) # Whether HttpServletRequest attributes are allowed to override (hide) controller generated model attributes of

Redis主從配置和哨兵監控配置——伺服器端環境搭建

一:介紹 公司用到的redis框架，主要分為cluster的快取叢集和sentinel中的哨兵主從。這種的選用方式一般需要更具業務場景來做區分，兩種框架的配置圖為：右圖為哨兵主從框架和cliuster的叢集框架。sentienl的叢集框架，適用於redis的key值都屬於熱

springboot2.0.5 freemarker配置檔案

# FREEMARKER (FreeMarkerProperties) # Whether HttpServletRequest attributes are allowed to override (hide) controller generated model attr

activemq + springboot2.0.5.release配置及使用

1. pom.xml檔案 <!-- 使用activemq必須：fastjson可以用其他，看喜好 --> <parent> <groupId>org.springframework.boot</groupId>

idea Springboot2.0.6 Thymeleaf配置國際化

前言：thymeleaf肯定得匯入pom檔案了 1.先在resource下新建一個資料夾，用來存國際化的配置檔案 2.在 i18n 下 新建一個register.properties(現在idea還沒有識別出來是在進行國際化配置) 現在長這樣 再建一個 reg

springboot2.0整合mongodb配置附工具類

jar包依賴 pom.xml： <!-- mongodb --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>

redis cluster配置和簡單初始化

-------------環境安裝------------ #安裝redis wget http://download.redis.io/releases/redis-3.2.5.tar.gz tar xzf redis-3.2.5.tar.gz cd redis-3.2.

Redis 主從配置和引數詳解

安裝redis 下載redis wget http://download.redis.io/releases/redis-3.0.7.tar.gz 解壓redis tar -xvf redis-3.0.7.tar.gz 安裝redis cd redis-3.0.7 “有可能需要安裝g

vue2.0子路由配置和跳轉 vue-router: 巢狀路由

路由跳轉 <li class="nav_li" v-link="{ path: '/home/reg'}"></li> <router-link to="/home/reg">註冊</router-link> this.

Redis 主從配置和參數詳解

value ppi threads shu 如何 指令 支持 aof pac 安裝redis 下載redis wget http://download.redis.io/releases/redis-3.0.7.tar.gz 解壓redis tar -x

Spring-Data-Redis叢集配置和RedisTemplate用法

使用SpringData更加方便我們對關係型資料庫和非關係型資料庫更好的操作，封裝了通用的程式碼，使得操作更加快捷簡單。 一、使用Spring-data-redis Jar包準備 spring-data-redis 需要在1.7 版本以上，他會依賴一些包，

Springboot2.0 專案中TKmybatis和Activiti整合的問題

版本資訊：springboot 2.0，mybatis 3.4.6 , tkmybatis 2.0 ,activiti 6.0今天在整合專案的時候，發現mybatis和activiti整合時不會報錯，但是mapper和activiti整合到一起時啟動就會報錯，錯誤資訊如下：P

Redis安全配置和未授權訪問寫

0x00 Redis 作為分散式資料庫的一種 在安裝後有時為了進行遠端管理 會將bind 127.0.0.1 同時沒有設定密碼是非常危險的 能輕易導致伺服器被攻破 0x01 Redis安全配置 CONFIG set requirepass "hellocarl"   設定密