Question

我试图弄清楚哪种API是我的SDK客户端提供的最佳API。基本上，典型的用例是一个应用程序中的一个会话实例和一个渲染器，但是，这可能在将来发生变化。

关键点：应该易于使用，具有前瞻性，稳定性和面向未来的用户。

方法A：

 /**
 * The user have to create and maintain the module
 *
 * pros:
 *  -module explicitly added at construction time
 *  -uses an object that would be only available using the extension
 *
 * cons:
 *  -does not enforce one-o-one relation between renderer and session
 *  -the burden of maintaining the module leaved to the user
 *  -the burden of creating the module leaved to the user
 *  -fixed StreamingModule implementation forever
 * */
public void createSessionWithUserInstalledModule(VideoRenderer.Callbacks renderer) throws Exception {
    SessionFactory factory = SessionFactory.newInstance();
    StreamingModule module = new StreamingModule();
    module.useRenderer(renderer);
    factory.install(module);
    factory.create(context, sessionCreatedCallback);

}

方法B：

/**
 * A static field of the module holds the instance.
 * The module will be implicitly picked up, and instantiated
 * when it's on the classpath.
 * It will be injected into the session during construction time.
 *
 * pros:
 *  -module doesn't need to be maintained by user
 *  -trivial implementation from user side
 *
 * cons:
 *  -only one renderer is possible
 *  -only one renderer will be available to all session instances
 *  -possibility of leaking the renderer instance
 * */
public void createSessionWithStaticHolder(VideoRenderer.Callbacks renderer) throws Exception {
    SessionFactory factory = SessionFactory.newInstance();
    StreamingModule.setRenderer(renderer);
    factory.create(context, sessionCreatedCallback);
}

方法C：

/**
 * The module can be retrieved from the session instance, after the
 * session is created.
 * The module will be implicitly picked up, and instantiated
 * when it's on the classpath.
 * It will be injected into the session during construction time.
 *
 * pros:
 *  -StreamingModule implementation can be replaced in the future
 *  -session instances have their own module
 *  -only the session instance needed to be maintained (which is probably
 *  already done on the user side)
 *
 * cons:
 *  -less trivial implementation on user side
 * */
public void createSessionUsingServiceStyle(final VideoRenderer.Callbacks renderer) throws Exception {
    SessionFactory factory = SessionFactory.newInstance();
    factory.create(context, new SessionFactory.SessionCreationCallback() {
        @Override
        public void onSessionCreated(Session session) {
            StreamingModule module = session.getModule(StreamingModule.class);
            module.useRenderer(renderer);
        }
    });
}

我会选择后一种解决方案（C），因为我认为它是易用性和未来可扩展性之间的黄金路径。请参阅我的评论，并提出建议！

Answer 1

我几乎选择了A，因为它使用起来更简单，“负担”的中间名称是“灵活性”。

尽管如此，我还是和A和C的混蛋孩子一起去，那里的类路径没有魔法可以获得模块。

思想/推理：每当我在同一句话中听到“JVM”，“隐含”和“classpath”这两个词时，我都会失去一些头发，觉得自己被公共汽车撞了。

与顺序代码相比，有些用户可能会发现处理异步SessionCreationCallback更加困难，但这只是关于计算机的RTFM案例。

这是实现客户端API的最佳方式

1 个答案: