国产xxxx99真实实拍_久久不雅视频_高清韩国a级特黄毛片_嗯老师别我我受不了了小说

資訊專欄INFORMATION COLUMN

java | Spring Boot 與 Redis 實現 Cache 以及 Session 共享

ssshooter / 2126人閱讀

摘要：完成狀態編寫中已完成維護中原文是一個使用編寫的開源支持網絡基于內存可選持久性的鍵值對存儲數據庫維基百科是目前業界使用廣泛的基于內存的數據庫。

完成狀態

[ ] 編寫中

[ ] 已完成

[x] 維護中

原文

Redis 
Redis是一個使用ANSI C編寫的開源、支持網絡、基于內存、可選持久性的鍵值對存儲數據庫   ------  維基百科

Redis 是目前業界使用廣泛的基于內存的 Key-Value數據庫。 其提供了豐富的數據結構，不僅限于字符串類型，例如hash, lists ,sets等復雜數據結構，同時提供了數據持久化功能。其基于內存的特性以及豐富的數據結構使起非常使用用于緩存系統并且其也提供了一般關系型數據庫所局域的事務，主從數據庫等功能。并且可以方便的實現集群擴展。本文將針對 Redis 以及Spring Boot結合進行簡單介紹

Redis 安裝  
redis 安裝可以參照其他關于Docker 部分內容，實現基于Docker 的redis 服務。這里將不再多帶帶介紹Redis 安裝。如果想要多帶帶安裝Redis 服務，請自行查找

本文將包含以下內容：

Redis 與 Spring boot 整合

Spring Boot 2.0 Redis 集成

Redis應用場景一 ------ 基于Redis 緩存實現

Redis應用場景二 ------ 基于Redis 的共享Session 實現

擴展

IDEA Redis 支持

Redis 與spring boot 整合

1.引入Redis 支持的包

  
    org.springframework.boot  
    spring-boot-starter-redis

2.配置spring boot Redis支持

以下是基于Spring Boot 自動化的屬性配置，其可以參照Spring Boot 配置篇進行多帶帶配置

# Redis數據庫索引（默認為0）
spring.redis.database=0  
# Redis服務器地址
spring.redis.host=192.168.99.100
# Redis服務器連接端口
spring.redis.port=32769  
# Redis服務器連接密碼（默認為空）
spring.redis.password=  
# 連接池最大連接數（使用負值表示沒有限制）
spring.redis.pool.max-active=8  
# 連接池最大阻塞等待時間（使用負值表示沒有限制）
spring.redis.pool.max-wait=-1  
# 連接池中的最大空閑連接
spring.redis.pool.max-idle=8  
# 連接池中的最小空閑連接
spring.redis.pool.min-idle=0  
# 連接超時時間（毫秒）
spring.redis.timeout=0

3.測試

通過以上方式已經完成了Redis 的配置，接下來通過實現測試用例的方式針對Redis進行測試，查看配置是否成功

@RunWith(SpringRunner.class)
@SpringBootTest
public class DemoApplicationTests {
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    @Test
    public void contextLoads() {
    }
    @Test
    public void test(){
        stringRedisTemplate.opsForValue().set("test","redis");
        Assert.assertEquals("redis", stringRedisTemplate.opsForValue().get("test"));
    }
}

注意: 通過以上方式測試，Spring Boot 的版本必須是1.5.x。 可以通過查看pom.xml文件中的內容確定版本


        org.springframework.boot
        spring-boot-starter-parent
        1.5.8.RELEASE
Spring Boot 2.0 Redis 集成

Spring Boot 1.5.8.RELEASE 版本的默認的Redis 客戶端操作采用的是Jedis 實現的，不過最新版本的Spring Boot 添加了lettuce 的實現方式,默認配置中心的Redis 配置進行了區別實現，并且默認采用lettuce 實現的。下面將針對最新版本的Spring Boot 進行兩種不同方式配置測試

Spring Boot 1.5.x 版本Starter Redis pom.xml 內容


        
            org.springframework.boot
            spring-boot-starter
        
        
            org.springframework.data
            spring-data-redis
        
        
            redis.clients
            jedis

Spring Boot 2.x Redis pom.xml 內容


        
            org.springframework.boot
            spring-boot-starter
        
        
            org.springframework.data
            spring-data-redis
            
                
                    org.slf4j
                    jcl-over-slf4j
                
            
        
        
            io.lettuce
            lettuce-core

可以在Spring Boot 下查看具體的Starter引用

Spring Boot 2.0 通過 Jedis 集成 Redis 服務

通過以上不同版本的Redis 集成引用可以發現，默認的2.x版本中，默認只引入了 Lettuce包，并沒有引入Redis包支持，所以如果要實現此功能，必須手動引入具體的包

1.引入需要的jar包


            org.springframework.boot
            spring-boot-starter-data-redis
            
            
            redis.clients
            jedis
            
            
        
        
        redis.clients
        jedis

通過以上方式引入jedis，并且將spring-boot-starter-data-redis中自帶的替換為 jedis

2.修改配置

前面提到了，默認最新版本的將配置進行了分離，所以以上的部分配置已經過期，下面將采用最新的配置

# Redis數據庫索引（默認為0）
spring.redis.database=0
# Redis服務器地址
spring.redis.host=192.168.99.100
# Redis服務器連接端口
spring.redis.port=32770
# Redis服務器連接密碼（默認為空）
spring.redis.password=
spring.redis.jedis.pool.max-active=8
spring.redis.jedis.pool.max-wait=-1
spring.redis.jedis.pool.min-idle=0
spring.redis.jedis.pool.max-idle=8

3.jedis 配置

通過以上配置實現的，在新的版本下是無法正常工作的，因為默認采用的Lettuce實現的，所以無法初始化出Jedis 的連接對象JedisConnectionFactory，需要自己創建并自行注入

public class JedisRedisConfig {
    @Bean
    JedisConnectionFactory jedisConnectionFactory() {
        JedisConnectionFactory factory = new JedisConnectionFactory();
        return factory;
    }

通過以上方式，你會發現，還是無法測試通過，默認可能會報一下兩個錯誤

錯誤原因:commons-pool2庫缺失


        org.apache.commons
        commons-pool2
        2.4.2


錯誤原因 : jedis 版本低或者maven導入失敗

錯誤原因: redis 連接失敗， 不止為何，spring boot 2.x 通過以上方式集成jedis，但是其不會讀取配置文件中的spring.redis.host等這樣的配置，需要自己手動設置

如果有人知道為什么，還請告知，感激不盡,或者我后續研究會補上具體的原因內容

雖然系統沒有提供正確的支持，不過我們可以通過自己的配置實現具體的功能支持，通過添加以下配置內容

@Configuration
@PropertySource(value = "classpath:/application.properties")
public class JedisRedisConfig {

    @Value("${spring.redis.host}")
    private  String host;
    @Value("${spring.redis.password}")
    private  String password;
    @Value("${spring.redis.port}")
    private  int port;
    @Value("${spring.redis.timeout}")
    private  int timeout;

    @Bean
    JedisConnectionFactory jedisConnectionFactory() {
        JedisConnectionFactory factory = new JedisConnectionFactory();
        factory.setHostName(host);
        factory.setPort(port);
        factory.setTimeout(timeout); //設置連接超時時間
        return factory;
    }
}

將系統配置設置為以上形式，就可以連接正確的redis 服務了，如果不設置，將采用默認配置連接的是localhost 的redis服務

4.測試

ok, 通過以上配置，運行測試用例, jedis 測試是可以連通的

Spring Boot 2.0 通過 Lettuce 集成 Redis 服務

1.導入包

默認的 Spring Boot 2.x 已經采用Lettuce為默認實現，所以只需要導入默認的 Redis支持包就好

        
            org.springframework.boot
            spring-boot-starter-data-redis
        
        
            org.apache.commons
            commons-pool2

2.配置

spring.redis.database=0
# Redis服務器地址
spring.redis.host=192.168.99.100
# Redis服務器連接端口
spring.redis.port=32770
# Redis服務器連接密碼（默認為空）
spring.redis.password=
spring.redis.lettuce.pool.max-active=8
spring.redis.lettuce.pool.max-wait=-1
spring.redis.lettuce.shutdown-timeout=100
spring.redis.lettuce.pool.max-idle=8
spring.redis.lettuce.pool.min-idle=0

3.測試連接

通過單元測試，測試是否連接通過

Redis應用場景一 ------ 基于Redis 緩存實現

由于Redis獨特的基于內存設計，優越性能以及豐富的數據結構，非常適合用于作為緩存系統實現，下面將實現基于Spring Boot與Redis 的緩存系統實現

緩存 
磁盤緩存（Disk Buffer）或磁盤快取（Disk Cache）實際上是將下載到的數據先保存于系統為軟件分配的內存空間中（這個內存空間被稱之為“內存池”），當保存到內存池中的數據達到一個程度時，便會將數據保存到硬盤中。這樣可以減少實際的磁盤操作，有效的保護磁盤免于重復的讀寫操作而導致的損壞。
磁盤緩存是為了減少CPU透過I/O讀取磁盤機的次數，提升磁盤I/O的效率，用一塊內存來儲存存取較頻繁的磁盤內容；因為內存的存取是電子動作，而磁盤的存取是機械動作，感覺上磁盤I/O變得較為快速。
相同的技巧可用在寫入動作，我們先將欲寫入的內容放入內存中，等到系統有其它空閑的時間，再將這塊內存的資料寫入磁盤中。 ------   維基百科

以上內容是維基百科中關于磁盤緩存的介紹，在大型網絡應用程序中，緩存的應用和磁盤緩存一樣，都是為了提高讀寫性能，網絡應用中減少對數據庫的訪問就可以一定程度上很好的提高性能(數據庫訪問還是對磁盤I/O 訪問，到最后還是磁盤讀取的問題)

緩存實現

通過以上配置實現Redis 支持
首先先通過以上內容實現Redis的正確支持

開啟緩存機制
Spring Boot 針對緩存支持比較完備，不需要更多的配置，只需要一個注解就可以開啟緩存，通過@EnableCaching 

    @SpringBootApplication
    @EnableCaching
    public class DemoApplication {

            public static void main(String[] args) {
                SpringApplication.run(DemoApplication.class, args);
            }
    }

通過以上方式雖然可以開啟緩存功能，不過還是推薦下面的方式，為緩存操作多帶帶創建配置類，方便管理并且方便自定義緩存功能

@Configuration
@EnableCaching
public class CacheConfig extends CachingConfigurerSupport {
    // cache 功能
        @Override
    public CacheManager cacheManager() {
        return null;
    }

    @Override
    public KeyGenerator keyGenerator() {
        return null;
    }

    @Override
    public CacheResolver cacheResolver() {
        return null;
    }

    @Override
    public CacheErrorHandler errorHandler() {
        return null;
    }
}

CachingConfigurerSupport 類是 Spring Cache 模塊下的關于cache配置的支持類，其中默認定義了四個關于緩存配置的4個方法，默認都是返回 null 以使用系統默認的緩存設置
我們可以通過重寫此方法，進行自定義的操作，比如自定義緩存key的生成策略等。默認的生成策略是看不懂的(亂碼內容) 通過Spring 的依賴注入特性進行自定義的配置注入并且此類是一個配置類可以更多程度的自定義配置

    @Override
    @Bean
    public KeyGenerator keyGenerator() {
        return  new KeyGenerator() {
            @Override
            public Object generate(Object target, Method method, Object... params) {
                StringBuilder stringBuilder = new StringBuilder();
                stringBuilder.append(target.getClass().getName());
                stringBuilder.append(method.getName());
                for (Object object : params){
                    stringBuilder.append(object.toString());
                }
                return  stringBuilder.toString();
            }
        };
    }

以上通過自定義key生成策略，通過自定義的策略規則，替換系統自動的策略規則(__Spring Cloud微服務部分會針對此處進行更加細致的配置，來確定來自哪個服務，如果感興趣先看看如何實現__)

3.Spring Boot 緩存支持
Spring Boot 是通過注解來進行緩存操作的，通過輸入 cache，可以看到，Spring Boot默認支持一下幾個緩存相關注解

以上截圖中只有5個 還是有一個沒有@Caching注解
下面將針對每個注解進行詳細的介紹:

@EnableCaching
此注解在上邊已經使用過了，其目的就是為了開啟緩存
次注解對應到XML配置中就是一下內容

@CacheConfig
通過名稱就可以看出，次注解是對cache配置注解(是類級別的)

    public @interface CacheConfig {
        String[] cacheNames() default {};
        String keyGenerator() default "";
        String cacheManager() default "";
        String cacheResolver() default "";
    }

以上是此注解的內容，其中和CachingConfigurerSupport中部分相對應，設置關于注解的

cacheNames: 設置緩存存儲的名稱,允許提供多個

keyGenerator: 配置緩存key生成策略，默認采用的是系統自定義的(接下來對默認規則介紹),通過設置此屬性給定自定義的key生成規則，此處需要給出一個bean名稱實現(此處spring 默認生成bean名稱是類名首字母小寫，此處需要自己給出正確的bean名稱，可以通過自定義實現key生成策略)

cacheManager: 給定義緩存管理器bean 名稱，默認會根據使用的緩存策略的不同生成不同的管理器，比如Redis 生成的就是 RedisCacheManager類的實例，默認系統實現的是一個 SimpleCacheManager, 使用的和keyGenerator規則相同

cacheResolver:

@Cacheable
用于設置支持緩存，一般用于需要緩存的方法上進行數據緩存操作實現，訪問此方法時先查詢緩存是否存在對應的緩存值，沒有執行具體查詢操作，并將查詢結果寫入緩存中(方法級別)

@AliasFor("cacheNames")
String[] value() default {};
@AliasFor("value")
String[] cacheNames() default {};
String key() default "";
String keyGenerator() default "";
String cacheManager() default "";
String cacheResolver() default "";
String condition() default "";
String unless() default "";
boolean sync() default false;

以上是此注解的全部內容

value,cacheNames: 這兩個注解功能相同，就是設置緩存的名稱,允許設置多個，在方法執行之前，每個緩存都將被檢測，只要一個檢測到有內容那么就直接返回，不執行方法體。如果都沒有那么執行過后每個緩存都將設置內容(一般情況下只用設置一個)

key： 設置緩存內容所對應的key

        //給出了通過 SpEL表達式生成key 的實例  
        @Cacheable(cacheNames="books", key="#isbn")
        public Book findBook(ISBN isbn, boolean checkWarehouse, boolean includeUsed)

        @Cacheable(cacheNames="books", key="#isbn.rawNumber")
        public Book findBook(ISBN isbn, boolean checkWarehouse, boolean includeUsed)

        @Cacheable(cacheNames="books", key="T(someType).hash(#isbn)")
        public Book findBook(ISBN isbn, boolean checkWarehouse, boolean includeUsed)

由于SpEL表達式的支持，其key 存在的可能性就很多，可以通過SpEL 表達式進行多種形式組合

keyGenerator:指定key 生成策略通過一定的操作自動生成唯一的key , 此參數和 key 參數是互斥的，所以不能同時使用

cacheManager: 用于指定使用哪個緩存管理器

condition: 條件，緩存需要的條件，可以通過設置此屬性，對內容進行條件性緩存，只有滿足條件了才進行緩存

unless: 此屬性和condition一樣都是設置條件的，不過此屬性時針對執行后的判斷，可以對執行結果進行判斷

@CachePut
次注解用于對緩存的更新上， 使用此注解與@Cacheable不同之處在于方法會被執行，執行過后會更新緩存

@CacheEvict
用于清除緩存

    boolean allEntries() default false;
    boolean beforeInvocation() default false;

此注解相對以上注解添加了兩個屬性

allEntries： 刪除所有緩存，默認是false，不刪除的，只有設置Wie true后會在方法執行后刪除所有緩存

beforeInvocation: 是否在方法執行前就清空,默認是在方法執行后刪除緩存，如果方法執行拋出異常，那么緩存不會被刪除

擴展

  * Spring cache key 生成策略  
       * 默認系統給出的策略是根據方法參數來實現的，如果方法沒有參數則key就為一個`SimpleKey.EMPTY`; 如果方法有一個參數，直接返回對象；如果有多個參數，那么返回的是一個包含所有參數的鍵。  
       * key 生成還支持 `SpEL`表達式生成，通過指定`SpEL`表達式指定key的生成策略  
       * key 還支持通過指定特定的`keyGenerator`屬性，指定一個key 生成器來通過此生成器生成適合的key  
       * 由于項目的需求，可能存在多個需求緩存相同，不過由于參數的不同，可以通過 `SpEL` 實現將對結果無關的參數忽略的形式組合成一組通用的key 實現多個需求可以使用同一份緩存

@Caching
此注解是一個輔助性注解，為了解決在多個相同注解多個同時使用的情況下。此注解允許@Cacheable,@CachePut,@CacheEvict三個注解的操作

    Cacheable[] cacheable() default {};
    CachePut[] put() default {};
    CacheEvict[] evict() default {};

以上是注解的具體內容

    @Caching(evict = { @CacheEvict("primary"), @CacheEvict(cacheNames="secondary", key="#p0") })
    public Book importBooks(String deposit, Date date)

具體的使用示例

如果需要了解詳細的內容，請查詢官方文檔Spring Cache

緩存功能測試

1.實現controller 以及service 代碼

@RestController
@RequestMapping("/cache")
public class CacheController {
    @Autowired
    private CacheService cacheService;
        @GetMapping("/get_user_by_name/{name}")
    public ResponseEntity findByName(@PathVariable String name)
    {
        return new ResponseEntity(cacheService.findByName(name), HttpStatus.OK);
    }

    @GetMapping("/get_user_by_age/{age}")
    public ResponseEntity findByAge(@PathVariable String age)
    {
        return new ResponseEntity(cacheService.findByAge(Integer.parseInt(age)), HttpStatus.OK);
    }
}

@Service
@CacheConfig(cacheNames = "cache")
public class CacheServiceImpl implements CacheService {

    @Cacheable(keyGenerator = "keyGenerator")
    @Override
    public User findByName(String name) {
        System.out.println("findByName沒有加載緩存");
        return  new User((new Long(1)),"張三", 18);
    }
    @Cacheable(keyGenerator = "keyGenerator")
    @Override
    public List findByAge(int age) {
        System.out.println("findByAge沒有加載緩存");
        return (List) new User(new Long(1),"李四", 18);
    }
}

以上是測試需要的代碼，代碼很簡單，不涉及到dao等數據庫操作，只是為了測試緩存功能是否正常

2.測試
通過PostMan 等 REST Ful 等請求模擬測試軟件進行測試 第一次請求單個方法會進打印，不過第二次請求就不會進行打印。以上代碼只是測試了 @Cacheable 請求添加功能具體的其他幾個功能請多帶帶測試
可以通過debug跟蹤到 CacheAspectSupport 類中的execute方法查看緩存值

// CacheAspectSupport 跟蹤方法  
    private Object execute(final CacheOperationInvoker invoker, Method method, CacheOperationContexts contexts) {
        // Special handling of synchronized invocation
        if (contexts.isSynchronized()) {
            CacheOperationContext context = contexts.get(CacheableOperation.class).iterator().next();
            if (isConditionPassing(context, CacheOperationExpressionEvaluator.NO_RESULT)) {
                Object key = generateKey(context, CacheOperationExpressionEvaluator.NO_RESULT);
                Cache cache = context.getCaches().iterator().next();
                try {
                    return wrapCacheValue(method, cache.get(key, new Callable() {
                        @Override
                        public Object call() throws Exception {
                            return unwrapReturnValue(invokeOperation(invoker));
                        }
                    }));
                }
                catch (Cache.ValueRetrievalException ex) {
                    // The invoker wraps any Throwable in a ThrowableWrapper instance so we
                    // can just make sure that one bubbles up the stack.
                    throw (CacheOperationInvoker.ThrowableWrapper) ex.getCause();
                }
            }
            else {
                // No caching required, only call the underlying method
                return invokeOperation(invoker);
            }
        }
        // Process any early evictions
        processCacheEvicts(contexts.get(CacheEvictOperation.class), true,
                CacheOperationExpressionEvaluator.NO_RESULT);

        // Check if we have a cached item matching the conditions
        Cache.ValueWrapper cacheHit = findCachedItem(contexts.get(CacheableOperation.class));

        // Collect puts from any @Cacheable miss, if no cached item is found
        List cachePutRequests = new LinkedList();
        if (cacheHit == null) {
            collectPutRequests(contexts.get(CacheableOperation.class),
                    CacheOperationExpressionEvaluator.NO_RESULT, cachePutRequests);
        }

        Object cacheValue;
        Object returnValue;

        if (cacheHit != null && cachePutRequests.isEmpty() && !hasCachePut(contexts)) {
            // If there are no put requests, just use the cache hit
            cacheValue = cacheHit.get();
            returnValue = wrapCacheValue(method, cacheValue);
        }
        else {
            // Invoke the method if we don"t have a cache hit
            returnValue = invokeOperation(invoker);
            cacheValue = unwrapReturnValue(returnValue);
        }

        // Collect any explicit @CachePuts
        collectPutRequests(contexts.get(CachePutOperation.class), cacheValue, cachePutRequests);

        // Process any collected put requests, either from @CachePut or a @Cacheable miss
        for (CachePutRequest cachePutRequest : cachePutRequests) {
            cachePutRequest.apply(cacheValue);
        }

        // Process any late evictions
        processCacheEvicts(contexts.get(CacheEvictOperation.class), false, cacheValue);

        return returnValue;
    }

說明 : 此處測試比較簡單，只是測試cache功能是否正常，但更加詳細的沒有實現，需要自己實現，往后有時間我會補全更加詳細的測試實現

Redis應用場景二 ------ 基于Redis 的共享 Session 實現

在大型分布式項目中，要保證項目的可伸縮型，帶狀態的 session 共享是越不過去的坎。針對Session 共享實現，業界有不同的實現方式，一種是將Session 直接持久化到數據庫中，不過這種方式針對數據庫的讀寫性能有很大要求，并且效率嚴重的受限于數據庫性能；另一種方式就是直接將數據存儲到Cookie中，但是這種方式由于Cookie的特性，存儲的數據大小受限；相比較下，將Session 存儲在 Redis 中是最好的選擇。其Redis 基于內存的實現滿足了高效性，訪問速度快，并且 Redis 支持集群化，所以不會受限數據庫的問題。下面將介紹基于Redis 實現的共享session

共享 Session 實現

1.引入 session支持包




            org.springframework.session
            spring-session-data-redis
        
        

    org.springframework.session
    spring-session-data-redis


    
            org.springframework.boot
            spring-boot-starter-data-jpa
        
        
            com.h2database
            h2
            1.4.196
            runtime
        


Spring Boot 針對 Redis 實現 Session 共享操作進行了封裝實現，可以很方便的將Session對象直接存儲在 Redis中


2.開啟 Session 支持   
   Spring Boot 中Session 支持多種形式存儲，包括Redis, Mongo,jdbc,hazelcast,hash_map等形式，此處需要指定為Redis,通過修改 application.properties配置文件，添加一下配置


spring.session.store-type=redis


通過以上方式指定session管理方式為redis，并通過一下方式開啟session redis 支持


@Configuration
@EnableRedisHttpSession(maxInactiveIntervalInSeconds = 86400)
public class SessionConfig {
}


Spring Boot 通過注解開啟 Redis 針對 Session 的支持, 此注解針對session進行配置，其內部是自動創建了Spring Bean對象，是一個過濾器bean--- springSessionRepositoryFilter。 關于此部分詳細內容請查詢官方文檔HttpSession with Redis


public @interface EnableRedisHttpSession {
    int maxInactiveIntervalInSeconds() default 1800;

    String redisNamespace() default "";

    RedisFlushMode redisFlushMode() default RedisFlushMode.ON_SAVE;
}


以上內容是此注解的源碼，可以發現，次注解主要設置了三個功能：


* `maxInactiveIntervalInSeconds`: 對應的是session的過期時間，默認是1800秒后過期，用戶可以通過自定義時間，如果設置了此屬性，項目中的`server.session.timeout`屬性將失效， __此處需要注意__  
* `redisNamespace`: 設置redis 的命名空間，就是設置數據存儲到哪里(相當于關系型數據庫中的庫)  
* `redisFlushMode`: redis 操作模式，是否立即刷新到redis數據庫中，默認的是不會的，系統并不是在剛設置就刷新，而是選擇在某個時間點刷新到數據庫中   



3.測試


    @PostMapping("/register")
    public ResponseEntity register(@RequestBody User user, HttpServletRequest request)
    {
        request.getSession().setAttribute("user", user);
        return  new ResponseEntity(userRespository.save(user), HttpStatus.OK);
    }
   @GetMapping("/session")
    public ResponseEntity getSessionMessage(HttpServletRequest request)
    {
        Map map = new HashMap<>();
        map.put("sessionId", request.getSession().getId());
        map.put("message",request.getSession().getAttribute("user")) ;
        return  new ResponseEntity(map, HttpStatus.OK);
    }


以上代碼為測試代碼





測試過程：



啟動項目，通過/register接口注冊用戶，系統會見用戶信息寫入session中


訪問/session 查看session信息


同時在另一個端口上啟動本項目


訪問 /session接口，查看session信息





測試結果：  
通過以上方式測試會發現，本地訪問兩個不同的項目，拿到的session是相同的   



session 的內容以及 session ID 是相同的，達到了session共享的目的



總結

以上介紹了 Redis以及其在 Spring Boot 中的兩種應用方式，緩存和 Session共享。 針對其具體的實現細節以及功能做了簡單介紹，如果需要更加細致的了解。可以根據文中提到參考文章查找更加細致了講解   


由于本人知識水平有限，文章可能會存在錯誤等，如果您有發現還請通過評論等方式聯系我將積極完善和改正，在此不勝感激

擴展
IDEA Redis 支持

IDEA 對通過插件的方式對 Redis 有很好的集成，通過插件可以實現Redis最基本的開發，下面將介紹如何實現


安裝插件



按照以上步驟安裝插件，我這里已經安裝，所有顯示的是update，根據提示安裝插件就好


連接Redis  
安裝完成需要重啟IDEA   


通過以上方式，填寫對應的地址和端口以及密碼等內容，測試連接是否成功 

以上就是Redis支持的操作界面，可以通過此界面操作Redis

參考


Redis的兩個典型應用場景


lettuce--Advanced Redis client


HttpSession with Redis


注釋驅動的 Spring cache 緩存


Cache Abstraction

           
               
                                           
                       
                 
            
                     
             
               

                   
 文章版權歸作者所有，未經允許請勿轉載,若此文章存在違規行為，您可以聯系管理員刪除。

                 
                   
轉載請注明本文地址：http://specialneedsforspecialkids.com/yun/70847.html

               

                      
               
              
              

                
相關文章

                
    
                             
                                                                                                    
  • 
                                                
    
                          
    SpringBoot+Redis+Nginx實現負載均衡以及Session緩存共享
    
                                                     
    摘要：并沒有因為不一致而不同使用連接，確實存儲了一個，如下工程目錄實際操縱過程中遇到一個問題啟動工程的時候報錯解決方法對于依賴，增加了一個，且版本為。啟動，未報錯，問題解決。后續有時間再研究。

1.環境信息nginx-1.11.10redis-latest包（redis windows版本）springboot1.5.1.RELEASE
2.新建一個SpringBoot項目，參考如下鏈接：h...
    
                                                   
                          
    
                                
    
                                    xuxueli
                                    
                                    評論0 
                                    收藏0 
                                
    
                          
    
                      
    
                    
    •  
                                                                                       
  • 
                                                
    
                          
    SpringBoot+Redis+Nginx實現負載均衡以及Session緩存共享
    
                                                     
    摘要：并沒有因為不一致而不同使用連接，確實存儲了一個，如下工程目錄實際操縱過程中遇到一個問題啟動工程的時候報錯解決方法對于依賴，增加了一個，且版本為。啟動，未報錯，問題解決。后續有時間再研究。

1.環境信息nginx-1.11.10redis-latest包（redis windows版本）springboot1.5.1.RELEASE
2.新建一個SpringBoot項目，參考如下鏈接：h...
    
                                                   
                          
    
                                
    
                                    charles_paul
                                    
                                    評論0 
                                    收藏0 
                                
    
                          
    
                      
    
                    
    •  
                                                                           
                

              

              
               

                  
                  
發表評論

                   
               

              

                

                  
0條評論
   
                
 
                      

              

           
           

              
 
                

                   
              
  

                  
最新活動
 
           
                             
              





                                
              

           

        
       
    
    
     

      
    

    
    

    
       
       

         
閱讀需要支付1元查看
  
         
     
       

      
  
    
    








        

            

              
              
            

             
        

    







<