Java Request类代码示例

import org.eclipse.californium.core.coap.Request; //导入依赖的package包/类
public static Response dtlsPSKRequest(String uri, String method, byte[] payload, int contentFormat, String pskIdentity, byte[] pskKey) throws Exception {

		Request request = Utils.newRequest(method);
		request.setURI(uri);
		request.setPayload(payload);
		request.getOptions().setContentFormat(contentFormat);

		DtlsConnectorConfig.Builder builder = new DtlsConnectorConfig.Builder(new InetSocketAddress(0));
		builder.setPskStore(new StaticPskStore(pskIdentity, pskKey));
		builder.setSupportedCipherSuites(new CipherSuite[] {CipherSuite.TLS_PSK_WITH_AES_128_CCM_8});

		DTLSConnector dtlsconnector = new DTLSConnector(builder.build(), null);

		NetworkConfig nc = NetworkConfig.getStandard().setInt("COAP_SECURE_PORT", 15686);

		dtlsEndpoint = new CoapEndpoint(dtlsconnector, nc);
		dtlsEndpoint.start();

		// execute request
		request.send(dtlsEndpoint);
		Response response = request.waitForResponse();
		
		return response;
	}
 

import org.eclipse.californium.core.coap.Request; //导入依赖的package包/类
/**
 * Returns the effective endpoint that the specified request is supposed to
 * be sent over. If an endpoint has explicitly been set to this CoapClient,
 * this endpoint will be used. If no endpoint has been set, the client will
 * effectively use a default endpoint of the {@link EndpointManager}.
 * 
 * @param request the request to be sent
 * @return the effective endpoint that the request is going o be sent over.
 */
protected Endpoint getEffectiveEndpoint(Request request) {
	Endpoint myEndpoint = getEndpoint();
	
	// custom endpoint
	if (myEndpoint != null) return myEndpoint;
	
	// default endpoints
	if (CoAP.COAP_SECURE_URI_SCHEME.equals(request.getScheme())) {
		// this is the case when secure coap is supposed to be used
		return EndpointManager.getEndpointManager().getDefaultSecureEndpoint();
	} else {
		// this is the normal case
		return EndpointManager.getEndpointManager().getDefaultEndpoint();
	}
}
 

import org.eclipse.californium.core.coap.Request; //导入依赖的package包/类
public OneM2mResponse process(OneM2mRequest reqMessage) throws Exception {
		OneM2mResponse resMessage = null;
//		try {
			Request request = CoapRequestCodec.encode(reqMessage);
			log.debug("SEND CoAP MESSAGE: ");
			log.debug(reqMessage.toString());
			log.debug(request.getPayloadString());
			
			CoapResponse response = client.advanced(request);
			if(response == null) {
				log.error("response is null");
				return null;
			}
			
			resMessage = CoapResponseCodec.decode(response);
//		} catch (Exception e) {
//			e.printStackTrace();
//		}
		
		return resMessage;
	}
 

import org.eclipse.californium.core.coap.Request; //导入依赖的package包/类
/**
 * Schedules a retransmission for confirmable messages. 
 */
@Override
public void sendRequest(final Exchange exchange, final Request request) {

	LOGGER.finer("Send request, failed transmissions: "+exchange.getFailedTransmissionCount());
	
	if (request.getType() == null)
		request.setType(Type.CON);
	
	if (request.getType() == Type.CON) {
		prepareRetransmission(exchange, new RetransmissionTask(exchange, request) {
			public void retransmit() {
				sendRequest(exchange, request);
			}
		});
	}
	super.sendRequest(exchange, request);
}
 

import org.eclipse.californium.core.coap.Request; //导入依赖的package包/类
/**
 * Refreshes the Observe relationship with a new GET request with same token
 * and options. The method also resets the notification orderer, since the
 * server might have rebooted and started the observe sequence number from
 * the beginning.
 */
public void reregister() {
	if (!request.isCanceled()) {
		Request refresh = Request.newGet();
		refresh.setDestination(request.getDestination());
		refresh.setDestinationPort(request.getDestinationPort());
		// use same Token
		refresh.setToken(request.getToken());
		// copy options, but set Observe to zero
		refresh.setOptions(request.getOptions());
		refresh.setObserve();
		
		// use same message observers
		for (MessageObserver mo : request.getMessageObservers()) {
			refresh.addMessageObserver(mo);
		}
		
		endpoint.sendRequest(refresh);
		
		// update request in observe handle for correct cancellation
		this.request = refresh;
		// reset orderer to accept any sequence number since server might have rebooted
		this.orderer = new ObserveNotificationOrderer();
	}
}
 

import org.eclipse.californium.core.coap.Request; //导入依赖的package包/类
private Request getNextRequestBlock(Request request, BlockwiseStatus status) {
	int num = status.getCurrentNum();
	int szx = status.getCurrentSzx();
	Request block = new Request(request.getCode());
	// do not enforce CON, since NON could make sense over SMS or similar transports
	block.setType(request.getType());
	block.setDestination(request.getDestination());
	block.setDestinationPort(request.getDestinationPort());
	// copy options
	block.setOptions(new OptionSet(request.getOptions()));
	
	int currentSize = 1 << (4 + szx);
	int from = num * currentSize;
	int to = Math.min((num + 1) * currentSize, request.getPayloadSize());
	int length = to - from;
	byte[] blockPayload = new byte[length];
	System.arraycopy(request.getPayload(), from, blockPayload, 0, length);
	block.setPayload(blockPayload);
	
	boolean m = (to < request.getPayloadSize());
	block.getOptions().setBlock1(szx, m, num);
	
	status.setComplete(!m);
	return block;
}
 

import org.eclipse.californium.core.coap.Request; //导入依赖的package包/类
@Override
public void sendRequest(Exchange exchange, Request request) {
	
	if (request.getDestination() == null)
		throw new NullPointerException("Request has no destination address");
	if (request.getDestinationPort() == 0)
		throw new NullPointerException("Request has no destination port");
	
	matcher.sendRequest(exchange, request);
	
	/* 
	 * Logging here causes significant performance loss.
	 * If necessary, add an interceptor that logs the messages,
	 * e.g., the MessageTracer.
	 */
	
	for (MessageInterceptor interceptor:interceptors)
		interceptor.sendRequest(request);

	// MessageInterceptor might have canceled
	if (!request.isCanceled())
		connector.send(serializer.serialize(request));
}
 

import org.eclipse.californium.core.coap.Request; //导入依赖的package包/类
/**
 * Proactive Observe cancellation:
 * Cancel the observe relation by sending a GET with Observe=1.
 */
public void proactiveCancel() {
	Request cancel = Request.newGet();
	cancel.setDestination(request.getDestination());
	cancel.setDestinationPort(request.getDestinationPort());
	// use same Token
	cancel.setToken(request.getToken());
	// copy options, but set Observe to cancel
	cancel.setOptions(request.getOptions());
	cancel.setObserveCancel();
	
	// dispatch final response to the same message observers
	for (MessageObserver mo: request.getMessageObservers()) {
		cancel.addMessageObserver(mo);
	}
	
	endpoint.sendRequest(cancel);
	
	// cancel old ongoing request
	request.cancel();
	setCanceled(true);
}
 

import org.eclipse.californium.core.coap.Request; //导入依赖的package包/类
public static Request newRequest(String method) {
	if (method.equalsIgnoreCase("GET")) {
		return Request.newGet();
	} else if (method.equalsIgnoreCase("POST")) {
		return Request.newPost();
	} else if (method.equalsIgnoreCase("PUT")) {
		return Request.newPut();
	} else if (method.equalsIgnoreCase("DELETE")) {
		return Request.newDelete();
	} else if (method.equalsIgnoreCase("DISCOVER")) {
		return Request.newGet();
	} else if (method.equalsIgnoreCase("OBSERVE")) {
		Request request = Request.newGet();
		request.setObserve();
		return request;
	} else {
		System.err.println("Unknown method: " + method);
		return null;
	}
}
 

import org.eclipse.californium.core.coap.Request; //导入依赖的package包/类
@Test
public void testSuccessPlaintext() throws Exception {
	Request request = Request.newPost();
	request.setURI("coap://localhost:"+config.getCoapPort()+"/"+Constants.TOKEN_RESOURCE);

	TokenRequest req = new TokenRequest();
	req.setGrantType("client_credentials");
	req.setAud(config.getResourceServers().get(0).getAud());
	req.setClientID(config.getClients().get(0).getClient_id());
	req.setClientSecret(config.getClients().get(0).getClient_secret());
	req.setScopes(config.getResourceServers().get(0).getScopes());

	request.getOptions().setContentFormat(MediaTypeRegistry.APPLICATION_JSON);
	request.setPayload(req.toPayload(MediaTypeRegistry.APPLICATION_JSON));
	Response response = request.send().waitForResponse();

	TokenResponse tokenResponse = new TokenResponse(response.getPayload(), MediaTypeRegistry.APPLICATION_JSON);

	TestUtils.validateToken(tokenResponse.getAccessToken().getBytes(), config.getResourceServers().get(0).getAud(), MediaTypeRegistry.APPLICATION_JSON);
}
 

import org.eclipse.californium.core.coap.Request; //导入依赖的package包/类
/**
 * Formats a {@link Request} into a readable String representation. 
 * 
 * @param r the Request
 * @return the pretty print
 */
public static String prettyPrint(Request r) {

        StringBuilder sb = new StringBuilder();
        
        sb.append("==[ CoAP Request ]=============================================\n");
        sb.append(String.format("MID    : %d\n", r.getMID()));
        sb.append(String.format("Token  : %s\n", r.getTokenString()));
        sb.append(String.format("Type   : %s\n", r.getType().toString()));
        sb.append(String.format("Method : %s\n", r.getCode().toString()));
        sb.append(String.format("Options: %s\n", r.getOptions().toString()));
        sb.append(String.format("Payload: %d Bytes\n", r.getPayloadSize()));
        if (r.getPayloadSize() > 0 && MediaTypeRegistry.isPrintable(r.getOptions().getContentFormat())) {
        	sb.append("---------------------------------------------------------------");
        	sb.append(r.getPayloadString());
        }
        sb.append("===============================================================");

        return sb.toString();
}
 

import org.eclipse.californium.core.coap.Request; //导入依赖的package包/类
@Override
public void deliverRequest(final Exchange exchange) {
	Request request = exchange.getRequest();
	List<String> path = request.getOptions().getUriPath();
	final Resource resource = findResource(path);
	if (resource != null) {
		checkForObserveOption(exchange, resource);
		
		// Get the executor and let it process the request
		Executor executor = resource.getExecutor();
		if (executor != null) {
			exchange.setCustomExecutor();
			executor.execute(new Runnable() {
				public void run() {
					resource.handleRequest(exchange);
				} });
		} else {
			resource.handleRequest(exchange);
		}
	} else {
		LOGGER.info("Did not find resource " + path.toString() + " requested by " + request.getSource()+":"+request.getSourcePort());
		exchange.sendResponse(new Response(ResponseCode.NOT_FOUND));
	}
}
 

import org.eclipse.californium.core.coap.Request; //导入依赖的package包/类
@Override
public void sendRequest(Request request) {
    CoapMessageListener listener = listeners.get(toStringAddress(request.getDestination(),
            request.getDestinationPort()));
    if (listener != null) {
        listener.trace(new CoapMessage(request, false));
    }
}
 

import org.eclipse.californium.core.coap.Request; //导入依赖的package包/类
@Override
public void receiveRequest(Request request) {
    CoapMessageListener listener = listeners.get(toStringAddress(request.getSource(), request.getSourcePort()));
    if (listener != null) {
        listener.trace(new CoapMessage(request, true));
    }

}
 

import org.eclipse.californium.core.coap.Request; //导入依赖的package包/类
public CoapSessionCtx(CoapExchange exchange, DeviceAuthService authService, long timeout) {
  this.authService = authService;
  Request request = exchange.advanced().getRequest();
  this.token = request.getTokenString();
  this.sessionId = new CoapSessionId(request.getSource().getHostAddress(), request.getSourcePort(), this.token);
  this.exchange = exchange;
  this.timeout = timeout;
}