Java Endpoint类代码示例

import org.eclipse.californium.core.network.Endpoint; //导入依赖的package包/类
public EventServlet(LeshanServer server, int securePort) {
    server.getRegistrationService().addListener(this.registrationListener);
    server.getObservationService().addListener(this.observationListener);

    // add an interceptor to each endpoint to trace all CoAP messages
    coapMessageTracer = new CoapMessageTracer(server.getRegistrationService());
    for (Endpoint endpoint : server.getCoapServer().getEndpoints()) {
        endpoint.addInterceptor(coapMessageTracer);
    }

    GsonBuilder gsonBuilder = new GsonBuilder();
    gsonBuilder.registerTypeHierarchyAdapter(Registration.class, new RegistrationSerializer(securePort));
    gsonBuilder.registerTypeHierarchyAdapter(LwM2mNode.class, new LwM2mNodeSerializer());
    gsonBuilder.setDateFormat("yyyy-MM-dd'T'HH:mm:ssXXX");
    this.gson = gsonBuilder.create();
}
 

import org.eclipse.californium.core.network.Endpoint; //导入依赖的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.network.Endpoint; //导入依赖的package包/类
/**
 * Sets the endpoint this client is supposed to use.
 *
 * @param endpoint the endpoint
 * @return the CoAP client
 */
public CoapClient setEndpoint(Endpoint endpoint) {
			
	this.endpoint = endpoint;
	
	if (!endpoint.isStarted()) {
		try {
			endpoint.start();
			LOGGER.log(Level.INFO, "Started set client endpoint " + endpoint.getAddress());
		} catch (IOException e) {
			LOGGER.log(Level.SEVERE, "Could not set and start client endpoint", e);
		}
		
	}
	
	return this;
}
 

import org.eclipse.californium.core.network.Endpoint; //导入依赖的package包/类
public EventServlet(LeshanServer server, int securePort) {
    this.server = server;
    server.getClientRegistry().addListener(this.clientRegistryListener);
    server.getObservationRegistry().addListener(this.observationRegistryListener);

    // add an interceptor to each endpoint to trace all CoAP messages
    coapMessageTracer = new CoapMessageTracer(server.getClientRegistry());
    for (Endpoint endpoint : server.getCoapServer().getEndpoints()) {
        endpoint.addInterceptor(coapMessageTracer);
    }

    GsonBuilder gsonBuilder = new GsonBuilder();
    gsonBuilder.registerTypeHierarchyAdapter(Client.class, new ClientSerializer(securePort));
    gsonBuilder.registerTypeHierarchyAdapter(LwM2mNode.class, new LwM2mNodeSerializer());
    gsonBuilder.setDateFormat("yyyy-MM-dd'T'HH:mm:ssXXX");
    this.gson = gsonBuilder.create();
}
 

import org.eclipse.californium.core.network.Endpoint; //导入依赖的package包/类
/**
 * Creates a new AllInterfacesCoapServer which listens on all available IP addresses.
 */
public AllInterfacesCoapServer() {
	addEndpoints();
	start();

	String interfaces = getEndpoints().stream().
			map(Endpoint::getAddress).
			map(a -> "[" + a.getHostString() + ":" + a.getPort() + "]")
			.collect(Collectors.joining(", "));


	logger.info("DCAF server running on " + interfaces + ".");
}
 

import org.eclipse.californium.core.network.Endpoint; //导入依赖的package包/类
private CoapResponse synchronous(Request request, Endpoint outEndpoint) {
	try {
		Response response = send(request, outEndpoint).waitForResponse(getTimeout());
		if (response == null) return null;
		else return new CoapResponse(response);
	} catch (InterruptedException e) {
		throw new RuntimeException(e);
	}
}
 

import org.eclipse.californium.core.network.Endpoint; //导入依赖的package包/类
private CoapObserveRelation observeAndWait(Request request, CoapHandler handler) {
	Endpoint outEndpoint = getEffectiveEndpoint(request);
	CoapObserveRelation relation = new CoapObserveRelation(request, outEndpoint);
	request.addMessageObserver(new ObserveMessageObserverImpl(handler, relation));
	CoapResponse response = synchronous(request, outEndpoint);
	if (response == null || !response.advanced().getOptions().hasObserve())
		relation.setCanceled(true);
	relation.setCurrent(response);
	return relation;
}
 

import org.eclipse.californium.core.network.Endpoint; //导入依赖的package包/类
private CoapObserveRelation observe(Request request, CoapHandler handler) {
	Endpoint outEndpoint = getEffectiveEndpoint(request);
	CoapObserveRelation relation = new CoapObserveRelation(request, outEndpoint);
	request.addMessageObserver(new ObserveMessageObserverImpl(handler, relation));
	send(request, outEndpoint);
	return relation;
}
 

import org.eclipse.californium.core.network.Endpoint; //导入依赖的package包/类
/**
 * Sends the specified request over the specified endpoint.
 * 
 * @param request the request
 * @param outEndpoint the endpoint
 * @return the request
 */
protected Request send(Request request, Endpoint outEndpoint) {
	// use the specified message type
	request.setType(this.type);

	if (blockwise!=0) {
		request.getOptions().setBlock2(new BlockOption(BlockOption.size2Szx(this.blockwise), false, 0));
	}
	
	outEndpoint.sendRequest(request);
	return request;
}
 

import org.eclipse.californium.core.network.Endpoint; //导入依赖的package包/类
/**
 * Constructs a server with the specified configuration that listens to the
 * specified ports after method {@link #start()} is called.
 *
 * @param config the configuration, if <code>null</code> the configuration returned by
 * {@link NetworkConfig#getStandard()} is used.
 * @param ports the ports to bind to
 */
public CoapServer(NetworkConfig config, int... ports) {
	
	// global configuration that is passed down (can be observed for changes)
	if (config != null) {
		this.config = config;
	} else {
		this.config = NetworkConfig.getStandard();
	}
	
	// resources
	this.root = createRoot();
	this.deliverer = new ServerMessageDeliverer(root);
	
	CoapResource well_known = new CoapResource(".well-known");
	well_known.setVisible(false);
	well_known.add(new DiscoveryResource(root));
	root.add(well_known);
	
	// endpoints
	this.endpoints = new ArrayList<Endpoint>();
	// sets the central thread pool for the protocol stage over all endpoints
	this.executor = Executors.newScheduledThreadPool( config.getInt(NetworkConfig.Keys.PROTOCOL_STAGE_THREAD_COUNT) );
	// create endpoint for each port
	for (int port:ports)
		addEndpoint(new CoapEndpoint(port, this.config));
}
 

import org.eclipse.californium.core.network.Endpoint; //导入依赖的package包/类
public void setExecutor(ScheduledExecutorService executor) {
	
	if (this.executor!=null) this.executor.shutdown();
	
	this.executor = executor;
	for (Endpoint ep:endpoints)
		ep.setExecutor(executor);
}
 

import org.eclipse.californium.core.network.Endpoint; //导入依赖的package包/类
/**
 * Starts the server by starting all endpoints this server is assigned to.
 * Each endpoint binds to its port. If no endpoint is assigned to the
 * server, an endpoint is started on the port defined in the config.
 */
@Override
public void start() {
	
	LOGGER.info("Starting server");
	
	if (endpoints.isEmpty()) {
		// servers should bind to the configured port (while clients should use an ephemeral port through the default endpoint)
		int port = config.getInt(NetworkConfig.Keys.COAP_PORT);
		LOGGER.info("No endpoints have been defined for server, setting up server endpoint on default port " + port);
		addEndpoint(new CoapEndpoint(port, this.config));
	}
	
	int started = 0;
	for (Endpoint ep:endpoints) {
		try {
			ep.start();
			// only reached on success
			++started;
		} catch (IOException e) {
			LOGGER.severe(e.getMessage() + " at " + ep.getAddress());
		}
	}
	if (started==0) {
		throw new IllegalStateException("None of the server endpoints could be started");
	}
}
 

import org.eclipse.californium.core.network.Endpoint; //导入依赖的package包/类
/**
 * Stops the server, i.e., unbinds it from all ports. Frees as much system
 * resources as possible to still be able to be re-started with the previous binds.
 */
@Override
public void stop() {
	LOGGER.info("Stopping server");
	for (Endpoint ep:endpoints)
		ep.stop();
}
 

import org.eclipse.californium.core.network.Endpoint; //导入依赖的package包/类
/**
 * Destroys the server, i.e., unbinds from all ports and frees all system resources.
 */
@Override
public void destroy() {
	LOGGER.info("Destroy server");
	for (Endpoint ep:endpoints)
		ep.destroy();
	executor.shutdown(); // cannot be started again
	try {
		boolean succ = executor.awaitTermination(5, TimeUnit.SECONDS);
		if (!succ)
			LOGGER.warning("Server executor did not shutdown in time");
	} catch (InterruptedException e) {
		LOGGER.log(Level.WARNING, "Exception while terminating server executor", e);
	}
}
 

import org.eclipse.californium.core.network.Endpoint; //导入依赖的package包/类
/**
 * Returns the endpoint with a specific port.
 * @param port the port
 * @return the endpoint 
 */
@Override
public Endpoint getEndpoint(int port) {
	Endpoint endpoint = null;

	for (Endpoint ep : endpoints) {
		if (ep.getAddress().getPort() == port) {
			endpoint = ep;
		}
	}
	return endpoint;
}