插件系统接口设计（插件系统接口设计规范）

本篇文章给大家谈谈插件系统接口设计，以及插件系统接口设计规范对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。 今天给各位分享插件系统接口设计的知识，其中也会对插件系统接口设计规范进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

• 1、插件机制详解
• 2、Vue入坑史，插件系统详解
• 3、接口设计怎么写？
• 4、mybatis自定义插件要实现什么接口

插件机制详解

插件模式是一种应用非常广泛的模式。我们用的很多软件都拥有自身的插件机制，通过插件可以拓展软件的功能。另外，插件模式也广泛应用于 web 方面。例如 Webpack、 Vue CLI、UMI、Babel等。

那么插件系统是如何实现的呢？

如上图所示，插件应用的流程很简单：

其中，第 3 步的时候，回去调用插件，调用插件时会在主应用或者状态库中添加一系列的属性和钩子。插件调用完毕后，在主应用中就可以使用这些被插件添加的属性和钩子，以此来拓展应用的功能。

关键地方在于插件的形式及插件接口的设计。

插件的形式多种多样，不同的应用有不同的设计。例如 Webpack 插件是一个对象，必须对外暴露一个 apply 方法；UMI 及 VUE CLI 的插件是函数的形式。
毫无疑问，每种插件系统都提供了固定的插件 API 供插件开发者使用，插件 API 的设计也是一个重点。

那么现在，我们可以根据以上的流程实现一个简单的拥有插件系统的 Demo。

这里，我们规定我们的插件是一个函数，接收 PluginApi 实例作为参数。

假如我们的应用入口非常简单，实例化主应用类，执行 run 方法，如下所示

现在我们的主应用已经实现。接下来实现我们关键的对外API，即 PluginApi。

至此，我们的插件化机制已经实现。那么接下来，我们来依据我们的插件系统写个插件

那么，现在使用 ts-node 运行index.ts，我们就能看到如下输出：

与我们预计的效果是相同的。

Vue入坑史，插件系统详解

在谈主题插件之前，我想先引出两个关于 Vue 的问题，这也是我存在的两个疑问，希望有人能够帮忙解答。

如果你比较心急，可以直接跳到 Vue.use源码解读 。

这两个是我最近在开发过程中遇到的问题，也没有找到相关的答案，希望有谁能够帮忙解答，在此先行谢过了。

Vue 的插件一般就是用来 扩展Vue的功能 。比如，当需要 Vue 实现 Ajax 请求功能，我们希望通过 this.$get(url) 的形式就可以发送一个 get 请求。那么，我们就需要给 Vue 的实例添加一个 $get 方法， Vue 实例本身是没有这个方法的。

Vue 的一些插件：

在创建 Vue 实例之前，通过全局方法 Vue.use() 来使用插件：

是不是很简单，好像也没有什么好说的。

有时候，我们看到某些插件使用起来可能有些不一样。比如使用 vuex ：

其实本质上还是一样的，也是通过 Vue.use() 方法注册插件。只不过它有一个 store 对象，然后并将 store 对象作为 Vue 根实例的属性，以便组件通过 this.$store 这种形式来访问。

其实当通过 Vue.use() 注册插件时，内部会自动调用插件的 install() 方法。也就是说，插件必须要提供一个公开的 install() 方法，作为接口。该方法第一个参数是 Vue ，第二个参数是可选的 options 对象。

总结起来说，插件是一个对象。该对象要有一个公开的 install() 方法，那么写起来可能是这样的：

在 install() 方法中，我们通过参数可以拿到Vue对象，那么，我们就可以对它做很多事情。

这里直接就看几个插件的源码吧，看看他们是怎么写的，其实我也是参照了这些源码才真正弄明白了插件是怎么一回事。源码很长，这里只说一些关键点。

针对 vue-resource 插件问题，我查看了一下 vue 的源码，它的源码是这样的：

通过源码，我们知道， Vue插件可以是一个对象或者是一个函数 。只有当插件实现了 install 接口时（有 install 这个函数时），才会调用插件的 install 方法；否则再判断插件本身是否是一个函数，如果是，就直接调用它。

现在就能很好的解释 vue-resource 插件的写法了。好吧，我也是刚刚得知，又长了一点见识。

其实官网也有 说明 ：

写一篇文章，对别人来说是一种分享，其实对自己来说更是一种提高。因为你要写好一篇文章，一方面你得尽量保证其正确性，有时候你不得不亲自去验证，另一方面也是对自己所学的知识进行一遍系统的复习和整理。

如果你有时间，我建议你多写一些技术类文章；如果你实在没时间写，那也要多读读别人写的文章。

接口设计怎么写？

接口设计包括三个方面：一、用户接口用来说明将向用户提供的命令和它们的语法结构，以及软件的回答信息。二、外部接口用来说明本系统同外界的所有接口的安排包括软件与硬件之间的接口、本系统与各支持软件之间的接口关系。三、内部接口用来说明本系统之内的各个系统元素之间的接口的安排

mybatis自定义插件要实现什么接口

竟然Mybatis是对四大接口进行拦截的，那我们药先要知道Mybatis的四大接口对象 Executor, StatementHandler, ResultSetHandler, ParameterHandler。
上图Mybatis框架的整个执行过程。Mybatis插件能够对则四大对象进行拦截，可以包含到了Mybatis一次会议的所有操作。可见Mybatis的的插件很强大。
Executor是 Mybatis的内部执行器，它负责调用StatementHandler操作数据库，并把结果集通过 ResultSetHandler进行自动映射，另外，他还处理了二级缓存的操作。从这里可以看出，我们也是可以通过插件来实现自定义的二级缓存的。
StatementHandler是Mybatis直接和数据库执行sql脚本的对象。另外它也实现了Mybatis的一级缓存。这里，我们可以使用插件来实现对一级缓存的操作(禁用等等)。
ParameterHandler是Mybatis实现Sql入参设置的对象。插件可以改变我们Sql的参数默认设置。
ResultSetHandler是Mybatis把ResultSet集合映射成POJO的接口对象。我们可以定义插件对Mybatis的结果集自动映射进行修改。
插件Interceptor
Mybatis的插件实现要实现Interceptor接口，我们看下这个接口定义的方法。
public interface Interceptor {
Object intercept(Invocation invocation) throws Throwable;
Object plugin(Object target);
void setProperties(Properties properties);
}
这个接口只声明了三个方法。
setProperties方法是在Mybatis进行配置插件的时候可以配置自定义相关属性，即：接口实现对象的参数配置
plugin方法是插件用于封装目标对象的，通过该方法我们可以返回目标对象本身，也可以返回一个它的代理，可以决定是否要进行拦截进而决定要返回一个什么样的目标对象，官方提供了示例：return Plugin.wrap(target, this);
intercept方法就是要进行拦截的时候要执行的方法
理解这个接口的定义，先要知道java动态代理机制。plugin接口即返回参数target对象(Executor/ParameterHandler/ResultSetHander/StatementHandler)的代理对象。在调用对应对象的接口的时候，可以进行拦截并处理。
Mybatis四大接口对象创建方法
Mybatis的插件是采用对四大接口的对象生成动态代理对象的方法来实现的。那么现在我们看下Mybatis是怎么创建这四大接口对象的。
public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
//确保ExecutorType不为空(defaultExecutorType有可能为空)
executorType = executorType == null ? defaultExecutorType : executorType;
executorType = executorType == null ? ExecutorType.SIMPLE : executorType;
Executor executor; if (ExecutorType.BATCH == executorType) {
executor = new BatchExecutor(this, transaction);
} else if (ExecutorType.REUSE == executorType) {
executor = new ReuseExecutor(this, transaction);
} else {
executor = new SimpleExecutor(this, transaction);
} if (cacheEnabled) {
executor = new CachingExecutor(executor);
}
executor = (Executor) interceptorChain.pluginAll(executor);
return executor;
}
public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler, boundSql);
statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);
return statementHandler;
}
public ParameterHandler newParameterHandler(MappedStatement mappedStatement, Object parameterObject, BoundSql boundSql) {
ParameterHandler parameterHandler = mappedStatement.getLang().createParameterHandler(mappedStatement, parameterObject, boundSql);
parameterHandler = (ParameterHandler) interceptorChain.pluginAll(parameterHandler);
return parameterHandler;
}
public ResultSetHandler newResultSetHandler(Executor executor, MappedStatement mappedStatement, RowBounds rowBounds, ParameterHandler parameterHandler, ResultHandler resultHandler, BoundSql boundSql) {
ResultSetHandler resultSetHandler = new DefaultResultSetHandler(executor, mappedStatement, parameterHandler, resultHandler, boundSql, rowBounds);
resultSetHandler = (ResultSetHandler) interceptorChain.pluginAll(resultSetHandler);
return resultSetHandler;
}
查看源码可以发现， Mybatis框架在创建好这四大接口对象的实例后，都会调用InterceptorChain.pluginAll()方法。InterceptorChain对象是插件执行链对象，看源码就知道里面维护了Mybatis配置的所有插件(Interceptor)对象。
// target -- Executor/ParameterHandler/ResultSetHander/StatementHandler
public Object pluginAll(Object target) {
for (Interceptor interceptor : interceptors) {
target = interceptor.plugin(target);
}
return target;
}
其实就是安顺序执行我们插件的plugin方法,一层一层返回我们原对象(Executor/ParameterHandler/ResultSetHander/StatementHandler)的代理对象。当我们调用四大接口对象的方法时候，实际上是调用代理对象的响应方法，代理对象又会调用十大接口对象的实例。
Plugin对象
我们知道，官方推荐插件实现plugin方法为：Plugin.wrap(target, this);
public static Object wrap(Object target, Interceptor interceptor) {
// 获取插件的Intercepts注解
Map<Class<?, Set<Method signatureMap = getSignatureMap(interceptor);
Class<? type = target.getClass();
Class<?[] interfaces = getAllInterfaces(type, signatureMap);
if (interfaces.length 0) {
return Proxy.newProxyInstance(type.getClassLoader(), interfaces, new Plugin(target, interceptor, signatureMap));
}
return target;
}
这个方法其实是Mybatis简化我们插件实现的工具方法。其实就是根据当前拦截的对象创建了一个动态代理对象。代理对象的InvocationHandler处理器为新建的Plugin对象。
插件配置注解@Intercepts
Mybatis的插件都要有Intercepts注解来指定要拦截哪个对象的哪个方法。我们知道，Plugin.warp方法会返回四大接口对象的代理对象(通过new Plugin()创建的IvocationHandler处理器)，会拦截所有的执行方法。在代理对象执行对应方法的时候，会调用InvocationHandler处理器的invoke方法。Mybatis中利用了注解的方式配置指定拦截哪些方法。具体如下：
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
try {
Set<Method methods = signatureMap.get(method.getDeclaringClass());
if (methods != null methods.contains(method)) {
return interceptor.intercept(new Invocation(target, method, args));
}
return method.invoke(target, args);
} catch (Exception e) {
throw ExceptionUtil.unwrapThrowable(e);
}
}
可以看到，只有通过Intercepts注解指定的方法才会执行我们自定义插件的intercept方法。未通过Intercepts注解指定的将不会执行我们的intercept方法。
官方插件开发方式
@Intercepts({@Signature(type = Executor.class, method = "query",
args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class})})
public class TestInterceptor implements Interceptor {
public Object intercept(Invocation invocation) throws Throwable {
Object target = invocation.getTarget(); //被代理对象
Method method = invocation.getMethod(); //代理方法
Object[] args = invocation.getArgs(); //方法参数
// do something ...... 方法拦截前执行代码块
Object result = invocation.proceed();
// do something .......方法拦截后执行代码块
return result;
}
public Object plugin(Object target) {
return Plugin.wrap(target, this);
}
}
以上就是Mybatis官方推荐的插件实现的方法，通过Plugin对象创建被代理对象的动态代理对象。可以发现，Mybatis的插件开发还是很简单的。
自定义开发方式
Mybatis的插件开发通过内部提供的Plugin对象可以很简单的开发。只有理解了插件实现原理，对应不采用Plugin对象我们一样可以自己实现插件的开发。下面是我个人理解之后的自己实现的一种方式。
public class TestInterceptor implements Interceptor {
public Object intercept(Invocation invocation) throws Throwable {
Object target = invocation.getTarget(); //被代理对象
Method method = invocation.getMethod(); //代理方法
Object[] args = invocation.getArgs(); //方法参数
// do something ...... 方法拦截前执行代码块
Object result = invocation.proceed();
// do something .......方法拦截后执行代码块
return result;
}
public Object plugin(final Object target) {
return Proxy.newProxyInstance(Interceptor.class.getClassLoader(), target.getClass().getInterfaces(), new InvocationHandler() {
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
return intercept(new Invocation(target, method, args));
}
});
}
public void setProperties(Properties properties) {
}
}
当然，Mybatis插件的那这个时候Intercepts的注解起不到作用了。
作者：曹金桂
链接：http://www.jianshu.com/p/7c7b8c2c985d
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。 关于插件系统接口设计和插件系统接口设计规范的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。 插件系统接口设计的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于插件系统接口设计规范、插件系统接口设计的信息别忘了在本站进行查找喔。

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。