Java LocalSessionStore.create方法代码示例

import io.vertx.ext.web.sstore.LocalSessionStore; //导入方法依赖的package包/类
private Router createRouter() {
	Router router = Router.router(vertx);
	router.route().failureHandler(ErrorHandler.create(true));

	/* Static resources */
	staticHandler(router);

	/* Session / cookies for users */
	router.route().handler(CookieHandler.create());
	SessionStore sessionStore = LocalSessionStore.create(vertx);
	SessionHandler sessionHandler = SessionHandler.create(sessionStore);
	router.route().handler(sessionHandler);
	userContextHandler = new UserContextHandler(mongo);

	/* Dynamic pages */
	dynamicPages(router);

	/* API */
	router.mountSubRouter("/api", apiRouter());

	/* SockJS / EventBus */
	router.route("/eventbus/*").handler(eventBusHandler());

	return router;
}
 

import io.vertx.ext.web.sstore.LocalSessionStore; //导入方法依赖的package包/类
@Test
public void testGetSessionById() throws Exception {

    final Vertx vertx = Vertx.vertx();

    // We need to create a pre-programmed vertx session so we can validate
    final LocalSessionStore vertxSessionStore = LocalSessionStore.create(vertx);
    final io.vertx.ext.web.Session vertxSession = vertxSessionStore.createSession(300000);
    final CountDownLatch latch = new CountDownLatch(1);
    vertxSessionStore.put(vertxSession, b -> latch.countDown());
    latch.await(1, TimeUnit.SECONDS);
    vertxSession.put(TEST_SESSION_KEY, TEST_SESSION_VALUE);
    final String sessionId = vertxSession.id();

    // Now let's wrap in a pac4j sessionStore
    final ExtendedSessionStore<VertxWebContext> pac4jSessionStore = new VertxSessionStore(vertxSessionStore);
    final org.pac4j.vertx.context.session.Session pac4jSession = pac4jSessionStore.getSession(sessionId);
    assertThat(pac4jSession, is(notNullValue()));
    assertThat(pac4jSession.get(TEST_SESSION_KEY), is(TEST_SESSION_VALUE));
}
 

import io.vertx.ext.web.sstore.LocalSessionStore; //导入方法依赖的package包/类
private void addSessionHandler(Vertx vertx, Router router) {
    SessionStore
            sessionStore = clustered ? ClusteredSessionStore.create(vertx) : LocalSessionStore
            .create(vertx);
    router.route().handler(CookieHandler.create());
    router.route().handler(SessionHandler
            .create(sessionStore)
            .setCookieHttpOnlyFlag(true)
            .setCookieSecureFlag(true)
    );
}
 

import io.vertx.ext.web.sstore.LocalSessionStore; //导入方法依赖的package包/类
private void startWebApp(int port){
	SessionStore store = LocalSessionStore.create(vertx, appName + ".sessionmap");
	SessionHandler sessionHandler = SessionHandler.create(store);
	
	ServerVerticle serverVerticle = context.getBean(ServerVerticle.class);
   	serverVerticle.setPort(port);
   	serverVerticle.setSessionHandler(sessionHandler);
   	
       vertx.deployVerticle(serverVerticle);
}
 

import io.vertx.ext.web.sstore.LocalSessionStore; //导入方法依赖的package包/类
public void example31(Vertx vertx) {

    // Create a local session store using defaults
    SessionStore store1 = LocalSessionStore.create(vertx);

    // Create a local session store specifying the local shared map name to use
    // This might be useful if you have more than one application in the same
    // Vert.x instance and want to use different maps for different applications
    SessionStore store2 = LocalSessionStore.create(vertx, "myapp3.sessionmap");

    // Create a local session store specifying the local shared map name to use and
    // setting the reaper interval for expired sessions to 10 seconds
    SessionStore store3 = LocalSessionStore.create(vertx, "myapp3.sessionmap", 10000);

  }
 

import io.vertx.ext.web.sstore.LocalSessionStore; //导入方法依赖的package包/类
private void doLoginCommon(Handler<RoutingContext> handler, Set<String> authorities) throws Exception {
  router.route().handler(BodyHandler.create());
  router.route().handler(CookieHandler.create());
  SessionStore store = LocalSessionStore.create(vertx);
  router.route().handler(SessionHandler.create(store));
  router.route().handler(UserSessionHandler.create(authProvider));
  AuthHandler authHandler = RedirectAuthHandler.create(authProvider);
  if (authorities != null) {
    authHandler.addAuthorities(authorities);
  }
  router.route("/protected/*").handler(authHandler);
  router.route("/protected/somepage").handler(handler);
  String loginHTML = createloginHTML();
  router.route("/loginpage").handler(rc -> rc.response().putHeader("content-type", "text/html").end(loginHTML));
  if (formLoginHandler == null) {
    formLoginHandler = FormLoginHandler.create(authProvider);
  }
  router.route("/login").handler(formLoginHandler);
  testRequest(HttpMethod.GET, "/protected/somepage", null, resp -> {
    String location = resp.headers().get("location");
    assertNotNull(location);
    assertEquals("/loginpage", location);
    String setCookie = resp.headers().get("set-cookie");
    assertNotNull(setCookie);
    sessionCookie.set(setCookie);
  }, 302, "Found", null);
  testRequest(HttpMethod.GET, "/loginpage", req -> req.putHeader("cookie", sessionCookie.get()), resp -> {
  }, 200, "OK", loginHTML);
}
 

import io.vertx.ext.web.sstore.LocalSessionStore; //导入方法依赖的package包/类
@Test
public void testSendRequiresAuthorityHasAuthority() throws Exception {
  sockJSHandler.bridge(defaultOptions.addInboundPermitted(new PermittedOptions().setAddress(addr).setRequiredAuthority("bang_sticks")));
  router.clear();
  router.route().handler(CookieHandler.create());
  SessionStore store = LocalSessionStore.create(vertx);
  router.route().handler(SessionHandler.create(store));
  JsonObject authConfig = new JsonObject().put("properties_path", "classpath:login/loginusers.properties");
  AuthProvider authProvider = ShiroAuth.create(vertx, ShiroAuthRealmType.PROPERTIES, authConfig);
  addLoginHandler(router, authProvider);
  router.route("/eventbus/*").handler(sockJSHandler);
  testSend("foo");
}
 

import io.vertx.ext.web.sstore.LocalSessionStore; //导入方法依赖的package包/类
@Test
public void testSendRequiresAuthorityHasnotAuthority() throws Exception {
  sockJSHandler.bridge(defaultOptions.addInboundPermitted(new PermittedOptions().setAddress(addr).setRequiredAuthority("pick_nose")));
  router.clear();
  router.route().handler(CookieHandler.create());
  SessionStore store = LocalSessionStore.create(vertx);
  router.route().handler(SessionHandler.create(store));
  JsonObject authConfig = new JsonObject().put("properties_path", "classpath:login/loginusers.properties");
  AuthProvider authProvider = ShiroAuth.create(vertx, ShiroAuthRealmType.PROPERTIES, authConfig);
  addLoginHandler(router, authProvider);
  router.route("/eventbus/*").handler(sockJSHandler);
  testError(new JsonObject().put("type", "send").put("address", addr).put("body", "foo"), "access_denied");
}
 

import io.vertx.ext.web.sstore.LocalSessionStore; //导入方法依赖的package包/类
private void addBasicRoute(JsonObject conf) {
	router.route().handler(CookieHandler.create());

	BodyHandler bh = BodyHandler.create();
	bh.setMergeFormAttributes(false);
	bh.setUploadsDirectory(this.upload_dir);
	// bh.setDeleteUploadedFilesOnEnd(false);
	router.route().handler(bh);

	String hasSession = conf.getString("session","true");
	if("true".equals(hasSession)){		
		SessionStore sessionStore = null;
		if (vertx.isClustered())
			sessionStore = ClusteredSessionStore.create(vertx,SessionName);
		else
			sessionStore = LocalSessionStore.create(vertx,SessionName);		
		
		SessionHandler sessionHandler = SessionHandler.create(sessionStore);
		sessionHandler.setNagHttps(false).setCookieHttpOnlyFlag(true);
		Long sessionTimeount = conf.getLong("session.timeout");
		if(sessionTimeount!=null && sessionTimeount>0)
			sessionHandler.setSessionTimeout(sessionTimeount);
		
		router.route().handler(sessionHandler);

		if(gsetting.hasAuth()  && !this.appContain.isEmpty()){
			router.route().handler(UserSessionHandler.create(authMgr.authProvider));
			
			GateAuthHandler authHandler = new GateAuthHandler(authMgr);
			router.route().handler(authHandler::handle);
			
		}
	}
	
	router.route().failureHandler(rc->{
		
		HttpServerResponse response = rc.response();
		
		if(response.ended())
			return;
		
		int statusCode = rc.statusCode() == -1 ? 500 : rc.statusCode();

           log.error("Error,status code: {}. ",statusCode);
           response.setStatusCode(statusCode).end("status code:"+statusCode);
	});

}
 

import io.vertx.ext.web.sstore.LocalSessionStore; //导入方法依赖的package包/类
static Router createRouter() {

        Router router = Router.router(vertx);

        SockJSHandler sockJSHandler = SockJSHandler.create(vertx);

        sockJSHandler.bridge(eventBusBridgeOptions());

        router.route("/eventbus/*").handler(sockJSHandler);

        router.route().handler(CookieHandler.create());

        SessionStore store = LocalSessionStore.create(vertx);

        SessionHandler sessionHandler = SessionHandler.create(store);

        router.route().handler(sessionHandler);

        return router;
    }
 

import io.vertx.ext.web.sstore.LocalSessionStore; //导入方法依赖的package包/类
protected SessionStore createSessionStore() {
    if (vertx.isClustered()) {
        return ClusteredSessionStore.create(vertx);
    }
    return LocalSessionStore.create(vertx);
}
 

import io.vertx.ext.web.sstore.LocalSessionStore; //导入方法依赖的package包/类
@Before
public void setUp(TestContext context) {
    vertx = Vertx.vertx();
    localSessionStore = LocalSessionStore.create(vertx);
}
 

import io.vertx.ext.web.sstore.LocalSessionStore; //导入方法依赖的package包/类
private LocalSessionStore sessionStore() {
    return LocalSessionStore.create(vertx);
}
 

import io.vertx.ext.web.sstore.LocalSessionStore; //导入方法依赖的package包/类
protected SessionStore getSessionStore() {
  return LocalSessionStore.create(vertx);
}