正文

springboot2.1.3+spring-session2.1.4分库处理

IP云
IP云V管理员/5 阅读
12/01
提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

使用spring session框架来统一管理session，该框架支持jdbc、redis存储，使用非常简单，可以去官网查看文档一步步接入即可，
官网文档如下：https://docs.spring.io/spring-session/docs/current/reference/html5/，

不过，我使用的场景官网没有提供方法给予解决，最后，本人只能重写了它的部分源码，来实现分库管理session，好了，上代码。

pom.xml 

<dependency>

    <groupId>org.springframework.session</groupId>

    <artifactId>spring-session-core</artifactId>

    <version>2.1.4.RELEASE</version>

</dependency>

<dependency>

    <groupId>org.springframework.session</groupId>

    <artifactId>spring-session-jdbc</artifactId>

    <version>2.1.4.RELEASE</version>

</dependency>

<!--

<dependency>

    <groupId>org.springframework.session</groupId>

    <artifactId>spring-session-redis</artifactId>

    <version>2.1.4.RELEASE</version>

</dependency>

-->

<dependency>

    <groupId>com.zaxxer</groupId>

    <artifactId>HikariCP</artifactId>

    <version>3.2.0</version>

</dependency>

application.properties 

# spring-session setting, timeout: 2 years

spring.session.timeout.setting=63072000

# sharding number, CONFIG_SHARDING_NUM 环境变量名

mydb.server.sharding.num=${CONFIG_SHARDING_NUM:4}

# global setting dbs parameter

mysql.global.pools.MinimumIdle=1

mysql.global.pools.MaximumPoolSize=20

mysql.global.pools.IdleTimeout=600000

mysql.global.pools.MaxLifetime=1800000

# 这里配置分库信息，这里只是demo，本人配置了4个主库，至于分库分表不在本博客中体现。

# master0

sharding.jdbc.datasource.mainshard0.type=com.zaxxer.hikari.HikariDataSource

sharding.jdbc.datasource.mainshard0.driver-class-name=org.mariadb.jdbc.Driver

sharding.jdbc.datasource.mainshard0.jdbc-url=jdbc:mysql://127.0.0.1:3306/demo?useUnicode=true&characterEncoding-utf8&allowMutiQueries=true

sharding.jdbc.datasource.mainshard0.username=xxxx

sharding.jdbc.datasource.mainshard0.password=xxxxxx

# master1

sharding.jdbc.datasource.mainshard1.type=com.zaxxer.hikari.HikariDataSource

sharding.jdbc.datasource.mainshard1.driver-class-name=org.mariadb.jdbc.Driver

sharding.jdbc.datasource.mainshard1.jdbc-url=jdbc:mysql://127.0.0.1:3307/demo?useUnicode=true&characterEncoding-utf8&allowMutiQueries=true

sharding.jdbc.datasource.mainshard1.username=xxxx

sharding.jdbc.datasource.mainshard1.password=xxxxxx

# master2

sharding.jdbc.datasource.mainshard2.type=com.zaxxer.hikari.HikariDataSource

sharding.jdbc.datasource.mainshard2.driver-class-name=org.mariadb.jdbc.Driver

sharding.jdbc.datasource.mainshard2.jdbc-url=jdbc:mysql://127.0.0.1:3308/demo?useUnicode=true&characterEncoding-utf8&allowMutiQueries=true

sharding.jdbc.datasource.mainshard2.username=xxxx

sharding.jdbc.datasource.mainshard2.password=xxxxxx

# master3

sharding.jdbc.datasource.mainshard3.type=com.zaxxer.hikari.HikariDataSource

sharding.jdbc.datasource.mainshard3.driver-class-name=org.mariadb.jdbc.Driver

sharding.jdbc.datasource.mainshard3.jdbc-url=jdbc:mysql://127.0.0.1:3309/demo?useUnicode=true&characterEncoding-utf8&allowMutiQueries=true

sharding.jdbc.datasource.mainshard3.username=xxxx

sharding.jdbc.datasource.mainshard3.password=xxxxxx

重写第一个类(源码文件是JdbcHttpSessionConfiguration.java，可以去官网下载)，本人重写如下： 

package com.szl.demo.spring.session.common.datasource.sessionConfig;

import java.util.HashMap;

import java.util.Map;

import javax.sql.DataSource;

import org.springframework.beans.factory.BeanClassLoaderAware;

import org.springframework.beans.factory.ObjectProvider;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Qualifier;

import org.springframework.context.EmbeddedValueResolverAware;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.context.annotation.ImportAware;

import org.springframework.core.annotation.AnnotationAttributes;

import org.springframework.core.convert.ConversionService;

import org.springframework.core.convert.support.GenericConversionService;

import org.springframework.core.serializer.support.DeserializingConverter;

import org.springframework.core.serializer.support.SerializingConverter;

import org.springframework.core.type.AnnotationMetadata;

import org.springframework.jdbc.core.JdbcTemplate;

import org.springframework.jdbc.support.JdbcUtils;

import org.springframework.jdbc.support.MetaDataAccessException;

import org.springframework.jdbc.support.lob.DefaultLobHandler;

import org.springframework.jdbc.support.lob.LobHandler;

import org.springframework.scheduling.annotation.EnableScheduling;

import org.springframework.scheduling.annotation.SchedulingConfigurer;

import org.springframework.scheduling.config.ScheduledTaskRegistrar;

import org.springframework.session.MapSession;

import org.springframework.session.config.annotation.web.http.SpringHttpSessionConfiguration;

import org.springframework.session.jdbc.JdbcOperationsSessionRepository;

import org.springframework.session.jdbc.config.annotation.SpringSessionDataSource;

import org.springframework.session.web.http.SessionRepositoryFilter;

import org.springframework.transaction.PlatformTransactionManager;

import org.springframework.util.StringUtils;

import org.springframework.util.StringValueResolver;

import com.zaxxer.hikari.HikariConfig;

import com.zaxxer.hikari.HikariDataSource;

/**

 *  @author Jimmy Shan

 *  @date 2019-06-25

 *  @desc 重写jdbc session配置类

 */

@Configuration

@EnableScheduling

public class CustomizedJdbcHttpSessionConfiguration extends SpringHttpSessionConfiguration

        implements BeanClassLoaderAware, EmbeddedValueResolverAware, ImportAware,

        SchedulingConfigurer {

  static final String DEFAULT_CLEANUP_CRON = "0 0 0/1 * * *";

  private String tableName = JdbcOperationsSessionRepository.DEFAULT_TABLE_NAME;

  private String cleanupCron = DEFAULT_CLEANUP_CRON;

  private LobHandler lobHandler;

  private ConversionService springSessionConversionService;

  private ConversionService conversionService;

  private ClassLoader classLoader;

  private StringValueResolver embeddedValueResolver;

  //--------------Modify by Jimmy Shan, the date is 2019-06-25 start------//

  @Value("${mydb.server.sharding.num}")

  private String shardingNum;

  @Autowired

  private Environment env;

  private Map<Integer, JdbcTemplate> myJdbcTemplateMap = new HashMap<>();

  private Map<Integer, PlatformTransactionManager> myDataSourceTransactionMap = new HashMap<>();

  private DataSource dataSource;

  // 时间设置，间隔时间为30秒

  private Integer maxInactiveIntervalInSeconds;

  //--------------Modify by Jimmy Shan, the date is 2019-06-25 end-------//

    /**

     * @desc 创建数据源，手动创建，为了后面的分库

     */

    private DataSource convertDataSource(int num) {

        HikariConfig hkConfig = new HikariConfig();

        hkConfig.setDriverClassName("org.mariadb,jdbc.Driver");

        hkConfig.setMinimumIdle(env.getProperty("mysql.global.pools.MinimumIdle") == null ? 5 : env.getProperty("mysql.global.pools.MinimumIdle")));

        hkConfig.setMaximumPoolSize(env.getProperty("mysql.global.pools.MaximumPoolSize") == null ? 20 : env.getProperty("mysql.global.pools.MaximumPoolSize")));

        hkConfig.setIdleTimeout(env.getProperty("mysql.global.pools.IdleTimeout") == null ? 600000 : Integer.parseInt(env.getProperty("mysql.global.pools.IdleTimeout")));

        hkConfig.setMaxLifetime(env.getProperty("mysql.global.pools.MaxLifetime") == null ? 1800000 : Integer.parseInt(env.getProperty("mysql.global.pools.MaxLifetime")));

        hkConfig.setJdbcUrl(env.getProperty("sharding.jdbc.datasource.mainshard" + num + ".jdbc-url"));

        hkConfig.setUsername(env.getProperty("sharding.jdbc.datasource.mainshard" + num + ".username"));

        hkConfig.setPassword(env.getProperty("sharding.jdbc.datasource.mainshard" + num + ".password"));

        HikariDataSource ds = new HikariDataSource(hkConfig);

        return ds;

    }

  /**

   * @desc 重写了部分逻辑

   */

    @Bean

    public CustomizedJdbcOperationsSessionRepository sessionRepository() {

      for (int i = 0; i < Integer.parseInt(shardingNum); i++) {

          DataSource ds = convertDataSource(i);

          myJdbcTemplateMap.put(i, new JdbcTemplate(ds));

          myDataSourceTransactionMap.put(i, new DataSourceTransactionManager(ds));

      }

      this.dataSource = myJdbcTemplateMap.get(0).getDataSource();

        CustomizedJdbcOperationsSessionRepository sessionRepository =

            new JdbcOperationsSessionRepository(myJdbcTemplateMap, myDataSourceTransactionMap);

        if (StringUtils.hasText(this.tableName)) {

            sessionRepository.setTableName(this.tableName);

        }

        this.setMaxInactiveIntervalInSeconds(Integer.parseInt(env.getProperty("spring.session.timeout.setting")));

        sessionRepository.setDefaultMaxInactiveInterval(this.maxInactiveIntervalInSeconds);

        if (this.lobHandler != null) {

             sessionRepository.setLobHandler(this.lobHandler);

        }    else if (requiresTemporaryLob(this.dataSource)) {

             DefaultLobHandler lobHandler = new DefaultLobHandler();

             lobHandler.setCreateTemporaryLob(true);

             sessionRepository.setLobHandler(lobHandler);

        }

        if (this.springSessionConversionService != null) {

             sessionRepository.setConversionService(this.springSessionConversionService);

        }    else if (this.conversionService != null) {

             sessionRepository.setConversionService(this.conversionService);

        }    else {

             sessionRepository.setConversionService(createConversionServiceWithBeanClassLoader());

        }

        return sessionRepository;

    }

    private static boolean requiresTemporaryLob(DataSource dataSource) {

        try {

            String productName = JdbcUtils.extractDatabaseMetaData(dataSource,

                    "getDatabaseProductName");

            return "Oracle".equalsIgnoreCase(JdbcUtils.commonDatabaseName(productName));

        }

        catch (MetaDataAccessException ex) {

            return false;

        }

    }

    public void setMaxInactiveIntervalInSeconds(Integer maxInactiveIntervalInSeconds) {

        this.maxInactiveIntervalInSeconds = maxInactiveIntervalInSeconds;

    }

    public void setTableName(String tableName) {

        this.tableName = tableName;

    }

    public void setCleanupCron(String cleanupCron) {

        this.cleanupCron = cleanupCron;

    }

    @Autowired(required = false)

    @Qualifier("springSessionLobHandler")

    public void setLobHandler(LobHandler lobHandler) {

        this.lobHandler = lobHandler;

    }

    @Autowired(required = false)

    @Qualifier("springSessionConversionService")

    public void setSpringSessionConversionService(ConversionService conversionService) {

        this.springSessionConversionService = conversionService;

    }

    @Autowired(required = false)

    @Qualifier("conversionService")

    public void setConversionService(ConversionService conversionService) {

        this.conversionService = conversionService;

    }

    @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<String, Object> attributeMap = importMetadata

                .getAnnotationAttributes(EnableJdbcHttpSession.class.getName());

        AnnotationAttributes attributes = AnnotationAttributes.fromMap(attributeMap);

        this.maxInactiveIntervalInSeconds = attributes

                .getNumber("maxInactiveIntervalInSeconds");

        String tableNameValue = attributes.getString("tableName");

        if (StringUtils.hasText(tableNameValue)) {

            this.tableName = this.embeddedValueResolver

                    .resolveStringValue(tableNameValue);

        }

        String cleanupCron = attributes.getString("cleanupCron");

        if (StringUtils.hasText(cleanupCron)) {

            this.cleanupCron = cleanupCron;

        }

    }

    @Override

    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {

        taskRegistrar.addCronTask(() -> sessionRepository().cleanUpExpiredSessions(),

                this.cleanupCron);

    }

    private GenericConversionService createConversionServiceWithBeanClassLoader() {

        GenericConversionService conversionService = new GenericConversionService();

        conversionService.addConverter(Object.class, byte[].class,

                new SerializingConverter());

        conversionService.addConverter(byte[].class, Object.class,

                new DeserializingConverter(this.classLoader));

        return conversionService;

    }

}

重写第二个类(源码文件是JdbcOperationsSessionRepository.java，可以去官网下载)，本人重写如下： 

package com.szl.demo.spring.session.common.datasource.sessionConfig;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.time.Duration;

import java.time.Instant;

import java.util.ArrayList;

import java.util.Collections;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.UUID;

import java.util.function.Supplier;

import java.util.stream.Collectors;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.core.convert.ConversionService;

import org.springframework.core.convert.TypeDescriptor;

import org.springframework.core.convert.support.GenericConversionService;

import org.springframework.core.serializer.support.DeserializingConverter;

import org.springframework.core.serializer.support.SerializingConverter;

import org.springframework.dao.DataAccessException;

import org.springframework.expression.Expression;

import org.springframework.expression.spel.standard.SpelExpressionParser;

import org.springframework.jdbc.core.BatchPreparedStatementSetter;

import org.springframework.jdbc.core.JdbcOperations;

import org.springframework.jdbc.core.JdbcTemplate;

import org.springframework.jdbc.core.ResultSetExtractor;

import org.springframework.jdbc.support.lob.DefaultLobHandler;

import org.springframework.jdbc.support.lob.LobHandler;

import org.springframework.session.FindByIndexNameSessionRepository;

import org.springframework.session.MapSession;

import org.springframework.session.Session;

import org.springframework.session.jdbc.JdbcOperationsSessionRepository;

import org.springframework.transaction.PlatformTransactionManager;

import org.springframework.transaction.TransactionDefinition;

import org.springframework.transaction.TransactionException;

import org.springframework.transaction.TransactionStatus;

import org.springframework.transaction.support.TransactionCallback;

import org.springframework.transaction.support.TransactionCallbackWithoutResult;

import org.springframework.transaction.support.TransactionOperations;

import org.springframework.transaction.support.TransactionTemplate;

import org.springframework.util.Assert;

import org.springframework.util.StringUtils;

/**

 * @author Jimmy Shan

 * @date 2019-06-25

 * @desc 重写jdbc session类

 */

public class CustomizedJdbcOperationsSessionRepository implements

        FindByIndexNameSessionRepository<JdbcOperationsSessionRepository.JdbcSession> {

    public static final String DEFAULT_TABLE_NAME = "SPRING_SESSION";

    private static final String SPRING_SECURITY_CONTEXT = "SPRING_SECURITY_CONTEXT";

    private static final String CREATE_SESSION_QUERY =

            "INSERT INTO %TABLE_NAME%(PRIMARY_ID, SESSION_ID, CREATION_TIME, LAST_ACCESS_TIME, MAX_INACTIVE_INTERVAL, EXPIRY_TIME, PRINCIPAL_NAME) " +

                    "VALUES (?, ?, ?, ?, ?, ?, ?)";

    private static final String CREATE_SESSION_ATTRIBUTE_QUERY =

            "INSERT INTO %TABLE_NAME%_ATTRIBUTES(SESSION_PRIMARY_ID, ATTRIBUTE_NAME, ATTRIBUTE_BYTES) " +

                    "SELECT PRIMARY_ID, ?, ? " +

                    "FROM %TABLE_NAME% " +

                    "WHERE SESSION_ID = ?";

    private static final String GET_SESSION_QUERY =

            "SELECT S.PRIMARY_ID, S.SESSION_ID, S.CREATION_TIME, S.LAST_ACCESS_TIME, S.MAX_INACTIVE_INTERVAL, SA.ATTRIBUTE_NAME, SA.ATTRIBUTE_BYTES " +

                    "FROM %TABLE_NAME% S " +

                    "LEFT OUTER JOIN %TABLE_NAME%_ATTRIBUTES SA ON S.PRIMARY_ID = SA.SESSION_PRIMARY_ID " +

                    "WHERE S.SESSION_ID = ?";

    private static final String UPDATE_SESSION_QUERY =

            "UPDATE %TABLE_NAME% SET SESSION_ID = ?, LAST_ACCESS_TIME = ?, MAX_INACTIVE_INTERVAL = ?, EXPIRY_TIME = ?, PRINCIPAL_NAME = ? " +

                    "WHERE PRIMARY_ID = ?";

    private static final String UPDATE_SESSION_ATTRIBUTE_QUERY =

            "UPDATE %TABLE_NAME%_ATTRIBUTES SET ATTRIBUTE_BYTES = ? " +

                    "WHERE SESSION_PRIMARY_ID = ? " +

                    "AND ATTRIBUTE_NAME = ?";

    private static final String DELETE_SESSION_ATTRIBUTE_QUERY =

            "DELETE FROM %TABLE_NAME%_ATTRIBUTES " +

                    "WHERE SESSION_PRIMARY_ID = ? " +

                    "AND ATTRIBUTE_NAME = ?";

    private static final String DELETE_SESSION_QUERY =

            "DELETE FROM %TABLE_NAME% " +

                    "WHERE SESSION_ID = ?";

    private static final String LIST_SESSIONS_BY_PRINCIPAL_NAME_QUERY =

            "SELECT S.PRIMARY_ID, S.SESSION_ID, S.CREATION_TIME, S.LAST_ACCESS_TIME, S.MAX_INACTIVE_INTERVAL, SA.ATTRIBUTE_NAME, SA.ATTRIBUTE_BYTES " +

                    "FROM %TABLE_NAME% S " +

                    "LEFT OUTER JOIN %TABLE_NAME%_ATTRIBUTES SA ON S.PRIMARY_ID = SA.SESSION_PRIMARY_ID " +

                    "WHERE S.PRINCIPAL_NAME = ?";

    private static final String DELETE_SESSIONS_BY_EXPIRY_TIME_QUERY =

            "DELETE FROM %TABLE_NAME% " +

                    "WHERE EXPIRY_TIME < ?";

    private static final Log logger = LogFactory.getLog(JdbcOperationsSessionRepository.class);

    private static final PrincipalNameResolver PRINCIPAL_NAME_RESOLVER = new PrincipalNameResolver();

    private final ResultSetExtractor<List<JdbcSession>> extractor = new SessionResultSetExtractor();

    private String tableName = DEFAULT_TABLE_NAME;

    private String createSessionQuery;

    private String createSessionAttributeQuery;

    private String getSessionQuery;

    private String updateSessionQuery;

    private String updateSessionAttributeQuery;

    private String deleteSessionAttributeQuery;

    private String deleteSessionQuery;

    private String listSessionsByPrincipalNameQuery;

    private String deleteSessionsByExpiryTimeQuery;

    private Integer defaultMaxInactiveInterval;

    private ConversionService conversionService;

  private LobHandler lobHandler = new DefaultLobHandler();

  //--------------Modify by Jimmy Shan, the date is 2019-06-25 start--------------//

  private Map<Integer, JdbcOperations> jdbcOperationMaps = new Hash<>();

  private Map<Integer, TransactionOperations> transOperationMaps = new Hash<>();

  @Value("{mydb.server.sharding.num}")

  private String shardingNum;

  //--------------Modify by Jimmy Shan, the date is 2019-06-25 end----------------//

  /**

   * @desc 重写这个方法

   */

    public CustomizedJdbcOperationsSessionRepository(Map<Integer, JdbcTemplate> myJdbcTemplateMap,

            Map<Integer, PlatformTransactionManager> myDataSourceTransactionMap) {

            if (myJdbcTemplateMap == null || myJdbcTemplateMap.isEmpty()) {

                Assert.notNull(myJdbcTemplateMap, "myJdbcTemplateMap must not be null");

            }

            if (myDataSourceTransactionMap == null || myDataSourceTransactionMap.isEmpty()) {

                Assert.notNull(myDataSourceTransactionMap, "myDataSourceTransactionMap must not be null");

            }

            jdbcOperationMaps.putAll(myJdbcTemplateMap);

            this.conversionService = createDefaultConversionService();

            prepareQueries();

            Set<Integer> setKey = myDataSourceTransactionMap.keySet();

            for (Iterator ir = setKey.iterator(); ir.hasNext(); ) {

                Integer key = (Integer) ir.next();

                TransactionOperations transOperations = createTransactionTemplate(myDataSourceTransactionMap.get(key));

                transOperationMaps.put(key, transOperations);

            }

    }

    public void setTableName(String tableName) {

        Assert.hasText(tableName, "Table name must not be empty");

        this.tableName = tableName.trim();

        prepareQueries();

    }

    public void setCreateSessionQuery(String createSessionQuery) {

        Assert.hasText(createSessionQuery, "Query must not be empty");

        this.createSessionQuery = createSessionQuery;

    }

    public void setCreateSessionAttributeQuery(String createSessionAttributeQuery) {

        Assert.hasText(createSessionAttributeQuery, "Query must not be empty");

        this.createSessionAttributeQuery = createSessionAttributeQuery;

    }

    public void setGetSessionQuery(String getSessionQuery) {

        Assert.hasText(getSessionQuery, "Query must not be empty");

        this.getSessionQuery = getSessionQuery;

    }

    public void setUpdateSessionQuery(String updateSessionQuery) {

        Assert.hasText(updateSessionQuery, "Query must not be empty");

        this.updateSessionQuery = updateSessionQuery;

    }

    public void setUpdateSessionAttributeQuery(String updateSessionAttributeQuery) {

        Assert.hasText(updateSessionAttributeQuery, "Query must not be empty");

        this.updateSessionAttributeQuery = updateSessionAttributeQuery;

    }

    public void setDeleteSessionAttributeQuery(String deleteSessionAttributeQuery) {

        Assert.hasText(deleteSessionAttributeQuery, "Query must not be empty");

        this.deleteSessionAttributeQuery = deleteSessionAttributeQuery;

    }

    public void setDeleteSessionQuery(String deleteSessionQuery) {

        Assert.hasText(deleteSessionQuery, "Query must not be empty");

        this.deleteSessionQuery = deleteSessionQuery;

    }

    public void setListSessionsByPrincipalNameQuery(String listSessionsByPrincipalNameQuery) {

        Assert.hasText(listSessionsByPrincipalNameQuery, "Query must not be empty");

        this.listSessionsByPrincipalNameQuery = listSessionsByPrincipalNameQuery;

    }

    public void setDeleteSessionsByExpiryTimeQuery(String deleteSessionsByExpiryTimeQuery) {

        Assert.hasText(deleteSessionsByExpiryTimeQuery, "Query must not be empty");

        this.deleteSessionsByExpiryTimeQuery = deleteSessionsByExpiryTimeQuery;

    }

    public void setDefaultMaxInactiveInterval(Integer defaultMaxInactiveInterval) {

        this.defaultMaxInactiveInterval = defaultMaxInactiveInterval;

    }

    public void setLobHandler(LobHandler lobHandler) {

        Assert.notNull(lobHandler, "LobHandler must not be null");

        this.lobHandler = lobHandler;

    }

    public void setConversionService(ConversionService conversionService) {

        Assert.notNull(conversionService, "conversionService must not be null");

        this.conversionService = conversionService;

    }

    @Override

    public JdbcSession createSession() {

        JdbcSession session = new JdbcSession();

        if (this.defaultMaxInactiveInterval != null) {

            session.setMaxInactiveInterval(Duration.ofSeconds(this.defaultMaxInactiveInterval));

        }

        return session;

    }

  /**

   * @desc Modify by Jimmy Shan, the date is 2019-06-25

   *      Implementing Routing Function

   */

    @Override

    public void save(final JdbcSession session) {

      String sessionId = session.getId();

      int hashCode = Math.abs(sessionId.hashCode());

      int mod = hashCode % Integer.parseInt(shardingNum);

        if (session.isNew()) {

            this.transOperationMaps.get(mod).execute(new TransactionCallbackWithoutResult() {

                        @Override

                        protected void doInTransactionWithoutResult(TransactionStatus status) {

                            CustomizedJdbcOperationsSessionRepository.this.jdbcOperationMaps.get(mod).update(

                                    CustomizedJdbcOperationsSessionRepository.this.createSessionQuery,

                                    (ps) -> {

                                        ps.setString(1, session.primaryKey);

                                        ps.setString(2, session.getId());

                                        ps.setLong(3, session.getCreationTime().toEpochMilli());

                                        ps.setLong(4, session.getLastAccessedTime().toEpochMilli());

                                        ps.setInt(5, (int) session.getMaxInactiveInterval().getSeconds());

                                        ps.setLong(6, session.getExpiryTime().toEpochMilli());

                                        ps.setString(7, session.getPrincipalName());

                                    });

                            Set<String> attributeNames = session.getAttributeNames();

                            if (!attributeNames.isEmpty()) {

                                  insertSessionAttributes(session, new ArrayList<>(attributeNames));

                            }

                }

            });

        }    else {

            this.transOperationMaps.get(mod).execute(new TransactionCallbackWithoutResult() {

                        @Override

                        protected void doInTransactionWithoutResult(TransactionStatus status) {

                            if (session.isChanged()) {

                                    CustomizedJdbcOperationsSessionRepository.this.jdbcOperationMaps.get(mod).update(

                                            CustomizedJdbcOperationsSessionRepository.this.updateSessionQuery,

                                            (ps) -> {

                                                ps.setString(1, session.getId());

                                                ps.setLong(2, session.getLastAccessedTime().toEpochMilli());

                                                ps.setInt(3, (int) session.getMaxInactiveInterval().getSeconds());

                                                ps.setLong(4, session.getExpiryTime().toEpochMilli());

                                                ps.setString(5, session.getPrincipalName());

                                                ps.setString(6, session.primaryKey);

                                            });

                            }

                            List<String> addedAttributeNames = session.delta.entrySet().stream()

                                    .filter((entry) -> entry.getValue() == DeltaValue.ADDED)

                                    .map(Map.Entry::getKey)

                                    .collect(Collectors.toList());

                            if (!addedAttributeNames.isEmpty()) {

                                insertSessionAttributes(session, addedAttributeNames);

                            }

                            List<String> updatedAttributeNames = session.delta.entrySet().stream()

                                    .filter((entry) -> entry.getValue() == DeltaValue.UPDATED)

                                    .map(Map.Entry::getKey)

                                    .collect(Collectors.toList());

                            if (!updatedAttributeNames.isEmpty()) {

                                updateSessionAttributes(session, updatedAttributeNames);

                            }

                            List<String> removedAttributeNames = session.delta.entrySet().stream()

                                    .filter((entry) -> entry.getValue() == DeltaValue.REMOVED)

                                    .map(Map.Entry::getKey)

                                    .collect(Collectors.toList());

                            if (!removedAttributeNames.isEmpty()) {

                                  deleteSessionAttributes(session, removedAttributeNames);

                            }

                        }

            });

        }

        session.clearChangeFlags();

    }

  /**

   * @desc Modify by Jimmy Shan, the date is 2019-06-25

   *      Implementing Routing Function

   */

    @Override

    public JdbcSession findById(final String id) {

      String sessionId = id;

      int hashCode = Math.abs(sessionId.hashCode());

      int mod = hashCode % Integer.parseInt(shardingNum);

        final JdbcSession session = this.transOperationMaps.get(mod).execute((status) -> {

            List<JdbcSession> sessions = CustomizedJdbcOperationsSessionRepository

                                 .this.jdbcOperationMaps.get(mod).query(

                                                                     CustomizedJdbcOperationsSessionRepository.this.getSessionQuery,

                    (ps) -> ps.setString(1, id),

                    CustomizedJdbcOperationsSessionRepository.this.extractor

            );

            if (sessions.isEmpty()) {

                    return null;

            }

            return sessions.get(0);

        });

        if (session != null) {

            if (session.isExpired()) {

                    deleteById(id);

            }    else {

                    return session;

            }

        }

        return null;

    }

    /**

   * @desc Modify by Jimmy Shan, the date is 2019-06-25

   *      Implementing Routing Function

   */

    @Override

    public void deleteById(final String id) {

      String sessionId = id;

      int hashCode = Math.abs(sessionId.hashCode());

      int mod = hashCode % Integer.parseInt(shardingNum);

        this.transOperationMaps.get(mod).execute(new TransactionCallbackWithoutResult() {

                @Override

                protected void doInTransactionWithoutResult(TransactionStatus status) {

                        CustomizedJdbcOperationsSessionRepository.this.jdbcOperationMaps.get(mod).update(

                                CustomizedJdbcOperationsSessionRepository.this.deleteSessionQuery, id);

                }

        });

    }

    /**

   * @desc Modify by Jimmy Shan, the date is 2019-06-25

   *      Implementing Routing Function

   */

    @Override

    public Map<String, JdbcSession> findByIndexNameAndIndexValue(String indexName, final String indexValue) {

        if (!PRINCIPAL_NAME_INDEX_NAME.equals(indexName)) {

                return Collections.emptyMap();

        }

        List<JdbcSession> sessions = new ArrayList<>();

        Set<Integer> setKey = transOperationMaps.keySet();

        for (Iterator ir = setKey.iterator(); ir.hasNext(); ) {

                Integer key = (Integer) ir.next();

                TransactionOperations transOperation = (TransactionOperations) transOperationMaps.get(key);

                List<JdbcSession> tempSession = transOperation.execute(status) ->

                                CustomizedJdbcOperationsSessionRepository.this.jdbcOperationMaps.get(key).query(

                                        CustomizedJdbcOperationsSessionRepository.this.listSessionsByPrincipalNameQuery,

                                        (ps) -> ps.setString(1, indexValue),

                                        CustomizedJdbcOperationsSessionRepository.this.extractor));

                if (tempSession != null && !tempSession.isEmpty()) {

                        sessions.addAll(tempSession);

                }

        }

        Map<String, JdbcSession> sessionMap = new HashMap<>(sessions.size());

        for (JdbcSession session : sessions) {

                sessionMap.put(session.getId(), session);

        }

        return sessionMap;

    }

    /**

   * @desc Modify by Jimmy Shan, the date is 2019-06-25

   *      Implementing Routing Function

   */

    private void insertSessionAttributes(JdbcSession session, List<String> attributeNames) {

        Assert.notEmpty(attributeNames, "attributeNames must not be null or empty");

      String sessionId = session.getId();

      int hashCode = Math.abs(sessionId.hashCode());

      int mod = hashCode % Integer.parseInt(shardingNum);

        if (attributeNames.size() > 1) {

            this.jdbcOperationMaps.get(mod).batchUpdate(this.createSessionAttributeQuery, new BatchPreparedStatementSetter() {

                        @Override

                        public void setValues(PreparedStatement ps, int i) throws SQLException {

                                String attributeName = attributeNames.get(i);

                                ps.setString(1, attributeName);

                                setObjectAsBlob(ps, 2, session.getAttribute(attributeName));

                                ps.setString(3, session.getId());

                        }

                        @Override

                        public int getBatchSize() {

                                return attributeNames.size();

                        }

            });

        }    else {

                this.jdbcOperationMaps.get(mod).update(this.createSessionAttributeQuery, (ps) -> {

                    String attributeName = attributeNames.get(0);

                    ps.setString(1, attributeName);

                    setObjectAsBlob(ps, 2, session.getAttribute(attributeName));

                    ps.setString(3, session.getId());

                });

        }

    }

    /**

   * @desc Modify by Jimmy Shan, the date is 2019-06-25

   *      Implementing Routing Function

   */

    private void updateSessionAttributes(JdbcSession session, List<String> attributeNames) {

        Assert.notEmpty(attributeNames, "attributeNames must not be null or empty");

      String sessionId = session.getId();

      int hashCode = Math.abs(sessionId.hashCode());

      int mod = hashCode % Integer.parseInt(shardingNum);

        if (attributeNames.size() > 1) {

                this.jdbcOperationMaps.get(mod).batchUpdate(this.updateSessionAttributeQuery, new BatchPreparedStatementSetter() {

                            @Override

                            public void setValues(PreparedStatement ps, int i) throws SQLException {

                                String attributeName = attributeNames.get(i);

                                setObjectAsBlob(ps, 1, session.getAttribute(attributeName));

                                ps.setString(2, session.primaryKey);

                                ps.setString(3, attributeName);

                            }

                            @Override

                            public int getBatchSize() {

                                return attributeNames.size();

                            }

                });

        }    else {

                this.jdbcOperationMaps.get(mod).update(this.updateSessionAttributeQuery, (ps) -> {

                    String attributeName = attributeNames.get(0);

                    setObjectAsBlob(ps, 1, session.getAttribute(attributeName));

                    ps.setString(2, session.primaryKey);

                    ps.setString(3, attributeName);

                });

        }

    }

    /**

   * @desc Modify by Jimmy Shan, the date is 2019-06-25

   *      Implementing Routing Function

   */

    private void deleteSessionAttributes(JdbcSession session, List<String> attributeNames) {

        Assert.notEmpty(attributeNames, "attributeNames must not be null or empty");

      String sessionId = session.getId();

      int hashCode = Math.abs(sessionId.hashCode());

      int mod = hashCode % Integer.parseInt(shardingNum);

        if (attributeNames.size() > 1) {

                this.jdbcOperationMaps.get(mod).batchUpdate(this.deleteSessionAttributeQuery, new BatchPreparedStatementSetter() {

                            @Override

                            public void setValues(PreparedStatement ps, int i) throws SQLException {

                                String attributeName = attributeNames.get(i);

                                ps.setString(1, session.primaryKey);

                                ps.setString(2, attributeName);

                            }

                            @Override

                            public int getBatchSize() {

                                return attributeNames.size();

                            }

                });

        } else {

                this.jdbcOperationMaps.get(mod).update(this.deleteSessionAttributeQuery, (ps) -> {

                    String attributeName = attributeNames.get(0);

                    ps.setString(1, session.primaryKey);

                    ps.setString(2, attributeName);

                });

        }

    }

    /**

   * @desc Modify by Jimmy Shan, the date is 2019-06-25

   *      Implementing Routing Function

   */

    public void cleanUpExpiredSessions() {

        Set<Integer> setKey = transOperationMaps.keySet();

        for (Iterator ir = setKey.iterator(); ir.hasNext(); ) {

                Integer key = (Integer) ir.next();

                TransactionOperations transOperation = (TransactionOperations) transOperationMaps.get(key);

                Integer deletedCount = transOperation.execute((status) ->

                        CustomizedJdbcOperationsSessionRepository.this.jdbcOperationMaps.get(key).update(

                                CustomizedJdbcOperationsSessionRepository.this.deleteSessionsByExpiryTimeQuery,

                                        System.currentTimeMillis()));

                if (logger.isDebugEnabled()) {

                        logger.debug("Cleaned up " + deletedCount + " expired sessions");

                }

        }

    }

    private static TransactionTemplate createTransactionTemplate(

            PlatformTransactionManager transactionManager) {

            TransactionTemplate transactionTemplate = new TransactionTemplate(

                    transactionManager);

            transactionTemplate.setPropagationBehavior(

                    TransactionDefinition.PROPAGATION_REQUIRES_NEW);

            transactionTemplate.afterPropertiesSet();

            return transactionTemplate;

    }

    private static GenericConversionService createDefaultConversionService() {

            GenericConversionService converter = new GenericConversionService();

            converter.addConverter(Object.class, byte[].class,

                    new SerializingConverter());

            converter.addConverter(byte[].class, Object.class,

                    new DeserializingConverter());

            return converter;

    }

    private String getQuery(String base) {

            return StringUtils.replace(base, "%TABLE_NAME%", this.tableName);

    }

    private void prepareQueries() {

            this.createSessionQuery = getQuery(CREATE_SESSION_QUERY);

            this.createSessionAttributeQuery = getQuery(CREATE_SESSION_ATTRIBUTE_QUERY);

            this.getSessionQuery = getQuery(GET_SESSION_QUERY);

            this.updateSessionQuery = getQuery(UPDATE_SESSION_QUERY);

            this.updateSessionAttributeQuery = getQuery(UPDATE_SESSION_ATTRIBUTE_QUERY);

            this.deleteSessionAttributeQuery = getQuery(DELETE_SESSION_ATTRIBUTE_QUERY);

            this.deleteSessionQuery = getQuery(DELETE_SESSION_QUERY);

            this.listSessionsByPrincipalNameQuery =

                    getQuery(LIST_SESSIONS_BY_PRINCIPAL_NAME_QUERY);

            this.deleteSessionsByExpiryTimeQuery =

                    getQuery(DELETE_SESSIONS_BY_EXPIRY_TIME_QUERY);

    }

    private void setObjectAsBlob(PreparedStatement ps, int paramIndex, Object object)

            throws SQLException {

            byte[] bytes = (byte[]) this.conversionService.convert(object,

                    TypeDescriptor.valueOf(Object.class),

                    TypeDescriptor.valueOf(byte[].class));

            this.lobHandler.getLobCreator().setBlobAsBytes(ps, paramIndex, bytes);

    }

    private Object getBlobAsObject(ResultSet rs, String columnName) throws SQLException {

            byte[] bytes = this.lobHandler.getBlobAsBytes(rs, columnName);

            return this.conversionService.convert(bytes, TypeDescriptor.valueOf(byte[].class),

                    TypeDescriptor.valueOf(Object.class));

    }

    private enum DeltaValue {

            ADDED, UPDATED, REMOVED

    }

    private static <T> Supplier<T> value(T value) {

            return (value != null) ? () -> value : null;

    }

    private static <T> Supplier<T> lazily(Supplier<T> supplier) {

            Supplier<T> lazySupplier = new Supplier<T>() {

                private T value;

                @Override

                public T get() {

                    if (this.value == null) {

                        this.value = supplier.get();

                    }

                    return this.value;

                }

            };

            return (supplier != null) ? lazySupplier : null;

    }

    final class JdbcSession implements Session {

        private final Session delegate;

        private final String primaryKey;

        private boolean isNew;

        private boolean changed;

        private Map<String, DeltaValue> delta = new HashMap<>();

        JdbcSession() {

            this.delegate = new MapSession();

            this.isNew = true;

            this.primaryKey = UUID.randomUUID().toString();

        }

        JdbcSession(String primaryKey, Session delegate) {

            Assert.notNull(primaryKey, "primaryKey cannot be null");

            Assert.notNull(delegate, "Session cannot be null");

            this.primaryKey = primaryKey;

            this.delegate = delegate;

        }

        boolean isNew() {

            return this.isNew;

        }

        boolean isChanged() {

            return this.changed;

        }

        Map<String, DeltaValue> getDelta() {

            return this.delta;

        }

        void clearChangeFlags() {

            this.isNew = false;

            this.changed = false;

            this.delta.clear();

        }

        String getPrincipalName() {

            return PRINCIPAL_NAME_RESOLVER.resolvePrincipal(this);

        }

        Instant getExpiryTime() {

            return getLastAccessedTime().plus(getMaxInactiveInterval());

        }

        @Override

        public String getId() {

            return this.delegate.getId();

        }

        @Override

        public String changeSessionId() {

            this.changed = true;

            return this.delegate.changeSessionId();

        }

        @Override

        public <T> T getAttribute(String attributeName) {

            Supplier<T> supplier = this.delegate.getAttribute(attributeName);

            return (supplier != null) ? supplier.get() : null;

        }

        @Override

        public Set<String> getAttributeNames() {

            return this.delegate.getAttributeNames();

        }

        @Override

        public void setAttribute(String attributeName, Object attributeValue) {

            boolean attributeExists = (this.delegate.getAttribute(attributeName) != null);

            boolean attributeRemoved = (attributeValue == null);

            if (!attributeExists && attributeRemoved) {

                return;

            }

            if (attributeExists) {

                if (attributeRemoved) {

                    this.delta.merge(attributeName, DeltaValue.REMOVED, (oldDeltaValue,

                            deltaValue) -> (oldDeltaValue == DeltaValue.ADDED) ? null

                                    : deltaValue);

                }

                else {

                    this.delta.merge(attributeName, DeltaValue.UPDATED,

                            (oldDeltaValue,

                                    deltaValue) -> (oldDeltaValue == DeltaValue.ADDED)

                                            ? oldDeltaValue

                                            : deltaValue);

                }

            }

            else {

                this.delta.merge(attributeName, DeltaValue.ADDED,

                        (oldDeltaValue, deltaValue) -> (oldDeltaValue == DeltaValue.ADDED)

                                ? oldDeltaValue

                                : DeltaValue.UPDATED);

            }

            this.delegate.setAttribute(attributeName, value(attributeValue));

            if (PRINCIPAL_NAME_INDEX_NAME.equals(attributeName) ||

                    SPRING_SECURITY_CONTEXT.equals(attributeName)) {

                this.changed = true;

            }

        }

        @Override

        public void removeAttribute(String attributeName) {

            setAttribute(attributeName, null);

        }

        @Override

        public Instant getCreationTime() {

            return this.delegate.getCreationTime();

        }

        @Override

        public void setLastAccessedTime(Instant lastAccessedTime) {

            this.delegate.setLastAccessedTime(lastAccessedTime);

            this.changed = true;

        }

        @Override

        public Instant getLastAccessedTime() {

            return this.delegate.getLastAccessedTime();

        }

        @Override

        public void setMaxInactiveInterval(Duration interval) {

            this.delegate.setMaxInactiveInterval(interval);

            this.changed = true;

        }

        @Override

        public Duration getMaxInactiveInterval() {

            return this.delegate.getMaxInactiveInterval();

        }

        @Override

        public boolean isExpired() {

            return this.delegate.isExpired();

        }

    }

    static class PrincipalNameResolver {

        private SpelExpressionParser parser = new SpelExpressionParser();

        public String resolvePrincipal(Session session) {

            String principalName = session.getAttribute(PRINCIPAL_NAME_INDEX_NAME);

            if (principalName != null) {

                return principalName;

            }

            Object authentication = session.getAttribute(SPRING_SECURITY_CONTEXT);

            if (authentication != null) {

                Expression expression = this.parser

                        .parseExpression("authentication?.name");

                return expression.getValue(authentication, String.class);

            }

            return null;

        }

    }

    private class SessionResultSetExtractor implements ResultSetExtractor<List<JdbcSession>> {

        @Override

        public List<JdbcSession> extractData(ResultSet rs) throws SQLException, DataAccessException {

            List<JdbcSession> sessions = new ArrayList<>();

            while (rs.next()) {

                String id = rs.getString("SESSION_ID");

                JdbcSession session;

                if (sessions.size() > 0 && getLast(sessions).getId().equals(id)) {

                    session = getLast(sessions);

                }

                else {

                    MapSession delegate = new MapSession(id);

                    String primaryKey = rs.getString("PRIMARY_ID");

                    delegate.setCreationTime(Instant.ofEpochMilli(rs.getLong("CREATION_TIME")));

                    delegate.setLastAccessedTime(Instant.ofEpochMilli(rs.getLong("LAST_ACCESS_TIME")));

                    delegate.setMaxInactiveInterval(Duration.ofSeconds(rs.getInt("MAX_INACTIVE_INTERVAL")));

                    session = new JdbcSession(primaryKey, delegate);

                }

                String attributeName = rs.getString("ATTRIBUTE_NAME");

                if (attributeName != null) {

                    Object attributeValue = getBlobAsObject(rs, "ATTRIBUTE_BYTES");

                    session.delegate.setAttribute(attributeName, lazily(() -> attributeValue));

                }

                sessions.add(session);

            }

            return sessions;

        }

        private JdbcSession getLast(List<JdbcSession> sessions) {

            return sessions.get(sessions.size() - 1);

        }

    }

}

以上工作都完成后，让我们来看看如何使用。

代码如下： 

package com.szl.demo.spring.session.controller;

import java.io.PrintWriter;

import java.util.UUID;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import javax.servlet.http.HttpSession;

import org.springframework.stereotype.Controller;

import org.springframework.ui.ModelMap;

import org.springframework.web.bind.annotation.RequestMapping;

@Controller

public class TestSessionController {

        @RequestMapping("/testGetSession")

        public void testGetSession(HttpServletRequest request, HttpServletResponse response, ModelMap model) {

                PrintWriter out = null;

                try {

                        out = response.getWriter();

                        HttpSession session = request.getSession();

                        String content = (String) session.getAttribute("userId");

                        System.out.println("session content is : " + content);

                        out.println("session content is : " + content);

                        out.flush();

                        out.close();

                } catch (Exception e) {

                        e.printStackTrace();

                }

        }

        @RequestMapping("/testSetSession")

        public void testSetSession(HttpServletRequest request, HttpServletResponse response, ModelMap model) {

                PrintWriter out = null;

                try {

                        out = response.getWriter();

                        UUID uuid = UUID.randomUUID();

                        String uid = uuid.toString().replaceAll("-", "");

                        HttpSession session = request.getSession();

                        String content = (String) session.getAttribute("userId");

                        System.out.println("old session content is : " + content);

                        // 设置session内容

                        session.setAttribute("userId", uid);

                        out.println("new session content is : " + uid);

                        out.flush();

                        out.close();

                } catch (Exception e) {

                        e.printStackTrace();

                }

        }

}

是不是很简单，和平时使用session方式一样。

下面是建表脚本(mysql5.6) 

CREATE TABLE SPRING_SESSION (

        PRIMARY_ID CHAR(36) NOT NULL,

        SESSION_ID CHAR(36) NOT NULL,

        CREATION_TIME BIGINT NOT NULL,

        LAST_ACCESS_TIME BIGINT NOT NULL,

        MAX_INACTIVE_INTERVAL INT NOT NULL,

        EXPIRY_TIME BIGINT NOT NULL,

        PRINCIPAL_NAME VARCHAR(100),

        CONSTRAINT SPRING_SESSION_PK PRIMARY KEY (PRIMARY_ID)

) ENGINE=InnoDB ROW_FORMAT=DYNAMIC;

CREATE UNIQUE INDEX SPRING_SESSION_IX1 ON SPRING_SESSION (SESSION_ID);

CREATE INDEX SPRING_SESSION_IX2 ON SPRING_SESSION (EXPIRY_TIME);

CREATE INDEX SPRING_SESSION_IX3 ON SPRING_SESSION (PRINCIPAL_NAME);

CREATE TABLE SPRING_SESSION_ATTRIBUTES (

        SESSION_PRIMARY_ID CHAR(36) NOT NULL,

        ATTRIBUTE_NAME VARCHAR(200) NOT NULL,

        ATTRIBUTE_BYTES BLOB NOT NULL,

        CONSTRAINT SPRING_SESSION_ATTRIBUTES_PK PRIMARY KEY (SESSION_PRIMARY_ID, ATTRIBUTE_NAME),

        CONSTRAINT SPRING_SESSION_ATTRIBUTES_PK FOREIGN KEY (SESSION_PRIMARY_ID) REFERENCES SPRING_SESSION(PRIMARY_ID) ON DELETE CASCADE

) ENGINE=InnoDB ROW_FORMAT=DYNAMIC;

好了，备忘录记录到此，还是那句，
仅供有需要的朋友参考，也欢迎转载，但请注明原著，谢谢。

相关阅读

目录[+]