想54256
想54256

Spring Session 源码解读

title: Spring Session 源码解读
date: 2021/02/21 11:00

概述

本文基于以下组合的应用：

Spring Boot 2.1.3.RELEASE

  • SessionAutoConfiguration（@Conditional(Spring Session Core)）
  • RedisSessionConfiguration（@Conditional(Spring Session Data Redis)）

Spring Session Core 2.1.4.RELEASE

Spring Session Data Redis 2.1.3.RELEASE

其中 Spring Session Core 提供了部分接口交由子类实现，一般我们用的实现就是 Spring Session Data Redis

SessionAutoConfiguration

package org.springframework.boot.autoconfigure.session;

// 省略 imports 行

/**
 * EnableAutoConfiguration Auto-configuration for Spring Session.
 *
 * @since 1.4.0
 */
 // 声明这是一个配置类
@Configuration
// 仅在类 Session 存在于 classpath 时候才生效,
// Session 类由包 Spring Session Core 提供
@ConditionalOnClass(Session.class)
// 仅在当前应用是 Web 应用时才生效 : Servlet Web 应用， Reactive Web 应用都可以
@ConditionalOnWebApplication
// 确保如下前缀的配置属性的加载到如下 bean :
// server ==> ServerProperties
// spring.session ==> SessionProperties
@EnableConfigurationProperties({ ServerProperties.class, SessionProperties.class })
// 当前配置必须在指定的自动配置结束之后进行，这里虽然列出了很多，但同一应用中它们未必
// 都存在，这里指的是当前应用中如果它们中间某些存在的话，SessionAutoConfiguration
// 自动配置的执行必须要在这些自动配置结束之后完成,本文的分析使用 Redis 支持 Spring Session,
// 并且是 Servlet Web 应用，所以 RedisAutoConfiguration 会被启用
// 为什么要在 RedisAutoConfiguration 之后执行？
// 因为当前配置类会引入 RedisSessionConfiguration 其需要 RedisAutoConfiguration 自动装配的 RedisConnectionFactory。
@AutoConfigureAfter({ DataSourceAutoConfiguration.class, HazelcastAutoConfiguration.class,
        JdbcTemplateAutoConfiguration.class, MongoDataAutoConfiguration.class,
        MongoReactiveDataAutoConfiguration.class, RedisAutoConfiguration.class,
        RedisReactiveAutoConfiguration.class })
//  在自动配置  HttpHandlerAutoConfiguration 执行前执行      
@AutoConfigureBefore(HttpHandlerAutoConfiguration.class)
public class SessionAutoConfiguration {

    // 内嵌配置子类，针对 Servlet Web 的情况
    @Configuration
    @ConditionalOnWebApplication(type = Type.SERVLET)
    // 1. 导入 ServletSessionRepositoryValidator，确保存储库类型被指定以及相应的存储库类的存在（校验用户填写的 spring.session.store-type 属性，校验容器中有 SessionRepository）；
    // 2. 导入 SessionRepositoryFilterConfiguration，配置 “注册 SessionRepositoryFilter 到 Servlet 容器”的 FilterRegistrationBean
    @Import({ ServletSessionRepositoryValidator.class,
            SessionRepositoryFilterConfiguration.class })
    static class ServletSessionConfiguration {

        // 定义一个 bean  cookieSerializer
        @Bean
        // 仅在条件 DefaultCookieSerializerCondition 被满足时才生效
        // 1. Bean HttpSessionIdResolver 和 CookieSerializer 都不存在 
        // 或者
        // 2. Bean CookieHttpSessionIdResolver 存在 但 bean CookieSerializer 不存在
        @Conditional(DefaultCookieSerializerCondition.class)
        public DefaultCookieSerializer cookieSerializer(
                ServerProperties serverProperties) {
            Cookie cookie = serverProperties.getServlet().getSession().getCookie();
            DefaultCookieSerializer cookieSerializer = new DefaultCookieSerializer();
            PropertyMapper map = PropertyMapper.get().alwaysApplyingWhenNonNull();
            map.from(cookie::getName).to(cookieSerializer::setCookieName);
            map.from(cookie::getDomain).to(cookieSerializer::setDomainName);
            map.from(cookie::getPath).to(cookieSerializer::setCookiePath);
            map.from(cookie::getHttpOnly).to(cookieSerializer::setUseHttpOnlyCookie);
            map.from(cookie::getSecure).to(cookieSerializer::setUseSecureCookie);
            map.from(cookie::getMaxAge).to((maxAge) -> cookieSerializer
                    .setCookieMaxAge((int) maxAge.getSeconds()));
            return cookieSerializer;
        }


        // 内嵌配置类
        // 该类自身没有提供任何实现，其效果主要通过注解来实现 :
        // 仅在 bean SessionRepository 不存在时导入 ServletSessionRepositoryImplementationValidator 和 ServletSessionConfigurationImportSelector
        // ServletSessionRepositoryImplementationValidator：检查类路径下是否有多个 SessionRepository 实现类，如果有多个则检查是否指定了 StoreType，如果没指定则报错
        // ServletSessionConfigurationImportSelector：引入所有支持的类型的自动配置类，例如 Redis 的是 RedisSessionConfiguration
        @Configuration
        @ConditionalOnMissingBean(SessionRepository.class)
        @Import({ ServletSessionRepositoryImplementationValidator.class,
                ServletSessionConfigurationImportSelector.class })
        static class ServletSessionRepositoryConfiguration {

        }

    }

    // 内嵌配置子类，针对 Reactive Web 的情况
    @Configuration
    @ConditionalOnWebApplication(type = Type.REACTIVE)
    @Import(ReactiveSessionRepositoryValidator.class)
    static class ReactiveSessionConfiguration {


        // 内嵌配置类
        // 该类自身没有提供任何实现，其效果主要通过注解来实现 :
        // 仅在 bean ReactiveSessionRepository 不存在时导入 ReactiveSessionRepositoryImplementationValidator
        // 和 ReactiveSessionConfigurationImportSelector
        @Configuration
        // 仅在 bean ReactiveSessionRepository 不存在时生效 
        @ConditionalOnMissingBean(ReactiveSessionRepository.class)
        // 导入 ReactiveSessionRepositoryImplementationValidator
        // 和 ReactiveSessionConfigurationImportSelector
        @Import({ ReactiveSessionRepositoryImplementationValidator.class,
                ReactiveSessionConfigurationImportSelector.class })
        static class ReactiveSessionRepositoryConfiguration {

        }

    }

    /**
     * Condition to trigger the creation of a DefaultCookieSerializer. This kicks
     * in if either no HttpSessionIdResolver and CookieSerializer beans
     * are registered, or if CookieHttpSessionIdResolver is registered but
     * CookieSerializer is not.
     * 触发创建 DefaultCookieSerializer 的条件 :
     * 1. Bean HttpSessionIdResolver 和 CookieSerializer 都不存在 
     * 或者
     * 2. Bean CookieHttpSessionIdResolver 存在 但 bean CookieSerializer 不存在
     *
     * DefaultCookieSerializerCondition 是一个 AnyNestedCondition,
     * 这种条件被满足的条件是：某个内嵌子条件被满足
     */
    static class DefaultCookieSerializerCondition extends AnyNestedCondition {

        DefaultCookieSerializerCondition() {
            super(ConfigurationPhase.REGISTER_BEAN);
        }

        @ConditionalOnMissingBean({ HttpSessionIdResolver.class, CookieSerializer.class })
        static class NoComponentsAvailable {

        }

        @ConditionalOnBean(CookieHttpSessionIdResolver.class)
        @ConditionalOnMissingBean(CookieSerializer.class)
        static class CookieHttpSessionIdResolverAvailable {

        }

    }

    /**
     * ImportSelector base class to add StoreType configuration classes.
     * 抽象基类，提供工具方法用于不同 Web 环境下决定导入哪些 Session Store 配置类
     */
    abstract static class SessionConfigurationImportSelector implements ImportSelector {

        protected final String[] selectImports(WebApplicationType webApplicationType) {
            List imports = new ArrayList<>();
            StoreType[] types = StoreType.values();
            for (int i = 0; i < types.length; i++) {
                imports.add(SessionStoreMappings.getConfigurationClass(webApplicationType,
                        types[i]));
            }
            return StringUtils.toStringArray(imports);
        }

    }

    /**
     * ImportSelector to add StoreType configuration classes for reactive
     * web applications.
     * 在 Reactive Web 情况下使用，用于导入相应的 Session Store 配置类 
     */
    static class ReactiveSessionConfigurationImportSelector
            extends SessionConfigurationImportSelector {

        @Override
        public String[] selectImports(AnnotationMetadata importingClassMetadata) {
            return super.selectImports(WebApplicationType.REACTIVE);
        }

    }

    /**
     * ImportSelector to add StoreType configuration classes for Servlet
     * web applications.
     * 在 Servlet Web 情况下使用，用于导入相应的 Session Store 配置类 
     */
    static class ServletSessionConfigurationImportSelector
            extends SessionConfigurationImportSelector {

        @Override
        public String[] selectImports(AnnotationMetadata importingClassMetadata) {
            return super.selectImports(WebApplicationType.SERVLET);
        }

    }

    /**
     * Base class for beans used to validate that only one supported implementation is
     * available in the classpath when the store-type property is not set.
     * 抽象基类，用于检查 store type 未设置的情况下仅有一个session repository 实现类存在于 classpath
     */
    abstract static class AbstractSessionRepositoryImplementationValidator {

        private final List candidates;

        private final ClassLoader classLoader;

        private final SessionProperties sessionProperties;

        AbstractSessionRepositoryImplementationValidator(
                ApplicationContext applicationContext,
                SessionProperties sessionProperties, List candidates) {
            this.classLoader = applicationContext.getClassLoader();
            this.sessionProperties = sessionProperties;
            this.candidates = candidates;
        }

        @PostConstruct
        public void checkAvailableImplementations() {
            List> availableCandidates = new ArrayList<>();
            for (String candidate : this.candidates) {
                addCandidateIfAvailable(availableCandidates, candidate);
            }
            StoreType storeType = this.sessionProperties.getStoreType();
            if (availableCandidates.size() > 1 && storeType == null) {
                // 这里通过异常方式确保storeType 属性未设置时必须只有一个session存储库实现类存在
                throw new NonUniqueSessionRepositoryException(availableCandidates);
            }
        }

        // 对类型 type 进行检查，如果该类型对应的类能够被 classLoader 加载成功，则将其作为候选类，
        // 也就是添加到列表 candidates 中，否则该类型 type 不作为候选。
        private void addCandidateIfAvailable(List> candidates, String type) {
            try {
                Class candidate = this.classLoader.loadClass(type);
                if (candidate != null) {
                    candidates.add(candidate);
                }
            }
            catch (Throwable ex) {
                // Ignore
            }
        }

    }

    /**
     * Bean used to validate that only one supported implementation is available in the
     * classpath when the store-type property is not set.
     */
    static class ServletSessionRepositoryImplementationValidator
            extends AbstractSessionRepositoryImplementationValidator {

        ServletSessionRepositoryImplementationValidator(
                ApplicationContext applicationContext,
                SessionProperties sessionProperties) {
            super(applicationContext, sessionProperties, Arrays.asList(
                    "org.springframework.session.hazelcast.HazelcastSessionRepository",
                    "org.springframework.session.jdbc.JdbcOperationsSessionRepository",
                    "org.springframework.session.data.mongo.MongoOperationsSessionRepository",
                    "org.springframework.session.data.redis.RedisOperationsSessionRepository"));
        }

    }

    /**
     * Bean used to validate that only one supported implementation is available in the
     * classpath when the store-type property is not set.
     */
    static class ReactiveSessionRepositoryImplementationValidator
            extends AbstractSessionRepositoryImplementationValidator {

        ReactiveSessionRepositoryImplementationValidator(
                ApplicationContext applicationContext,
                SessionProperties sessionProperties) {
            super(applicationContext, sessionProperties, Arrays.asList(
                    "org.springframework.session.data.redis.ReactiveRedisOperationsSessionRepository",
                    "org.springframework.session.data.mongo.ReactiveMongoOperationsSessionRepository"));
        }

    }

    /**
     * Base class for validating that a (reactive) session repository bean exists.
     * 抽象基类，用于确保只有一个 session repository bean 实例存在，如果有多个，则抛出异常
     */
    abstract static class AbstractSessionRepositoryValidator {

        private final SessionProperties sessionProperties;

        private final ObjectProvider sessionRepositoryProvider;

        protected AbstractSessionRepositoryValidator(SessionProperties sessionProperties,
                ObjectProvider sessionRepositoryProvider) {
            this.sessionProperties = sessionProperties;
            this.sessionRepositoryProvider = sessionRepositoryProvider;
        }

        @PostConstruct
        public void checkSessionRepository() {
            StoreType storeType = this.sessionProperties.getStoreType();
            if (storeType != StoreType.NONE
                    && this.sessionRepositoryProvider.getIfAvailable() == null
                    && storeType != null) {
                throw new SessionRepositoryUnavailableException(
                        "No session repository could be auto-configured, check your "
                                + "configuration (session store type is '"
                                + storeType.name().toLowerCase(Locale.ENGLISH) + "')",
                        storeType);
            }
        }

    }

    /**
     * Bean used to validate that a SessionRepository exists and provide a
     * meaningful message if that's not the case.
     */
    static class ServletSessionRepositoryValidator
            extends AbstractSessionRepositoryValidator {

        ServletSessionRepositoryValidator(SessionProperties sessionProperties,
                ObjectProvider> sessionRepositoryProvider) {
            super(sessionProperties, sessionRepositoryProvider);
        }

    }

    /**
     * Bean used to validate that a ReactiveSessionRepository exists and provide a
     * meaningful message if that's not the case.
     */
    static class ReactiveSessionRepositoryValidator
            extends AbstractSessionRepositoryValidator {

        ReactiveSessionRepositoryValidator(SessionProperties sessionProperties,
                ObjectProvider> sessionRepositoryProvider) {
            super(sessionProperties, sessionRepositoryProvider);
        }

    }

}

从以上源代码可以看出,SessionAutoConfiguration自身没有提供任何配置方法或者进行任何bean定义，其配置效果主要通过自身所使用的注解和它的嵌套配置类来完成。

SessionAutoConfiguration自身的注解约定了如下配置效果 :

  1. SessionAutoConfiguration

    生效的条件

    • 类Session必须存在于classpath上，换句话讲，也就是要求必须依赖包Spring Session Core;
    • 当前应用必须是一个Web应用，Servlet Web应用，Reactive Web应用均可

  2. 导入了如下配置到相应的bean
    – 前缀为server的配置项到类型为ServerProperties的bean
    – 前缀为spring.session的配置项到类型为SessionProperties的bean

  3. SessionAutoConfiguration

    自动配置(以及嵌套配置)的执行时机

    • 在以下自动配置执行之后

      这些自动配置主要是配置Spring Session存储库机制所使用底层基础设施，所以要在SessionAutoConfiguration之前完成

      • DataSourceAutoConfiguration
      • HazelcastAutoConfiguration
      • JdbcTemplateAutoConfiguration
      • MongoDataAutoConfiguration
      • MongoReactiveDataAutoConfiguration
      • RedisAutoConfiguration

    • 在以下自动配置执行之前

      • HttpHandlerAutoConfiguration

  4. ServletSessionConfiguration

ServletSessionConfiguration配置类定义了一个bean :

  • DefaultCookieSerializer cookieSerializer

    仅在条件DefaultCookieSerializerCondition被满足时定义 :

    1. Bean HttpSessionIdResolver 和 CookieSerializer 都不存在 或者
    2. Bean CookieHttpSessionIdResolver 存在 但 bean CookieSerializer 不存在

  • 导入配置类 SessionRepositoryFilterConfiguration 用于配置注册 SessionRepositoryFilter 到 Servlet 容器的 FilterRegistrationBean

    SessionRepositoryFilter是Spring Session机制在运行时工作的核心组件,用于服务用户请求处理过程中所有HttpSession操作请求

  • 导入验证器组件ServletSessionRepositoryValidator确保只存在一个SessionRepository bean或者指定的SessionRepository bean存在

  • 定义嵌套配置类 ServletSessionRepositoryConfiguration

    • 仅在bean SessionRepository不存在时生效

    • 导入 ServletSessionConfigurationImportSelector 以选择合适的存储库配置类

      针对本文所使用的应用的情形，最终会选择RedisSessionConfiguration。
      RedisSessionConfiguration配置类会应用sping.session/spring.session.redis为前缀的配置项,并定义如下bean :

      1. RedisOperationsSessionRepository sessionRepository, (重要)
      2. RedisMessageListenerContainer redisMessageListenerContainer,
      3. InitializingBean enableRedisKeyspaceNotificationsInitializer,
      4. SessionRepositoryFilter springSessionRepositoryFilter, (重要)
      5. SessionEventHttpSessionListenerAdapter sessionEventHttpSessionListenerAdapter,

    • 导入验证器组件ServletSessionRepositoryImplementationValidator以确保相应的存储库配置类存在于classpath

总结

  1. 检查用户配置的 StoreType 的正确性
  2. 配置 SessionRepositoryFilter 到 Servlet 容器中
  3. 配置默认的 DefaultCookieSerializer
  4. 检查当前类路径下至少存在一个 SessionRepository 的实现
  5. 导入配置类 RedisSessionConfiguration

RedisSessionConfiguration

上面的 ServletSessionConfigurationImportSelector 会导入一系列配置类，但是配置类上有条件（@Conditional），所以在本例中只有 RedisSessionConfiguration 会生效。

package org.springframework.boot.autoconfigure.session;

// 省略 import 行

@Configuration
// 仅在指定类存在于 classpath 上时才生效
@ConditionalOnClass({ RedisTemplate.class, RedisOperationsSessionRepository.class })
// 仅在 bean SessionRepository 不存在时才生效
@ConditionalOnMissingBean(SessionRepository.class)
// 仅在 bean RedisConnectionFactory 存在时才生效
@ConditionalOnBean(RedisConnectionFactory.class)
// 仅在条件 ServletSessionCondition 被满足时才生效
@Conditional(ServletSessionCondition.class)
// 确保前缀为 spring.session.redis 的配置参数被加载到 bean RedisSessionProperties
@EnableConfigurationProperties(RedisSessionProperties.class)
class RedisSessionConfiguration {

    // 配置 redis 的键空间通知功能，notify-keyspace-events Exg，这里先买个关子。
    @Bean
    @ConditionalOnMissingBean
    ConfigureRedisAction configureRedisAction(RedisSessionProperties redisSessionProperties) {
        switch (redisSessionProperties.getConfigureAction()) {
        case NOTIFY_KEYSPACE_EVENTS:
            return new ConfigureNotifyKeyspaceEventsAction();
        case NONE:
            return ConfigureRedisAction.NO_OP;
        }
        throw new IllegalStateException(
                "Unsupported redis configure action '" + redisSessionProperties.getConfigureAction() + "'.");
    }

    // 内置配置类
    // 1. 应用配置参数
    // 2. 继承自 RedisHttpSessionConfiguration 以定义 sessionRepository，springSessionRepositoryFilter 等运行时工作组件 bean
    @Configuration
    public static class SpringBootRedisHttpSessionConfiguration
            extends RedisHttpSessionConfiguration {

        // 应用用户配置的 spring.session.redis 属性
        @Autowired
        public void customize(SessionProperties sessionProperties,
                RedisSessionProperties redisSessionProperties) {
            Duration timeout = sessionProperties.getTimeout();
            if (timeout != null) {
                setMaxInactiveIntervalInSeconds((int) timeout.getSeconds());
            }
            setRedisNamespace(redisSessionProperties.getNamespace());
            setRedisFlushMode(redisSessionProperties.getFlushMode());
            setCleanupCron(redisSessionProperties.getCleanupCron());
        }

    }

}

父类 RedisHttpSessionConfiguration

package org.springframework.session.data.redis.config.annotation.web.http;

// 省略 import 行

/**
 * Exposes the SessionRepositoryFilter as a bean named
 * springSessionRepositoryFilter. In order to use this a single
 * RedisConnectionFactory must be exposed as a Bean.
 *
 * @since 1.0
 */
@Configuration
@EnableScheduling
public class RedisHttpSessionConfiguration extends SpringHttpSessionConfiguration
        implements BeanClassLoaderAware, EmbeddedValueResolverAware, ImportAware,
        SchedulingConfigurer {

    // 清除过期 session 的定时任务的 cron 表达式，
    static final String DEFAULT_CLEANUP_CRON = "0 * * * * *";

    // 会话被允许处于不活跃状态的最长时间, 超过该事件，会话会被认为是过期无效
    // 使用缺省值 30 分钟
    private Integer maxInactiveIntervalInSeconds = MapSession.DEFAULT_MAX_INACTIVE_INTERVAL_SECONDS;

   // 所创建的 session 在 redis 中的命名空间， 使用缺省值 : spring:session 
    private String redisNamespace = RedisOperationsSessionRepository.DEFAULT_NAMESPACE;
  
    private RedisFlushMode redisFlushMode = RedisFlushMode.ON_SAVE;

    // 清除过期 session 的定时任务的 cron 表达式，
    // 使用缺省值 : "0 * * * * *", 表示每个分钟的0秒执行一次
    private String cleanupCron = DEFAULT_CLEANUP_CRON;

    // 对 redis 的配置动作，缺省是 ： notify-keyspace-events
    // 该缺省值确保 redis keyspace 事件通知机制启用
    private ConfigureRedisAction configureRedisAction = new ConfigureNotifyKeyspaceEventsAction();

   // 创建连接到目标 redis 数据库的工厂类，由外部提供
    private RedisConnectionFactory redisConnectionFactory;

    private RedisSerializer defaultRedisSerializer;

    private ApplicationEventPublisher applicationEventPublisher;

    // redis 消息监听器容器使用的异步执行器，用于监听到消息时执行监听器逻辑
    private Executor redisTaskExecutor;

    private Executor redisSubscriptionExecutor;

    private ClassLoader classLoader;

    private StringValueResolver embeddedValueResolver;

    // 定义 bean RedisOperationsSessionRepository，这是创建其他spring session 工作组件
    // 所必要的底层存储库组件对象
    @Bean
    public RedisOperationsSessionRepository sessionRepository() {
       // 注意，这里使用了自己创建的  RedisTemplate 对象，而不是某个 RedisTemplate bean
        RedisTemplate redisTemplate = createRedisTemplate();
        RedisOperationsSessionRepository sessionRepository = new RedisOperationsSessionRepository(
                redisTemplate);
        sessionRepository.setApplicationEventPublisher(this.applicationEventPublisher);
        if (this.defaultRedisSerializer != null) {
            sessionRepository.setDefaultSerializer(this.defaultRedisSerializer);
        }
        sessionRepository
                .setDefaultMaxInactiveInterval(this.maxInactiveIntervalInSeconds);
        if (StringUtils.hasText(this.redisNamespace)) {
            sessionRepository.setRedisKeyNamespace(this.redisNamespace);
        }
        sessionRepository.setRedisFlushMode(this.redisFlushMode);
        int database = resolveDatabase();
        sessionRepository.setDatabase(database);
        return sessionRepository;
    }

    // 定义 bean RedisMessageListenerContainer， 它使用一个 redis 连接多路,异步处理 redis 消息
    @Bean
    public RedisMessageListenerContainer redisMessageListenerContainer() {
        RedisMessageListenerContainer container = new RedisMessageListenerContainer();
       // 设置 redis 连接工厂对象 
        container.setConnectionFactory(this.redisConnectionFactory);
        
       // 设置异步消息监听器逻辑执行器 
        if (this.redisTaskExecutor != null) {
            container.setTaskExecutor(this.redisTaskExecutor);
        }
        if (this.redisSubscriptionExecutor != null) {
            container.setSubscriptionExecutor(this.redisSubscriptionExecutor);
        }
        
       // 添加消息监听器 
       // 监听 session 的 创建，删除 和 过期 等消息
        container.addMessageListener(sessionRepository(), Arrays.asList(
                new ChannelTopic(sessionRepository().getSessionDeletedChannel()),
                new ChannelTopic(sessionRepository().getSessionExpiredChannel())));
        container.addMessageListener(sessionRepository(),
                Collections.singletonList(new PatternTopic(
                        sessionRepository().getSessionCreatedChannelPrefix() + "*")));
        return container;
    }

    // 定义一个 bean EnableRedisKeyspaceNotificationsInitializer ，这是一个 InitializingBean,
    // 他在自己的初始化阶段对 redis 配置 notify-keyspace-events， 确保 redis keyspace 事件
    // 通知机制启动，用于确保 key 超时和删除逻辑。
    @Bean
    public InitializingBean enableRedisKeyspaceNotificationsInitializer() {
        return new EnableRedisKeyspaceNotificationsInitializer(
                this.redisConnectionFactory, this.configureRedisAction);
    }

    public void setMaxInactiveIntervalInSeconds(int maxInactiveIntervalInSeconds) {
        this.maxInactiveIntervalInSeconds = maxInactiveIntervalInSeconds;
    }

    public void setRedisNamespace(String namespace) {
        this.redisNamespace = namespace;
    }

    public void setRedisFlushMode(RedisFlushMode redisFlushMode) {
        Assert.notNull(redisFlushMode, "redisFlushMode cannot be null");
        this.redisFlushMode = redisFlushMode;
    }

    public void setCleanupCron(String cleanupCron) {
        this.cleanupCron = cleanupCron;
    }

    /**
     * Sets the action to perform for configuring Redis.
     *
     * @param configureRedisAction the configureRedis to set. The default is
     * ConfigureNotifyKeyspaceEventsAction.
     */
    @Autowired(required = false)
    public void setConfigureRedisAction(ConfigureRedisAction configureRedisAction) {
        this.configureRedisAction = configureRedisAction;
    }

    // 连接到 redis 的连接的工厂组件 RedisConnectionFactory 由外部提供，
    // 关于 RedisConnectionFactory 工厂组件的创建，可以参考 LettuceConnectionConfiguration,
    // JedisConnectionConfiguration
    @Autowired
    public void setRedisConnectionFactory(
            @SpringSessionRedisConnectionFactory ObjectProvider 
            springSessionRedisConnectionFactory,
            ObjectProvider redisConnectionFactory) {
        RedisConnectionFactory redisConnectionFactoryToUse = springSessionRedisConnectionFactory
                .getIfAvailable();
        if (redisConnectionFactoryToUse == null) {
            redisConnectionFactoryToUse = redisConnectionFactory.getObject();
        }
        this.redisConnectionFactory = redisConnectionFactoryToUse;
    }

    @Autowired(required = false)
    @Qualifier("springSessionDefaultRedisSerializer")
    public void setDefaultRedisSerializer(
            RedisSerializer defaultRedisSerializer) {
        this.defaultRedisSerializer = defaultRedisSerializer;
    }

    @Autowired
    public void setApplicationEventPublisher(
            ApplicationEventPublisher applicationEventPublisher) {
        this.applicationEventPublisher = applicationEventPublisher;
    }

    @Autowired(required = false)
    @Qualifier("springSessionRedisTaskExecutor")
    public void setRedisTaskExecutor(Executor redisTaskExecutor) {
        this.redisTaskExecutor = redisTaskExecutor;
    }

    @Autowired(required = false)
    @Qualifier("springSessionRedisSubscriptionExecutor")
    public void setRedisSubscriptionExecutor(Executor redisSubscriptionExecutor) {
        this.redisSubscriptionExecutor = redisSubscriptionExecutor;
    }

    @Override
    public void setBeanClassLoader(ClassLoader classLoader) {
        this.classLoader = classLoader;
    }

    @Override
    public void setEmbeddedValueResolver(StringValueResolver resolver) {
        this.embeddedValueResolver = resolver;
    }

    @Override
    public void setImportMetadata(AnnotationMetadata importMetadata) {
        Map attributeMap = importMetadata
                .getAnnotationAttributes(EnableRedisHttpSession.class.getName());
        AnnotationAttributes attributes = AnnotationAttributes.fromMap(attributeMap);
        this.maxInactiveIntervalInSeconds = attributes
                .getNumber("maxInactiveIntervalInSeconds");
        String redisNamespaceValue = attributes.getString("redisNamespace");
        if (StringUtils.hasText(redisNamespaceValue)) {
            this.redisNamespace = this.embeddedValueResolver
                    .resolveStringValue(redisNamespaceValue);
        }
        this.redisFlushMode = attributes.getEnum("redisFlushMode");
        String cleanupCron = attributes.getString("cleanupCron");
        if (StringUtils.hasText(cleanupCron)) {
            this.cleanupCron = cleanupCron;
        }
    }

    // 注册后台执行任务，用来清除过期的 session
    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
        taskRegistrar.addCronTask(() -> sessionRepository().cleanupExpiredSessions(),
                this.cleanupCron);
    }

    private RedisTemplate createRedisTemplate() {
        RedisTemplate redisTemplate = new RedisTemplate<>();
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        if (this.defaultRedisSerializer != null) {
            redisTemplate.setDefaultSerializer(this.defaultRedisSerializer);
        }
        redisTemplate.setConnectionFactory(this.redisConnectionFactory);
        redisTemplate.setBeanClassLoader(this.classLoader);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }

    private int resolveDatabase() {
        if (ClassUtils.isPresent("io.lettuce.core.RedisClient", null)
                && this.redisConnectionFactory instanceof LettuceConnectionFactory) {
            return ((LettuceConnectionFactory) this.redisConnectionFactory).getDatabase();
        }
        if (ClassUtils.isPresent("redis.clients.jedis.Jedis", null)
                && this.redisConnectionFactory instanceof JedisConnectionFactory) {
            return ((JedisConnectionFactory) this.redisConnectionFactory).getDatabase();
        }
        return RedisOperationsSessionRepository.DEFAULT_DATABASE;
    }

    /**
     * Ensures that Redis is configured to send keyspace notifications. This is important
     * to ensure that expiration and deletion of sessions trigger SessionDestroyedEvents.
     * Without the SessionDestroyedEvent resources may not get cleaned up properly. For
     * example, the mapping of the Session to WebSocket connections may not get cleaned
     * up.
     */
    static class EnableRedisKeyspaceNotificationsInitializer implements InitializingBean {

        private final RedisConnectionFactory connectionFactory;

        private ConfigureRedisAction configure;

        EnableRedisKeyspaceNotificationsInitializer(
                RedisConnectionFactory connectionFactory,
                ConfigureRedisAction configure) {
            this.connectionFactory = connectionFactory;
            this.configure = configure;
        }

        @Override
        public void afterPropertiesSet() throws Exception {
            if (this.configure == ConfigureRedisAction.NO_OP) {
                return;
            }
            RedisConnection connection = this.connectionFactory.getConnection();
            try {
                this.configure.configure(connection);
            }
            finally {
                try {
                    connection.close();
                }
                catch (Exception ex) {
                    LogFactory.getLog(getClass()).error("Error closing RedisConnection",
                            ex);
                }
            }
        }

    }

}
 
 
父类 SpringHttpSessionConfiguration
 
 
package org.springframework.session.config.annotation.web.http;

// 省略 import 行

@Configuration
public class SpringHttpSessionConfiguration implements ApplicationContextAware {

    private final Log logger = LogFactory.getLog(getClass());

    private CookieHttpSessionIdResolver defaultHttpSessionIdResolver = 
        new CookieHttpSessionIdResolver();

    private boolean usesSpringSessionRememberMeServices;

    private ServletContext servletContext;

    private CookieSerializer cookieSerializer;

    private HttpSessionIdResolver httpSessionIdResolver = this.defaultHttpSessionIdResolver;

    private List httpSessionListeners = new ArrayList<>();

    @PostConstruct
    public void init() {
        // 如果用户没有配置 CookieSerializer 则自己创建一个默认的
        CookieSerializer cookieSerializer = (this.cookieSerializer != null)
                ? this.cookieSerializer
                : createDefaultCookieSerializer();
        this.defaultHttpSessionIdResolver.setCookieSerializer(cookieSerializer);
    }

   // 定义bean SessionEventHttpSessionListenerAdapter，一个ApplicationListener,
   // 它会监听 Spring Session 的事件 SessionDestroyedEvent,SessionCreatedEvent
   // 并将其转换为HttpSessionEvent，然后转发给所注册的各个 HttpSessionListener
    @Bean
    public SessionEventHttpSessionListenerAdapter sessionEventHttpSessionListenerAdapter() {
        return new SessionEventHttpSessionListenerAdapter(this.httpSessionListeners);
    }

    // 定义从 Servlet 容器层面可见的 Filter SessionRepositoryFilter, 它会对 Servlet 容器原生 
    // request/response 进行包装，从而拦截 HttpSession 的获取，创建和删除等操作，这些
    // 操作最终会由底层的 Spring Session 机制支持，在本文所使用的项目例子中，其实就是
    // 使用 redis 以及相关工作组件来支持 session
    @Bean
    public  SessionRepositoryFilter 
            springSessionRepositoryFilter(
            SessionRepository sessionRepository) {
        SessionRepositoryFilter sessionRepositoryFilter = new SessionRepositoryFilter<>(
                sessionRepository);
        sessionRepositoryFilter.setServletContext(this.servletContext);
        sessionRepositoryFilter.setHttpSessionIdResolver(this.httpSessionIdResolver);
        return sessionRepositoryFilter;
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext)
            throws BeansException {
        if (ClassUtils.isPresent(
                "org.springframework.security.web.authentication.RememberMeServices",
                null)) {
            this.usesSpringSessionRememberMeServices = !ObjectUtils
                    .isEmpty(applicationContext
                            .getBeanNamesForType(SpringSessionRememberMeServices.class));
        }
    }

    @Autowired(required = false)
    public void setServletContext(ServletContext servletContext) {
        this.servletContext = servletContext;
    }

    @Autowired(required = false)
    public void setCookieSerializer(CookieSerializer cookieSerializer) {
        this.cookieSerializer = cookieSerializer;
    }

    @Autowired(required = false)
    public void setHttpSessionIdResolver(HttpSessionIdResolver httpSessionIdResolver) {
        this.httpSessionIdResolver = httpSessionIdResolver;
    }

    @Autowired(required = false)
    public void setHttpSessionListeners(List listeners) {
        this.httpSessionListeners = listeners;
    }

    private CookieSerializer createDefaultCookieSerializer() {
        DefaultCookieSerializer cookieSerializer = new DefaultCookieSerializer();
        if (this.servletContext != null) {
            SessionCookieConfig sessionCookieConfig = null;
            try {
                sessionCookieConfig = this.servletContext.getSessionCookieConfig();
            }
            catch (UnsupportedOperationException ex) {
                this.logger
                        .warn("Unable to obtain SessionCookieConfig: " + ex.getMessage());
            }
            if (sessionCookieConfig != null) {
                if (sessionCookieConfig.getName() != null) {
                    cookieSerializer.setCookieName(sessionCookieConfig.getName());
                }
                if (sessionCookieConfig.getDomain() != null) {
                    cookieSerializer.setDomainName(sessionCookieConfig.getDomain());
                }
                if (sessionCookieConfig.getPath() != null) {
                    cookieSerializer.setCookiePath(sessionCookieConfig.getPath());
                }
                if (sessionCookieConfig.getMaxAge() != -1) {
                    cookieSerializer.setCookieMaxAge(sessionCookieConfig.getMaxAge());
                }
            }
        }
        if (this.usesSpringSessionRememberMeServices) {
            cookieSerializer.setRememberMeRequestAttribute(
                    SpringSessionRememberMeServices.REMEMBER_ME_LOGIN_ATTR);
        }
        return cookieSerializer;
    }

}

 
 
总结
 
 
     
  
  1. 注入 ConfigureRedisAction 以 redis 启用键空间通知功能
    2.  
  
  2. 应用用户配置的 spring.session 和 spring.session.redis 属性
    3.  
  
  3. 配置 RedisIndexedSessionRepository
    4.  
  
  4. 配置 RedisMessageListenerContainer 来处理 redis 的消息
    5.  
  
  5. 执行 ConfigureRedisAction 启用键空间通知功能
    6.  
  
  6. 注册后台执行任务，以清除过期的 session
    7.  
  
  7. 如果 CookieSerializer 为空则创建默认的，并设置到 CookieHttpSessionIdResolver 中
    8.  
  
  8. 创建 SessionEventHttpSessionListenerAdapter 以监听 Spring Session 相关的事件
    9.  
  
  9. 创建 SessionRepositoryFilter
    10.  
 
 
 
SessionRepositoryFilterConfiguration
 
 
SessionAutoConfiguration 引入的用来配置 SessionRepositoryFilter 的配置类。
 
 
package org.springframework.boot.autoconfigure.session;

// 省略 import 行

@Configuration
// 在 bean SessionRepositoryFilter 存在的的情况下才生效
@ConditionalOnBean(SessionRepositoryFilter.class)
// 确保配置属性项 server.session.* 提取到 bean SessionProperties
@EnableConfigurationProperties(SessionProperties.class)
class SessionRepositoryFilterConfiguration {

    // 定义bean FilterRegistrationBean, 这是一个过滤器注册bean，它的任务是将一个过滤器注册到
    // Servlet 容器,这里的过滤器指的就是 bean SessionRepositoryFilter
    @Bean
    public FilterRegistrationBean> sessionRepositoryFilterRegistration(
            SessionProperties sessionProperties, SessionRepositoryFilter filter) {
        FilterRegistrationBean> registration = new FilterRegistrationBean<>(
                filter);
        registration.setDispatcherTypes(getDispatcherTypes(sessionProperties));
        registration.setOrder(sessionProperties.getServlet().getFilterOrder());
        return registration;
    }

    // 从配置属性项中获取所指定的 DispatcherType 集合，如果配置属性中没有指定该信息，则使用
    // 缺省值 : DispatcherType.ASYNC, DispatcherType.ERROR, DispatcherType.REQUEST
    private EnumSet getDispatcherTypes(
            SessionProperties sessionProperties) {
        SessionProperties.Servlet servletProperties = sessionProperties.getServlet();
        if (servletProperties.getFilterDispatcherTypes() == null) {
            return null;
        }
        return servletProperties.getFilterDispatcherTypes().stream()
                .map((type) -> DispatcherType.valueOf(type.name())).collect(Collectors
                        .collectingAndThen(Collectors.toSet(), EnumSet::copyOf));
    }

}

 
 
SessionRepositoryFilter
 
 
 
  
 
   
  
   
 
  
 
  

    过滤器的 doFilter 方法 
  
 
 
 
 
先不点进去了，先看下 request.getSession() 的流程
 
 
request#getSession()
 
 
 
  
 
   
  
   
 
  
 
  

    request#getSession() 
  
 
 
 
 
 
  
 
   
  
   
 
  
 
  

    createSession() 
  
 
 
 
 
看一下 RedisSession 吧
 
 
final class RedisSession implements Session {

    // 缓存对象、委托对象，这个类中的所有方法几乎都是委托这个对象来做的
    private final MapSession cached;

    private Instant originalLastAccessTime;

    // 存储 Session 域中的数据
    private Map delta = new HashMap<>();

    // 标识当前 Session 是否是新创建的，当修改了 SessionId的时候用来决定是否使用 rename 命令
    private boolean isNew;

    private String originalPrincipalName;

    // 当前会话的 id
    private String originalSessionId;

    RedisSession(MapSession cached, boolean isNew) {
        this.cached = cached;
        this.isNew = isNew;
        this.originalSessionId = cached.getId();
        Map indexes = RedisIndexedSessionRepository.this.indexResolver.resolveIndexesFor(this);
        this.originalPrincipalName = indexes.get(PRINCIPAL_NAME_INDEX_NAME);
        // 如果是新创建的，则添加几个属性
        if (this.isNew) {
            this.delta.put(RedisSessionMapper.CREATION_TIME_KEY, cached.getCreationTime().toEpochMilli());
            this.delta.put(RedisSessionMapper.MAX_INACTIVE_INTERVAL_KEY,
                    (int) cached.getMaxInactiveInterval().getSeconds());
            this.delta.put(RedisSessionMapper.LAST_ACCESSED_TIME_KEY, cached.getLastAccessedTime().toEpochMilli());
        }
        if (this.isNew || (RedisIndexedSessionRepository.this.saveMode == SaveMode.ALWAYS)) {
            getAttributeNames().forEach((attributeName) -> this.delta.put(getSessionAttrNameKey(attributeName),
                    cached.getAttribute(attributeName)));
        }
    }

    @Override
    public void setLastAccessedTime(Instant lastAccessedTime) {
        this.cached.setLastAccessedTime(lastAccessedTime);
        this.delta.put(RedisSessionMapper.LAST_ACCESSED_TIME_KEY, getLastAccessedTime().toEpochMilli());
        flushImmediateIfNecessary();
    }

    @Override
    public boolean isExpired() {
        return this.cached.isExpired();
    }

    @Override
    public Instant getCreationTime() {
        return this.cached.getCreationTime();
    }

    @Override
    public String getId() {
        return this.cached.getId();
    }

    @Override
    public String changeSessionId() {
        return this.cached.changeSessionId();
    }

    @Override
    public Instant getLastAccessedTime() {
        return this.cached.getLastAccessedTime();
    }

    @Override
    public void setMaxInactiveInterval(Duration interval) {
        this.cached.setMaxInactiveInterval(interval);
        this.delta.put(RedisSessionMapper.MAX_INACTIVE_INTERVAL_KEY, (int) getMaxInactiveInterval().getSeconds());
        flushImmediateIfNecessary();
    }

    @Override
    public Duration getMaxInactiveInterval() {
        return this.cached.getMaxInactiveInterval();
    }

    @Override
    public  T getAttribute(String attributeName) {
        T attributeValue = this.cached.getAttribute(attributeName);
        if (attributeValue != null
                && RedisIndexedSessionRepository.this.saveMode.equals(SaveMode.ON_GET_ATTRIBUTE)) {
            this.delta.put(getSessionAttrNameKey(attributeName), attributeValue);
        }
        return attributeValue;
    }

    @Override
    public Set getAttributeNames() {
        return this.cached.getAttributeNames();
    }

    @Override
    public void setAttribute(String attributeName, Object attributeValue) {
        this.cached.setAttribute(attributeName, attributeValue);
        this.delta.put(getSessionAttrNameKey(attributeName), attributeValue);
        flushImmediateIfNecessary();
    }

    @Override
    public void removeAttribute(String attributeName) {
        this.cached.removeAttribute(attributeName);
        this.delta.put(getSessionAttrNameKey(attributeName), null);
        flushImmediateIfNecessary();
    }

    private void flushImmediateIfNecessary() {
        if (RedisIndexedSessionRepository.this.flushMode == FlushMode.IMMEDIATE) {
            save();
        }
    }

    // wrappedRequest.commitSession() 会调用这个方法
    private void save() {
        saveChangeSessionId();
        saveDelta();
    }

    /**
        * Saves any attributes that have been changed and updates the expiration of this
        * session.
        */
    private void saveDelta() {
        if (this.delta.isEmpty()) {
            return;
        }
        String sessionId = getId();
        // 将数据保存到 redis 中
        getSessionBoundHashOperations(sessionId).putAll(this.delta);

        // 下面这部分好像和 redis 索引和安全相关，等学完 redis 再看吧
        String principalSessionKey = getSessionAttrNameKey(
                FindByIndexNameSessionRepository.PRINCIPAL_NAME_INDEX_NAME);
        String securityPrincipalSessionKey = getSessionAttrNameKey(SPRING_SECURITY_CONTEXT);
        if (this.delta.containsKey(principalSessionKey) || this.delta.containsKey(securityPrincipalSessionKey)) {
            if (this.originalPrincipalName != null) {
                String originalPrincipalRedisKey = getPrincipalKey(this.originalPrincipalName);
                RedisIndexedSessionRepository.this.sessionRedisOperations.boundSetOps(originalPrincipalRedisKey)
                        .remove(sessionId);
            }
            Map indexes = RedisIndexedSessionRepository.this.indexResolver.resolveIndexesFor(this);
            String principal = indexes.get(PRINCIPAL_NAME_INDEX_NAME);
            this.originalPrincipalName = principal;
            if (principal != null) {
                String principalRedisKey = getPrincipalKey(principal);
                RedisIndexedSessionRepository.this.sessionRedisOperations.boundSetOps(principalRedisKey)
                        .add(sessionId);
            }
        }

        // 将当前 Session 中的 delta 清空
        this.delta = new HashMap<>(this.delta.size());

        // 计算过期时间
        Long originalExpiration = (this.originalLastAccessTime != null)
                ? this.originalLastAccessTime.plus(getMaxInactiveInterval()).toEpochMilli() : null;
        // 设置过期时间
        RedisIndexedSessionRepository.this.expirationPolicy.onExpirationUpdated(originalExpiration, this);
    }

    private void saveChangeSessionId() {
        String sessionId = getId();
            
        if (sessionId.equals(this.originalSessionId)) {
            return;
        }        
        // 如果不是新创建的 Session 对象，则使用 rename 重命名 key
        if (!this.isNew) {
            String originalSessionIdKey = getSessionKey(this.originalSessionId);
            String sessionIdKey = getSessionKey(sessionId);
            try {
                RedisIndexedSessionRepository.this.sessionRedisOperations.rename(originalSessionIdKey,
                        sessionIdKey);
            }
            catch (NonTransientDataAccessException ex) {
                handleErrNoSuchKeyError(ex);
            }
            // 获取到和过期时间相关的两个 key，对他们重命名
            //  "spring:session:expirations:1523934840000"
            //  "spring:session:sessions:expires:39feb101-87d4-42c7-ab53-ac6fe0d91925"
            String originalExpiredKey = getExpiredKey(this.originalSessionId);
            String expiredKey = getExpiredKey(sessionId);
            try {
                RedisIndexedSessionRepository.this.sessionRedisOperations.rename(originalExpiredKey, expiredKey);
            }
            catch (NonTransientDataAccessException ex) {
                handleErrNoSuchKeyError(ex);
            }
        }
        // 将最新的 sessionId 赋值到 originalSessionId
        this.originalSessionId = sessionId;
    }

    private void handleErrNoSuchKeyError(NonTransientDataAccessException ex) {
        if (!"ERR no such key".equals(NestedExceptionUtils.getMostSpecificCause(ex).getMessage())) {
            throw ex;
        }
    }

}

 
 
 
  
问题：delta 中没有存 redis 中已有的数据，加入操作 session 的时候数据库中的信息过期了，那么就会有数据丢失了。看代码好像吧 SaveModel 改为 ALWAYS 可以解决这个问题。
 
 
 
 
RedisIndexedSessionRepository.this.expirationPolicy.onExpirationUpdated(originalExpiration, this);
 
 
看接下来的内容之前强烈建议看下这篇文章：https://www.iocoder.cn/Spring-Session/laoxu/spring-session-4/?self
 
 
 
  
 
   
  
   
 
  
 
  

    image 
  
 
 
 
 
太乱了，总结一下：
 
 
     
  
  1. 对过期时间四舍五入到下一分钟
    2.  
  
  2. 将 B 类型键移动到新的过期时间桶中，设置过期时间为 35min
    3.  
  
  3. 将 C 类型键（它相当于 A 类型键的引用），设置过期时间为 30min
    4.  
  
  4. 设置 A 类型键的过期时间为 35min
    5.  
 
 
 
后台执行删除操作的线程（在 RedisHttpSessionConfiguration 中配置的）
 
 
 
  
 
   
  
   
 
  
 
  

    image 
  
 
 
 
 
回头看下 request#getSession() 中的
 
 
 
  
 
   
  
   
 
  
 
  

    image 
  
 
 
 
 
 
  
 
   
  
   
 
  
 
  

    image 
  
 
 
 
 
 
  
 
   
  
   
 
  
 
  

    image 
  
 
 
 
 
很简单，就是从数据库里找到 A 类型键，获取他的数据，封装成 MapSession，判断是否过期，再次封装成 RedisSession。
 
 
过期咋接收的 notify-keyspace-events Exg
 
 
先了解下键空间通知功能：http://doc.redisfans.com/topic/notification.html
 
 
 
  
 
   
  
   
 
  
 
  

    Spring 使用的三个参数 
  
 
 
 
 
这里有一个使用键空间通知功能的一个 demo，可以看下：
 
 
     
  
  1. https://blog.csdn.net/liuchuanhong1/article/details/70147149
    2.  
  
  2. https://zhuanlan.zhihu.com/p/59065399
    3.  
 
 
 
我们再回头看 RedisHttpSessionConfiguration 中配置的 RedisMessageListenerContainer：
 
 
RedisHttpSessionConfiguration.java

@Bean
public RedisMessageListenerContainer springSessionRedisMessageListenerContainer(
        RedisIndexedSessionRepository sessionRepository) {
    RedisMessageListenerContainer container = new RedisMessageListenerContainer();
    container.setConnectionFactory(this.redisConnectionFactory);
    if (this.redisTaskExecutor != null) {
        container.setTaskExecutor(this.redisTaskExecutor);
    }
    if (this.redisSubscriptionExecutor != null) {
        container.setSubscriptionExecutor(this.redisSubscriptionExecutor);
    }

    // 其中 sessionRepository 是 MessageListener 的实现
    // 配置了两个监听的 topic 分别是：
    // __keyevent@0__:del
    // __keyevent@0__:expired
    container.addMessageListener(sessionRepository,
            Arrays.asList(new ChannelTopic(sessionRepository.getSessionDeletedChannel()),
                    new ChannelTopic(sessionRepository.getSessionExpiredChannel())));

    // 这里配置了一个基于模式匹配的 topic：spring:session:event:0:created:*
    container.addMessageListener(sessionRepository,
            Collections.singletonList(new PatternTopic(sessionRepository.getSessionCreatedChannelPrefix() + "*")));
    return container;
}

 
 
RedisIndexedSessionRepository.java

@Override
public void onMessage(Message message, byte[] pattern) {
    byte[] messageChannel = message.getChannel();
    byte[] messageBody = message.getBody();

    String channel = new String(messageChannel);
    
    // 如果 topic 是以 spring:session:event:3:created: 开头的，则发布 SessionCreatedEvent 
    if (channel.startsWith(this.sessionCreatedChannelPrefix)) {
        // TODO: is this thread safe?
        @SuppressWarnings("unchecked")
        Map loaded = (Map) this.defaultSerializer.deserialize(message.getBody());
        handleCreated(loaded, channel);
        return;
    }

    String body = new String(messageBody);
    if (!body.startsWith(getExpiredKeyPrefix())) {
        return;
    }

    // 判断是否是 __keyevent@0__:del 或 __keyevent@0__:expired Channel 的。
    boolean isDeleted = channel.equals(this.sessionDeletedChannel);
    if (isDeleted || channel.equals(this.sessionExpiredChannel)) {
        int beginIndex = body.lastIndexOf(":") + 1;
        int endIndex = body.length();
        String sessionId = body.substring(beginIndex, endIndex);

        RedisSession session = getSession(sessionId, true);

        if (session == null) {
            logger.warn("Unable to publish SessionDestroyedEvent for session " + sessionId);
            return;
        }

        if (logger.isDebugEnabled()) {
            logger.debug("Publishing SessionDestroyedEvent for session " + sessionId);
        }

        cleanupPrincipalIndex(session);

        // 如果是删除则触发 SessionDeletedEvent
        if (isDeleted) {
            handleDeleted(session);
        }
        // 如果是过期则触发 SessionExpiredEvent
        else {
            handleExpired(session);
        }
    }
}

 
 
但是 Spring 并没有写这些事件的监听器，是留给我们的一个钩子。他把 A 类型键设置多 5min 也是为了让我们在这段时间内做一些我们想做的事，比如日志记录等。
 
 
 
  
其实，如果说 Spring 使用 A 类型、B 类型、C 类型键来保证到指定时间会释放内存是错误的，因为A 类型键实际上还是由 redis 来清除的，而且增加了 B、C 类型键会增加 redis 的消耗，所以他这样做的目的就是为了让我们在这段时间内做一些我们想做的事。
 
 
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Spring Session 源码解读)

        

            

                
    
                    
  • SpringBlade dict-biz/list 接口 SQL 注入漏洞
                        文章永久免费只为良心
oracle数据库
                        
    SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
    
                    
    • 
                    
  • spring如何整合druid连接池？
                        惜.己
springspringjunit数据库javaidea后端xml
                        
    目录spring整合druid连接池1.新建maven项目2.新建mavenModule3.导入相关依赖4.配置log4j2.xml5.配置druid.xml1)xml中如何引入properties2)下面是配置文件6.准备jdbc.propertiesJDBC配置项解释7.配置druid8.测试spring整合druid连接池1.新建maven项目打开IDE（比如IntelliJIDEA,Ecl
    
                    
    • 
                    
  • SpringCloudAlibaba—Sentinel(限流)
                        菜鸟爪哇

                        
    前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
    
                    
    • 
                    
  • springboot+vue项目实战一-创建SpringBoot简单项目
                        苹果酱0567
面试题汇总与解析springboot后端java中间件开发语言
                        
    这段时间抽空给女朋友搭建一个个人博客，想着记录一下建站的过程，就当做笔记吧。虽然复制zjblog只要一个小时就可以搞定一个网站，或者用cms系统，三四个小时就可以做出一个前后台都有的网站，而且想做成啥样也都行。但是就是要从新做，自己做的意义不一样，更何况，俺就是专门干这个的，嘿嘿嘿要做一个网站，而且从零开始，首先呢就是技术选型了，经过一番思量决定选择-SpringBoot做后端，前端使用Vue做一
    
                    
    • 
                    
  • Spring MVC 全面指南：从入门到精通的详细解析
                        一杯梅子酱
技术栈学习springmvcjava
                        
    引言：SpringMVC，作为Spring框架的一个重要模块，为构建Web应用提供了强大的功能和灵活性。无论是初学者还是有一定经验的开发者，掌握SpringMVC都将显著提升你的Web开发技能。本文旨在为初学者提供一个全面且易于理解的学习路径，通过详细的知识点分析和实际案例，帮助你快速上手SpringMVC，让学习过程既深刻又高效。一、SpringMVC简介1.1什么是SpringMVC？Spri
    
                    
    • 
                    
  • Spring Boot中实现跨域请求
                        BABA8891
springboot后端java
                        
    在SpringBoot中实现跨域请求（CORS，Cross-OriginResourceSharing）可以通过多种方式，以下是几种常见的方法：1.使用@CrossOrigin注解在SpringBoot中，你可以在控制器或者具体的请求处理方法上使用@CrossOrigin注解来允许跨域请求。在控制器上应用：importorg.springframework.web.bind.annotation.
    
                    
    • 
                    
  • 博客网站制作教程
                        2401_85194651
javamaven
                        
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
    
                    
    • 
                    
  • RabbitMQ生产者重复机制与确认机制
                        java炒饭小能手
java-rabbitmqrabbitmqjava
                        
    重复机制生产者发送消息时，出现了网络故障，导致与MQ的连接中断。为了解决这个问题，SpringAMQP提供的消息发送时的重试机制。即：当RabbitTemplate与MQ连接超时后，多次重试。需要修该发送端模块的application.yaml文件，添加下面的内容：spring:rabbitmq:connection-timeout:1s#设置MQ的连接超时时间template:retry:ena
    
                    
    • 
                    
  • 【Java】已解决：org.springframework.jdbc.datasource.lookup.DataSourceLookupFailureException
                        屿小夏
java开发语言
                        
    文章目录一、分析问题背景问题背景描述出现问题的场景二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：org.springframework.jdbc.datasource.lookup.DataSourceLookupFailureException在使用Spring框架进行开发时，数据源的配置和使用是非常关键的一环。然而，有时候我们可能会遇到org.springframewo
    
                    
    • 
                    
  • SpringBoot和SpringMVC是什么关系?SpringBoot替代SpringMVC了吗?
                        瑞金彭于晏
springboot后端javaMVCspring数据库
                        
    SpringBoot和SpringMVC都是SpringFramework生态系统中的一部分，但它们各自扮演着不同的角色和提供不同的功能集。理解它们之间的关系，首先需要了解SpringFramework本身。SpringFrameworkSpringFramework是一个全面的、开源的应用程序开发框架，它提供了广泛的功能来支持企业应用开发的几乎所有方面。SpringFramework的核心特性之
    
                    
    • 
                    
  • spring mvc @RequestBody String类型参数
                        zoyation
spring-mvcspringmvc
                        
    通过如下配置：text/html;charset=UTF-8application/json;charset=UTF-8在springmvc的Controller层使用@RequestBody接收Content-Type为application/json的数据时，默认支持Map方式和对象方式参数@RequestMapping(value="/{code}/saveUser",method=Requ
    
                    
    • 
                    
  • Java -jar 如何在后台运行项目
                        vincent_hahaha

                        
    撸了今年阿里、头条和美团的面试，我有一个重要发现.......>>>说到运行jar包通常我们都会以下面的方式运行:java-jarspringboot-0.0.1-SNAPSHOT.jar这样运行的话会有一个问题，就是我们一关闭当前窗口就会停止运行项目，要想解决这个问题，就需要在后台运行。nohupjava-jarbabyshark-0.0.1-SNAPSHOT.jar >log.file 2>&
    
                    
    • 
                    
  • spring security中几大组件的作用和执行顺序
                        阿信在这里
javaspring
                        
    springsecurity中几大组件的作用和执行顺序在SpringSecurity中，AuthenticationProvider、GroupPermissionEvaluator、PermissionEvaluator、AbstractAuthenticationProcessingFilter、DefaultMethodSecurityExpressionHandler和ManageSecu
    
                    
    • 
                    
  • 探索Zebra4J：构建高效企业级Web应用的微服务框架
                        叶准鑫Natalie

                        
    探索Zebra4J：构建高效企业级Web应用的微服务框架ZebraZebra4J/Zebra4Js基于SpringBoot的JavaWeb/Nodejs框架项目地址:https://gitcode.com/gh_mirrors/zebra/Zebra项目介绍在当今快速发展的技术环境中，构建高效、可扩展的企业级Web应用是每个开发团队的追求。Zebra4J作为一款基于SpringBoot的全新微服务
    
                    
    • 
                    
  • 基于JavaWeb开发的Java+SpringMvc+vue+element实现上海汽车博物馆平台
                        网顺技术团队
成品程序项目javavue.js汽车课程设计springboot
                        
    基于JavaWeb开发的Java+SpringMvc+vue+element实现上海汽车博物馆平台作者主页网顺技术团队欢迎点赞收藏⭐留言文末获取源码联系方式查看下方微信号获取联系方式承接各种定制系统精彩系列推荐精彩专栏推荐订阅不然下次找不到哟Java毕设项目精品实战案例《1000套》感兴趣的可以先收藏起来，还有大家在毕设选题，项目以及论文编写等相关问题都可以给我留言咨询，希望帮助更多的人文章目录基
    
                    
    • 
                    
  • 分布式锁和spring事务管理
                        暴躁的鱼
锁及事务分布式springjava
                        
    最近开发一个小程序遇到一个需求需要实现分布式事务管理业务需求用户在使用小程序的过程中可以查看景点，对景点地区或者城市标记是否想去，那么需要统计一个地点被标记的人数，以及记录某个用户对某个地点是否标记为想去，用两个表存储数据，一个地点表记录改地点被标记的次数，一个用户意向表记录某个用户对某个地点是否标记为想去。由于可能有多个用户同时标记一个地点，每个用户在前端点击想去按钮之后，后台接收到请求，从数据
    
                    
    • 
                    
  • 深度学习-点击率预估-研究论文2024-09-14速读
                        sp_fyf_2024
深度学习人工智能
                        
    深度学习-点击率预估-研究论文2024-09-14速读1.DeepTargetSessionInterestNetworkforClick-ThroughRatePredictionHZhong,JMa,XDuan,SGu,JYao-2024InternationalJointConferenceonNeuralNetworks,2024深度目标会话兴趣网络用于点击率预测摘要：这篇文章提出了一种新
    
                    
    • 
                    
  • Java面试笔记记录6
                        今天背八股了吗
java面试笔记
                        
    1.Spring是什么？特性？有哪些模块？Spring是一个轻量级、非入侵式的控制反转Ioc和面向切面AOP的框架。特性：1.Ioc和DISpring的核心就是一个大的工厂容器，可以维护所有对象的创建和依赖关系，Spring工厂用于生成Bean，并且管理Bean的生命周期，实现高内聚低耦合的设计理念。2.AOP编程Spring提供面向切面编程，可以方便实现对程序进行权限拦截、运行监控等切面功能。3
    
                    
    • 
                    
  • Sentinel
                        眼泪落在琴弦
springcloudjavajava
                        
    Sentinel（服务熔断降级限流）1.引入spring-cloud-starter-alibaba-sentinel2.下载sentinel服务器3.配置application地址信息4.在控制台调整参数【默认所以流控设置保存在内存中，重启失效】5.想实时监控需每个微服务导入actuator，并配置application暴露所有端口6.自定义sentinel流控返回数据7.配置sentinel类
    
                    
    • 
                    
  • Spring @Async 深度解读：默认线程池执行器的配置与优化
                        小码快撩
springjava前端
                        
    在Spring中，@Async注解用于异步执行方法。默认情况下，@Async注解的任务是由一个线程池执行的。然而，这个默认的线程池是如何初始化的呢？本文将深入探讨这一过程，帮助你理解Spring异步任务背后的线程池执行器的初始化原理。1.@Async的基本使用首先，让我们快速回顾一下@Async的基本用法。@Async通常用于标注在需要异步执行的方法上，比如：@Servicepublicclass
    
                    
    • 
                    
  • Sentinel实时监控不展示问题
                        朱杰jjj
sentinelsentinel
                        
    问题官方插件Endpoint支持，可以实时统计出SpringBoot的健康状况和请求的调用信息在使用Endpoint特性之前需要在Maven中添加spring-boot-starter-actuator依赖，并在配置中允许Endpoints的访问。SpringBoot1.x中添加配置management.security.enabled=false。暴露的endpoint路径为/sentinelS
    
                    
    • 
                    
  • 36. MyBatis如何支持多数据库操作？如何配置不同的数据源？
                        这孩子叫逆
Mybatis笔记mybatis数据库
                        
    在许多企业级应用中，可能需要访问多个数据库。MyBatis可以通过配置多个数据源和动态切换数据源来支持多数据库操作。下面介绍如何在MyBatis中配置和使用多个数据源。1.多数据源的基本配置1.1配置多个数据源要支持多个数据源，首先需要在Spring或SpringBoot中配置不同的数据源。假设我们要连接两个数据库db1和db2，可以通过以下步骤进行配置。SpringBoot示例：applicat
    
                    
    • 
                    
  • SpringBoot整合ES搜索引擎 实现网站热搜词及热度计算
                        码踏云端
springbootElasticsearchspringbootelasticsearch后端热搜词热度计算java
                        
    博主简介：历代文学网（PC端可以访问：https://literature.sinhy.com/#/literature?__c=1000，移动端可微信小程序搜索“历代文学”）总架构师，15年工作经验，精通Java编程，高并发设计，Springboot和微服务，熟悉Linux，ESXI虚拟化以及云原生Docker和K8s，热衷于探索科技的边界，并将理论知识转化为实际应用。保持对新技术的好奇心，乐于
    
                    
    • 
                    
  • Spring Security静态资源过滤（11）
                        小黑屋说YYDS
spring
                        
    在一个实际项目中，并非所有的请求都需要经过SpringSecurity过滤器，有一些特殊的请求，例如静态资源等，一般来说并不需要经过SpringSecurity过滤器链，用户如果访问这些静态资源，直接返回对应的资源即可。回顾关于WebSecurity的讲解，提到它里边维护了一个ignoredRequests变量,该变量，记录的就是所有需要被忽略的请求，这些被忽略的请求将不再经过SpringSecu
    
                    
    • 
                    
  • Spring Security定义多个过滤器链（10）
                        小黑屋说YYDS
spring
                        
    在SpringSecurity中可以同时存在多个过滤器链，一个WebSecurityConfigurerAdapter的实例就可以配置一条过滤器链。我们来看如下一个案例：@ConfigurationpublicclassSecurityConfig{@BeanUserDetailsServiceus(){InMemoryUserDetailsManagerusers=newInMemoryUser
    
                    
    • 
                    
  • java 技术 架构 相关文档
                        圣心
java架构开发语言
                        
    在Java中，有许多不同的技术和架构，这里我将列举一些常见的Java技术和架构，并提供一些相关的文档资源。SpringFrameworkSpring是一个开源的Java/JavaEE全功能框架，以Apache许可证形式发布，提供了一种实现企业级应用的方法。官方文档：SpringFrameworkSpringBootSpringBoot是Spring的一个子项目，旨在简化创建生产级的Spring应用
    
                    
    • 
                    
  • SpringSecurity初学总结
                        weixin_66442229
spring
                        
    springSecurity安全框架基于Java的安全框架主要有:SpringSecurity和Shiro介绍基础概念安全框架是对用户访问权限的控制,保证应用的安全性。其主要的工作是用户认证和用户授权|鉴权主要应用于Spring的企业应用系统,提供声明式的安全访问控制解决方案。它提供了一组可以在Spring应用上下文中配置的Bean能很好的结合Spring的DI依赖注入和AOP面向切面编程功能应用
    
                    
    • 
                    
  • java获取applicationcontext,SpringBoot获取ApplicationContext的3种方式
                        花儿街参考

                        
    ApplicationContext是什么？简单来说就是Spring中的容器，可以用来获取容器中的各种bean组件，注册监听事件，加载资源文件等功能。ApplicationContext获取的几种方式1直接使用Autowired注入@ComponentpublicclassBook1{@AutowiredprivateApplicationContextapplicationContext;pub
    
                    
    • 
                    
  • SpringBoot 设置传入参数非必要
                        loveLifeLoveCoding
springbootspringbootjavaspring
                        
    查看RequestParam源码packageorg.springframework.web.bind.annotation;importjava.lang.annotation.Documented;importjava.lang.annotation.ElementType;importjava.lang.annotation.Retention;importjava.lang.annotat
    
                    
    • 
                    
  • SpringBoot 获取 ApplicationContext
                        loveLifeLoveCoding
springbootspringbootjavaspring
                        
    1.概念ApplicationContext是什么？简单来说就是Spring中的容器，可以用来获取容器中的各种bean组件，注册监听事件，加载资源文件等功能2.获取ApplicationContext的方式2.1.创建工具类通过此工具类，可以方便的获取bean组件,获取配置信息等importorg.springframework.beans.BeansException;importorg.spr
    
                    
    • 
                                
  • tomcat基础与部署发布
                                    暗黑小菠萝
Tomcat java web
                                    
    从51cto搬家了，以后会更新在这里方便自己查看。 
做项目一直用tomcat，都是配置到eclipse中使用，这几天有时间整理一下使用心得，有一些自己配置遇到的细节问题。 
Tomcat：一个Servlets和JSP页面的容器，以提供网站服务。 
一、Tomcat安装 
    安装方式：①运行.exe安装包 
     &n
    
                                
    • 
                                
  • 网站架构发展的过程
                                    ayaoxinchao
数据库应用服务器网站架构
                                    
    1.初始阶段网站架构：应用程序、数据库、文件等资源在同一个服务器上 
2.应用服务和数据服务分离：应用服务器、数据库服务器、文件服务器 
3.使用缓存改善网站性能：为应用服务器提供本地缓存，但受限于应用服务器的内存容量，可以使用专门的缓存服务器，提供分布式缓存服务器架构 
4.使用应用服务器集群改善网站的并发处理能力：使用负载均衡调度服务器，将来自客户端浏览器的访问请求分发到应用服务器集群中的任何
    
                                
    • 
                                
  • [信息与安全]数据库的备份问题
                                    comsci
数据库
                                    
     
 
      如果你们建设的信息系统是采用中心-分支的模式,那么这里有一个问题 
  
 如果你的数据来自中心数据库,那么中心数据库如果出现故障,你的分支机构的数据如何保证安全呢? 
 
   是否应该在这种信息系统结构的基础上进行改造,容许分支机构的信息系统也备份一个中心数据库的文件呢? 
 
 &n
    
                                
    • 
                                
  • 使用maven tomcat plugin插件debug关联源代码
                                    商人shang
mavendebug查看源码tomcat-plugin
                                    
    *首先需要配置好'''maven-tomcat7-plugin'''，参见[[Maven开发Web项目]]的'''Tomcat'''部分。 
*配置好后，在[[Eclipse]]中打开'''Debug Configurations'''界面，在'''Maven Build'''项下新建当前工程的调试。在'''Main'''选项卡中点击'''Browse Workspace...'''选择需要开发的
    
                                
    • 
                                
  • 大访问量高并发
                                    oloz
大访问量高并发
                                    
    大访问量高并发的网站主要压力还是在于数据库的操作上，尽量避免频繁的请求数据库。下面简 
 
要列出几点解决方案： 
 
01、优化你的代码和查询语句，合理使用索引 
 
02、使用缓存技术例如memcache、ecache将不经常变化的数据放入缓存之中 
 
03、采用服务器集群、负载均衡分担大访问量高并发压力 
 
04、数据读写分离 
 
05、合理选用框架，合理架构(推荐分布式架构)。 
 
    
                                
    • 
                                
  • cache 服务器
                                    小猪猪08
cache
                                    
    Cache   即高速缓存.那么cache是怎么样提高系统性能与运行速度呢？是不是在任何情况下用cache都能提高性能？是不是cache用的越多就越好呢？我在近期开发的项目中有所体会，写下来当作总结也希望能跟大家一起探讨探讨，有错误的地方希望大家批评指正。 
　　1.Cache   是怎么样工作的? 
　　Cache   是分配在服务器上
    
                                
    • 
                                
  • mysql存储过程
                                    香水浓
mysql
                                    
    Description:插入大量测试数据 
 
use xmpl;

drop procedure if exists mockup_test_data_sp;

create procedure mockup_test_data_sp(
	in number_of_records int
)
begin
	declare cnt int;
	declare name varch
    
                                
    • 
                                
  • CSS的class、id、css文件名的常用命名规则
                                    agevs
JavaScriptUI框架Ajaxcss
                                    
      CSS的class、id、css文件名的常用命名规则 
    (一)常用的CSS命名规则 
　　头：header 
　　内容：content/container 
　　尾：footer 
　　导航：nav 
　　侧栏：sidebar 
　　栏目：column 
　　页面外围控制整体布局宽度：wrapper 
　　左右中：left right 
    
                                
    • 
                                
  • 全局数据源
                                    AILIKES
javatomcatmysqljdbcJNDI
                                    
    实验目的：为了研究两个项目同时访问一个全局数据源的时候是创建了一个数据源对象，还是创建了两个数据源对象。 
1：将diuid和mysql驱动包（druid-1.0.2.jar和mysql-connector-java-5.1.15.jar）copy至%TOMCAT_HOME%/lib下；2：配置数据源，将JNDI在%TOMCAT_HOME%/conf/context.xml中配置好,格式如下：&l
    
                                
    • 
                                
  • MYSQL的随机查询的实现方法
                                    baalwolf
mysql
                                    
    MYSQL的随机抽取实现方法。举个例子，要从tablename表中随机提取一条记录，大家一般的写法就是：SELECT * FROM tablename ORDER BY RAND() LIMIT 1。但是，后来我查了一下MYSQL的官方手册，里面针对RAND()的提示大概意思就是，在ORDER BY从句里面不能使用RAND()函数，因为这样会导致数据列被多次扫描。但是在MYSQL 3.23版本中，
    
                                
    • 
                                
  • JAVA的getBytes()方法
                                    bijian1013
javaeclipseunixOS
                                    
        在Java中，String的getBytes()方法是得到一个操作系统默认的编码格式的字节数组。这个表示在不同OS下，返回的东西不一样！  
    String.getBytes(String decode)方法会根据指定的decode编码返回某字符串在该编码下的byte数组表示，如： 
    byte[] b_gbk = "
    
                                
    • 
                                
  • AngularJS中操作Cookies
                                    bijian1013
JavaScriptAngularJSCookies
                                    
            如果你的应用足够大、足够复杂，那么你很快就会遇到这样一咱种情况：你需要在客户端存储一些状态信息，这些状态信息是跨session(会话)的。你可能还记得利用document.cookie接口直接操作纯文本cookie的痛苦经历。 
        幸运的是，这种方式已经一去不复返了，在所有现代浏览器中几乎
    
                                
    • 
                                
  • [Maven学习笔记五]Maven聚合和继承特性
                                    bit1129
maven
                                    
    Maven聚合 
  
在实际的项目中，一个项目通常会划分为多个模块，为了说明问题，以用户登陆这个小web应用为例。通常一个web应用分为三个模块：   
1. 模型和数据持久化层user-core, 
2. 业务逻辑层user-service以 
3. web展现层user-web， 
user-service依赖于user-core 
user-web依赖于user-core和use
    
                                
    • 
                                
  • 【JVM七】JVM知识点总结
                                    bit1129
jvm
                                    
      1. JVM运行模式 
1.1 JVM运行时分为-server和-client两种模式，在32位机器上只有client模式的JVM。通常，64位的JVM默认都是使用server模式，因为server模式的JVM虽然启动慢点，但是，在运行过程，JVM会尽可能的进行优化 
1.2 JVM分为三种字节码解释执行方式：mixed mode, interpret mode以及compiler 
    
                                
    • 
                                
  • linux下查看nginx、apache、mysql、php的编译参数
                                    ronin47

                                    
    在linux平台下的应用，最流行的莫过于nginx、apache、mysql、php几个。而这几个常用的应用，在手工编译完以后，在其他一些情况下（如：新增模块），往往想要查看当初都使用了那些参数进行的编译。这时候就可以利用以下方法查看。 
1、nginx 
[root@361way ~]# /App/nginx/sbin/nginx -V
nginx: nginx version: nginx/
    
                                
    • 
                                
  • unity中运用Resources.Load的方法？
                                    brotherlamp
unity视频unity资料unity自学unityunity教程
                                    
    问：unity中运用Resources.Load的方法？ 
答：Resources.Load是unity本地动态加载资本所用的方法,也即是你想动态加载的时分才用到它,比方枪弹,特效,某些实时替换的图像什么的,主张此文件夹不要放太多东西,在打包的时分,它会独自把里边的一切东西都会集打包到一同,不论里边有没有你用的东西,所以大多数资本应该是自个建文件放置 
1、unity实时替换的物体即是依据环境条件
    
                                
    • 
                                
  • 线段树-入门
                                    bylijinnan
java算法线段树
                                    
    


/**
 * 线段树入门
 * 问题：已知线段[2,5] [4,6] [0,7]；求点2,4,7分别出现了多少次
 * 以下代码建立的线段树用链表来保存，且树的叶子结点类似[i,i]
 * 
 * 参考链接：http://hi.baidu.com/semluhiigubbqvq/item/be736a33a8864789f4e4ad18
 * @author lijinna
    
                                
    • 
                                
  • 全选与反选
                                    chicony
全选
                                    
      
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>全选与反选</title>

    
                                
    • 
                                
  • vim一些简单记录
                                    chenchao051
vim
                                    
    mac在/usr/share/vim/vimrc linux在/etc/vimrc 
  
1、问：后退键不能删除数据，不能往后退怎么办？ 
      答：在vimrc中加入set backspace=2 
  
2、问：如何控制tab键的缩进？ 
      答：在vimrc中加入set tabstop=4 (任何
    
                                
    • 
                                
  • Sublime Text 快捷键
                                    daizj
快捷键sublime
                                    
    [size=large][/size]Sublime Text快捷键：Ctrl+Shift+P：打开命令面板Ctrl+P：搜索项目中的文件Ctrl+G：跳转到第几行Ctrl+W：关闭当前打开文件Ctrl+Shift+W：关闭所有打开文件Ctrl+Shift+V：粘贴并格式化Ctrl+D：选择单词，重复可增加选择下一个相同的单词Ctrl+L：选择行，重复可依次增加选择下一行Ctrl+Shift+L：
    
                                
    • 
                                
  • php 引用(&)详解
                                    dcj3sjt126com
PHP
                                    
    在PHP 中引用的意思是：不同的名字访问同一个变量内容. 与Ｃ语言中的指针是有差别的．Ｃ语言中的指针里面存储的是变量的内容在内存中存放的地址 变量的引用 PHP 的引用允许你用两个变量来指向同一个内容   复制代码代码如下:   
<?  
$a="ABC";  
$b =&$a;  
echo
    
                                
    • 
                                
  • SVN中trunk,branches,tags用法详解
                                    dcj3sjt126com
SVN
                                    
    Subversion有一个很标准的目录结构，是这样的。比如项目是proj，svn地址为svn://proj/，那么标准的svn布局是svn://proj/|+-trunk+-branches+-tags这是一个标准的布局，trunk为主开发目录，branches为分支开发目录，tags为tag存档目录（不允许修改）。但是具体这几个目录应该如何使用，svn并没有明确的规范，更多的还是用户自己的习惯。
    
                                
    • 
                                
  • 对软件设计的思考
                                    e200702084
设计模式数据结构算法ssh活动
                                    
    软件设计的宏观与微观  
 
   软件开发是一种高智商的开发活动。一个优秀的软件设计人员不仅要从宏观上把握软件之间的开发，也要从微观上把握软件之间的开发。宏观上，可以应用面向对象设计，采用流行的SSH架构，采用web层，业务逻辑层，持久层分层架构。采用设计模式提供系统的健壮性和可维护性。微观上，对于一个类，甚至方法的调用，从计算机的角度模拟程序的运行情况。了解内存分配，参数传
    
                                
    • 
                                
  • 同步、异步、阻塞、非阻塞
                                    geeksun
非阻塞
                                    
    同步、异步、阻塞、非阻塞这几个概念有时有点混淆，在此文试图解释一下。 
  
同步：发出方法调用后，当没有返回结果，当前线程会一直在等待（阻塞）状态。 
场景：打电话，营业厅窗口办业务、B/S架构的http请求-响应模式。 
  
异步：方法调用后不立即返回结果，调用结果通过状态、通知或回调通知方法调用者或接收者。异步方法调用后，当前线程不会阻塞，会继续执行其他任务。 
实现：
    
                                
    • 
                                
  • Reverse SSH Tunnel 反向打洞實錄
                                    hongtoushizi
ssh
                                    
    實際的操作步驟：  
# 首先，在客戶那理的機器下指令連回我們自己的 Server，並設定自己 Server 上的 12345 port 會對應到幾器上的 SSH port
ssh -NfR 12345:localhost:22 [email protected]

# 然後在 myhost 的機器上連自己的 12345 port，就可以連回在客戶那的機器
ssh localhost -p 1
    
                                
    • 
                                
  • Hibernate中的缓存
                                    Josh_Persistence
一级缓存Hiberante缓存查询缓存二级缓存
                                    
    Hibernate中的缓存 
  
一、Hiberante中常见的三大缓存：一级缓存，二级缓存和查询缓存。 
Hibernate中提供了两级Cache，第一级别的缓存是Session级别的缓存，它是属于事务范围的缓存。这一级别的缓存是由hibernate管理的，一般情况下无需进行干预；第二级别的缓存是SessionFactory级别的缓存，它是属于进程范围或群集范围的缓存。这一级别的缓存
    
                                
    • 
                                
  • 对象关系行为模式之延迟加载
                                    home198979
PHP架构延迟加载
                                    
    形象化设计模式实战     HELLO!架构 
  
一、概念 
Lazy Load：一个对象，它虽然不包含所需要的所有数据，但是知道怎么获取这些数据。 
延迟加载貌似很简单，就是在数据需要时再从数据库获取，减少数据库的消耗。但这其中还是有不少技巧的。 
  
  
二、实现延迟加载 
实现Lazy Load主要有四种方法：延迟初始化、虚
    
                                
    • 
                                
  • xml 验证
                                    pengfeicao521
xmlxml解析
                                    
    有些字符，xml不能识别，用jdom或者dom4j解析的时候就报错 
 
public static void testPattern() { 
 
 // 含有非法字符的串 
 String str =       "Jamey&#52828;&#01;&#02;&#209;&#1282
    
                                
    • 
                                
  • div设置半透明效果
                                    spjich
css半透明
                                    
    为div设置如下样式： 
  
div{filter:alpha(Opacity=80);-moz-opacity:0.5;opacity: 0.5;}  
  
  
  
 说明： 
1、filter：对win IE设置半透明滤镜效果，filter:alpha(Opacity=80)代表该对象80%半透明，火狐浏览器不认2、-moz-opaci
    
                                
    • 
                                
  • 你真的了解单例模式么？
                                    w574240966
java单例设计模式jvm
                                    
        单例模式，很多初学者认为单例模式很简单，并且认为自己已经掌握了这种设计模式。但事实上，你真的了解单例模式了么。 
  
一，单例模式的5中写法。（回字的四种写法，哈哈。） 
    1，懒汉式 
          （1）线程不安全的懒汉式 
    public cla
    
                                
    •