Java AtmosphereResource类代码示例

import org.atmosphere.cpr.AtmosphereResource; //导入依赖的package包/类
/**
 * @see org.atmosphere.cpr.AtmosphereInterceptor#inspect(org.atmosphere.cpr.AtmosphereResource)
 */
@Override
public Action inspect(final AtmosphereResource atmosphereResource) {
	try {
		SecurityContext context = (SecurityContext) atmosphereResource.getRequest().getSession().getAttribute(HttpSessionSecurityContextRepository.SPRING_SECURITY_CONTEXT_KEY);
		final Authentication auth = context.getAuthentication();
		if (auth instanceof Authentication) {
			MDC.put(UserMdcServletFilter.USER_KEY, auth.getName());
			logger.trace("Username set in MDC");
		}	
	} catch (final NullPointerException e) {}
	return Action.CONTINUE;
}
 

import org.atmosphere.cpr.AtmosphereResource; //导入依赖的package包/类
public void onDisconnect(AtmosphereResource r, SocketIOSessionOutbound outbound, DisconnectReason reason) {
    log.debug("ondisconnect, reason is :" + reason);

    String sessionId = outbound.getSessionId();

    Collection<String> termIds = sessions.get(sessionId);

    for (String termId : termIds) {
        String key = makeConnectorKey(sessionId, termId);

        TerminalEmulator emulator = connectors.get(key);
        if (emulator != null) {
            emulator.close();
            connectors.remove(key);
        }
    }

    sessions.removeAll(sessionId);
}
 

import org.atmosphere.cpr.AtmosphereResource; //导入依赖的package包/类
/**
 * Tries to send a critical notification to the client and close the
 * connection. Does nothing if the connection is already closed.
 */
private static void sendNotificationAndDisconnect(
    AtmosphereResource resource, String notificationJson) {
    // TODO Implemented differently from sendRefreshAndDisconnect
    try {
        if (resource instanceof AtmosphereResourceImpl
            && !((AtmosphereResourceImpl) resource).isInScope()) {
            // The resource is no longer valid so we should not write
            // anything to it
            getLogger()
                .fine("sendNotificationAndDisconnect called for resource no longer in scope");
            return;
        }
        resource.getResponse().getWriter().write(notificationJson);
        resource.resume();
    } catch (Exception e) {
        getLogger().log(Level.FINEST,
            "Failed to send critical notification to client", e);
    }
}
 

import org.atmosphere.cpr.AtmosphereResource; //导入依赖的package包/类
private static void broadcastMessage(String uuid, Object message) {
    if (uuid != null) {
        AtmosphereResource res = null;
        int waitTime = 0;
        while ((res = atmosphereResourceFactory.find(uuid)) == null
                && waitTime < MESSAGE_BROADCAST_TIMEOUT) {
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
            }
            waitTime += 500;
        }
        if (res == null) {
            LOG.warn("Unable to find atmosphere resource for uuid: {}", uuid);
        } else {
            res.getBroadcaster().broadcast(message, res);
        }
    }
}
 

import org.atmosphere.cpr.AtmosphereResource; //导入依赖的package包/类
@Override
public void init(ServletConfig sc) throws ServletException {
  super.init(sc);
  framework().addAtmosphereHandler("/", new AtmosphereHandlerAdapter() {
    @Override
    public void onRequest(AtmosphereResource resource) throws IOException {
      if (isWebSocketResource(resource)) {
        if (resource.getRequest().getMethod().equals("GET")) {
          wsActions.fire(new AtmosphereServerWebSocket(resource));
        }
      } else {
        httpActions.fire(new AtmosphereServerHttpExchange(resource));
      }
    }
  });
}
 

import org.atmosphere.cpr.AtmosphereResource; //导入依赖的package包/类
/**
 * Initialize WebSocket based communication channel between the client and
 * the server.
 */
@GET
@Path("/events")
public String subscribe(@Context HttpServletRequest req, @HeaderParam("sessionid") String sessionId)
        throws NotConnectedRestException {
    checkAccess(sessionId);
    HttpSession session = checkNotNull(req.getSession(),
                                       "HTTP session object is null. HTTP session support is requried for REST Scheduler eventing.");
    AtmosphereResource atmosphereResource = checkNotNull((AtmosphereResource) req.getAttribute(AtmosphereResource.class.getName()),
                                                         "No AtmosphereResource is attached with current request.");
    // use session id as the 'topic' (or 'id') of the broadcaster
    session.setAttribute(ATM_BROADCASTER_ID, sessionId);
    session.setAttribute(ATM_RESOURCE_ID, atmosphereResource.uuid());
    Broadcaster broadcaster = lookupBroadcaster(sessionId, true);
    if (broadcaster != null) {
        atmosphereResource.setBroadcaster(broadcaster).suspend();
    }
    return null;
}
 

import org.atmosphere.cpr.AtmosphereResource; //导入依赖的package包/类
@GET 
 @Produces( { MediaType.WILDCARD })
 public Response getLogin(
 		@Context HttpHeaders headers,
 		@QueryParam("u") String user,
 		@QueryParam("p") String password,
 		@QueryParam("d") String device,
 		@QueryParam("jsoncallback") @DefaultValue("callback") String callback,
 		@Context AtmosphereResource resource) {
 	String responseType = MediaTypeHelper.getResponseMediaType(headers.getAcceptableMediaTypes());
 	if(responseType!=null) {
  	return Response.ok(getLoginBean(resource), responseType).build();
 	} else {
return Response.notAcceptable(null).build();
 	}
 }
 

import org.atmosphere.cpr.AtmosphereResource; //导入依赖的package包/类
@Override
public BroadcastAction filter(String broadcasterId, AtmosphereResource resource,
		Object originalMessage, Object message) {
	final HttpServletRequest request = resource.getRequest();
	try {
		// websocket and HTTP streaming
		if (ResponseTypeHelper.isStreamingTransport(request)
				&& originalMessage instanceof Item) {
			if (message instanceof ItemStateListBean) {
				return new BroadcastAction(ACTION.CONTINUE,
						getSingleResponseObject(
								(ItemStateListBean) message,
								(Item) originalMessage, request));
			} else {
				return new BroadcastAction(ACTION.CONTINUE,
						getSingleResponseObject(null,
								(Item) originalMessage, request));
			}
		}
	} catch (Exception e) {
		logger.error(e.getMessage());
		return new BroadcastAction(ACTION.ABORT, message);
	}
	// pass message to next filter
	return new BroadcastAction(ACTION.CONTINUE, message);
}
 

import org.atmosphere.cpr.AtmosphereResource; //导入依赖的package包/类
@GET @Path("/{itemname: [a-zA-Z_0-9]*}/state") 
@Produces( { MediaType.TEXT_PLAIN })
   public SuspendResponse<String> getPlainItemState(
   		@PathParam("itemname") String itemname, 
   		@Context AtmosphereResource resource) {
   	if(TRANSPORT.UNDEFINED.equals(resource.transport())) {
    	Item item = getItem(itemname);
    	if(item!=null) {
			if (logger.isDebugEnabled()) logger.debug("Received HTTP GET request at '{}'.", uriInfo.getPath());
			throw new WebApplicationException(Response.ok(item.getState().toString()).build());
    	} else {
    		if (logger.isDebugEnabled()) logger.info("Received HTTP GET request at '{}' for the unknown item '{}'.", uriInfo.getPath(), itemname);
    		throw new WebApplicationException(404);
    	}
	}
   	
   	BroadcasterFactory broadcasterFactory = resource.getAtmosphereConfig().getBroadcasterFactory();
   	GeneralBroadcaster itemBroadcaster = (GeneralBroadcaster) broadcasterFactory.lookup(GeneralBroadcaster.class, resource.getRequest().getPathInfo(), true); 
	itemBroadcaster.addStateChangeListener(new ItemStateChangeListener());
	return new SuspendResponse.SuspendResponseBuilder<String>()
			.scope(SCOPE.REQUEST)
			.resumeOnBroadcast(!ResponseTypeHelper.isStreamingTransport(resource.getRequest()))
			.broadcaster(itemBroadcaster)
			.outputComments(true).build();
   }
 

import org.atmosphere.cpr.AtmosphereResource; //导入依赖的package包/类
@Override
public BroadcastAction filter(String broadcasterId, AtmosphereResource resource, Object originalMessage, Object message) {
	final  HttpServletRequest request = resource.getRequest();
	
	try {	
		if(!isDoubleBroadcast(request,message ) ){
			return new BroadcastAction(ACTION.CONTINUE,  message);
		}
		else {
			return new BroadcastAction(ACTION.ABORT,  message);
		}
		
	} catch (Exception e) {
		logger.error(e.getMessage(), e);
		return new BroadcastAction(ACTION.ABORT,  message);
	} 
	
}
 

import org.atmosphere.cpr.AtmosphereResource; //导入依赖的package包/类
/**
 * This is a middle level method to handle the details of Atmosphere and
 * http/ws level of processing request. It will eventually call
 * ApiFactory.process which handles the "pure" Jvm Java only processing
 * 
 * @param r
 *          r
 * @throws Exception
 *           e
 * 
 */
public void handleServiceApi(AtmosphereResource r) throws Exception {
  AtmosphereRequest request = r.getRequest();
  AtmosphereResponse response = r.getResponse();
  OutputStream out = response.getOutputStream();
  response.addHeader("Content-Type", CodecUtils.MIME_TYPE_JSON);
  
  String hack = null;
  byte[] data = null;
  if (request.body() != null) {
    hack = request.body().asString();
    // data = request.body().asBytes();
    if (hack != null){ // FIXME - hack because request.body().asBytes() ALWAYS returns null !!
      data = hack.getBytes();
    }
  }
  api.process(out, r.getRequest().getRequestURI(), data);
}
 

import org.atmosphere.cpr.AtmosphereResource; //导入依赖的package包/类
@Override
public void init(ServletConfig sc) throws ServletException {
    super.init(sc);
    framework().addAtmosphereHandler("/", new AtmosphereHandlerAdapter() {
        @Override
        public void onRequest(AtmosphereResource resource) throws IOException {
            if (isWebSocketResource(resource)) {
                if (resource.getRequest().getMethod().equals("GET")) {
                    wsActions.fire(new AtmosphereServerWebSocket(resource));
                }
            } else {
                httpActions.fire(new AtmosphereServerHttpExchange(resource));
            }
        }
    });
}
 

import org.atmosphere.cpr.AtmosphereResource; //导入依赖的package包/类
@Override
public Action inspect(AtmosphereResource r)
{
	// do pre-request stuff
	// In certain circumstances push can be called after the standard filter
	// which means there will already
	// be an EM on the thread hence we check if one already exits
	if (EntityManagerProvider.getEntityManager() == null)
	{
		em = EntityManagerProvider.createEntityManager();
		t = new Transaction(em);

		// Create and set the entity manager
		EntityManagerProvider.setCurrentEntityManager(em);
	}

	return super.inspect(r);
}
 

import org.atmosphere.cpr.AtmosphereResource; //导入依赖的package包/类
@Override
public void onTextMessage(WebSocket webSocket, String data)
		throws IOException {
	AtmosphereResource r = webSocket.resource();
	AtmosphereRequest req = r.getRequest();
	String sessionId = req.getSession(true).getId();
	LOGGER.info("sessionId: {}, resourceId: {} : text message", sessionId,
			r.uuid());

	String json = data.trim();

	Player player = this.sessions.get(sessionId);
	LOGGER.info(player.toString());
	BaseClientGameCommand clientEvent = mapper.readValue(json,
			BaseClientGameCommand.class);
	clientEvent.setPlayer(player);
	clientEvent.setGameId(DEFAULT_GAME_ID);
	this.updater.issueCommand(DEFAULT_GAME_ID, clientEvent);

}
 

import org.atmosphere.cpr.AtmosphereResource; //导入依赖的package包/类
private void playerExit(AtmosphereResource resource) {
	String sessionId = resource.getRequest().getSession(true).getId();
	LOGGER.info("sessionId: {}, resourceId: {} : websocket close",
			sessionId, resource.uuid());

	Player player = this.sessions.get(sessionId);

	// without this check one can crash the server using chrome and chromium
	// at the same time
	if (player != null) {

		// remove connection associated data
		this.sessions.remove(sessionId);
		this.connections.remove(player);

		// tell the game to account for the missing player
		PlayerQuitCommand quit = new PlayerQuitCommand();
		quit.setPlayer(player);
		quit.setGameId(DEFAULT_GAME_ID);
		this.updater.issueCommand(DEFAULT_GAME_ID, quit);

	}

}