Spring Boot 學習之快取和 NoSQL 篇（四）

阿新 • • 發佈：2019-02-07

該系列並非完全原創，官方文件、作者

一、前言

當系統的訪問量增大時，相應的資料庫的效能就逐漸下降。但是，大多數請求都是在重複的獲取相同的資料，如果使用快取，將結果資料放入其中可以很大程度上減輕資料庫的負擔，提升系統的響應速度。

本篇將介紹 Spring Boot 中快取和 NoSQL 的使用。上篇文章《Spring Boot 入門之持久層篇（三）》。

二、整合EhCache 快取

Spring Boot 針對不同的快取技術實現了不同的封裝，提供了以下幾個註解實現宣告式快取：

@EnableCaching	開啟快取功能，放在配置類或啟動類上
@CacheConfig	快取配置，設定快取名稱
@Cacheable	執行方法前先查詢快取是否有資料。有則直接返回快取資料；否則查詢資料再將資料放入快取
@CachePut	執行新增或更新方法後，將資料放入快取中
@CacheEvict	清除快取
@Caching	將多個快取操作重新組合到一個方法中

1、新增依賴

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>
<dependency>
    <groupId>net.sf.ehcache</groupId>
    <artifactId>ehcache</artifactId>
</dependency>

2、新增配置

在 src/main/resources 目錄下建立 ehcache.xml 檔案，內容如下：

<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:noNamespaceSchemaLocation="ehcache.xsd">
    <cache name="question" 
           eternal="false"
           maxEntriesLocalHeap="0" 
           timeToIdleSeconds="50">
    </cache>
</ehcache>

這裡的name可以多個，與@CacheConfig的cacheNames對應

application.properties 新增

spring.cache.type=ehcache
spring.cache.ehcache.config=classpath:ehcache.xml

3、新增快取註解

在前文基礎之上進行修改新增

Service層

package com.phil.springboot.service.impl;

import java.util.List;
import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheConfig;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;

import com.phil.springboot.mappper.QuestionMapper;
import com.phil.springboot.service.QuestionService;

@Service
@CacheConfig(cacheNames = "question")
public class QuestionServiceImpl implements QuestionService {

	@Autowired
	private QuestionMapper questionMapper;
	
	@Transactional(propagation=Propagation.SUPPORTS,readOnly=true)
	@Override
	@Cacheable(key = "#params")
	public List<Map<String, Object>> findByPage(Map<String, Object> params) {
		return questionMapper.findByPage(params);
	}
	
	@Transactional(propagation=Propagation.SUPPORTS,readOnly=true)
	@Override
	@Cacheable(key = "#params")
	public Map<String, Object> findByProperty(Map<String, Object> params) {
		return questionMapper.findByProperty(params);
	}
	
	@Transactional(propagation=Propagation.REQUIRED, rollbackFor=Exception.class)
	@Override
	@CachePut(key = "#params")
	public Integer saveOrUpdate(Map<String, Object> params){
		Integer i = 0;
		if (StringUtils.isEmpty(params.get("id"))) {
			i = questionMapper.save(params);
		} else {
			i = questionMapper.update(params);
			i ++;
		}
		return i;
	}
	
	@Transactional(propagation=Propagation.REQUIRED, rollbackFor=Exception.class)
	@CacheEvict(key = "#ids")
	@Override
	public Integer delete(String ids){
		if(StringUtils.isEmpty(ids)){
			return -1;
		}
		String[] strs = ids.trim().split(",");
		Integer[] ids_ = new Integer[strs.length];
		for(int i = 0; i < strs.length; i++){
			ids_[i] = Integer.parseInt(strs[i]);
		}
		return questionMapper.delete(ids_);
	}
}

控制層

package com.phil.springboot.controller;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.phil.springboot.service.QuestionService;

import io.swagger.annotations.Api;

@Api(value = "問題Rest介面")
@RestController
@RequestMapping("api/question")
public class QuestionController {
	
	private Logger logger = LoggerFactory.getLogger(this.getClass());

	@Autowired
	private QuestionService questionService;
	
	@PostMapping("list")
	public Map<String, Object> list(@RequestBody Map<String, Object> map) {
		Map<String, Object> data = new HashMap<String, Object>();
		List<Map<String, Object>> list;
		try {
			list = questionService.findByPage(map);
			data.put("msg", list);
			data.put("code", 200);
		} catch (Exception e) {
			data.put("msg", e.getMessage());
			data.put("code", -1);
		}
		logger.debug("list {}" , data);
		return data;
	}
	
	@GetMapping("get/{id}")
	public Map<String, Object> get(@PathVariable("id")Integer id) {
		Map<String, Object> data = new HashMap<String, Object>();
		Map<String, Object> params = new HashMap<String, Object>();
		params.put("id", id);
		Map<String, Object> map;
		try {
			map = questionService.findByProperty(params);
			data.put("msg", map);
			data.put("code", 200);
		} catch (Exception e) {
			data.put("msg", e.getMessage());
			data.put("code", -1);
		}
		logger.debug("get {}" , data);
		return data;
	}
	
	@PostMapping("put")
	public Map<String, Object> put(@RequestBody Map<String, Object> map) {
		Map<String, Object> data = new HashMap<String, Object>();
		Integer i = questionService.saveOrUpdate(map);
		logger.debug("put status {}" , i);
		if(i == 1){
			data.put("msg", "新增成功");
			data.put("code", 200);
		} else if (i == 2) {
			data.put("msg", "修改成功");
			data.put("code", 200);
		} else {
			data.put("msg", "資料處理失敗");
			data.put("code", -1);
		}
		logger.debug("put {}" , data);
		return data;
	}

	@PostMapping("delete")
	public Map<String, Object> delete(@RequestBody String ids) {
		Map<String, Object> data = new HashMap<String, Object>();
		Integer i = questionService.delete(ids);
		logger.debug("delete {}" , i);
		if(i > 0){
			data.put("msg", "刪除成功");
			data.put("code", 200);
		} else {
			data.put("msg", "刪除失敗");
			data.put("code", -1);
		}
		logger.debug("delete {}" , data);
		return data;
	}
}

啟動類

新增 @EnableCaching 註解，開啟快取功能

4、介面測試

1）List :http://localhost:8081/api/question/list

連續發起兩次list請求

2018-04-04 16:23:40.807 |-DEBUG [http-nio-8081-exec-2] com.phil.springboot.mappper.QuestionMapper.findByPage [159] -| ==>  Preparing: select id, number, description from question 
2018-04-04 16:23:40.808 |-DEBUG [http-nio-8081-exec-2] com.phil.springboot.mappper.QuestionMapper.findByPage [159] -| ==> Parameters: 
2018-04-04 16:23:40.810 |-DEBUG [http-nio-8081-exec-2] com.phil.springboot.mappper.QuestionMapper.findByPage [159] -| <==      Total: 15
2018-04-04 16:23:40.811 |-DEBUG [http-nio-8081-exec-2] com.phil.springboot.controller.QuestionController [43] -| list {code=200, msg=[{id=24, description=問題三不需要描述了, number=3}, {id=25, description=問題四描述, number=4}, {id=27, description=問題四描述, number=4}, {id=29, description=問題二描述, number=2}, {id=30, description=問題三描述, number=3}, {id=31, description=問題四描述, number=4}, {id=32, description=問題40描述, number=40}, {id=33, description=問題63描述, number=63}, {id=36, description=問題87描述, number=87}, {id=39, description=新問題, number=6}, {id=40, description=新問題, number=6}, {id=41, description=新問題, number=8}, {id=42, description=新問題, number=118}, {id=43, description=新問題, number=119}, {id=44, description=新問題, number=119}]}
2018-04-04 16:23:44.887 |-DEBUG [http-nio-8081-exec-3] com.phil.springboot.controller.QuestionController [43] -| list {code=200, msg=[{id=24, description=問題三不需要描述了, number=3}, {id=25, description=問題四描述, number=4}, {id=27, description=問題四描述, number=4}, {id=29, description=問題二描述, number=2}, {id=30, description=問題三描述, number=3}, {id=31, description=問題四描述, number=4}, {id=32, description=問題40描述, number=40}, {id=33, description=問題63描述, number=63}, {id=36, description=問題87描述, number=87}, {id=39, description=新問題, number=6}, {id=40, description=新問題, number=6}, {id=41, description=新問題, number=8}, {id=42, description=新問題, number=118}, {id=43, description=新問題, number=119}, {id=44, description=新問題, number=119}]}

2）http://localhost:8081/api/question/get/24

連續發起兩次get請求

2018-04-04 16:25:52.984 |-DEBUG [http-nio-8081-exec-6] com.phil.springboot.mappper.QuestionMapper.findByProperty [159] -| ==>  Preparing: select id, number, description from question WHERE id = ? 
2018-04-04 16:25:52.985 |-DEBUG [http-nio-8081-exec-6] com.phil.springboot.mappper.QuestionMapper.findByProperty [159] -| ==> Parameters: 24(Integer)
2018-04-04 16:25:52.986 |-DEBUG [http-nio-8081-exec-6] com.phil.springboot.mappper.QuestionMapper.findByProperty [159] -| <==      Total: 1
2018-04-04 16:25:52.987 |-DEBUG [http-nio-8081-exec-6] com.phil.springboot.controller.QuestionController [61] -| get {code=200, msg={id=24, description=問題三不需要描述了, number=3}}
2018-04-04 16:25:55.310 |-DEBUG [http-nio-8081-exec-7] com.phil.springboot.controller.QuestionController [61] -| get {code=200, msg={id=24, description=問題三不需要描述了, number=3}}

3）http://localhost:8081/api/question/put

{
  "description": "新問題",
  "number": 150
}

發起儲存

2018-04-04 16:27:28.300 |-DEBUG [http-nio-8081-exec-10] com.phil.springboot.mappper.QuestionMapper.save [159] -| ==>  Preparing: insert into question (number,description) values (?, ?) 
2018-04-04 16:27:28.301 |-DEBUG [http-nio-8081-exec-10] com.phil.springboot.mappper.QuestionMapper.save [159] -| ==> Parameters: 150.0(Double), 新問題(String)
2018-04-04 16:27:28.302 |-DEBUG [http-nio-8081-exec-10] com.phil.springboot.mappper.QuestionMapper.save [159] -| <==    Updates: 1
2018-04-04 16:27:28.306 |-DEBUG [http-nio-8081-exec-10] com.phil.springboot.controller.QuestionController [79] -| save {code=200, msg=新增成功}

4)http://localhost:8081/api/question/put

 {
      "id": 24,
      "description": "問題三三三不需要描述了",
      "number": 333
}

發起update

2018-04-04 16:55:26.791 |-DEBUG [http-nio-8081-exec-4] com.phil.springboot.mappper.QuestionMapper.update [159] -| ==>  Preparing: update question set number = ?, description = ? where id = ? 
2018-04-04 16:55:26.791 |-DEBUG [http-nio-8081-exec-4] com.phil.springboot.mappper.QuestionMapper.update [159] -| ==> Parameters: 333.0(Double), 問題三三三不需要描述了(String), 24.0(Double)
2018-04-04 16:55:26.793 |-DEBUG [http-nio-8081-exec-4] com.phil.springboot.mappper.QuestionMapper.update [159] -| <==    Updates: 1

沒有日誌列印，但返回修改後的物件資料，說明快取中的資料已經同步。（增加了一個新的Key）

目前發現個bug，gson會把int long自動轉換為double

三、整合Redis 快取

1、新增依賴

<!-- Redis 依賴 -->
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

2、安裝Redis並配置

再加上以下指令碼檔案

startup.bat

redis-server.exe redis.windows.conf

service-install.bat

redis-server.exe --service-install redis.windows.conf --loglevel verbose

uninstall-service.bat

redis-server --service-uninstall

查詢Redis所有Key的命令

redis 127.0.0.1:6379> KEYS *

application-local.properties新增redis的配置（檢視RedisProperties.class原始碼，部分已經預設）

#spring.redis.host=localhost
spring.redis.password=
#spring.redis.port=6379
spring.redis.timeout=3000

把原來ehcache.xml rename為ehcache.xml--，啟動類的@EnableCaching去除就可以完全使用Redis快取。

3、建立配置類

package com.phil.springboot.config;

import java.time.Duration;
import java.util.HashMap;
import java.util.Map;

import org.springframework.boot.autoconfigure.data.redis.RedisProperties;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.cache.RedisCacheWriter;
import org.springframework.data.redis.connection.RedisConnectionFactory;

@Configuration
@EnableConfigurationProperties(RedisProperties.class)
@EnableCaching
public class RedisCacheManagerConfig {

//	@Bean
//	@ConditionalOnMissingBean(name = "redisTemplate")
//	public RedisTemplate<?, ?> redisTemplate(RedisConnectionFactory redisConnectionFactory)
//			throws UnknownHostException {
//		RedisTemplate<?, ?> template = new RedisTemplate<>();
//		template.setConnectionFactory(redisConnectionFactory);
//		return template;
//	}

	@Bean
//	public CacheManager cacheManager(RedisTemplate<?, ?> redisTemplate) {
	public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
		/**1.x寫法 
		RedisCacheManager cacheManager = new RedisCacheManager(redisTemplate);
		//cacheManager.setDefaultExpiration(3000); // =Sets the default expire time
		 */
		//2.x寫法
		//question資訊快取配置
	    RedisCacheConfiguration questionCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig().entryTtl(Duration.ofMinutes(30)).disableCachingNullValues().prefixKeysWith("question");
	    Map<String, RedisCacheConfiguration> redisCacheConfigurationMap = new HashMap<>();
	    redisCacheConfigurationMap.put("question", questionCacheConfiguration);
	    
	    //初始化一個RedisCacheWriter
	    RedisCacheWriter redisCacheWriter = RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory);
	    
	    //設定CacheManager的值序列化方式為JdkSerializationRedisSerializer,但其實RedisCacheConfiguration預設就是使用StringRedisSerializer序列化key，JdkSerializationRedisSerializer序列化value,所以以下注釋程式碼為預設實現
	    //ClassLoader loader = this.getClass().getClassLoader();
	    //JdkSerializationRedisSerializer jdkSerializer = new JdkSerializationRedisSerializer(loader);
	    //RedisSerializationContext.SerializationPair<Object> pair = RedisSerializationContext.SerializationPair.fromSerializer(jdkSerializer);
	    //RedisCacheConfiguration defaultCacheConfig=RedisCacheConfiguration.defaultCacheConfig().serializeValuesWith(pair);   
	    RedisCacheConfiguration defaultCacheConfig = RedisCacheConfiguration.defaultCacheConfig();
	    //設定預設超過期時間是30秒
	    defaultCacheConfig.entryTtl(Duration.ofSeconds(30));
	    //初始化RedisCacheManager
	    RedisCacheManager cacheManager = new RedisCacheManager(redisCacheWriter, defaultCacheConfig, redisCacheConfigurationMap);
		return cacheManager;
	}
	
}

在專案中可以直接引用RedisTemplate 和 StringRedisTemplate 兩個模板進行資料操作，或者自定義封裝API

4、介面測試

略，同上（可通過查詢Redis所有Key的命令發現快取的Key變化）

5、Redis測試

package com.phil.springboot.redis;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest
public class RedisTest {

	@Autowired
	private StringRedisTemplate stringRedisTemplate;

	@Test
	public void testSet() {
		String key = "name";
		String value = "zhangsan";
		stringRedisTemplate.opsForValue().set(key, value);
	}

	@Test
	public void testGet() {
		String key = "name";
		String value = stringRedisTemplate.opsForValue().get(key);
		System.out.println(value);
	}

	@Test
	public void testDelete() {
		String key = "name";
		stringRedisTemplate.delete(key);
	}
}

四、整合Redis 叢集

1、新增依賴

在3.1基礎之上，在pom.xml繼續新增

<dependency>
	<groupId>redis.clients</groupId>
	<artifactId>jedis</artifactId>
</dependency>

2、配置檔案

在application-local.properties新增以下配置

spring.redis.pool.max-idle=8
spring.redis.pool.max-wait=-1
spring.redis.cluster.nodes=127.0.0.1:6379,127.0.0.1:6380,127.0.0.1:6381,127.0.0.1:6382,127.0.0.1:6383,127.0.0.1:6384
spring.redis.commandTimeout=5000

3、配置類

package com.phil.springboot.config;

import java.time.Duration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.data.redis.RedisProperties;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.cache.RedisCacheWriter;
import org.springframework.data.redis.connection.RedisConnectionFactory;

import redis.clients.jedis.HostAndPort;
import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.JedisPoolConfig;

@Configuration
@EnableConfigurationProperties(RedisProperties.class)
@EnableCaching
public class RedisCacheManagerConfig {

	@Value("${spring.redis.cluster.nodes}")
	private String clusterNodes;

	@Value("${spring.redis.pool.max-idle}")
	private int maxIdle;

	@Value("${spring.redis.pool.max-wait}")
	private int maxWait;

	@Value("${spring.redis.commandTimeout}")
	private int commandTimeout;

	// @Bean
	// @ConditionalOnMissingBean(name = "redisTemplate")
	// public RedisTemplate<?, ?> redisTemplate(RedisConnectionFactory
	// redisConnectionFactory)
	// throws UnknownHostException {
	// RedisTemplate<?, ?> template = new RedisTemplate<>();
	// template.setConnectionFactory(redisConnectionFactory);
	// return template;
	// }

	@Bean
	public JedisCluster getJedisCluster() {
		String[] c_nodes = clusterNodes.split(",");
		Set<HostAndPort> nodes = new HashSet<>();
		// 分割叢集節點
		for (String node : c_nodes) {
			String[] h = node.split(":");
			nodes.add(new HostAndPort(h[0].trim(), Integer.parseInt(h[1].trim())));
			System.err.println("h[1] = " + h[1].trim());
		}
		JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
		jedisPoolConfig.setMaxIdle(maxIdle); //預設是8
		jedisPoolConfig.setMaxWaitMillis(maxWait);//預設是-1
		return new JedisCluster(nodes, commandTimeout, jedisPoolConfig);
	}

	@Bean
	// public CacheManager cacheManager(RedisTemplate<?, ?> redisTemplate) {
	public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
		/**
		 * 1.x寫法 RedisCacheManager cacheManager = new RedisCacheManager(redisTemplate);
		 * //cacheManager.setDefaultExpiration(3000); // =Sets the default expire time
		 */
		// 2.x寫法
		// question資訊快取配置
		// RedisClusterConnection redisClusterConnection = new
		// JedisClusterConnection(getJedisCluster());
		RedisCacheConfiguration questionCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
				.entryTtl(Duration.ofMinutes(30)).disableCachingNullValues().prefixKeysWith("question");
		Map<String, RedisCacheConfiguration> redisCacheConfigurationMap = new HashMap<>();
		redisCacheConfigurationMap.put("question", questionCacheConfiguration);
		System.err.println("question 快取 啟動");
		// 初始化一個RedisCacheWriter
		RedisCacheWriter redisCacheWriter = RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory);
		// 設定CacheManager的值序列化方式為JdkSerializationRedisSerializer,但其實RedisCacheConfiguration預設就是使用StringRedisSerializer序列化key，JdkSerializationRedisSerializer序列化value,所以以下注釋程式碼為預設實現
		// ClassLoader loader = this.getClass().getClassLoader();
		// JdkSerializationRedisSerializer jdkSerializer = new
		// JdkSerializationRedisSerializer(loader);
		// RedisSerializationContext.SerializationPair<Object> pair =
		// RedisSerializationContext.SerializationPair.fromSerializer(jdkSerializer);
		// RedisCacheConfiguration
		// defaultCacheConfig=RedisCacheConfiguration.defaultCacheConfig().serializeValuesWith(pair);
		RedisCacheConfiguration defaultCacheConfig = RedisCacheConfiguration.defaultCacheConfig();
		// 設定預設超過期時間是30秒
		defaultCacheConfig.entryTtl(Duration.ofSeconds(30));
		// 初始化RedisCacheManager
		RedisCacheManager cacheManager = new RedisCacheManager(redisCacheWriter, defaultCacheConfig,
				redisCacheConfigurationMap);
		return cacheManager;
	}
}

4、介面測試

略

Spring Boot 學習之快取和 NoSQL 篇（四）

該系列並非完全原創，官方文件、作者一、前言當系統的訪問量增大時，相應的資料庫的效能就逐漸下降。但是，大多數請求都是在重複的獲取相同的資料，如果使用快取，將結果資料放入其中可以很大程度上減輕資料庫的負擔，提升系統的響應速度。本篇將介紹 Spring Boot 中快取和 NoSQ

Spring Boot學習之Logback和Log4j2整合與日誌發展史

一、簡介 Java知名的日誌有很多，比如：JUL、Log4j、JCL、SLF4J、Logback、Log4j2，那麼這些日誌框架之間有著怎樣的關係？誕生的原因又是解決什麼問題？下面一起來看。 1.1 JUL Java有自己的日誌框架JUL（Java Util Logging）在java.

spring原始碼學習之路---IOC實現原理（二）

上一章我們已經初步認識了BeanFactory和BeanDefinition，一個是IOC的核心工廠介面，一個是IOC的bean定義介面，上章提到說我們無法讓BeanFactory持有一個Map package org.springframework.beans.factory.supp

C++學習之迴圈和關係表示式（1）

在c語言中我這部分還算學習的挺好，所以這部分我只新增一些我不太懂的點： 1.通常,cout在顯示bool值之前將它們轉換為int，但是在前面使用cout.setf(ios:boolalpha)函式呼叫設定了一個標記，該標記命令cout顯示true和false，而不是1和0；

spring cloud 學習之服務註冊及發現（eureka）（一）

首先，spring cloud使用的基礎是spring boot ，建立在能熟悉spring boot的基礎之上。開發工具使用IDEA ，jdk選用8。一、搭建eureka註冊中心 1、建立spring boot工程，eureka-server，pom.xm

Spring原始碼學習之IOC容器實現原理（一）-DefaultListableBeanFactory

從這個繼承體系結構圖來看，我們可以發現DefaultListableBeanFactory是第一個非抽象類，非介面類。實際IOC容器。所以這篇部落格以DefaultListableBeanFactoryIOC容器為基準進行IOC原理解析。一.兩個重要介面前面已經分析了BeanFactor，它的三個直接子

Spring原始碼學習之路---IOC實現原理（三）

原文地址：https://blog.csdn.net/zuoxiaolong8810/article/details/8548478 上一章我們已經初步認識了BeanFactory和BeanDefinition，一個是IOC的核心工廠介面，一個是IOC的be

機器學習之支持向量機（四）

應用問題計算過程非線性簡單常熟一段約束有關引言：　　SVM是一種常見的分類器，在很長一段時間起到了統治地位。而目前來講SVM依然是一種非常好用的分類器，在處理少量數據的時候有非常出色的表現。SVM是一個非常常見的分類器，在真正了解他的原理之前我們多多少少

spring boot 整合thyemleaf基本使用條件判斷（四）

thyemleaf基本使用條件判斷  <span th:if="${sex}=='男'"> 性別：男 </span> <span th:if="${sex}=='女'">

pandas縱向學習之10 minutes to pandas（四）

時間序列 resample函式的用法： In [14]: rng = pd.date_range('1/1/2012', periods=100, freq='S') In [15]: ts = pd.Series(np.random.randint(0, 500, len(rn

Qt網路程式設計之QNetworkRequest和QNetworkReply例項（四）

設想有如下場景：輸入若干的url，然後依次的下載並存儲到檔案。本案例使用QNetworkRequest和QNetworkReply。原始碼如下：案例原始碼標頭檔案 #pragma once //////////////////////////////////

linux安全和加密篇（四）—openssl證書申請和建立CA

OpenSSL證書申請 1、PKI： Public Key Infrastructure CA 證書頒發機構 RA 證書請求機構 request CRL 2、建立私有CA: 搭建CA OpenCA

Linux學習之多執行緒程式設計（四）

言之者無罪，聞之者足以戒。 ——《詩序》三、Linux執行緒的高階控制 1、一次性初始化有些事需要且只能執行一次（比如互斥量初始化）。通常當初始化應用程式時，可以比較容易地將其放在main函式中。但當你寫一個庫函式時，就不能在main裡面初始化了，你可以用靜態初始化

Spring Boot 學習之持久層篇（三）

該系列並非完全原創，官方文件、作者一、前言上一篇《Spring Boot 入門之 Web 篇（二）》介紹了 Spring Boot 的 Web 開發相關的內容，專案的開發離不開資料，因此本篇開始介紹持久層相關的知識。二、整合 JdbcTemplate1、新增依賴在pom.xm

Spring Boot 學習之基礎篇（一）

該系列並非完全原創，官方文件、作者Spring Boot 是由 Pivotal 團隊提供的全新框架，其設計目的是用來簡化新 Spring 應用的初始搭建以及開發過程。該框架使用了特定的方式來進行配置，從而使開發人員不再需要定義樣板化的配置。一、環境搭建建立一個Maven專案，

Spring Boot 學習之 Web 篇（二）

該系列並非完全原創，官方文件、作者一、前言上一篇《Spring Boot 入門之基礎篇（一）》介紹了 Spring Boot 的環境搭建以及專案啟動打包等基礎內容，本篇繼續深入介紹 Spring Boot 與 Web 開發相關的知識。二、整合模板引擎由於 jsp 不被 Spr

spring boot 學習之路3（集成mybatis ）

sys pat min lba asn ria [] system emp 下面就簡單來說一下spring boot 與mybatiis的整合問題，如果你還沒學習spring boot的註解的話，要先去看spring boot的註解好了，現在讓我們來搞一下與mybat

Spring Boot 學習之路——4 AOP註解方式實現列印日誌

前言：據XX統計，四分之一的程式碼都是日誌有關，日誌對於定位和解決問題尤為重要，以前公司的編碼規範中要求介面必須在日誌中記錄入參和返回值以及關鍵程式碼，引數部分完全可以用Spring的AOP——面向切面來實現。什麼叫AOP？百度：AOP(Aspect Oriented Pro

Spring Boot學習之旅：（四）springboot 整合 fastjson

springboot 預設使用的 jackson 但是聽說某寶的fastjson 效能很好，而且平時用的習慣，所以來整合一下。首先在pom 中匯入依賴 <dependency> <groupId>

Spring Boot 學習之路——1 入門demo

前言：使用Spring Boot已有一年多時間，卻從未靜下心來總結，今天抽空寫個傻瓜式教程，鞏固一下。Spring Boot的主要優點：為所有Spring開發者更快的入門開箱即用，提供各種預設配置來簡化專案配置內嵌式容器簡化Web專案沒有冗餘程式碼生成和XML配置的要求（Sp

Spring Boot 學習之快取和 NoSQL 篇（四）

一、前言

二、整合EhCache 快取

1、新增依賴

2、新增配置

3、新增快取註解

4、介面測試

三、整合Redis 快取

1、新增依賴

2、安裝Redis並配置

3、建立配置類

4、介面測試

5、Redis測試

四、整合Redis 叢集

1、新增依賴

2、配置檔案

3、配置類

4、介面測試

相關推薦