如何在GoogleGuice中使用Play框架的请求和会话范围？

Question

在我的Play（Java）框架项目中，我正在使用Guice进行依赖项注入，并且正在努力理解如何最好地将“会话”的概念与Guice和Play结合使用？

我知道Play是无状态的，除了可以在cookie中存储值之外，实际上没有会话的概念。我对Guice和Play的理解是，虽然Guice文档描述了支持不同的作用域（单例、会话、请求、无作用域），但因为我们正在用每个请求实例化一个新的注入器，所以仅适用于Play的作用域是单例和“无作用域”。

我感到困惑的是：使用Guice和Play“模拟”会话的最佳方式是什么？我应该定义“自定义范围”吗？

请注意，我正在使用Redis来存储我的会话数据。以下是我正在考虑的一些选择：

• 编写一个单例Guice类，作为Redis的薄包装器
• 编写一个无作用域Guice类，该类使用ctx（）对象来获取和设置Java对象

这里是否有一个标准的实践，或者我可能遵循的任何其他指导方针来在我的Play应用程序中设置会话概念？

Answer 1

我可能会迟到一点，但这对我很有效。使用播放！2.4和Guice 4.0。

我是在试图找出如何解决将一个实例限定到Http的问题时看到这篇文章的。上下文当前。

这是我的解决方案：

import com.google.common.collect.Maps;
import com.google.inject.Key;
import com.google.inject.Provider;
import com.google.inject.Scope;
import com.google.inject.Scopes;
import play.mvc.Http;

import java.util.Map;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * Allows objects to be bound to Play! Http.Context.current.args with a ThreadLocal fallback.
 */
public class HttpContextScope implements Scope {

    private static final ThreadLocal<Context> httpContextScopeContext = new ThreadLocal<>();

    enum NullableObject {
        INSTANCE
    }

    @Override
    public <T> Provider<T> scope(final Key<T> key, final Provider<T> provider) {
        return new Provider<T>() {
            @Override
            public T get() {
                Http.Context currentContext = Http.Context.current();
                if (currentContext == null) {
                    Context context = httpContextScopeContext.get();
                    if (context != null) {
                        T t = (T) context.map.get(key);
                        if (t == NullableObject.INSTANCE) {
                            return null;
                        }

                        if (t == null) {
                            t = provider.get();
                            if (!Scopes.isCircularProxy(t)) {
                                context.map.put(key, t != null ? t : NullableObject.INSTANCE);
                            }
                        }
                        return t;
                    }
                }

                String name = key.toString();
                synchronized (currentContext) {
                    Object obj = currentContext.args.get(name);
                    if (obj == NullableObject.INSTANCE) {
                        return null;
                    }
                    T t = (T) obj;
                    if (t == null) {
                        t = provider.get();
                        if (!Scopes.isCircularProxy(t)) {
                            currentContext.args.put(name, t != null ? t : NullableObject.INSTANCE);
                        }
                    }
                    return t;
                }
            }
        };
    }

    @Override
    public String toString() {
        return "Http.Context.ARGS";
    }

    private static class Context implements ContextScoper {
        final Map<Key, Object> map = Maps.newHashMap();
        final Lock lock = new ReentrantLock();

        @Override
        public CloseableScope open() {
            lock.lock();
            final Context previous = httpContextScopeContext.get();
            httpContextScopeContext.set(this);
            return new CloseableScope() {
                @Override
                public void close() {
                    httpContextScopeContext.set(previous);
                    lock.unlock();
                }
            };
        }
    }
}

contextscope和contextscope。可关闭范围界面：

import java.io.Closeable;

public interface ContextScoper {

    CloseableScope open();

    interface CloseableScope extends Closeable {
        @Override
        void close();
    }
}

和Scope注解：

import com.google.inject.ScopeAnnotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ ElementType.TYPE, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@ScopeAnnotation
public @interface HttpContextScoped {
}

并将其全部连接起来：

public class AppModule extends AbstractModule {
    @Override
    protected void configure() {
        HttpContextScope httpContextScope = new HttpContextScope();
        bindScope(HttpContextScoped.class, httpContextScope);
    }

    @Provides
    @HttpContextScoped
    public TheThing providesTheThing() {
        return new TheThing();
    }
}

FWIW，这是对谷歌自己的ServletScope的改编，可在此处找到：

免责声明：我还没有完成ThreadLocal回退测试，所以我不能确定这部分是否可靠。

干杯！

Answer 2

游戏中没有会话。如果你想要一个会话，你必须使用action composition和WrappedRequest提供一个：在这种情况下，你需要一个带有会话id的cookie，然后你需要一个服务，在Redis中查找会话id并返回会话数据，这样你就可以把它放在WrappedRequest中。

一旦您获得了一个公开会话数据的WrappedRequest，您就可以引用它：request。用户，请求。是的，您可以通过请求直接公开Guice查找。注入器，但这是有点黑客，而不是类型安全。