Add MongoOperationsSessionRepository
Fixes gh-17
This commit is contained in:
Jakub Kubrynski
committed by
Rob Winch
Rob Winch
parent
7b28b214ff
commit
34cebc3df6
@@ -0,0 +1,30 @@
|
||||
package org.springframework.session.data.mongo;
|
||||
|
||||
import org.springframework.expression.Expression;
|
||||
import org.springframework.expression.spel.standard.SpelExpressionParser;
|
||||
|
||||
/**
|
||||
* Utility class to extract principal name from {@code Authentication} object
|
||||
*
|
||||
* @author Jakub Kubrynski
|
||||
*/
|
||||
class AuthenticationParser {
|
||||
|
||||
private static final String NAME_EXPRESSION = "authentication?.name";
|
||||
|
||||
private static final SpelExpressionParser PARSER = new SpelExpressionParser();
|
||||
|
||||
/**
|
||||
* Extracts principal name from authentication
|
||||
*
|
||||
* @param authentication Authentication object
|
||||
* @return principal name
|
||||
*/
|
||||
static String extractName(Object authentication) {
|
||||
if (authentication != null) {
|
||||
Expression expression = PARSER.parseExpression(NAME_EXPRESSION);
|
||||
return expression.getValue(authentication, String.class);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,150 @@
|
||||
/*
|
||||
* Copyright 2002-2016 the original author or authors.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package org.springframework.session.data.mongo;
|
||||
|
||||
import com.mongodb.BasicDBObject;
|
||||
import com.mongodb.DBObject;
|
||||
import org.apache.commons.logging.Log;
|
||||
import org.apache.commons.logging.LogFactory;
|
||||
import org.springframework.core.convert.TypeDescriptor;
|
||||
import org.springframework.data.mongodb.core.query.Criteria;
|
||||
import org.springframework.data.mongodb.core.query.Query;
|
||||
import org.springframework.session.Session;
|
||||
|
||||
import java.io.ByteArrayInputStream;
|
||||
import java.io.ByteArrayOutputStream;
|
||||
import java.io.IOException;
|
||||
import java.io.ObjectInputStream;
|
||||
import java.io.ObjectOutputStream;
|
||||
import java.util.Collections;
|
||||
import java.util.Date;
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
import java.util.Set;
|
||||
|
||||
import static org.springframework.session.FindByIndexNameSessionRepository.PRINCIPAL_NAME_INDEX_NAME;
|
||||
|
||||
/**
|
||||
* {@code MongoSessionConverter} implementation transforming {@code MongoExpiringSession} to/from a BSON object
|
||||
* using standard Java serialization
|
||||
*
|
||||
* @author Jakub Kubrynski
|
||||
* @since 1.2
|
||||
*/
|
||||
class JdkMongoSessionConverter extends MongoSessionConverter {
|
||||
|
||||
private static final Log LOG = LogFactory.getLog(JdkMongoSessionConverter.class);
|
||||
|
||||
private static final String ID = "_id";
|
||||
private static final String CREATION_TIME = "created";
|
||||
private static final String LAST_ACCESSED_TIME = "accessed";
|
||||
private static final String MAX_INTERVAL = "interval";
|
||||
private static final String ATTRIBUTES = "attr";
|
||||
|
||||
private static final String PRINCIPAL_FIELD_NAME = "principal";
|
||||
private static final String SPRING_SECURITY_CONTEXT = "SPRING_SECURITY_CONTEXT";
|
||||
|
||||
public Query getQueryForIndex(String indexName, Object indexValue) {
|
||||
if (PRINCIPAL_NAME_INDEX_NAME.equals(indexName)) {
|
||||
return Query.query(Criteria.where(PRINCIPAL_FIELD_NAME).is(indexValue));
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
public Set<ConvertiblePair> getConvertibleTypes() {
|
||||
return Collections.singleton(new ConvertiblePair(DBObject.class, MongoExpiringSession.class));
|
||||
}
|
||||
|
||||
public Object convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType) {
|
||||
if (source == null) {
|
||||
return null;
|
||||
}
|
||||
|
||||
if (DBObject.class.isAssignableFrom(sourceType.getType())) {
|
||||
return convert((DBObject) source);
|
||||
} else {
|
||||
return convert((MongoExpiringSession) source);
|
||||
}
|
||||
}
|
||||
|
||||
private DBObject convert(MongoExpiringSession session) {
|
||||
BasicDBObject basicDBObject = new BasicDBObject();
|
||||
basicDBObject.put(ID, session.getId());
|
||||
basicDBObject.put(CREATION_TIME, session.getCreationTime());
|
||||
basicDBObject.put(LAST_ACCESSED_TIME, session.getLastAccessedTime());
|
||||
basicDBObject.put(MAX_INTERVAL, session.getMaxInactiveIntervalInSeconds());
|
||||
basicDBObject.put(PRINCIPAL_FIELD_NAME, extractPrincipal(session));
|
||||
basicDBObject.put(EXPIRE_AT_FIELD_NAME, session.getExpireAt());
|
||||
basicDBObject.put(ATTRIBUTES, serializeAttributes(session));
|
||||
return basicDBObject;
|
||||
}
|
||||
|
||||
private byte[] serializeAttributes(Session session) {
|
||||
try {
|
||||
ByteArrayOutputStream out = new ByteArrayOutputStream();
|
||||
ObjectOutputStream outputStream = new ObjectOutputStream(out);
|
||||
Map<String, Object> attributes = new HashMap<String, Object>();
|
||||
for (String attrName : session.getAttributeNames()) {
|
||||
attributes.put(attrName, session.getAttribute(attrName));
|
||||
}
|
||||
outputStream.writeObject(attributes);
|
||||
outputStream.flush();
|
||||
return out.toByteArray();
|
||||
} catch (IOException e) {
|
||||
LOG.error("Exception during session serialization", e);
|
||||
throw new IllegalStateException("Cannot serialize session", e);
|
||||
}
|
||||
}
|
||||
|
||||
private String extractPrincipal(Session expiringSession) {
|
||||
String resolvedPrincipal = AuthenticationParser.extractName(expiringSession.getAttribute(SPRING_SECURITY_CONTEXT));
|
||||
if (resolvedPrincipal != null) {
|
||||
return resolvedPrincipal;
|
||||
} else {
|
||||
return expiringSession.getAttribute(PRINCIPAL_NAME_INDEX_NAME);
|
||||
}
|
||||
}
|
||||
|
||||
private MongoExpiringSession convert(DBObject sessionWrapper) {
|
||||
MongoExpiringSession session =
|
||||
new MongoExpiringSession((String) sessionWrapper.get(ID), (Integer) sessionWrapper.get(MAX_INTERVAL));
|
||||
session.setCreationTime((Long) sessionWrapper.get(CREATION_TIME));
|
||||
session.setLastAccessedTime((Long) sessionWrapper.get(LAST_ACCESSED_TIME));
|
||||
session.setExpireAt((Date) sessionWrapper.get(EXPIRE_AT_FIELD_NAME));
|
||||
deserializeAttributes(sessionWrapper, session);
|
||||
return session;
|
||||
}
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
private void deserializeAttributes(DBObject sessionWrapper, Session session) {
|
||||
try {
|
||||
ByteArrayInputStream in = new ByteArrayInputStream((byte[]) sessionWrapper.get(ATTRIBUTES));
|
||||
ObjectInputStream objectInputStream = new ObjectInputStream(in);
|
||||
Map<String, Object> attributes = (Map<String, Object>) objectInputStream.readObject();
|
||||
for (Map.Entry<String, Object> entry : attributes.entrySet()) {
|
||||
session.setAttribute(entry.getKey(), entry.getValue());
|
||||
}
|
||||
objectInputStream.close();
|
||||
} catch (IOException e) {
|
||||
LOG.error("Exception during session deserialization", e);
|
||||
throw new IllegalStateException("Cannot deserialize session", e);
|
||||
} catch (ClassNotFoundException e) {
|
||||
LOG.error("Exception during session deserialization", e);
|
||||
throw new IllegalStateException("Cannot deserialize session", e);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,117 @@
|
||||
package org.springframework.session.data.mongo;
|
||||
|
||||
import org.springframework.session.ExpiringSession;
|
||||
|
||||
import java.util.Date;
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
import java.util.Set;
|
||||
import java.util.UUID;
|
||||
import java.util.concurrent.TimeUnit;
|
||||
|
||||
/**
|
||||
* Session object providing additional information about
|
||||
* the datetime of expiration
|
||||
*
|
||||
* @author Jakub Kubrynski
|
||||
* @since 1.2
|
||||
*/
|
||||
public class MongoExpiringSession implements ExpiringSession {
|
||||
|
||||
private final String id;
|
||||
private long created = System.currentTimeMillis();
|
||||
private long accessed;
|
||||
private int interval;
|
||||
private Date expireAt;
|
||||
private Map<String, Object> attrs = new HashMap<String, Object>();
|
||||
|
||||
public MongoExpiringSession() {
|
||||
this(MongoOperationsSessionRepository.DEFAULT_INACTIVE_INTERVAL);
|
||||
}
|
||||
|
||||
public MongoExpiringSession(int maxInactiveIntervalInSeconds) {
|
||||
this(UUID.randomUUID().toString(), maxInactiveIntervalInSeconds);
|
||||
}
|
||||
|
||||
public MongoExpiringSession(String id, int maxInactiveIntervalInSeconds) {
|
||||
this.id = id;
|
||||
this.interval = maxInactiveIntervalInSeconds;
|
||||
setLastAccessedTime(created);
|
||||
}
|
||||
|
||||
public String getId() {
|
||||
return id;
|
||||
}
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
public <T> T getAttribute(String attributeName) {
|
||||
return (T) attrs.get(attributeName);
|
||||
}
|
||||
|
||||
public Set<String> getAttributeNames() {
|
||||
return attrs.keySet();
|
||||
}
|
||||
|
||||
public void setAttribute(String attributeName, Object attributeValue) {
|
||||
if (attributeValue == null) {
|
||||
removeAttribute(attributeName);
|
||||
} else {
|
||||
attrs.put(attributeName, attributeValue);
|
||||
}
|
||||
}
|
||||
|
||||
public void removeAttribute(String attributeName) {
|
||||
attrs.remove(attributeName);
|
||||
}
|
||||
|
||||
public long getCreationTime() {
|
||||
return created;
|
||||
}
|
||||
|
||||
public void setCreationTime(long created) {
|
||||
this.created = created;
|
||||
}
|
||||
|
||||
public void setLastAccessedTime(long lastAccessedTime) {
|
||||
this.accessed = lastAccessedTime;
|
||||
expireAt = new Date(lastAccessedTime + TimeUnit.SECONDS.toMillis(interval));
|
||||
}
|
||||
|
||||
public long getLastAccessedTime() {
|
||||
return accessed;
|
||||
}
|
||||
|
||||
public void setMaxInactiveIntervalInSeconds(int interval) {
|
||||
this.interval = interval;
|
||||
}
|
||||
|
||||
public int getMaxInactiveIntervalInSeconds() {
|
||||
return interval;
|
||||
}
|
||||
|
||||
public boolean isExpired() {
|
||||
return new Date().after(expireAt);
|
||||
}
|
||||
|
||||
public Date getExpireAt() {
|
||||
return expireAt;
|
||||
}
|
||||
|
||||
public void setExpireAt(Date expireAt) {
|
||||
this.expireAt = expireAt;
|
||||
}
|
||||
|
||||
public boolean equals(Object o) {
|
||||
if (this == o) return true;
|
||||
if (o == null || getClass() != o.getClass()) return false;
|
||||
|
||||
MongoExpiringSession that = (MongoExpiringSession) o;
|
||||
|
||||
return id.equals(that.id);
|
||||
|
||||
}
|
||||
|
||||
public int hashCode() {
|
||||
return id.hashCode();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,135 @@
|
||||
/*
|
||||
* Copyright 2002-2016 the original author or authors.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package org.springframework.session.data.mongo;
|
||||
|
||||
import com.mongodb.DBObject;
|
||||
import org.springframework.core.convert.TypeDescriptor;
|
||||
import org.springframework.data.mongodb.core.IndexOperations;
|
||||
import org.springframework.data.mongodb.core.MongoOperations;
|
||||
import org.springframework.data.mongodb.core.query.Query;
|
||||
import org.springframework.session.FindByIndexNameSessionRepository;
|
||||
|
||||
import javax.annotation.PostConstruct;
|
||||
import java.util.Collections;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
|
||||
/**
|
||||
* Session repository implementation which stores sessions in Mongo.
|
||||
* Uses {@link MongoSessionConverter} to transform session objects from/to
|
||||
* native Mongo representation ({@code DBObject}).
|
||||
*
|
||||
* Repository is also responsible for removing expired sessions from database.
|
||||
* Cleanup is done every minute.
|
||||
*
|
||||
* @author Jakub Kubrynski
|
||||
* @since 1.2
|
||||
*/
|
||||
public class MongoOperationsSessionRepository implements FindByIndexNameSessionRepository<MongoExpiringSession> {
|
||||
|
||||
public static final int DEFAULT_INACTIVE_INTERVAL = 1800;
|
||||
public static final String DEFAULT_COLLECTION_NAME = "sessions";
|
||||
|
||||
private final MongoOperations mongoOperations;
|
||||
|
||||
private MongoSessionConverter mongoSessionConverter = new JdkMongoSessionConverter();
|
||||
private Integer maxInactiveIntervalInSeconds = DEFAULT_INACTIVE_INTERVAL;
|
||||
private String collectionName = DEFAULT_COLLECTION_NAME;
|
||||
|
||||
public MongoOperationsSessionRepository(MongoOperations mongoOperations) {
|
||||
this.mongoOperations = mongoOperations;
|
||||
}
|
||||
|
||||
public MongoExpiringSession createSession() {
|
||||
return new MongoExpiringSession(maxInactiveIntervalInSeconds);
|
||||
}
|
||||
|
||||
public void save(MongoExpiringSession session) {
|
||||
DBObject sessionDbObject = convertToDBObject(session);
|
||||
mongoOperations.getCollection(collectionName).save(sessionDbObject);
|
||||
}
|
||||
|
||||
public MongoExpiringSession getSession(String id) {
|
||||
DBObject sessionWrapper = findSession(id);
|
||||
if (sessionWrapper == null) {
|
||||
return null;
|
||||
}
|
||||
MongoExpiringSession session = convertToSession(sessionWrapper);
|
||||
if (session.isExpired()) {
|
||||
delete(id);
|
||||
return null;
|
||||
}
|
||||
return session;
|
||||
}
|
||||
|
||||
/**
|
||||
* Currently this repository allows only querying against {@code PRINCIPAL_NAME_INDEX_NAME}
|
||||
*
|
||||
* @param indexName the name if the index (i.e. {@link FindByIndexNameSessionRepository#PRINCIPAL_NAME_INDEX_NAME})
|
||||
* @param indexValue the value of the index to search for.
|
||||
* @return sessions map
|
||||
*/
|
||||
public Map<String, MongoExpiringSession> findByIndexNameAndIndexValue(String indexName, String indexValue) {
|
||||
HashMap<String, MongoExpiringSession> result = new HashMap<String, MongoExpiringSession>();
|
||||
Query query = mongoSessionConverter.getQueryForIndex(indexName, indexValue);
|
||||
if (query == null) {
|
||||
return Collections.emptyMap();
|
||||
}
|
||||
List<DBObject> mapSessions = mongoOperations.find(query, DBObject.class, collectionName);
|
||||
for (DBObject dbSession : mapSessions) {
|
||||
MongoExpiringSession mapSession = convertToSession(dbSession);
|
||||
result.put(mapSession.getId(), mapSession);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
public void delete(String id) {
|
||||
mongoOperations.remove(findSession(id), collectionName);
|
||||
}
|
||||
|
||||
@PostConstruct
|
||||
public void ensureIndexesAreCreated() {
|
||||
IndexOperations indexOperations = mongoOperations.indexOps(collectionName);
|
||||
mongoSessionConverter.ensureIndexes(indexOperations);
|
||||
}
|
||||
|
||||
DBObject findSession(String id) {
|
||||
return mongoOperations.findById(id, DBObject.class, collectionName);
|
||||
}
|
||||
|
||||
MongoExpiringSession convertToSession(DBObject session) {
|
||||
return (MongoExpiringSession) mongoSessionConverter.convert(session,
|
||||
TypeDescriptor.valueOf(DBObject.class), TypeDescriptor.valueOf(MongoExpiringSession.class));
|
||||
}
|
||||
|
||||
DBObject convertToDBObject(MongoExpiringSession session) {
|
||||
return (DBObject) mongoSessionConverter.convert(session,
|
||||
TypeDescriptor.valueOf(MongoExpiringSession.class), TypeDescriptor.valueOf(DBObject.class));
|
||||
}
|
||||
|
||||
public void setMongoSessionConverter(MongoSessionConverter mongoSessionConverter) {
|
||||
this.mongoSessionConverter = mongoSessionConverter;
|
||||
}
|
||||
|
||||
public void setMaxInactiveIntervalInSeconds(Integer maxInactiveIntervalInSeconds) {
|
||||
this.maxInactiveIntervalInSeconds = maxInactiveIntervalInSeconds;
|
||||
}
|
||||
|
||||
public void setCollectionName(String collectionName) {
|
||||
this.collectionName = collectionName;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,56 @@
|
||||
package org.springframework.session.data.mongo;
|
||||
|
||||
import org.apache.commons.logging.Log;
|
||||
import org.apache.commons.logging.LogFactory;
|
||||
import org.springframework.core.convert.converter.GenericConverter;
|
||||
import org.springframework.data.domain.Sort;
|
||||
import org.springframework.data.mongodb.core.IndexOperations;
|
||||
import org.springframework.data.mongodb.core.index.Index;
|
||||
import org.springframework.data.mongodb.core.index.IndexInfo;
|
||||
import org.springframework.data.mongodb.core.query.Query;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Base class for serializing and deserializing session objects.
|
||||
* To create custom serializer you have to implement this interface
|
||||
* and simply register your class as a bean.
|
||||
*
|
||||
* @author Jakub Kubrynski
|
||||
* @since 1.2
|
||||
*/
|
||||
public abstract class MongoSessionConverter implements GenericConverter {
|
||||
|
||||
private static final Log LOG = LogFactory.getLog(MongoSessionConverter.class);
|
||||
|
||||
protected static final String EXPIRE_AT_FIELD_NAME = "expireAt";
|
||||
|
||||
/**
|
||||
* Returns query to be executed to return sessions based on a particular index
|
||||
* @param indexName name of the index
|
||||
* @param indexValue value to query against
|
||||
* @return built query or null if indexName is not supported
|
||||
*/
|
||||
protected abstract Query getQueryForIndex(String indexName, Object indexValue);
|
||||
|
||||
/**
|
||||
* Method ensures that there is a TTL index on {@literal expireAt} field.
|
||||
* It's has {@literal expireAfterSeconds} set to zero seconds, so the expiration
|
||||
* time is controlled by the application.
|
||||
*
|
||||
* It can be extended in custom converters when there is a need for creating
|
||||
* additional custom indexes.
|
||||
*/
|
||||
protected void ensureIndexes(IndexOperations sessionCollectionIndexes) {
|
||||
List<IndexInfo> indexInfo = sessionCollectionIndexes.getIndexInfo();
|
||||
for (IndexInfo info : indexInfo) {
|
||||
if (EXPIRE_AT_FIELD_NAME.equals(info.getName())) {
|
||||
LOG.debug("TTL index on field " + EXPIRE_AT_FIELD_NAME + " already exists");
|
||||
return;
|
||||
}
|
||||
}
|
||||
LOG.info("Creating TTL index on field " + EXPIRE_AT_FIELD_NAME);
|
||||
sessionCollectionIndexes
|
||||
.ensureIndex(new Index(EXPIRE_AT_FIELD_NAME, Sort.Direction.ASC).named(EXPIRE_AT_FIELD_NAME).expire(0));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,66 @@
|
||||
/*
|
||||
* Copyright 2002-2016 the original author or authors.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package org.springframework.session.data.mongo.config.annotation.web.http;
|
||||
|
||||
import org.springframework.context.annotation.Configuration;
|
||||
import org.springframework.context.annotation.Import;
|
||||
import org.springframework.session.data.mongo.MongoOperationsSessionRepository;
|
||||
|
||||
import java.lang.annotation.Documented;
|
||||
import java.lang.annotation.ElementType;
|
||||
import java.lang.annotation.Retention;
|
||||
import java.lang.annotation.RetentionPolicy;
|
||||
import java.lang.annotation.Target;
|
||||
|
||||
/**
|
||||
* Add this annotation to a {@code @Configuration} class to expose the
|
||||
* SessionRepositoryFilter as a bean named "springSessionRepositoryFilter" and
|
||||
* backed by Mongo. Use {@code collectionName} to change default name of the
|
||||
* collection used to store sessions.
|
||||
* <pre>
|
||||
* <code>
|
||||
* {@literal @EnableMongoHttpSession}
|
||||
* public class MongoHttpSessionConfig {
|
||||
*
|
||||
* {@literal @Bean}
|
||||
* public MongoOperations mongoOperations() throws UnknownHostException {
|
||||
* return new MongoTemplate(new MongoClient(), "databaseName");
|
||||
* }
|
||||
*
|
||||
* }
|
||||
* </code>
|
||||
* </pre>
|
||||
*
|
||||
* @author Jakub Kubrynski
|
||||
* @since 1.2
|
||||
*/
|
||||
@Retention(RetentionPolicy.RUNTIME)
|
||||
@Target(ElementType.TYPE)
|
||||
@Documented
|
||||
@Import(MongoHttpSessionConfiguration.class)
|
||||
@Configuration
|
||||
public @interface EnableMongoHttpSession {
|
||||
|
||||
/**
|
||||
* @return default max inactive interval in seconds
|
||||
*/
|
||||
int maxInactiveIntervalInSeconds() default MongoOperationsSessionRepository.DEFAULT_INACTIVE_INTERVAL;
|
||||
|
||||
/**
|
||||
* @return name of the collection to store session
|
||||
*/
|
||||
String collectionName() default MongoOperationsSessionRepository.DEFAULT_COLLECTION_NAME;
|
||||
}
|
||||
@@ -0,0 +1,66 @@
|
||||
/*
|
||||
* Copyright 2002-2016 the original author or authors.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package org.springframework.session.data.mongo.config.annotation.web.http;
|
||||
|
||||
import org.springframework.beans.factory.annotation.Autowired;
|
||||
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.type.AnnotationMetadata;
|
||||
import org.springframework.data.mongodb.core.MongoOperations;
|
||||
import org.springframework.session.config.annotation.web.http.SpringHttpSessionConfiguration;
|
||||
import org.springframework.session.data.mongo.MongoOperationsSessionRepository;
|
||||
import org.springframework.session.data.mongo.MongoSessionConverter;
|
||||
|
||||
/**
|
||||
* Configuration class registering {@code MongoSessionRepository} bean
|
||||
* To import this configuration use {@link @EnableMongoHttpSession} annotation
|
||||
*
|
||||
* @author Jakub Kubrynski
|
||||
* @since 1.2
|
||||
*/
|
||||
@Configuration
|
||||
class MongoHttpSessionConfiguration extends SpringHttpSessionConfiguration implements ImportAware {
|
||||
|
||||
private MongoSessionConverter mongoSessionConverter;
|
||||
|
||||
private Integer maxInactiveIntervalInSeconds;
|
||||
private String collectionName;
|
||||
|
||||
@Bean
|
||||
MongoOperationsSessionRepository mongoSessionRepository(MongoOperations mongoOperations) {
|
||||
MongoOperationsSessionRepository repository = new MongoOperationsSessionRepository(mongoOperations);
|
||||
repository.setCollectionName(collectionName);
|
||||
repository.setMaxInactiveIntervalInSeconds(maxInactiveIntervalInSeconds);
|
||||
if (mongoSessionConverter != null) {
|
||||
repository.setMongoSessionConverter(mongoSessionConverter);
|
||||
}
|
||||
return repository;
|
||||
}
|
||||
|
||||
public void setImportMetadata(AnnotationMetadata importMetadata) {
|
||||
AnnotationAttributes attributes = AnnotationAttributes.fromMap(
|
||||
importMetadata.getAnnotationAttributes(EnableMongoHttpSession.class.getName()));
|
||||
maxInactiveIntervalInSeconds = attributes.getNumber("maxInactiveIntervalInSeconds");
|
||||
collectionName = attributes.getString("collectionName");
|
||||
}
|
||||
|
||||
@Autowired(required = false)
|
||||
public void setMongoSessionConverter(MongoSessionConverter mongoSessionConverter) {
|
||||
this.mongoSessionConverter = mongoSessionConverter;
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user