物联网协议Coap之Californium CoapServer解析

目录

前言
一、CoapServer对象
1、类对象定义
2、ServerInterface接口
3、CoapServer对象
 二、CoapServer服务运行分析
1、CoapServer对象实例化
1.1 调用构造方法
1.2 生成全局配置
1.3 创建Resource对象
1.4-1.8、配置消息通报器、添加CoapResource
1.9-1.12 创建线程池
1.3-1.7 端口绑定、服务配置
2、添加处置惩罚器
3、服务启动
 1.1-1.5、绑定端口及相关服务
1.7-1.8 循环启动EndPoint
4、服务运行
总结

---

前言

        在之前的博客物联网协议之COAP简介及Java实践中，我们采用使用Java开辟的Californium框架下进行Coap协议的Server端和Client的协议开辟。由于最根本的入门介绍博客，我们没有对它的CoapServer的实现进行深条理的分析。众所周知，Coap和Http协议类似，是分为Server端和Client端的，Server负责吸收哀求，同时负责业务哀求的的处置惩罚。而Client负责发起服务，同时吸收Server端返回的响应。
        这里将起首介绍CoapServer的内容，本文将采用OOP的筹划方法对Californium中Server的实现和启动进行源码级的分析，让读者对Coap的实现有进一步的了解，资助把握其筹划和实现细节。
一、CoapServer对象

        CoapServer对象是Californium中的焦点对象，主要功能作用是创建一个Coap协议的服务端，在指定端口和设置资源处置惩罚控制器后，就可以用于吸收来自客户端的哀求。CoapServer的基本架构如下：

2. * +------------------------------------- CoapServer --------------------------------------+
3. * |                                                                                       |
4. * |                               +-----------------------+                               |
5. * |                               |    MessageDeliverer   +--> (Resource Tree)            |
6. * |                               +---------A-A-A---------+                               |
7. * |                                         | | |                                         |
8. * |                                         | | |                                         |
9. * |                 .-------->>>------------' | '--------<<<------------.                 |
10. * |                /                          |                          \                |
11. * |               |                           |                           |               |
12. * |             * A                         * A                         * A               |
13. * | +-----------------------+   +-----------------------+   +-----------------------+     |
14. * | |        Endpoint       |   |        Endpoint       |   |      Endpoint         |     |
15. * | +-----------------------+   +-----------------------+   +-----------------------+     |
16. * +------------v-A--------------------------v-A-------------------------v-A---------------+
17. *              v A                          v A                         v A            
18. *              v A                          v A                         v A         
19. *           (Network)                    (Network)                   (Network)
20. *

复制代码

1、类对象定义

        起首我们来看一下CoapServer的类图，从它的类图看一下涉及的类的实现关系。详细如下图所示：

         从上图可以很清晰的看到CoapServer对象的依赖关系，它是ServerInterface的实现类，内部定义了RootResource,它是CoapResource的一个子类。
2、ServerInterface接口

        ServerInterface接口中定义了CoapServer的方法，比如启动、停止、移除、添加服务实例、销毁、addEndpoint等等。来看看其详细的定义：

2. package org.eclipse.californium.core.server;
3. import java.net.InetSocketAddress;
4. import java.util.List;
5. import org.eclipse.californium.core.network.Endpoint;
6. import org.eclipse.californium.core.server.resources.Resource;
8. public interface ServerInterface {
9.         /**
10.          * 启动服务
11.          */
12.         void start();
14.         /**
15.          *停止服务
16.          */
17.         void stop();
18.        
19.         /**
20.          * 销毁服务
21.          */
22.         void destroy();
23.        
24.         /**
25.          * 增加资源到服务实例中
26.          */
27.         ServerInterface add(Resource... resources);
28.        
29.         /**
30.          * 从服务实例中移除资源
31.          */
32.         boolean remove(Resource resource);
33.        
34.         void addEndpoint(Endpoint endpoint);
36.         List<Endpoint> getEndpoints();
38.         Endpoint getEndpoint(InetSocketAddress address);
39.        
40.         Endpoint getEndpoint(int port);
41.        
42. }

复制代码

序号	方法	阐明
1	void start();	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, the server binds to CoAP's default port 5683.
2	void stop();	Stops the server, i.e. unbinds it from all ports.
3	void destroy();	Destroys the server, i.e. unbinds from all ports and frees all system resources.
4	ServerInterface add(Resource... resources);	Adds one or more resources to the server.
5	boolean remove(Resource resource);	Adds an endpoint for receive and sending CoAP messages on.
6	List<Endpoint> getEndpoints();	Gets the endpoints this server is bound to.

3、CoapServer对象

        作为ServerInterface的实现子类，我们来看看Server的详细实现，起首来看下类图：

         成员属性：

序号	属性	阐明
1	Resource root	The root resource.
2	NetworkConfig config	网络配置对象
3	MessageDeliverer deliverer	The message deliverer
4	List<Endpoint> endpoints	The list of endpoints the server connects to the network.
5	ScheduledExecutorService executor;	The executor of the server for its endpoints (can be null).
6	boolean running	false
7	class RootResource extends CoapResource	内部实现类

        成员方法除了实现ServerInterface接口的方法之外，还提供以下方法：

序号	方法	阐明
1	Resource getRoot()	Gets the root of this server
2	Resource createRoot()	Creates a root for this server. Can be overridden to create another root.

 二、CoapServer服务运行分析

        在了解了上述的CoapServer的相关接口和类的筹划和实现后，我们可以来跟踪调试一下CoapServer的现实服务运行过程。它的生命周期运行是一个怎么样的过程，通过下面的章节来进行讲解。
1、CoapServer对象实例化

        在之前的代码中，我们对CoapServer对象进行了创建，来看一下关键代码。从使用者的角度来看，这是最简单不过的一个Java对象实例的创建，并没有特别。然而我们要深入到其类的内部实现，明白了解在创建CoapServer的过程中调用了什么逻辑。这里我们将结适时序图的方式进行讲解。

2. CoapServer server = new CoapServer();// 主机为localhost 端口为默认端口5683

复制代码

 从上面的时序图可以看到，在CoaServer的内部，在创建其实例的时间。其实做了许多的业务调用，大致可以分为18个步骤，下面联合代码进行介绍：
1.1 调用构造方法

1. /**
2.          * Constructs a server with the specified configuration that listens to the
3.          * specified ports after method {@link #start()} is called.
4.          *
5.          * @param config the configuration, if <code>null</code> the configuration returned by
6.          * {@link NetworkConfig#getStandard()} is used.
7.          * @param ports the ports to bind to
8.          */
9.         public CoapServer(final NetworkConfig config, final int... ports) {
10.                
11.                 // global configuration that is passed down (can be observed for changes)
12.                 if (config != null) {
13.                         this.config = config;
14.                 } else {
15.                         this.config = NetworkConfig.getStandard();
16.                 }
17.                
18.                 // resources
19.                 this.root = createRoot();
20.                 this.deliverer = new ServerMessageDeliverer(root);
21.                
22.                 CoapResource wellKnown = new CoapResource(".well-known");
23.                 wellKnown.setVisible(false);
24.                 wellKnown.add(new DiscoveryResource(root));
25.                 root.add(wellKnown);
26.                
27.                 // endpoints
28.                 this.endpoints = new ArrayList<>();
29.                 // sets the central thread pool for the protocol stage over all endpoints
30.                 this.executor = Executors.newScheduledThreadPool(//
31.                                 this.config.getInt(NetworkConfig.Keys.PROTOCOL_STAGE_THREAD_COUNT), //
32.                                 new NamedThreadFactory("CoapServer#")); //$NON-NLS-1$
33.                 // create endpoint for each port
34.                 for (int port : ports) {
35.                         CoapEndpoint.CoapEndpointBuilder builder = new CoapEndpoint.CoapEndpointBuilder();
36.                         builder.setPort(port);
37.                         builder.setNetworkConfig(config);
38.                         addEndpoint(builder.build());
39.                 }
40.         }

复制代码

1.2 生成全局配置

        在这里，系统会根据传入的参数进行全局配置，如果不传入config，则自动根据默认参数进行系统配置。否则根据传入参数进行配置。在系统分析时可以看到，如果系统第一次运行，配置文件是不存在的，因此在不存在的时间，会将默认配置写入到工程下面的配置文件中。

1. public static NetworkConfig getStandard() {
2.                 synchronized (NetworkConfig.class) {
3.                         if (standard == null)
4.                                 createStandardWithFile(new File(DEFAULT_FILE_NAME));
5.                 }
6.                 return standard;
7.         }
9. public static NetworkConfig createWithFile(final File file, final String header, final NetworkConfigDefaultHandler customHandler) {
10.                 NetworkConfig standard = new NetworkConfig();
11.                 if (customHandler != null) {
12.                         customHandler.applyDefaults(standard);
13.                 }
14.                 if (file.exists()) {
15.                         standard.load(file);
16.                 } else {
17.                         standard.store(file, header);
18.                 }
19.                 return standard;
20.         }
22. public void store(File file, String header) {
23.                 if (file == null) {
24.                         throw new NullPointerException("file must not be null");
25.                 } else {
26.                         try (FileWriter writer = new FileWriter(file)) {
27.                                 properties.store(writer, header);
28.                         } catch (IOException e) {
29.                                 LOGGER.warn("cannot write properties to file {}: {}",
30.                                                 new Object[] { file.getAbsolutePath(), e.getMessage() });
31.                         }
32.                 }
33.         }

复制代码

1.3 创建Resource对象

        通过Server对象本身提供的createRoot()方法进行Resource对象的创建。
1.4-1.8、配置消息通报器、添加CoapResource

1. CoapResource wellKnown = new CoapResource(".well-known");
2. wellKnown.setVisible(false);
3. wellKnown.add(new DiscoveryResource(root));
4. root.add(wellKnown);
5. this.endpoints = new ArrayList<>();

复制代码

1.9-1.12 创建线程池

        这里很告急，通过创建一个容量为16的线程池来进行服务对象的处置惩罚。

1. // sets the central thread pool for the protocol stage over all endpoints
2. this.executor=Executors.newScheduledThreadPool(this.config.getInt(NetworkConfig.Keys.PROTOCOL_STAGE_THREAD_COUNT), new NamedThreadFactory("CoapServer#")); //$NON-NLS-1$

复制代码

1.3-1.7 端口绑定、服务配置

        在这里通过for循环的方式，将各个须要处置惩罚的端口与应用步伐进行深度绑定，配置对应的服务。到此，CoapServer对象已经完成了初始创建。
2、添加处置惩罚器

        在创建好了CoapServer对象后，我们使用server.add（new CoapResource()）进行服务的绑定，这里的CoapResource其实就是类似于我们常见的Controller类或者servlet。
3、服务启动

下面来看下CoapServer的启动过程，它的启动主要是调用start方法。时序图调用如下图所示：

 1.1-1.5、绑定端口及相关服务

1. if (endpoints.isEmpty()) {
2.                         // servers should bind to the configured port (while clients should use an ephemeral port through the default endpoint)
3.                         int port = config.getInt(NetworkConfig.Keys.COAP_PORT);
4.                         LOGGER.info("no endpoints have been defined for server, setting up server endpoint on default port {}", port);
5.                         CoapEndpoint.CoapEndpointBuilder builder = new CoapEndpoint.CoapEndpointBuilder();
6.                         builder.setPort(port);
7.                         builder.setNetworkConfig(config);
8.                         addEndpoint(builder.build());
9.                 }

复制代码

1.7-1.8 循环启动EndPoint

1. int started = 0;
2.                 for (Endpoint ep : endpoints) {
3.                         try {
4.                                 ep.start();
5.                                 // only reached on success
6.                                 ++started;
7.                         } catch (IOException e) {
8.                                 LOGGER.error("cannot start server endpoint [{}]", ep.getAddress(), e);
9.                         }
10.                 }

复制代码

每个EndPoint会设置自己的启动方法，

1. @Override
2.         public synchronized void start() throws IOException {
3.                 if (started) {
4.                         LOGGER.debug("Endpoint at {} is already started", getUri());
5.                         return;
6.                 }
8.                 if (!this.coapstack.hasDeliverer()) {
9.                         setMessageDeliverer(new ClientMessageDeliverer());
10.                 }
11.                 if (this.executor == null) {
12.                         setExecutor(Executors.newSingleThreadScheduledExecutor(
13.                                         new DaemonThreadFactory("CoapEndpoint-" + connector + '#')));
14.                         addObserver(new EndpointObserver() {
15.                                 @Override
16.                                 public void started(final Endpoint endpoint) {
17.                                         // do nothing
18.                                 }
19.                                 @Override
20.                                 public void stopped(final Endpoint endpoint) {
21.                                         // do nothing
22.                                 }
23.                                 @Override
24.                                 public void destroyed(final Endpoint endpoint) {
25.                                         executor.shutdown();
26.                                 }
27.                         });
28.                 }
30.                 try {
31.                         started = true;
32.                         matcher.start();
33.                         connector.start();
34.                         for (EndpointObserver obs : observers) {
35.                                 obs.started(this);
36.                         }
37.                         startExecutor();
38.                 } catch (IOException e) {
39.                         stop();
40.                         throw e;
41.                 }
42.         }

复制代码

4、服务运行

        在经过了上述的实例对象创建、哀求资源绑定、服务启动三个环节，一个可用的CoapServer才算是真正完成。运行终端代码可以看到服务已经正常启动。

         由于篇幅有限，类内里还有其他告急的方法不能逐一讲解，感兴趣的各位，可以在工作中认真分析源代码，真正把握其焦点逻辑，做到胸中有数。
总结

        以上就是本文的主要内容，本文将采用OOP的筹划方法对Californium中Server的实现和启动进行源码级的分析，让读者对Coap的实现有进一步的了解，资助把握其筹划和实现细节。行文仓促，不免有遗漏和不当之处，欢迎各位朋友在批评区品评指正。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。