精华内容
下载资源
问答
  • 插件机制

    2018-08-02 11:19:00
    1 #region 插件机制 2 // 宿主(host):程序寄宿或挂载对象 3 // 有了宿主就可以定义插件(plug-in):符合指定宿主某种接口,并能够提供特定功能的程序 4 5 // 插件架构(插件机制):它降低了宿主与具体...
     1  #region 插件机制
     2         //  宿主(host):程序寄宿或挂载对象
     3         //  有了宿主就可以定义插件(plug-in):符合指定宿主某种接口,并能够提供特定功能的程序
     4 
     5         //  插件架构(插件机制):它降低了宿主与具体的应用模块的依赖,宿主不关心每一个具体的插件如何实现,
     6         //  只要该插件满足宿主的规范,那么宿主就能够加载它。
     7         //  作为插件,只要满足了宿主的规范便可以被宿主加载
     8 
     9         // 使用插件架构时一般都会使用到 反射(reflector)
    10 
    11         //  规范 在实际编码中体现为 Interface 或者 abstract class
    12 
    13         //  1.定义一个接口
    14         /// <summary>
    15         /// 插件应遵循的接口
    16         /// </summary>
    17         public interface IPlugIn{
    18             void Show();
    19         }
    20 
    21         //  2.定义一个插件,需要实现上述接口
    22         /// <summary>
    23         /// 具体插件
    24         /// </summary>
    25         public class MyPlugIn : IPlugIn
    26         {
    27             //  IPlugIn 成员
    28             public void Show()
    29             {
    30                 Console.WriteLine("this is my plugin");
    31             }
    32         }
    33 
    34         //  定义一个 宿主 ,并利用 反射 创建具体插件的实例
    35         public class PlugInHost
    36         {
    37             /// <summary>
    38             /// 加载所有的插件
    39             /// </summary>
    40             /// <returns></returns>
    41             public List<IPlugIn> LoadPlugIns()
    42             {
    43                 List<IPlugIn> plugList = new List<IPlugIn>();
    44                 Assembly pluginAssembly = null;
    45                 string path = System.IO.Directory.GetCurrentDirectory() + "/plugins/MyPlugin.dll";
    46                 try
    47                 {
    48                     //  加载程序集
    49                     pluginAssembly = Assembly.LoadFile(path);
    50                 }
    51                 catch (Exception ex)
    52                 {
    53 
    54                     Console.WriteLine(ex.Message);
    55                     return plugList;
    56                 }
    57 
    58                 Type[] types = pluginAssembly.GetTypes();
    59                 foreach (Type type in types)
    60                 {
    61                     if (type.GetInterface("IPlugIn") != null)
    62                     {
    63                         //  创建插件的实例
    64                         plugList.Add((IPlugIn)Activator.CreateInstance(type));
    65                     }
    66                 }
    67 
    68                 return plugList;
    69             }
    70         }
    71 
    72         //  定义完了插件,扩展规则,宿主之后调用
    73         static void Main(string[] args)
    74          {
    75              PlugInHost host = new PlugInHost();
    76              var plugins = host.LoadPlugIns();
    77              foreach (var plugin in plugins)
    78              {
    79                  plugin.Show();
    80              }
    81  
    82              Console.Read();
    83          }
    84          
    85         #endregion

     

    转载于:https://www.cnblogs.com/huangzewei/p/9406055.html

    展开全文
  • .net 插件机制的实现

    2018-03-01 14:44:00
    .net 插件机制的实现 .net 插件机制的实现 .net 插件机制的实现
  • mybatis插件机制

    2018-12-12 09:14:00
    mybatis插件机制 主要 类/接口 和 方法 mybatis插件机制实现 mybatis插件机制 mybatis的插件机制使用动态代理实现,不了解的朋友请先了解代理模式和动态代理;插件本质是功能增强,那么它如果需要对某个方法...

    mybatis插件机制

    mybatis的插件机制使用动态代理实现,不了解的朋友请先了解代理模式和动态代理;插件本质是功能增强,那么它如果需要对某个方法进行增强,首先要拦截这个方法,其实也就类似于拦截器,mybatis的插件在代码中定义为Interceptor,也就是拦截器;后面统一称作拦截器;

    主要 类/接口 和 方法

    • Interceptor
    方法 主要功能
    Object intercept(Invocation invocation) 拦截器功能具体实现
    Object plugin(Object target) 为被代理类生成代理对象
    void setProperties(Properties properties) 获取自定义配置
    • InterceptorChain
    方法 主要功能
    public Object pluginAll(Object target) 生成代理对象,通过代理的方式注入拦截器功能
    public void addInterceptor(Interceptor interceptor) 注册插件
    ...getInterceptors() 获取一个不可修改的拦截器集合
    • Plugin
    方法 主要功能
    public static Object wrap(Object target, Interceptor interceptor) 使用动态代理生成代理对象
    public Object invoke(Object proxy, Method method, Object[] args) 调用拦截器的intercept方法或者直接调用被代理对象的当前方法
    ...getSignatureMap(Interceptor interceptor) 根据拦截器上的注解反射获取目标方法

    mybatis插件机制实现

    InterceptorChain中维护了一个拦截器列表,也就说所有的拦截器都要在这里注册;

    InterceptorChain中关键的一个方法是pluginAll:

      public Object pluginAll(Object target) {
        for (Interceptor interceptor : interceptors) {
          target = interceptor.plugin(target);
        }
        return target;
      }

    pluginAll方法中是调用了Interceptor的plugin方法,
    这个plugin方法是一个覆写方法,需要插件开发者自己实现,但是Mybatis已经提供了相应的实现:

      @Override
        public Object plugin(Object target) {
            return Plugin.wrap(target, this);
        }

    打开Plugin这个工具类发现它实现了InvocationHandler接口,再看wrap方法:

    public static Object wrap(Object target, Interceptor interceptor) {
        //获取此拦截器想要代理的目标方法
        Map<Class<?>, Set<Method>> signatureMap = getSignatureMap(interceptor);
        Class<?> type = target.getClass();
        Class<?>[] interfaces = getAllInterfaces(type, signatureMap);
        //判断是否是否实现了接口,如果是则使用jdk动态代理生成代理对象,否则返回原对象
        if (interfaces.length > 0) {
          return Proxy.newProxyInstance(
              type.getClassLoader(),
              interfaces,
              new Plugin(target, interceptor, signatureMap));
        }
        return target;
      }

    实际上就是使用jdk动态代理为target创建了一个代理对象,并且这个被代理的对象必须是一个接口的实现类(jdk动态代理必须有接口),否则不会生成代理对象,也就是说拦截器只能拦截接口的方法;既然是动态代理肯定要看一下invoke方法:

     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        try {
          Set<Method> methods = signatureMap.get(method.getDeclaringClass());
          //如果当前执行的方法是拦截器想要拦截的方法则执行拦截器intercept方法否则,执行原方法;
          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);
        }
      }

    可以看到invoke方法中signatureMap是否有存在当前调用的Method决定了是否调用Interceptor的intercept方法,也就是说Interceptor只对signatureMap中的方法生效,那么再来看signatureMap是怎么来的:

     private static Map<Class<?>, Set<Method>> getSignatureMap(Interceptor interceptor) {
        //获取拦截器Intercepts注解
        Intercepts interceptsAnnotation = interceptor.getClass().getAnnotation(Intercepts.class);
        if (interceptsAnnotation == null) { // issue #251
          throw new PluginException("No @Intercepts annotation was found in interceptor " + interceptor.getClass().getName());      
        }
        Signature[] sigs = interceptsAnnotation.value();
        Map<Class<?>, Set<Method>> signatureMap = new HashMap<Class<?>, Set<Method>>();
        for (Signature sig : sigs) {
          Set<Method> methods = signatureMap.get(sig.type());
          if (methods == null) {
            methods = new HashSet<Method>();
            signatureMap.put(sig.type(), methods);
          }
          try {
           //根据方法签名(类类型,方法名,方法参数)反射获取方法对象
            Method method = sig.type().getMethod(sig.method(), sig.args());
            methods.add(method);
          } catch (NoSuchMethodException e) {
            throw new PluginException("Could not find method on " + sig.type() + " named " + sig.method() + ". Cause: " + e, e);
          }
        }
        return signatureMap;
      }

    到这里可以看到,Interceptor需要拦截的方法通过@Intercepts注解申明,这里根据注解中的方法签名(类类型,方法名,方法参数)反射获取具体方法并添加到signatureMap中;Interceptor中的Intercepts注解就是定义需要拦截的方法集合;

    那么再回过头看InterceptorChain的pluginAll方法,方法内遍历所有的拦截器并调用plugin方法,实际上就是每个插件都是一层代理,通过多层代理来绑定多个插件;换句话说,某个对象要想被InterceptorChain中的拦截器拦截,那么此对象必须经过InterceptorChain的pluginAll(Object target)方法的包装,当然由于jdk动态代理的关系必须是接口对象;

    比如mybatis分页插件:

    @SuppressWarnings({"rawtypes", "unchecked"})
    @Intercepts(
        {
            @Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class}),
            @Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class, CacheKey.class, BoundSql.class}),
        }
    )
    public class PageInterceptor implements Interceptor {
        //缓存count查询的ms
        protected Cache<CacheKey, MappedStatement> msCountMap = null;
        private Dialect dialect;
        private String default_dialect_class = "com.github.pagehelper.PageHelper";
        private Field additionalParametersField;
    
        @Override
        public Object intercept(Invocation invocation) throws Throwable {
            //分页逻辑
        }
    
        @Override
        public Object plugin(Object target) {
            return Plugin.wrap(target, this);
        }
    
        @Override
        public void setProperties(Properties properties) {
           //获取配置
        }
    
    }
    

    通过上文我们知道它需要拦截Executor的query方法,Executor是mybatis运行sql的核心组件,之所以能够被拦截是因为:
    在Configuration类中创建Executor之后,有这样一句代码:

    executor = (Executor) interceptorChain.pluginAll(executor);

    完~

    转载于:https://www.cnblogs.com/fengwbetter/p/10106522.html

    展开全文
  • 插件机制是代码/功能反向依赖注入到主体程序的一种方法,编译型语言通过动态加载动态库实现插件。对于Python这样的脚本语言,实现插件机制更简单。 机制 Python的__import__方法可以动态地加载Python文件,即以某个...
  • 如题,java开发web程序想实现插件机制有什么办法?就比如:一个论坛,里面有签到,积分,第三方登录,编辑器选择等等的功能,现在我想把他们都抽出来,当成插件,论坛核心只保留用户的登录,注册,发帖,回复等最...

    如题,java开发web程序想实现插件机制有什么办法?

    就比如:一个论坛,里面有签到,积分,第三方登录,编辑器选择等等的功能,现在我想把他们都抽出来,当成插件,论坛核心只保留用户的登录,注册,发帖,回复等最基本的功能,其他的功能都可以在后台点击安装,自动下载插件安装到服务器,然后就可以使用了

    eclipse,idea等开发工具都是java写的,插件都是以jar包来安装的,然后重启重新加载插件

    所以我也想让javaweb程序也能以jar包的形式来下载安装并使用看过alibaba开源的druid,就是jar包形式安装,然后将页面部分(数据库操作的监控页面)也都打包到jar里,然后在spring的配置文件里配置访问路径,这样就可以在浏览器里输入地址查看监控信息了,但这样实现与核心部分毫不相干的功能是可行的,但与核心功能有交集的话,这个该怎么处理呢?

    举个例子:签到功能,在论坛的首页的某处有一个按钮,用户点击了可以进行签到操作,代码部分还要是实现与用户个人信息相关的更新部分,这个该如何将一些与核心功能(页面)有交集的插件打包成jar,并能直接引入就使用呢?

    有些插件涉及到了用户的个人信息部分,关于获取用户的信息或处理用户信心该怎么处理比较好呢?

    后续核心部分版本升级,插件的兼容性处理方面应该怎么处理或在开发插件的时候应该注意些什么呢?

    自己百度了下,javaweb实现插件方式开发的文章基本上没有(不知道是不是我搜索的姿势不对),如果有相关文章还望留个链接,不甚感激!

    暂时想到这么多,跪求大神解答!!

    展开全文
  • Mybatis插件机制

    2020-04-25 10:54:12
    mybatis的插件机制是由拦截器实现的,也就是说,一旦配置上插件之后,parameterhandler,resultsethandler,statementhandler,executor这四大核心对象,将会生成变身,是一种代码对象,而不再是原身; 1,mybatis...

    mybatis的插件机制是由拦截器实现的,也就是说,一旦配置上插件之后,parameterhandler,resultsethandler,statementhandler,executor这四大核心对象,将会生成变身,是一种代码对象,而不再是原身;

    1,mybatis插件配置

    配置在mybatis-config.xml中

    2、插件的分类

    根据功能,可以将插件分为两大类:

    第一类:插件是对系统的一种补充,例如在分布式系统中,可以使用插件的方式,实现内存插件、磁盘插件、线性网络插件、Paxos插件等。此类插件等同于组件。

    第二类:插件是对系统默认功能的自定义修改,例如mybatis里面自定义插件,它实现的拦截器的功能。此类插件等同于拦截器。

    3,拦截对象

    • parameterhandler:处理sql的参数对象;
    • resultsethandler:处理sql的返回结果集;
    • statementhandler:数据库处理对象,用于执行sql的语句;
    • executor:mybatis执行器,用于执行sql的增删改查操作;

    每次调用executor的时候都会经过interceptor接口的拦截

    4,mybatis运行过程

    a,没有插件的运行过程

    b,有插件运行的过程

    展开全文
  • FIS 插件机制

    2019-09-30 08:19:04
    FIS 插件机制 author: @TiffanysBear 当我们使用 FIS 插件的时候,有没有想过自己也开发一个基于 FIS 的插件,参与 FIS 打包编译的整个流程;那么问题就来了: FIS 的编译过程运行原理是怎样的呢? FIS 编译打包的...
  • jQuery之插件机制

    2019-05-31 16:20:55
    jQuery插件机制
  • Nutch插件机制

    2011-12-27 10:16:48
    Nutch的插件机制...详细讲解了nutch的api 很有帮助
  • jquery插件机制

    2021-03-08 18:11:45
    为了扩展jquery的函数库,jquery提供了两种方式: $.extend(object); $.fn.extend(object); 第一种扩展方式,只能使用$符号直接调用,实验代码如下...插件机制</title> <script type="text/javascript
  • Python插件机制实现

    千次阅读 2018-09-17 10:48:37
    插件机制是代码/功能反向依赖注入到主体程序的一种方法,编译型语言通过动态加载动态库实现插件。对于Python这样的脚本语言,实现插件机制更简单。 机制 Python的__import__方法可以动态地加载Python文件,即以...
  • JQuery插件机制

    2019-07-12 22:27:00
    JQuery插件机制 自定义JQ插件,增强功能: <head> <meta charset="UTF-8"> <title>JQuery插件</title> <script src="js/jquery-3.3.1.min.js"></script> <script> ....
  • MyBatis - 插件机制(十六)

    万次阅读 2021-01-07 14:37:23
    MyBatis - 插件机制(十六) 该系列文档是本人在学习 Mybatis 的源码过程中总结下来的,可能对各位读者会不太友好,阅读前需要对 MyBatis 和 Spring 有一定的了解。比较适合刚接触,会使用但是一直没去探究底层的...
  • C++插件机制的实现

    2017-01-19 15:29:05
    C++插件机制的实现,VS2013下实现。
  • PHP中插件机制的一种实现方案. 这篇文章的出发点是我对插件机制的理解,及其在PHP中的实现。此方案仅是插件机制在PHP中的
  • 360手机助手使用的 DroidPlugin,它是360手机助手团队在Android系统上实现了一种插件机制。它可以在无需安装、修改的情况下运行APK文件,此机制对改进大型APP的架构,实现多团队协作开发具有一定的好处。 它是一种新...
  • 主要给大家介绍了关于mybatis插件机制的相关资料,文中通过示例代码介绍的非常详细,对大家学习或者使用mybatis具有一定的参考学习价值,需要的朋友们下面来一起学习学习吧
  • jQuery插件机制

    2019-11-12 16:56:58
    插件机制:为了扩展jQuery库函数,jQuery提供了两种方式: 一、jQuery.extend(object): jQuery.extend(object):扩展jQuery对象本身,主要是用来扩展jQuery全局函数 ,调用时直接$.函数名(参数)。 例如: <script...
  • 主要介绍了php利用反射实现插件机制的方法,涉及php反射机制与插件的实现技巧,需要的朋友可以参考下
  • 要想一针见血地理解MyBatis插件机制,只需要明白一点:原身和变身。也就是说,一旦配置上插件,ParameterHandler,ResultSetHandler,StatementHan...
  • 探寻 webpack 插件机制

    2018-04-18 16:45:00
    在探寻 webpack 插件机制前,首先需要了解一件有意思的事情,webpack 插件机制是整个 webpack 工具的骨架,而 webpack 本身也是利用这套插件机制构建出来的。因此在深入认识 webpack 插件机制后,再来进行项目的相关...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,316
精华内容 4,126
关键字:

插件机制