IT瘾插件推荐

chrome 插件开发指南（Manifest V3） - 掘金

Thu, 30 Mar 2023 20:33:50 CST

一、什么是 Chrome插件

1.1 概述

严格来讲，我们正在说的东西应该叫 Chrome 扩展（Chrome Extension）,真正意义上的 Chrome 插件是更底层的浏览器功能扩展，需要对浏览器源码有一定掌握才有能力去开发。鉴于 Chrome 插件的叫法已经习惯，本文中也全部采用这种叫法。在百度指数里也没有收录“chrome 扩展”这个词，只有“chrome 插件”。

Chrome 插件是一个用 Web 技术开发、用来增强浏览器功能的软件，它其实就是一个由HTML、CSS、JS、图片等资源组成的一个.crx后缀的压缩包。

另外，其实不只是前端技术，Chrome 还可以配合 C++ 编写的 dll 动态链接库实现一些更底层的功能（NPAPI），比如全屏幕截图等。

由于安全原因，Chrome 浏览器42以上版本已经陆续不在支持 NPAPI 插件，取而代之的是更安全的 PPAPI。

1.2 Chrome 插件是如何工作的

扩展是基于诸如 HTML、 JavaScript 和 CSS 之类的 Web 技术构建的。它们运行在一个独立的沙箱执行环境中，并与 Chrome 浏览器进行交互。

从图中可以看出，存在三个进程： 扩展进程（Extension Process）、 页面渲染进程（Render Process）、 浏览器进程（Browser Process）。
1）扩展进程中运行Extension Page，Extension Page主要包括backgrount.html和popup.html：

backgrount.html中没有任何内容，是通过background.js创建生成，当浏览器打开时，会自动加载插件的background.js文件，它独立于网页并且一直运行在后台，它主要通过调用浏览器提供的API和浏览器进行交互；
popup.html则不同，它有内容，是一个实实在在的页面，和我们普通的web页面一样，由html、css、Javascript组成，它是按需加载的，需要用户去点击地址栏的按钮去触发，才能弹出页面。

2）渲染进程主要运行Web Page,当打开页面时，会将content_script.js加载并注入到该网页的环境中，它和网页中引入的Javascript一样，可以操作该网页的DOM Tree，改变页面的展示效果；
3）浏览器进程在这里更多起到桥梁作用，作为中转可以实现Extension Page和content_script.js之间的消息通信。

1.3 延伸阅读：插件和扩展的区别

扩展（Extension）指的是通过调用 Chrome 提供的 Chrome API 来扩展浏览器功能的一种组件，工作在浏览器层面，使用 HTML + Javascript 语言开发。比如著名的 AdBlock plus。

插件（Plug-in）指的是通过调用 Webkit 内核 NPAPI 来扩展内核功能的一种组件，工作在内核层面，理论上可以用任何一种生成本地二进制程序的语言开发，比如C/C++、Delphi等。比如Flash player插件，就属于这种类型。一般在网页中 object 或者 embed 标签声明的部分，就要靠插件来渲染。

从安全性上来看，由于插件一般实现的都是比较底层的功能，所以一旦出现问题，往往就会牵涉到整个操作系统，像 Flash 就属于经常被扒出高危漏洞的那一类。相比较之下，扩展出现问题，其危害性往往类似于浏览器漏洞。不过 Chrome Extension 在为用户带来便利的同时，也的确带来了不少安全问题，即便是在 Chrome 应用商店中的应用也不能保证绝对安全，Google 自己也下线过一些有安全隐患的扩展。

二、Chrome 插件能做什么

扩展允许你通过使用 API 修改浏览器行为和访问网页内容来“扩展”浏览器。
扩展 API 允许扩展的代码访问浏览器本身的特性: 激活选项卡、修改网络请求等等。

插件能力概述：

		API
自定义扩展用户界面	控制一个扩展的显示的图标	Action
	添加触发操作的键盘快捷键	Commands
	添加页面右键菜单	Context Menus
	向地址栏添加关键字功能	Omnibox
	创建新标签卡、书签页或历史记录页	Override Pages
	在工具栏中动态显示图标。	Page Actions
构建扩展工具	无障碍扩展服务	Accessibility (a11y)
	有趣的事情发生时，做出检测和反应	Service Workers
	使用语言和语言环境	Internationalization
	获得OAuth2访问令牌	Identity
	管理已安装和正在运行的扩展插件	Management
	通过 Content Script 与其父扩展进行通信	Message Passing
	让用户自定义扩展	Options Pages
	修改一个扩展的权限	Permissions
	存储和检索数据	Storage
修改和监听 Chrome 浏览器	创建、组织和操作书签行为	Bookmarks
	从用户的本地配置文件中删除浏览数据	Browsing Data
	以编程方式启动、监视、操作和搜索下载	Downloads
	管理 Chrome 的字体设置	Font Settings
	与浏览器访问页面的记录交互	History
	控制 Chrome 的隐私特性	Privacy
	管理 Chrome 的代理设置	Proxy
	从浏览会话查询和还原选项卡和窗口	Sessions
	在浏览器中创建、修改和重新排列选项卡	Tabs
	访问用户访问次数最多的 URL	Top Sites
	更改浏览器的整体外观	Themes
	在浏览器中创建、修改和重新排列窗口	Windows
修改和监听网页	扩展临时访问当前活动选项卡的权限	Active Tab
	自定义网站特性，如 cookies、 JavaScript 和插件	Content Settings
	在网页上下文中运行 JavaScript 代码	Content Scripts
	浏览和修改浏览器的 Cookie 系统	Cookies
	使用 XMLHttpRequest 从远程服务器发送和接收数据	Cross-Origin XHR
	在不需要许可的情况下对页面内容执行操作	Declarative Content
	捕获屏幕、单个窗口或选项卡的内容	Desktop Capture
	将选项卡的源信息保存为 MHTML	Page Capture
	与标签页互动媒体流交互	Tab Capture
	接收 in-flight 导航请求状态的通知	Web Navigation
	提供规则告诉 Chrome 如何拦截、阻止或修改 in-flight 的请求。	Declarative Net Request
打包、部署和更新	使用 Chrome Web Store 托管和更新扩展	Chrome Web Store
	在指定的网络或其他软件上分发扩展	Other Deployment Options
扩展 Chrome DevTools	测试网络交互，调试 JavaScript，修改 DOM 和 CSS	Debugger
	为 Chrome 开发工具添加功能	Devtools

几个插件例子：


Google 翻译	Adblock Plus	Artemis and Britomartis	Octotree - GitHub code tree)

一句话总结： Chrome扩展插件是用前端的技术栈，来定制浏览器的功能，改善用户体验。

三、主要构成

一个chrome插件通常由3类文件组成：

配置文件 manifest.json
图片、css等资源文件
js脚本文件，包括popup.js、background.js、content_script.js等

3.1 Manifest.json

每一个扩展都有一个json格式的清单文件，用于配置扩展的名称、版本号、图标、权限、脚本路径等信息；
文件内容如下所示：

      {"manifest_version":3,"name":"MStars","description":"A chrome extension for sgfe","options_page":"options.html","background":{"service_worker":"background.bundle.js"},"action":{"default_popup":"popup.html","default_icon":"master-34.png"},"chrome_url_overrides":{"newtab":"newtab.html"},"icons":{"128":"master.png"},"content_scripts":[{"matches":["http://*/*","https://*/*","<all_urls>"],"js":["contentScript.bundle.js"],"css":["content.styles.css"]}],"web_accessible_resources":[{"resources":["injectScript.bundle.js","content.styles.css","master.png","master-34.png","vs/*"],"matches":["http://*/*","https://*/*","<all_urls>"]}],"permissions":["webRequest","storage","contextMenus","bookmarks"],"host_permissions":["<all_urls>"],"content_security_policy":{"extension_pages":"script-src 'self';object-src 'none'"}}复制代码

3.1.1 Manifest V2

自2022年1月17日起，Chrome 应用商店已经停止接受新的 Manifest V2扩展。
2023年6月 Chrome 115开始，关闭对 Manifest V2扩展的支持。
2024年1月，Chrome 应用商店将删除所有的 Manifest V2扩展。

（Manifest V2 support timeline）

3.1.2 Manifest V3

2020年年底推出V3版本，在安全性、隐私性和性能方面得到了增强；还可以使用更现代的开放 Web 技术，比如 service works和 promises。

Manifest V3 is available beginning with Chrome 88, and the Chrome Web Store begins accepting Manifest V3 extensions in January 2021.

详细文档： developer.chrome.com/docs/extens…

3.2 popup

3.2.1 概述

popup 是点击插件图标时打开的一个页面，点击 popup 之外的区域会收起，一般用来做一些临时性的交互。

（Web Vitals）

3.2.2 简单例子

1、创建 manifest.json 文件：

      {"manifest_version":3,"name":"Hello Extensions","description":"Base Level Extension","version":"1.0","action":{"default_popup":"hello.html","default_icon":"hello_extensions.png"}}复制代码

2、创建 html 文件：

      <html><body><h1>Hello Extensions</h1></body></html>复制代码

点击 action 后，就会看到：

3.3 content-scripts

3.3.1 概述

content-scripts 是在网页上下文中运行的文件。通过使用标准的文档对象模型(Document Object Model，DOM) ，它们能够读取浏览器访问的网页的详细信息，对它们进行更改。

如主题、样式、布局定制、广告拦截等等。

大部分浏览器插件都在围绕 content-scripts 做一些事情，background、popup、options等都为之服务。
配置示例：

      "content_scripts":[{"matches":["http://*/*","https://*/*","<all_urls>"],"js":["contentScript.bundle.js"],"css":["content.styles.css"]}],复制代码

3.3.2 特性

1）和原始页面共享 DOM，但是不能共享 JS，不能访问页面中的 JS（比如变量）。
2）网络请求受到同源策略限制。
3）只能访问以下 Chrome API：

i18n
storage
runtime:
- connect
- getManifest
- getURL
- id
- onConnect
- onMessage
- sendMessage

其他 API 都不能直接访问，但是可以通过通信让 background 来进行调用。

3.3.3 简单例子

在页面中增加一个按钮。

      functioninJectBtn() {if(document.querySelector('#openInIDE'))return;document.querySelector('.repo-detail-base-info .btn-box')
    .insertAdjacentHTML('beforeend','<button id="openInIDE" type="button" class="mtd-btn mtd-btn-warning"><span><div class="mtd-button-content"><span class="mtdicon mtdicon-link-o"></span><span>Open In WebIDE</span></div></span></button>');document.querySelector('#openInIDE').addEventListener('click',() =>{window.open('https://xxx.com/');
  });
}functioninit() {varheartBeat =setInterval(() =>{varwantedEl =document.querySelector('.repo-detail-base-info .btn-box');if(wantedEl) {clearInterval(heartBeat);inJectBtn();
    }
  },1000);
}init();复制代码

3.3.4 延伸阅读：如何访问页面中的 JS

content-scripts 不能访问页面中的 js，它可以操作 DOM，但是 DOM 却不能调用它，所以就有了通过 DOM 操作的方式向页面动态注入 JS 的操作。

      functioninjectJs(jsPath) {
  jsPath = jsPath ||'injectScript.bundle.js';vartemp =document.createElement('script');
  temp.setAttribute('type','text/javascript');// chrome-extension://mapfodeofmlldcgdgahpjiefememgeei/injectScript.bundle.jstemp.src= chrome.runtime.getURL(jsPath);
  temp.onload=function() {// 放在页面不好看，执行完后移除掉this.parentNode?.removeChild(this);
  };document.head.appendChild(temp);
}复制代码

injected 的内容需要在资源列表中进行声明：

      "web_accessible_resources":[{"resources":["injectScript.bundle.js",],"matches":["http://*/*","https://*/*","<all_urls>"]}]复制代码

例子：拦截 xhr 请求。

      // "injectScript.bundle.js"xhook.after(function(request, response) {if(request.url.match(/rest\/api.+files.+/)) {console.log(response?.data)
  }
});复制代码

3.4 background

3.4.1 概述

插件是基于事件的用来修改或增强 Chrome 浏览体验的程序。事件是浏览器触发的，例如导航到新页、删除书签或关闭选项卡。插件在 background 中监视这些事件，然后根据指定的指令进行响应。
background 一旦加载完成，只要执行某个操作（比如发起网络请求或调用 Chrome API）就会一直运行，此外，在关闭所有可见视图和所有消息端口之前，不会被卸载。

总而言之，background 为所有的视图和消息端口服务。

background 在需要的时候被加载，空闲的时候被卸载。一些事件的例子包括:

插件首次安装或者更新版本；

backgroud 正在监听一些事件，这些事件被触发；

content script 或者其他扩展发送消息；

插件中的其他视图调用 runtime.getBackgroundPage

3.4.2 简单例子

创建一个右键菜单。

      functioncreateContextMenus() {
  chrome.contextMenus.create({type:'normal',id:'savePage',title:'保存页面',checked:false,
  });
}
chrome.runtime.onInstalled.addListener(() =>{createContextMenus();
});复制代码

四、其他展现形式

4.1 homepage_url

插件主页，免费广告位！

      {"homepage_url":"https://km.xxxx.com", }复制代码

4.2 Options页面

4.2.1 概述

插件的配置页面。

4.2.2 配置

有两种配置方法，对应两种展现形式。

      {// 方式1"options_page":"options.html",// 方式2 优先级高"options_ui":{"page":"options.html"},}复制代码

4.3 Devtools

开发者工具。

4.4 override（覆盖特定页面）

可以将 Chrome 默认的一些特定的页面改为使用扩展提供的页面：

页面名称	url	配置
新标签页	chrome://newtab	"chrome_url_overrides": { "newtab": "newtab.html" }
历史记录	chrome://history	"chrome_url_overrides": { "history": "history.html" }
书签	chrome://bookmarks	"chrome_url_overrides": { "bookmarks": "bookmarks.html" }

注意点：

不能替换隐身模式下的新标签页；

一个插件只能覆盖一个页面。

4.5 Omnibox

Chrome和其他浏览器相比一个最大的区别就是地址栏——其实不仅仅是地址栏，而是一个多功能的输入框，Google将其称为omnibox（中文为“多功能框”）。我们熟悉的一个功能就是用户可以直接在omnibox搜索关键字，Chrome也将omnibox开放给开发者，这使得omnibox更加强大。

五、通讯

由于 content script 运行在网页的上下文中，而不在扩展中，因此它们通常需要某种方式来与扩展的其余部分进行通信。

从浏览器插件内的视角来看通讯：

5.1 简单的一次性请求

5.1.1 从 content-scripts 发起请求

      chrome.runtime.sendMessage({greeting:"hello"},function(response) {console.log(response.farewell);
});复制代码

5.1.2 发送消息到 content-scripts

      chrome.tabs.query({active:true,currentWindow:true},function(tabs) {
  chrome.tabs.sendMessage(tabs[0].id, {greeting:"hello"},function(response) {console.log(response.farewell);
  });
});复制代码

5.1.3 接受消息

      chrome.runtime.onMessage.addListener(function(request, sender, sendResponse) {console.log(sender.tab?"from a content script:"+ sender.tab.url:"from the extension");if(request.greeting==="hello")sendResponse({farewell:"goodbye"});
  }
);复制代码

5.2 长链接

可以使用 runtime.connect和 tabs.connect建立一个长链接进行通讯。

      // port1varport = chrome.runtime.connect({name:"knockknock"});
port.postMessage({joke:"Knock knock"});
port.onMessage.addListener(function(msg) {if(msg.question==="Who's there?")
    port.postMessage({answer:"Madame"});elseif(msg.question==="Madame who?")
    port.postMessage({answer:"Madame... Bovary"});
});// port2chrome.runtime.onConnect.addListener(function(port) {console.assert(port.name==="knockknock");
  port.onMessage.addListener(function(msg) {if(msg.joke==="Knock knock")
      port.postMessage({question:"Who's there?"});elseif(msg.answer==="Madame")
      port.postMessage({question:"Madame who?"});elseif(msg.answer==="Madame... Bovary")
      port.postMessage({question:"I don't get it."});
  });
});复制代码

5.3 跨插件通讯

除了在插件中的不同组件之间发送消息之外，还可以使用消息传递 API 与其他插件进行通信。
可以使用 runtime.onMessageExternal和 runtime.onConnectExternal来监听传入的请求和连接。
监听消息：

      // For simple requests:chrome.runtime.onMessageExternal.addListener(function(request, sender, sendResponse) {if(sender.id=== blocklistedExtension)return;// don't allow this extension accesselseif(request.getTargetData)sendResponse({targetData: targetData});elseif(request.activateLasers) {varsuccess =activateLasers();sendResponse({activateLasers: success});
    }
  });// For long-lived connections:chrome.runtime.onConnectExternal.addListener(function(port) {
  port.onMessage.addListener(function(msg) {// See other examples for sample onMessage handlers.});
});复制代码

发送消息：

      // The ID of the extension we want to talk to.varlaserExtensionId ="abcdefghijklmnoabcdefhijklmnoabc";// Make a simple request:chrome.runtime.sendMessage(laserExtensionId, {getTargetData:true},function(response) {if(targetInRange(response.targetData))
      chrome.runtime.sendMessage(laserExtensionId, {activateLasers:true});
  }
);// Start a long-running conversation:varport = chrome.runtime.connect(laserExtensionId);
port.postMessage(...);复制代码

5.4 从网页发送信息

插件可以接收和响应来自常规网页的消息。要使用这个特性，必须在 Manifent.json 中指定要与哪些网站通信。
通讯方式和跨插件通讯方式类似。

5.5 Native通讯

Chrome 插件可以与原生应用进行通讯，原生应用可以通过注册一个 Native Messaging Host，Chrome 以一个单独的进程启动 Host，并使用标准输入和标准输出流进行通信。
详情可参考： developer.chrome.com/docs/apps/n…

六、如何查看某个插件的源码

开源的，如 github.com/adblockplus…
本地查看
1. 第一步：打开开发者模式，找到对应插件的id
2. 第二步：本地插件目录，/Users/mac/Library/Application Support/Google/Chrome/Default/Extensions

七、最佳实践推荐

喜欢使用 React + TS：
github.com/chibat/chro…
github.com/lxieyang/ch…
喜欢使用 rxjs：
github.com/alibaba/bro…
不想要任何框架：
github.com/SimGus/chro…

八、适配其他浏览器

切换到 chromium 内核的浏览器适配工作还是比较小的，firefox 也支持 chrome API。

我们只需要对照各浏览器厂商提供的开发文档，关注我们用到的 API 是否有差异，有差异的部分，做一下兼容即可。

可参考各浏览器的 extension 开发文档：

firefox： developer.mozilla.org/en-US/docs/…

Edge： learn.microsoft.com/zh-cn/micro…

360： open.se.360.cn/open/extens…

搜狗： ie.sogou.com/open/doc/

九、发布

chrome开发者中心： chrome.google.com/webstore/de…

firefix发布文档： addons.mozilla.org/en-US/devel…

edge发布文档： learn.microsoft.com/zh-cn/micro…

十、未来

content-sctipts + Mockjs 自动填充表单？
UI检查，自动化测试？
性能、依赖检测，Lighthouse?
账号管理&一键登录？

可以在评论区说说你们用到的场景~~

参考

chrome 插件开发指南(字节跳动技术团队)
Chrome Extension 扩展程序迁移至 Manifest V3
Chromium扩展（Extension）的Content Script加载过程分析
 一种开发 Chrome 扩展程序的新姿势
 Message passing
Native Messaging

OpenAI宣布为ChatGPT引入插件功能解锁更多技能

Fri, 24 Mar 2023 15:43:47 CST

【TechWeb】3月24日消息，据外媒报道，当地时间周四，美国人工智能研究公司OpenAI宣布为ChatGPT引入插件功能。

到目前为止，ChatGPT一直受到限制，因为它只能从2021年9月之前的训练数据中提取信息。引入插件功能极大地扩展了ChatGPT的功能，并首次允许它访问来自网络的实时数据。

OpenAI表示，这些插件是专门为语言模型设计的工具，以安全为核心原则，帮助ChatGPT访问最新信息、运行计算或使用第三方服务。

据外媒报道，OpenAI的插件不只可以检索实时信息，还可以绑定API，让它“代表用户执行操作”。

外媒称，Expedia、FiscalNote、Instacart、KAYAK、Klarna、Milo、OpenTable、Shopify、Slack、Speak、Wolfram和Zapier等公司已经为ChatGPT开发了首批插件。插件系统开放之后，这些公司的服务就可以接入ChatGPT。

目前，OpenAI正在努力找出与新插件功能有关的潜在风险。该公司表示，其工程师已经进行了一些测试，以确定插件可能如何被滥用。此外，该公司还在邀请外部研究人员提供反馈。

Elasticsearch Head 插件使用小结

Tue, 13 Dec 2022 00:00:00 CST

作者：崔雄华

1 Elasticsearch Head是什么

ElasticSearch head就是一款能连接ElasticSearch搜索引擎，并提供可视化的操作页面对ElasticSearch搜索引擎进行各种设置和数据检索功能的管理插件，如在head插件页面编写RESTful接口风格的请求，就可以对ElasticSearch中的数据进行增删改查、创建或者删除索引等操作。类似于使用navicat工具连接MySQL这种关系型数据库，对数据库做操作。

2 本地安装

下面简单介绍下ES环境安装和Elasticsearch Head在chrome浏览器中插件安装。

2.1 ES安装

安装链接： https://www.elastic.co/cn/webinars/getting-started-elasticsearch?elektra=what-is-elasticsearch&storm=hero-banner-cta&rogue=gs-with-elasticsearch-webinar
1.双击运行

2.启动成功日志

3.查看版本信息
访问地址： http://localhost:9200/ 出现如下信息：

2.2 head插件安装

安装链接： https://chrome.google.com/webstore/detail/multi-elasticsearch-head/cpmmilfkofbeimbmgiclohpodggeheim?hl=zh-CN
git地址： https://github.com/mobz/elasticsearch-head
1.打开head后效果

重要信息，集群健康值。Elasticsearch 中其实有专门的衡量索引健康状况的标志，分为三个等级：

green，绿色。这代表所有的主分片和副本分片都已分配。你的集群是 100% 可用的。
yellow，黄色。所有的主分片已经分片了，但至少还有一个副本是缺失的。
red，红色。至少一个主分片以及它的全部副本都在缺失中。

3 基本查询

3.1 检索关键字

1.must子句
文档必须匹配must所有子句查询

2.should子句
文档应该匹配should子句查询的至少一个

3.must_not子句
文档不能匹配该查询条件，相当于“！=”

3.2 检索条件

match：分词匹配
term：表示精确匹配
wildcard：通配符匹配
prefix：前缀匹配
range：区间查询
query_string：允许在单个查询字符串中指定AND
text：文本
missing：无值（类似于sql中IS NULL）

4 复合查询

ES以RESTful接口风格的请求，使用json进行复杂的查询。请求格式： http://ip:port/索引/类型/文档Id

4.1 查询数据（GET）

user/user/BmH494EB0DXGzMoya1Bu

查询官方文档： https://www.elastic.co/guide/cn/elasticsearch/guide/current/query-dsl-intro.html

4.2 插入数据（PUT、POST）

PUT方法需要指明id

POST方法自动生成id

4.3 更新数据（PUT）

4.4 删除数据（DELETE）

4.5 给索引添加字段

user/user/_mapping也可以添加成功

5 具体实践

纯配ECLP运单数据除了落mysql数据库同时也会存储ES，商家工作台导出、运单列表功能就是查询ES数据。
例如下面就是根据运单号查询运单数据：

工作中需要在运单扩展表上增加字段，除了mysql数据表需要增加字段外，ES也要增加字段。lwb_main就是运单数据索引，给lwb_main索引增加字段执行语句如下：lwb_main/_mapping/lwb_main?pretty，pretty主要做美化作用，也可不要。

6 总结

Elasticsearch Head插件直接在chrome浏览器安装后就可以使用，非常方便，对于初学者大有益处，使用head插件可以快速实现ES索引数据的增删改查、创建或者删除索引等操作。

看了我常用的IDEA插件，同事也开始悄悄安装了...

Tue, 06 Sep 2022 09:40:34 CST

IDEA是程序员用的最多的开发工具，很多程序员想把它打造成一站式开发工具，于是安装了各种各样的插件。通过插件在IDEA中完成各种操作，无需安装其他软件，确实很方便！今天给大家分享下我平时常用的IDEA插件，个个是精品！

SpringBoot实战电商项目mall（50k+star）地址： https://github.com/macrozheng/mall

Key Promoter X

Key Promoter X 是一款帮助你快速学习IDEA快捷键的插件，当你在IDEA中用鼠标点击某些功能时，它会自动提示你使用该功能的快捷键。它能让你更轻松地摆脱使用鼠标功能，从而只使用键盘来开发，这大概是刚开始使用IDEA的程序员最需要的插件了。

当我们使用鼠标完成某些工作时，Key Promoter X会提示对应的快捷键，方便我们更快地掌握IDEA的快捷键。

Lombok

Lombok目前已经是开发Java应用的标配了，不仅SpringBoot默认支持它，连IDEA也内置了Lombok插件，无需安装即可使用。Lombok是一款Java代码功能增强库，通过Lombok的注解，你可以不用再写getter、setter、equals等方法，Lombok将在编译时为你自动生成。

举个例子，当我们给一个类添加@Getter和@Setter注解后；

  /**
 * 修改订单费用信息参数
 * Created by macro on 2018/10/29.
 */
@Getter
@Setter
public class OmsMoneyInfoParam {
    @ApiModelProperty("订单ID")
    private Long orderId;
    @ApiModelProperty("运费金额")
    private BigDecimal freightAmount;
    @ApiModelProperty("管理员后台调整订单所使用的折扣金额")
    private BigDecimal discountAmount;
    @ApiModelProperty("订单状态：0->待付款；1->待发货；2->已发货；3->已完成；4->已关闭；5->无效订单")
    private Integer status;
}

Lombok就会为我们自动生成所有属性的Getter和Setter方法，无需我们再手写，具体使用可以参考 Lombok的使用。

MyBatisX

MybatisX是一款基于IDEA的快速开发插件，由MyBatis-Plus团队开发维护，提示很全功能也很强大。支持xml和Mapper接口之间的跳转，自带图形化的代码生成器，可以通过类似JPA的方式，直接根据方法名称生成SQL实现。

我们点击Mapper接口方法左侧的图标可以直接跳转到xml中对应的SQL实现，在xml点击左侧图标也可以直接跳转到Mapper接口中对应的方法。

当我们创建符合JPA规范的方法时，能直接生成SQL实现无需手写，MyBatisX的功能很强大，详细使用可以参考 MybatisX插件的使用。

RestfulFastRequest

RestfulFastRequest号称是IDEA版本的Postman，它是一个功能强大的Restful API工具包插件，可以根据已有的方法快速生成接口调试用例。它有一个漂亮的界面来完成请求、检查服务器响应、存储你的API请求和导出API请求，该插件能帮助你在IDEA内更快更高效地调试API！

下面是使用RestfulFastRequest调试API接口的一张效果图，用起来还是非常方便的，具体使用可以参考 RestfulFastRequest插件的使用。

PlantUML

PlantUML是一款开源的UML图绘制工具，支持通过文本来生成图形，使用起来非常高效。可以支持时序图、类图、对象图、活动图、思维导图等图形的绘制。

下面使用PlantUML来绘制一张流程图，可以实时预览，速度也很快，具体使用可以参考 PlantUML插件的使用。

SequenceDiagram

SequenceDiagram是一款能根据代码生成时序图的插件，还支持在时序图上直接导航到对应代码以及导出为图片或PlantUML文件。

下面是一张使用SequenceDiagram制作的时序图，还是非常不错的，具体使用可以参考 SequenceDiagram插件的使用。

GsonFormatPlus

一款能根据JSON字符串自动生成实体类的插件，支持Lombok。

选择类名，右键生成，输入JSON字符串即可快速生成对应实体类。

Json Parser

一款简单小巧的JSON格式化插件，还在使用在线工具格式化JSON？试试这款IDEA插件吧！

直接打开右侧面板，输入JSON字符串即可快速格式化，支持折叠显示。

String Manipulation

一款专业处理字符串的插件，支持各种格式代码命名方式的切换、支持各种语言的转义和反转义、支持字符加密、支持多个字符的排序、对齐、过滤等。总之功能很强大，有需要字符串操作时，可以试试它。

选中需要处理的字符串，右键打开菜单即可开始使用。

MapStruct support

MapStruct是一款基于Java注解的对象属性映射工具，使用的时候我们只要在接口中定义好对象属性映射规则，它就能自动生成映射实现类，不使用反射，性能优秀。

当我们使用它的IDEA插件时，他能自动提示映射对象所包含的属性，并且在点击属性时能跳转到对应属性，具体使用可以参考 MapStruct的使用。

Alibaba Java Coding Guidelines

阿里巴巴《Java 开发手册》配套插件，可以实时检测代码中不符合手册规约的地方，助你码出高效，码出质量。

比如说手册里有这么一条：

当我们违反手册规约时，该插件会自动检测并进行提示。

同时提供了一键检测所有代码规约情况和切换语言的功能。

如果你想修改某条规约的检测规则的话，可以通过设置的 Editor->Inspections进行修改。

Alibaba Cloud Toolkit

CloudToolkit是阿里出品的一款IDEA插件，通过它我们可以更方便地实现自动化部署，其内置的终端工具和文件上传功能，即使用来管理服务器也非常方便！这款IDEA插件不仅功能强大，而且完全免费！

配置好服务器后，通过它可以一件打包上传到服务器，然后自动执行指定的脚本。

其内置了一个终端工具，提示还挺全的，如果你想在IDEA里管理Linux服务器，不妨可以试试，具体使用可以参考 CloudToolkit插件的使用。

arthas idea

基于IDEA开发的Arthas命令生成插件，支持Arthas官方常用的命令，比如 watch、trace、ognl static、ognl bean method、field、monitor、stack 、tt等命令。

直接打开右键菜单，选择Arthas命令即可快速生成命令，具体使用可以参考 Arthas使用教程。

Docker

IDEA官方提供的Docker插件，已内置，支持远程Docker环境的镜像和容器管理，同时支持使用Docker Compose实现批量部署。

通过它能自动打包应用的镜像，jar包会直接上传到远程服务器并打包成镜像，具体使用可以参考 IDEA官方Docker插件的使用。

Maven Helper

解决Maven依赖冲突的好帮手，可以快速查找项目中的依赖冲突，并予以解决！

我们可以通过 pom.xml文件底部的 依赖分析标签页查看当前项目中的所有依赖。

通过 冲突按钮我们可以筛选出所有冲突的依赖，当前项目 guava依赖有冲突，目前使用的是 18.0版本。

选中有冲突的依赖，点击 Exclude按钮可以直接排除该依赖。

同时 pom.xml中也会对该依赖添加 <exclusion>标签，是不是很方便啊！

Grep Console

一款帮你分析控制台日志的插件，可以对不同级别的日志进行不同颜色的高亮显示，还可以用来按关键字搜索日志内容。

当项目打印日志的时候，可以发现不同日志级别的日志会以不同颜色来显示。

如果你需要修改配色方案的话，可以通过 Tools打开该插件的配置菜单。

然后通过配置菜单修改配色方案。

可以通过在控制台右键并使用 Grep按钮来调出日志分析的窗口。

然后直接通过关键字来搜索即可。

Markdown

IDEA官方出品的一款Markdown插件，支持编辑Markdown文件并进行预览，对于习惯了使用IDEA的小伙伴还是非常方便的。

使用它来编辑Markdown文件最方便的地方在于，可以直接使用IDEA提供的各种快捷键，无需适应一套新的快捷键。

Translation

一款翻译插件，支持Google、有道、阿里、百度翻译，对我们看源码时翻译注释很有帮助！

直接选中需要翻译的内容，点击右键即可找到翻译按钮；

直接使用 翻译文档可以将整个文档都进行翻译；

还可以通过右上角的翻译按钮直接翻译指定内容。

Statistic

一款代码统计工具，可以用来统计当前项目中代码的行数和大小。

我们可以通过顶部菜单中的 View->Tool Windows->Statistic按钮开启该功能。

此时就可以看到我们项目代码的统计情况了，比如我的开源项目 mall中 java代码大小为 2818kB，行数为 85645。

Vue.js

Vue.js支持插件，写过前端的朋友肯定用过，可以根据模板创建 .vue文件，也可以对Vue相关代码进行智能提示。

启用该插件后，可以根据模板新建 .vue文件。

当我们在标签中写入以 v-开头的代码时，会提示Vue中的相关指令。

总结

以上是我常用的20款IDEA插件，涵盖了大部分应用场景，平时开发的时候基本上也够用了。不过IDEA插件虽然能增强它的功能，给我们提供一站式的开发体验，但是也不要安装过多，太多了容易卡！

Kubernetes容器网络及Flannel插件详解

Mon, 30 May 2022 15:07:54 CST

theme: smartblue highlight: a11y-dark

持续创作，加速成长！这是我参与「掘金日新计划 · 6 月更文挑战」的第2天，点击查看活动详情

1.1.容器网络基础

Kubernetes是一个开源容器调度编排引擎，管理大规模容器化应用，采用典型的Master-Worker主从分布式技术架构，由集中式管理节点（Master Node）,分布式的工作节点（Worker Node）组成。向下屏蔽底层差异化的分布式基础设施，以应用为中心构建云计算的基础操作系统能力（即云原生操作系统），面向用户提供云原生时代的云计算的新界面。

其中，Kubernetes网络至关重要，如果管理节点是控制大脑，运行节点是执行载体，那么网络就是将整个容器集群打通形成一个整体的神经网络；与Docker网络相比，Kubernetes网络最大的特点就是让容器组（Pod）拥有自己的身份证，即独立IP，实现在任何节点上的Pod都可以互相直接通信，而不需要任何的NAT地址转换；在不做限制时，Pod可以访问任何网络，并且拥有独立的网络栈，集群内部可见地址与外部可见地址保持一致。

在容器网络的具体实现上，Kubernetes通过开放的CNI标准，以插件化方式引入多种容器网络实现，从而支持各种差异化的场景的需求；当前社区比较常见的网络插件主要有Flannel、Calico、Cilium、OVN等，每个插件有不同的模式，需要按照实际的场景来选择使用。按照POD通信方式，有同主机的容器通信与跨主机的容器通信两大类型。

（一）同主机的容器通信

在kubernetes集群的节点上，会创建一个veth(virtual ethernet）虚拟设备，同时将veth一端插入到容器网络的命名空间中，一端连接到主机上的网桥（linux bridge）。这样在同一主机上的POD通过veth实现IP地址相互通信。网桥也会分配一个IP地址，充当从POD到不同节点的出口流量网关。

（二）跨主机的容器通信

在不同主机上运行的容器POD通过IP地址相互通信，需要通过网络插件实现，按照依赖底层的技术大致可以分为Overlay模式，路由模式，Underlay模式三大类：

①　Overlay模式是在二层或三层网络之上再构建起来一个独立的网络，这个网络通常会有自己独立的IP地址空间、交换或者路由的实现。VXLAN协议是目前最流行的Overlay网络隧道协议之一，显著优势就是灵活，对底层网络没有侵入性。

②　路由模式放弃了跨主机容器在L2的连通性，而专注于通过路由协议提供容器在L3的通信方案；路由模式更易于集成到现在的数据中心的基础设施之上，便捷地连接容器和主机，并在报文过滤和隔离方面有着更好的扩展能力及更精细的控制模型。

③　Underlay模式是借助驱动程序将宿主机的底层网络接口直接暴露给容器使用的一种网络构建技术，较为常见的解决方案有MAC VLAN、IP VLAN和直接路由等。

1.2.Flannel网络插件

Flannel是由go语言开发，是一种基于overlay网络的跨主机容器网络插件。Flannel插件为集群中所有节点重新规划IP地址的分配规则，使得不同节点上的容器能够在同一个子网内，且IP地址不重复，实现不同节点上的容器通过内网IP直接通信。Flannel目前支持udp、vxlan、host-gw、aws-vpc、gce和alloc路由等多种灵活模式。但Flannel缺少必要的安全隔离，Qos等能力，适合常见简单，安全隔离要求较低的场景。以下是Flannel三种模式比较：

模式	底层网络要求	实现模式	封包/解包	overlay网络	转发效率
Flannel UDP	三层网络	overlay	用户态	三层	低
Flannel VXLAN	三层网络	overlay	内核态	二层	中
Flannel host-gw	二层网络	路由	无	三层	高

在Flannel VXLAN模式时，插件会在kubernetes集群的每个节点上创建vxlan设备与路由表。发往不同主机上容器数据包都会通过vxlan设备，封装成UDP数据发往目的地；在目的主机上，封装的UDP数据包会被解压并路由到目标POD。但是具体到POD如何分配IP，以及整个容器生命周期过程中CNI插件与其他组件怎么交互配合，是一个相当复杂的过程，本文通过Flannel插件，以及容器运行时Containerd，详细的说明容器网络运行的全过程。

1.3.Kubelet、Container Runtime和CNI插件

1.3.1.Pod IP地址分配机制

当节点首次向集群注册时，nodeipam作为选项传递给kube-controller-manager的--controllers参数，控制器就会从集群CIDR（集群网络的IP范围）中为每个节点分配一个专用子网（podCIDR）。由于节点子网podCIDR保证不会重复，所以在为节点POD分配的IP地址也确保了唯一；如果需要更改节点的podCIDR，可以通过取消注册节点再重新注册实现。使用以下命令列出节点的podCIDR：

  $ kubectl get no-o json | jq '.spec.podCIDR'10.244.0.0/24

1.3.2.Pod启动时网络配置过程

当一个POD被调度到节点时，会有很多初始化操作，以下是网络配置相关的配置及初始化过程详细步骤：

①　POD被调度到容器集群的某个节点上

②　节点的kubelet通过调用CRI插件来创建POD

③　CRI插件创建POD Sandbox ID与POD网络命名空间

④　CRI插件通过POD网络命名空间和POD Sandbox ID来调用CNI插件

⑤　CNI插件配置POD网络，调用顺序从Flannel CNI插件，Bridge CNI 插件到主机IPAM CNI 插件，最后返回POD IP地址。

⑥　创建Pause容器，并将其添加第三步创建的POD的网络命名空间

⑦　Kubelet调用CRI插件拉取应用容器镜像

⑧　容器运行时containerd拉取应用容器镜像

⑨　Kubelet调用CRI插件来启动应用容器

⑩　CRI插件调用容器运行时containerd来启动和配置在pod cgroup和namespaces中的应用容器。

1.3.3.CRI插件与CNI插件的交互

在POD初始化过程中，CRI插件会调用CNI插件来完成对POD网络的配置。CNI网络插件都会在kubernetes节点上安装配置代理，并附带CNI配置，然后CRI插件通过该配置来确定要调用那个CNI插件。CNI配置文件的位置默认值为/etc/cni/net.d/，可以自定义配置。同时在每个节点上都会有CNI插件，CNI插件位置默认值为/opt/cni/bin，也可以自定义配置。在containerd作为容器运行时，CNI配置和CNI插件二进制文件的路径可以在containerd配置的[plugins."io.containerd.grpc.v1.cri".cni]中指定。

对于Flannel插件，Flanneld作为Flannel守护进程，通常安装在 kubernetes集群的节点上，而install-cni作为init容器，在每个节点上创建 CNI配置文件-/etc/cni/net.d/10-flannel.conflist。Flanneld创建vxlan设备，从API-SERVER获取并监听POD网络元数据。在创建POD时，为整个集群中的所有POD分配路由，通过路由实现POD IP地址相互通信。CRI插件与CNI插件之间的交互如下：

①　Kubelet通过CRI插件调用容器运行时

②　CRI插件通过CNI配置文件调用CNI插件，为POD创建网络命名空间，网络命名空间在/var/run/netns/文件下

③　Flannel CNI插件配置和调用Bridge CNI plugin

④　Bridge CNI插件在主机上创建cniO网桥，并创建了veth对，一端插入容器网络命名空间，另一端连接到cniO网桥。然后调用已配置的IPAM 插件。

⑤　host-local IPAM插件返回容器的IP地址和网关（cniO桥作为容器的网关），将IP地址分配给POD，桥接插件将网关IP地址分配给cniO桥接。所有分配的IP地址都存储在本地磁盘上的/var/lib/cni/networks/cni0/目录下。

1.3.4.CNI插件间的交互

CNI插件配置POD网络，调用顺序从Flannel CNI插件，Bridge CNI 插件到主机IPAM CNI 插件，最后返回POD IP地址。详情如下：

①　Flannel CNI插件：Containerd CRI插件使用CNI配置文件- /etc/cni/net.d/10-flannel.conflist调用Flannel CNI插件：

  $ cat /etc/cni/net.d/10-flannel.conflist{  "name": "cni0",  "plugins": [    {      "type": "flannel",      "delegate": {       "ipMasq": false,        "hairpinMode": true,        "isDefaultGateway": true      }    }  ]}

当Flanneld启动时，会从API-SERVER获取podCIDR和其他与网络相关的详细信息，并存储在 -/run/flannel/subnet.env文件中：

  FLANNEL_NETWORK=10.244.0.0/16 
FLANNEL_SUBNET=10.244.0.1/24
FLANNEL_MTU=1450 
FLANNEL_IPMASQ=false

Flannel CNI插件使用/run/flannel/subnet.env中的信息来配置和调用网桥CNI插件。

②　Bridge CNI插件：Flannel CNI插件调用Bridge CNI插件，配置如下：

  {
  "name": "cni0",
  "type": "bridge",
  "mtu": 1450,
  "ipMasq": false,
  "isGateway": true,
  "ipam": {
    "type": "host-local",
    "subnet": "10.244.0.0/24"
  }
}

首次调用Bridge CNI插件时，会创建一个linux网桥，并在配置文件中指定“名称”：“cni0”。然后为每一个POD创建veth对，veth对一端位于容器的网络命名空间中，另一端连接到主机网络的网桥上，使用 Bridge CNI插件，主机上的所有容器都连接到主机网络的网桥上。

配置veth对后，Bridge插件调用主机本地IPAM CNI插件，可以在CNI config CRI插件中配置使用具体IPAM 插件。

③　主机本地 IPAM CNI 插件：Bridge CNI插件使用以下配置调用主机本地 IPAM CNI 插件：

  {
  "name": "cni0",
  "ipam": {
    "type": "host-local",
    "subnet": "10.244.0.0/24",
    "dataDir": "/var/lib/cni/networks"
  }
}

Host-local IPAM（IP地址管理）插件从子网返回容器的IP地址，并将分配的IP本地存储在主机上dataDir下指定的目录下- /var/lib/cni/networks/。/var/lib/cni/networks/文件包含分配 IP 的容器 ID。

调用时，主机本地IPAM 插件返回以下结果：

  {
  "ip4": {
    "ip": "10.244.4.2",
    "gateway": "10.244.4.3"
  },
  "dns": {}
}

1.4.总结

总体来说，容器网络是Kubernetes最复杂部分，同时也是设计精华所在，通过CNI标准开放，根据实际需求实现不同的CNI来满足差异化的需求，尤其是与底层基础云能力深度集成的场景，每个云厂商都有实现各自高效的网络插件。整个容器网络大致从以下三个方面理解：

首先，在整体设计上，让POD有唯一的IP地址，通过为每个节点分配一个子网，从而保证节点为POD分配的IP地址，在整个集群内部不会重复。

其次，在容器网络是实现上，通过CNI将容器网络标准与具体实现解耦分类，通过插件引入不同的容器网络插件。

最后，在容器POD创建时，通过Kubelet，CRI插件，以及CNI插件相互配合，实现容器POD网络配置及初始化。

Spring Boot 如何热加载jar实现动态插件？

Sun, 17 Oct 2021 10:21:06 CST

一、背景

动态插件化编程是一件很酷的事情，能实现业务功能的解耦便于维护，另外也可以提升 可扩展性 随时可以在不停服务器的情况下扩展功能，也具有非常好的 开放性 除了自己的研发人员可以开发功能之外，也能接纳第三方开发商按照规范开发的插件。

常见的动态插件的实现方式有 SPI、 OSGI 等方案，由于脱离了 Spring IOC 的管理在插件中无法注入主程序的 Bean 对象，例如主程序中已经集成了 Redis 但是在插件中无法使用。

本文主要介绍在 Spring Boot 工程中热加载 jar 包并注册成为 Bean 对象的一种实现思路，在动态扩展功能的同时支持在插件中注入主程序的 Bean 实现功能更强大的插件。

二、热加载 jar 包

通过指定的链接或者路径动态加载 jar 包，可以使用 URLClassLoader 的 addURL 方法来实现，样例代码如下：

ClassLoaderUtil 类

public class ClassLoaderUtil {     
    public static ClassLoader getClassLoader(String url) {     
        try {     
            Method method = URLClassLoader.class.getDeclaredMethod("addURL", URL.class);     
            if (!method.isAccessible()) {     
                method.setAccessible(true);     
            }     
            URLClassLoader classLoader = new URLClassLoader(new URL[]{}, ClassLoader.getSystemClassLoader());     
            method.invoke(classLoader, new URL(url));     
            return classLoader;     
        } catch (Exception e) {     
            log.error("getClassLoader-error", e);     
            return null;     
        }     
    }     
}

其中在创建 URLClassLoader 时，指定当前系统的 ClassLoader 为父类加载器 ClassLoader.getSystemClassLoader() 这步比较关键，用于打通主程序与插件之间的 ClassLoader ，解决把插件注册进 IOC 时的各种 ClassNotFoundException 问题。

三、动态注册 Bean

将插件 jar 中加载的实现类注册到 Spring 的 IOC 中，同时也会将 IOC 中已有的 Bean 注入进插件中；分别在程序启动时和运行时两种场景下的实现方式。

3.1. 启动时注册 Bean

使用 ImportBeanDefinitionRegistrar 实现在 Spring Boot 启动时动态注册插件的 Bean，样例代码如下：

PluginImportBeanDefinitionRegistrar 类

public class PluginImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {     
    private final String targetUrl = "file:/D:/SpringBootPluginTest/plugins/plugin-impl-0.0.1-SNAPSHOT.jar";     
    private final String pluginClass = "com.plugin.impl.PluginImpl";     
     
    @SneakyThrows     
    @Override     
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {     
        ClassLoader classLoader = ClassLoaderUtil.getClassLoader(targetUrl);     
        Class<?> clazz = classLoader.loadClass(pluginClass);     
        BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(clazz);     
        BeanDefinition beanDefinition = builder.getBeanDefinition();     
        registry.registerBeanDefinition(clazz.getName(), beanDefinition);     
    }     
}

3.2. 运行时注册 Bean

程序运行时动态注册插件的 Bean 通过使用 ApplicationContext 对象来实现，样例代码如下：

@GetMapping("/reload")     
public Object reload() throws ClassNotFoundException {     
        ClassLoader classLoader = ClassLoaderUtil.getClassLoader(targetUrl);     
        Class<?> clazz = classLoader.loadClass(pluginClass);     
        springUtil.registerBean(clazz.getName(), clazz);     
        PluginInterface plugin = (PluginInterface)springUtil.getBean(clazz.getName());     
        return plugin.sayHello("test reload");     
}

SpringUtil 类

@Component     
public class SpringUtil implements ApplicationContextAware {     
    private DefaultListableBeanFactory defaultListableBeanFactory;     
    private ApplicationContext applicationContext;     
     
    @Override     
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {     
        this.applicationContext = applicationContext;     
        ConfigurableApplicationContext configurableApplicationContext = (ConfigurableApplicationContext) applicationContext;     
        this.defaultListableBeanFactory = (DefaultListableBeanFactory) configurableApplicationContext.getBeanFactory();     
    }     
     
    public void registerBean(String beanName, Class<?> clazz) {     
        BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(clazz);     
        defaultListableBeanFactory.registerBeanDefinition(beanName, beanDefinitionBuilder.getRawBeanDefinition());     
    }     
     
    public Object getBean(String name) {     
        return applicationContext.getBean(name);     
    }     
}

四、总结

本文介绍的插件化实现思路通过 共用 ClassLoader 和 动态注册 Bean 的方式，打通了插件与主程序之间的类加载器和 Spring 容器，使得可以非常方便的实现插件与插件之间和插件与主程序之间的 类交互，例如在插件中注入主程序的 Redis、DataSource、调用远程 Dubbo 接口等等。

但是由于没有对插件之间的 ClassLoader 进行隔离也可能会存在如类冲突、版本冲突等问题；并且由于 ClassLoader 中的 Class 对象无法销毁，所以除非修改类名或者类路径，不然插件中已加载到 ClassLoader 的类是没办法动态修改的。

所以本方案比较适合插件数据量不会太多、具有较好的开发规范、插件经过测试后才能上线或发布的场景。

五、完整 demo

https://github.com/zlt2000/springs-boot-plugin-test

Spring Boot 如何热加载 jar 实现动态插件？

Tue, 19 Oct 2021 00:00:00 CST

一、背景

动态插件化编程是一件很酷的事情，能实现业务功能的 「解耦」便于维护，另外也可以提升 「可扩展性」随时可以在不停服务器的情况下扩展功能，也具有非常好的 「开放性」除了自己的研发人员可以开发功能之外，也能接纳第三方开发商按照规范开发的插件。

常见的动态插件的实现方式有 SPI、 OSGI等方案，由于脱离了 Spring IOC 的管理在插件中无法注入主程序的 Bean 对象，例如主程序中已经集成了 Redis 但是在插件中无法使用。

二、热加载 jar 包

通过指定的链接或者路径动态加载 jar 包，可以使用 URLClassLoader的 addURL方法来实现，样例代码如下：

「ClassLoaderUtil 类」

  public class ClassLoaderUtil {   
    public static ClassLoader getClassLoader(String url) {   
        try {   
            Method method = URLClassLoader.class.getDeclaredMethod("addURL", URL.class);   
            if (!method.isAccessible()) {   
                method.setAccessible(true);   
            }   
            URLClassLoader classLoader = new URLClassLoader(new URL[]{}, ClassLoader.getSystemClassLoader());   
            method.invoke(classLoader, new URL(url));   
            return classLoader;   
        } catch (Exception e) {   
            log.error("getClassLoader-error", e);   
            return null;   
        }   
    }   
}

其中在创建 URLClassLoader时，指定当前系统的 ClassLoader 为父类加载器 ClassLoader.getSystemClassLoader()这步比较关键，用于打通主程序与插件之间的 ClassLoader ，解决把插件注册进 IOC 时的各种 ClassNotFoundException 问题。

三、动态注册 Bean

将插件 jar 中加载的实现类注册到 Spring 的 IOC 中，同时也会将 IOC 中已有的 Bean 注入进插件中；分别在程序启动时和运行时两种场景下的实现方式。

3.1. 启动时注册

使用 ImportBeanDefinitionRegistrar 实现在 Spring Boot 启动时动态注册插件的 Bean，样例代码如下： 「PluginImportBeanDefinitionRegistrar 类」

  public class PluginImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {   
    private final String targetUrl = "file:/D:/SpringBootPluginTest/plugins/plugin-impl-0.0.1-SNAPSHOT.jar";   
    private final String pluginClass = "com.plugin.impl.PluginImpl";   
   
    @SneakyThrows   
    @Override   
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {   
        ClassLoader classLoader = ClassLoaderUtil.getClassLoader(targetUrl);   
        Class<?> clazz = classLoader.loadClass(pluginClass);   
        BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(clazz);   
        BeanDefinition beanDefinition = builder.getBeanDefinition();   
        registry.registerBeanDefinition(clazz.getName(), beanDefinition);   
    }   
}

3.2. 运行时注册

程序运行时动态注册插件的 Bean 通过使用 ApplicationContext对象来实现，样例代码如下：

  @GetMapping("/reload")   
public Object reload() throws ClassNotFoundException {   
  ClassLoader classLoader = ClassLoaderUtil.getClassLoader(targetUrl);   
  Class<?> clazz = classLoader.loadClass(pluginClass);   
  springUtil.registerBean(clazz.getName(), clazz);   
  PluginInterface plugin = (PluginInterface)springUtil.getBean(clazz.getName());   
  return plugin.sayHello("test reload");   
}

「SpringUtil 类」

  @Component   
public class SpringUtil implements ApplicationContextAware {   
    private DefaultListableBeanFactory defaultListableBeanFactory;   
    private ApplicationContext applicationContext;   
   
    @Override   
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {   
        this.applicationContext = applicationContext;   
        ConfigurableApplicationContext configurableApplicationContext = (ConfigurableApplicationContext) applicationContext;   
        this.defaultListableBeanFactory = (DefaultListableBeanFactory) configurableApplicationContext.getBeanFactory();   
    }   
   
    public void registerBean(String beanName, Class<?> clazz) {   
        BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(clazz);   
        defaultListableBeanFactory.registerBeanDefinition(beanName, beanDefinitionBuilder.getRawBeanDefinition());   
    }   
   
    public Object getBean(String name) {   
        return applicationContext.getBean(name);   
    }   
}

四、总结

本文介绍的插件化实现思路通过 「共用 ClassLoader」和 「动态注册 Bean」的方式，打通了插件与主程序之间的类加载器和 Spring 容器，使得可以非常方便的实现插件与插件之间和插件与主程序之间的 「类交互」，例如在插件中注入主程序的 Redis、DataSource、调用远程 Dubbo 接口等等。

但是由于没有对插件之间的 ClassLoader进行 「隔离」也可能会存在如类冲突、版本冲突等问题；并且由于 ClassLoader 中的 Class 对象无法销毁，所以除非修改类名或者类路径，不然插件中已加载到 ClassLoader 的类是没办法动态修改的。

所以本方案比较适合插件数据量不会太多、具有较好的开发规范、插件经过测试后才能上线或发布的场景。

五、完整 demo

https://github.com/zlt2000/springs-boot-plugin-test

本地elasticsearch-head插件的安装与使用

Fri, 10 Apr 2020 01:36:47 CST

上一篇谈到在Ubuntu16.04中安装elasticsearch，这一篇我们来谈谈如何在本地机器中安装elasticsearch-head插件，进行ES可视化管理

环境配置

Node JS版本：10.16.0
虚拟机中已经安装好elasticsearch，版本：5.6.8

安装elasticsearch-head

安装NodeJS

elasticsearch-head 是在nodejs环境下运行的，因此必须提前安装好NodeJS，安装教程可参考此篇博客，够详细了： NodeJS 安装及环境配置

安装好后，在cmd命令行中键入

node -v

得到如下版本信息，便安装成功

1 2	C:\Users\Administrator>node -v v10.16.0

安装grunt

运行elasticsearch-head需要借助grunt命令，因此需要安装grunt。打开命令行窗口进入nodejs 安装目录，运行以下命令

1	npm install -g grunt -cli

如果没有报错就安装成功

PS D:\nodejs> npm install -g grunt-cli     
D:\nodejs\node_global\grunt -> D:\nodejs\node_global\node_modules\grunt-cli\bin\grunt     
+ grunt-cli@1.3.2     
added 150 packages from 121 contributors in 23.241s

下载elasticsearch-head

进入网址： https://github.com/mobz/elasticsearch-head 下载整个项目到本地目录下并进行解压，我将解压后的目录放在了D盘

下载ES-head

解压后的head文件

Gruntfile.js 是个配置文件，里面可以配elasticsearch-head在本地的端口

npm安装elasticsearch-head

使用命令行进入elasticsearch-head 目录，执行下述命令

1	npm install

进行npm安装，如果没有报错则安装成功

npm安装

如果提示

npm ERR! code ELIFECYCLE     
npm ERR! errno 1     
npm ERR! phantomjs-prebuilt@2.1.16 install: `node install.js`     
npm ERR! Exit status 1     
npm ERR!     
npm ERR! Failed at the phantomjs-prebuilt@2.1.16 install script.     
npm ERR! This is probably not a problem with npm. There is likely additional logging output above.     
     
npm ERR! A complete log of this run can be found in:     
npm ERR!     D:\nodejs\node_cache\_logs\2020-04-09T15_58_31_720Z-debug.log

这种错误，则先执行以下命令

1	npm install phantomjs-prebuilt@2.1.14 --ignore-scripts

安装成功后再执行 npm install，就会发现没有报错了

修改虚拟机中的elasticsearch配置

先将运行中的ES停掉，如果有的话，然后进入编辑虚拟机中的/usr/local/elasticsearch-5.6.8/conf/elasticsearch.yml 文件，添加下述两行代码

1 2	http.cors.enabled: true http.cors.allow-origin: "*"

http.cors.enabled：表示是否支持跨域，默认为false
http.cors.allow-origin：当设置允许跨域，默认为*,表示支持所有域名，如果我们只是允许某些网站能访问，那么可以使用正则表达式。比如只允许本地地址。 /https?:\/\/localhost(:[0-9]+)?/

编辑完后保存并退出，重新运行虚拟机中的ES

运行elasticsearch-head

上述安装和配置都完成后，在本地主机命令行中键入 grunt server 运行elasticsearch-head，得到如下提示则运行成功

PS D:\elasticsearch-head-master> grunt server     
Running "connect:server" (connect) task     
Waiting forever...     
Started connect web server on http://localhost:9100

此时就可以在浏览器中输入 http://localhost:9100 打开elasticsearch-head
然后在连接栏中输入虚拟机IP:9200 进行连接，便能连接上虚拟机中的ES

打开ES-head

连接虚拟机中的ES

完结撒花。

k8s 重置，更换网络插件_云深不知处的技术博客_51CTO博客

Wed, 28 Jul 2021 19:27:17 CST

一，重置k8s

1，主节点：
kubectl delete node node01 node02 master
kubeadm reset
rm -rf .kube /var/log/containers /var/log/pods
2，从节点
kubeadm reset
rm -rf .kube /var/log/containers /var/log/pods

二，更换网络插件

卸载flannel：
在master节点删除flannel
kubectl delete -f kube-flannel.yml
重启kubelet
sytemctl restart kubelet
安装calico：
wget https://docs.projectcalico.org/manifests/calico.yaml
kubectl apply -f calico.yaml
安装完毕后使用docker images 查看容器镜像可以看见如下以calico打头的镜像

K8s网络插件flannel与calico - 小雨淅淅o0 - 博客园

Fri, 18 Jun 2021 17:13:32 CST

Kubernetes的网络通信问题:
　　1. 容器间通信：即同一个Pod内多个容器间通信，通常使用loopback来实现。
　　2. Pod间通信： K8s要求,Pod和Pod之间通信必须使用Pod-IP 直接访问另一个Pod-IP
　　3. Pod与Service通信：即PodIP去访问ClusterIP，当然，clusterIP实际上是IPVS 或 iptables规则的虚拟IP，是没有TCP/IP协议栈支持的。但不影响Pod访问它.
　　4. Service与集群外部Client的通信，即K8s中Pod提供的服务必须能被互联网上的用户所访问到。

需要注意的是，k8s集群初始化时的service网段，pod网段，网络插件的网段，以及真实服务器的网段，都不能相同，如果相同就会出各种各样奇怪的问题，而且这些问题在集群做好之后是不方便改的，改会导致更多的问题，所以，就在搭建前将其规划好。

CNI(容器网络接口)：
　　这是K8s中提供的一种通用网络标准规范，因为k8s本身不提供网络解决方案。
　　目前比较知名的网络解决方案有:
　　　　flannel
　　　　calico
　　　　canel
　　　　kube-router
　　　　.......
等等，目前比较常用的时flannel和calico，flannel的功能比较简单，不具备复杂网络的配置能力，calico是比较出色的网络管理插件，单具备复杂网络配置能力的同时，往往意味着本身的配置比较复杂，所以相对而言，比较小而简单的集群使用flannel，考虑到日后扩容，未来网络可能需要加入更多设备，配置更多策略，则使用calico更好
所有的网络解决方案，它们的共通性：
　　1. 虚拟网桥
　　2. 多路复用：MacVLAN
　　3. 硬件交换：SR-IOV（单根-I/O虚拟网络）：它是一种物理网卡的硬件虚拟化技术，它通过输出VF(虚拟功能)来将网卡虚拟为多个虚拟子接口，每个VF绑定给一个VM后，该VM就可以直接操纵该物理网卡。

kubelet来调CNI插件时，会到 /etc/cni/net.d/目录下去找插件的配置文件，并读取它，来加载该插件,并让该网络插件来为Pod提供网络服务。

flannel网络插件要怎么部署？
　1. flannel部署到那个节点上？
　　因为kubelet是用来管理Pod的，而Pod运行需要网络，因此凡是部署kubelet的节点，都需要部署flannel来提供网络，因为kubelet正是通过调用flannel来实现为Pod配置网络的(如:添加网络，配置网络，激活网络等)。

　2. flannel自身要如何部署？
　　1》它支持直接运行为宿主机上的一个守护进程。
　　2》它也支持运行为一个Pod
　　对于运行为一个Pod这种方式：就必须将flannel配置为共享当前宿主机的网络名称空间的Pod，若flannel作为控制器控制的Pod来运行的话，它的控制器必须是DaemonSet，在每一个节点上都控制它仅能运行一个Pod副本，而且该副本必须直接共享宿主机的网络名称空间，因为只有这样，此Pod才能设置宿主机的网络名称空间，因为flannel要在当前宿主机的网络名称空间中创建CNI虚拟接口，还要将其他Pod的另一半veth桥接到虚拟网桥上，若不共享宿主机的网络名称空间，这是没法做到的。

3. flannel的工作方式有3种:
　　1) VxLAN:
　　　而VxLAN有两种工作方式:
　　　　a. VxLAN:　这是原生的VxLAN，即直接封装VxLAN首部，UDP首部，IP，MAC首部这种的。
　　　　b. DirectRouting: 这种是混合自适应的方式, 即它会自动判断，若当前是相同二层网络
　　　　 (即：不垮路由器,二层广播可直达)，则直接使用Host-GW方式工作，若发现目标是需要跨网段
　　　　 (即：跨路由器)则自动转变为使用VxLAN的方式。
　　2) host-GW: 这种方式是宿主机内Pod通过虚拟网桥互联，然后将宿主机的物理网卡作为网关，当需要访问其它Node上的Pod时，只需要将报文发给宿主机的物理网卡，由宿主机通过查询本地路由表，来做路由转发，实现跨主机的Pod通信，这种模式带来的问题时，当k8s集群非常大时，会导致宿主机上的路由表变得非常巨大，而且这种方式，要求所有Node必须在同一个二层网络中，否则将无法转发路由，这也很容易理解，因为如果Node之间是跨路由的，那中间的路由器就必须知道Pod网络的存在，它才能实现路由转发，但实际上，宿主机是无法将Pod网络通告给中间的路由器，因此它也就无法转发理由。
　　3) UDP: 这种方式性能最差的方式，这源于早期flannel刚出现时，Linux内核还不支持VxLAN，即没有VxLAN核心模块，因此flannel采用了这种方式，来实现隧道封装，其效率可想而知，因此也给很多人一种印象，flannel的性能很差，其实说的是这种工作模式，若flannel工作在host-GW模式下，其效率是非常高的，因为几乎没有网络开销。

4. flannel的网络配置参数：
　　1) Network: flannel使用的CIDR格式的网络地址，主要用于为Pod配置网络功能。
　　　如: 10.10.0.0/16 --->
　　　　master: 10.10.0.0/24
　　　　node01: 10.10.1.0/24
　　　　.....
　　　　node255: 10.10.255.0/24

　　2) SubnetLen: 把Network切分为子网供各节点使用时，使用多长的掩码来切分子网，默认是24位.
　　3) SubnetMin: 若需要预留一部分IP时，可设置最小从那里开始分配IP，如：10.10.0.10/24 ，这样就预留出了10个IP
　　4) SubnetMax: 这是控制最多分配多个IP，如: 10.10.0.100/24 这样在给Pod分配IP时，最大分配到10.10.0.100了。
　　5) Backend: 指定后端使用的协议类型，就是上面提到的：vxlan( 原始vxlan，directrouter)，host-gw, udp

flannel的配置：
　　.....
　　net-conf.json: |
　　　　{
　　　　　"Network": "10.10.0.0/16",
　　　　　"Backend": {
　　　　　"Type": "vxlan", 　　 #当然，若你很确定自己的集群以后也不可能跨网段，你完全可以直接设置为 host-gw.
　　　　　"Directrouting": true #默认是false，修改为true就是可以让VxLAN自适应是使用VxLAN还是使用host-gw了。
　　　　　}
　　　　}

#在配置flannel时，一定要注意，不要在半道上，去修改，也就是说要在你部署k8s集群后，就直接规划好，而不要在k8s集群已经运行起来了，你再去修改，虽然可能也不会出问题，但一旦出问题，你就！！

#在配置好，flannel后，一定要测试，创建新Pod，看看新Pod是否能从flannel哪里获得IP地址，是否能通信。

Calico：
　　Calico是一种非常复杂的网络组件，它需要自己的etcd数据库集群来存储自己通过BGP协议获取的路由等各种所需要持久保存的网络数据信息，因此在部署Calico时，早期是需要单独为Calico部署etcd集群的，因为在k8s中，访问etcd集群只有APIServer可以对etcd进行读写，其它所有组件都必须通过APIServer作为入口，将请求发给APIServer，由APIServer来从etcd获取必要信息来返回给请求者，但Caclico需要自己写，因此就有两种部署Calico网络插件的方式，一种是部署两套etcd，另一种就是Calico不直接写，而是通过APIServer做为代理，来存储自己需要存储的数据。通常第二种使用的较多，这样可降低系统复杂度。
　　当然由于Calico本身很复杂，但由于很多k8s系统可能存在的问题是，早期由于各种原因使用了flannel来作为网络插件，但后期发现需要使用网络策略的需求，怎么办？
　　目前比较成熟的解决方案是：flannel + Calico, 即使用flannel来提供简单的网络管理功能，而使用Calico提供的网络策略功能。

Calico网络策略：

Egress：是出站的流量，即自己是源，远端为服务端，因此我自己的源IP可确定，但端口不可预知，目标的端口和IP都是确定的，因此to 和 ports都是指目标的IP和端口。
Ingress：是入站的流量，即自己为目标，而远端是客户端，因此要做控制，就只能对自己的端口和客户端的地址做控制。
我们通过Ingress 和 Egress定义的网络策略是对一个Pod生效还是对一组Pod生效？
这个就要通过podSelector来实现了。
而且在定义网络策略时，可以很灵活，如：入站都拒绝，仅允许出站的；或仅允许指定入站的，出站都允许等等。
另外，在定义网络策略时，也可定义在同一名称空间中的Pod都可以自由通信，但跨名称空间就都拒绝。

网络策略的生效顺序：
　　越具体的规则越靠前，越靠前，越优先匹配

网络策略的定义：
　　kubectl explain networkpolicy
　　spec:
　　　egress: <[]Object> :定义出站规则
　　　ingress: <[]Object>: 定义入站规则
　　　podSelector：如论是入站还是出站，这些规则要应用到那些Pod上。
　　　policyType：[Ingress|Egress| Ingress,Egress] :
　　　它用于定义若同时定义了egress和ingress，到底那个生效？若仅给了ingress，则仅ingress生效，若设置为Ingress,Egress则两个都生效。
　　注意：policyType在使用时,若不指定，则当前你定义了egress就egress生效，若egress,ingress都定义了,则两个都生效！！
　　　　还有，若你定义了egress，但policyType: ingress, egress ； egress定义了，但ingress没有定义,这种要会怎样？
　　　　其实，这时ingress的默认规则会生效，即：若ingress的默认规则为拒绝，则会拒绝所有入站请求，若为允许，则会允许所有入站请求，
　　　　所以，若你只想定义egress规则，就明确写egress ！！

　　egress：<[]Object>
　　 ports: <[]Object> :因为ports是有端口号和协议类型的，因此它也是对象列表
　　　port :
　　　　protocol: 这两个就是用来定义目标端口和协议的。
　　　to :<[]Object>
　　　 podSelector: <Object> : 在控制Pod通信时，可控制源和目标都是一组Pod，然后控制这两组Pod之间的访问。
　　　 ipBlock：<[]Object> : 指定一个Ip地址块，只要在这个IP范围内的，都受到策略的控制，而不区分是Pod还是Service。
　　　 namespaceSelector：这是控制对指定名称空间内的全部Pod 或部分Pod做访问控制。

　　Ingress：
　　 from：这个from指访问者访问的IP
　　 ports: 也是访问者访问的Port

#定义网络策略：
vim   networkpolicy-demo.yaml
apiVersion:  networking.k8s.io/v1  
    #注意：虽然kubectl  explain networkpolicy中显示为 extensions/v1beta1 ，但你要注意看说明部分.
kind:  NetworkPolicy
metadata:
     name:  deny-all-ingressnamespace:  dev
spec:
     podSelector:  {}  #这里写空的含义是，选择指定名称空间中所有Pod
     policyTypes:-Ingress        #这里指定要控制Ingress(进来的流量)，但又没有指定规则，就表示全部拒绝，只有明确定义的,才是允许的。
                       #egress: 出去的流量不控制，其默认规则就是允许，因为不关心，所以爱咋咋地的意思。
    
#写一个简单的自主式Pod的定义:
vim  pod1.yaml
    apiVersion:  v1
    kind: Pod
    metadata: 
      name:  pod1
    spec:
      containers:-name:  myapp
        image:  harbor.zcf.com/k8s/myapp:v1

#创建dev名称空间，并应用规则
kubectl apply-f networkpolicy-demo.yaml -n dev

# kubectl describe-n dev networkpolicies
    Name:         deny-all-ingress
    Namespace:    dev
   ........................
    Spec:
      PodSelector:<none> (Allowing the specific traffic to all podsinthisnamespace)
      Allowing ingress traffic:<none> (Selected pods are isolatedforingress connectivity)
      Allowing egress traffic:<none> (Selected pods are isolatedforegress connectivity)


#查看dev名称空间中的网络规则:
kubectlgetnetworkpolicy -n dev     
 或   
 kubectlgetnetpol  -n  dev

#然后在dev 和 prod 两个名称空间中分别创建pod
kubectl  apply-f  pod1.yaml   -n   dev
kubectl  apply-f  pod1.yaml   -n   prod

#接着测试访问这两个名称空间中的pod
kubectlgetpod  -n  dev   -o   wide
    
    #测试访问:
        curl   http://POD_IPkubectlgetpod  -n  prod   -o   wide

    #测试访问:
        curl   http://POD_IP#通过以上测试，可以看到，dev名称空间中的pod无法被访问，而prod名称空间中的pod则可被访问。

#测试放行所有dev的ingress入站请求。
# vim  networkpolicy-demo.yaml
    apiVersion:  networking.k8s.io/v1   
    kind:  NetworkPolicy
    metadata:
       name: allow-all-ingressnamespace:  dev
    spec:
       podSelector:  {}
       ingress:-{}      #这就表示允许所有，因为定义了规则，但规则是空的，即允许所有。
       policyTypes:-Ingress

#接着测试，和上面测试一样，也是访问dev 和 prod两个名称空间中的pod，若能访问，则成功。
# kubectl describe-n dev netpol
    Name:         deny-all-ingress
    Namespace:    dev
    .....................
    Spec:
      PodSelector:<none> (Allowing the specific traffic to all podsinthisnamespace)
      Allowing ingress traffic:
        To Port:<any>(traffic allowed to all ports)
        From:<any>(traffic not restricted by source)
      Allowing egress traffic:<none> (Selected pods are isolatedforegress connectivity)
      Policy Types: Ingress

#测试定义一个仅允许访问dev名称空间中，pod标签 app=myapp 的一组pod的80端口

#先给pod1打上app=myapp的标签
#kubectl label pod pod1 app=myapp -n dev
    
vim  allow-dev-80.yaml
 apiVersion: networking.k8s.io/v1
 kind: NetworkPolicy
 metadata:
    name: allow-myapp-ingress
 spec:
   podSelector:
      matchLabels:
        app: myapp
     ingress:-from:-ipBlock:
            cidr:10.10.0.0/16except:-10.10.1.2/32ports:-protocol:  TCP
         port:88-protocol:  TCP
         port:443#查看定义的ingress规则
kubectlgetnetpol  -n  dev

#然后测试访问 dev 名称空间中的pod
curl  http://Pod_IPcurl  http://Pod_IP:443curl   http://Pod_IP:88

上图测试：1. 先给dev名称空间打上标签
  kubectl   labelnamespacedev   ns=dev2. 编写网络策略配置清单
  vim  allow-ns-dev.yaml
    apiVersion: networking.k8s.io/v1
    kind: NetworkPolicy
    metadata:
      name: allow-ns-dev
    spec:
      podSelector: {}
      ingress:-from:-namespaceSelector:
              matchLabels:
                ns: dev
      egress:-to:-namespaceSelector:
             matchLabels:
               ns: dev



#要控制egress，也是如此，只是将ingress替换为egress即可，然后在做测试。
另外，关于网络策略，建议：
 名称空间内：
     拒绝所有出站，入站流量
     仅放行出站目标为当前名称空间内各Pod间通信，因为网络策略控制的颗粒度是Pod级别的，不是名称空间级别。
     具体的网络策略，要根据实际需求，来定义ingress 和 egress规则。

PostgreSQL 时序数据库插件 timescaleDB 部署实践(含例子纽约TAXI数据透视分析) - PostGIS + timescaleDB => PG时空数据库 - Digoal.Zhou’s Blog

Tue, 30 Mar 2021 14:13:02 CST

背景

现实社会中，很多业务产生的数据具有时序数据属性（在时间维度上顺序写入，同时包括大量时间区间查询统计的需求）。

例如业务的FEED数据，物联网产生的时序数据（如气象传感器、车辆轨迹、等），金融行业的实时数据等等。

PostgreSQL的UDF和BRIN（块级索引）很适合时序数据的处理。具体有以下的两个例子

《PostgreSQL 按需切片的实现(TimescaleDB插件自动切片功能的plpgsql schemaless实现)》

《PostgreSQL 时序最佳实践 - 证券交易系统数据库设计 - 阿里云RDS PostgreSQL最佳实践》

实际上PostgreSQL生态中，衍生了一个时序插件：timescaleDB。专门用于处理时序数据。（timescale的改进，包括SQL优化器的改进(支持merge append，时间片聚合非常高效)，rotate接口，自动分片等）

同时timescaleDB也非常受投资者的关注，已获5000万美金的投资，也间接说明时序数据库在未来是非常受用户欢迎的。

timescaleDB的优势

首先，timescaleDB是自动切片的，对用户无感知，在数据量非常庞大的时候，写入性能不衰减。（主要指IOPS较低的磁盘，如果IOPS较好的磁盘PG在写入大量数据后性能也是OK的。）

其次，timescale改进了SQL优化器，增加了merge append的执行节点，同时在对小时间片进行group by时，可以不用HASH或GROUP整个数据范围，而是分片计算，使得效率非常高。

最后，timescale增加了一些API，使得用户在时序数据的写入、维护、查询都非常的高效、同时易于维护。

API如下

http://docs.timescale.com/v0.8/api

部署timescaleDB

以CentOS 7.x x64为例。

1、首先要安装好PostgreSQL

参考《PostgreSQL on Linux 最佳部署手册》

        export USE_NAMED_POSIX_SEMAPHORES=1  
LIBS=-lpthread CFLAGS="-O3" ./configure --prefix=/home/digoal/pgsql10 --with-segsize=8 --with-wal-segsize=256  
LIBS=-lpthread CFLAGS="-O3" make world -j 64  
LIBS=-lpthread CFLAGS="-O3" make install-world

2、其次需要安装cmake3

        epel  
  
yum install -y cmake3  
  
ln -s /usr/bin/cmake3 /usr/bin/cmake

3、编译timescaleDB

        git clone https://github.com/timescale/timescaledb/  
  
cd timescaledb  
git checkout release-0.8.0  
  
或  
  
wget https://github.com/timescale/timescaledb/archive/0.8.0.tar.gz  
  
  
  
export PATH=/home/digoal/pgsql10/bin:$PATH  
export LD_LIBRARY_PATH=/home/digoal/pgsql10/lib:$LD_LIBRARY_PATH  
  
# Bootstrap the build system  
./bootstrap  
  
cd ./build && make  
  
make install  
  
  
[  2%] Built target sqlupdatefile  
[  4%] Built target sqlfile  
[100%] Built target timescaledb  
Install the project...  
-- Install configuration: "Release"  
-- Installing: /home/dege.zzz/pgsql10/share/extension/timescaledb.control  
-- Installing: /home/dege.zzz/pgsql10/share/extension/timescaledb--0.8.0.sql  
-- Installing: /home/dege.zzz/pgsql10/share/extension/timescaledb--0.7.1--0.8.0.sql  
-- Installing: /home/dege.zzz/pgsql10/share/extension/timescaledb--0.1.0--0.2.0.sql  
-- Installing: /home/dege.zzz/pgsql10/share/extension/timescaledb--0.2.0--0.3.0.sql  
-- Installing: /home/dege.zzz/pgsql10/share/extension/timescaledb--0.3.0--0.4.0.sql  
-- Installing: /home/dege.zzz/pgsql10/share/extension/timescaledb--0.4.0--0.4.1.sql  
-- Installing: /home/dege.zzz/pgsql10/share/extension/timescaledb--0.4.1--0.4.2.sql  
-- Installing: /home/dege.zzz/pgsql10/share/extension/timescaledb--0.4.2--0.5.0.sql  
-- Installing: /home/dege.zzz/pgsql10/share/extension/timescaledb--0.5.0--0.6.0.sql  
-- Installing: /home/dege.zzz/pgsql10/share/extension/timescaledb--0.6.0--0.6.1.sql  
-- Installing: /home/dege.zzz/pgsql10/share/extension/timescaledb--0.6.1--0.7.0.sql  
-- Installing: /home/dege.zzz/pgsql10/share/extension/timescaledb--0.6.1--0.7.1.sql  
-- Installing: /home/dege.zzz/pgsql10/share/extension/timescaledb--0.7.0--0.7.1.sql  
-- Installing: /home/dege.zzz/pgsql10/lib/timescaledb.so

4、配置postgresql.conf，在数据库启动时自动加载timescale lib库。

        vi $PGDATA/postgresql.conf  
shared_preload_libraries = 'timescaledb'  
  
pg_ctl restart -m fast

5、对需要使用timescaledb的数据库，创建插件.

        psql  
psql (10.1)  
Type "help" for help.  
  
postgres=# create extension timescaledb ;

6、timescaledb的相关参数

        timescaledb.constraint_aware_append     
timescaledb.disable_optimizations       
timescaledb.optimize_non_hypertables    
timescaledb.restoring    
  
postgres=# show timescaledb.constraint_aware_append ;  
 timescaledb.constraint_aware_append   
-------------------------------------  
 on  
(1 row)  
  
postgres=# show timescaledb.disable_optimizations ;  
 timescaledb.disable_optimizations   
-----------------------------------  
 off  
(1 row)  
  
postgres=# show timescaledb.optimize_non_hypertables ;  
 timescaledb.optimize_non_hypertables   
--------------------------------------  
 off  
(1 row)  
  
postgres=# show timescaledb.restoring ;  
 timescaledb.restoring   
-----------------------  
 off  
(1 row)

timescaleDB使用例子1 - 纽约TAXI数据透视分析

第一个例子是real-life New York City taxicab data ，

http://docs.timescale.com/v0.8/tutorials/tutorial-hello-nyc

数据为真实的数据，来自

http://www.nyc.gov/html/tlc/html/about/trip_record_data.shtml

1、下载样本数据

        wget https://timescaledata.blob.core.windows.net/datasets/nyc_data.tar.gz

2、解压

        tar -zxvf nyc_data.tar.gz

3、建表，其中包括将普通表转换为时序存储表的API create_hypertable 的使用。

        psql -f nyc_data.sql

截取一些nyc_data.sql的内容如下：

        cat nyc_data.sql  
  
-- 打车数据: 包括时长、计费、路程、上车、下车经纬度、时间、人数等等。  
  
CREATE TABLE "rides"(  
    vendor_id TEXT,  
    pickup_datetime TIMESTAMP WITHOUT TIME ZONE NOT NULL,  
    dropoff_datetime TIMESTAMP WITHOUT TIME ZONE NOT NULL,  
    passenger_count NUMERIC,  
    trip_distance NUMERIC,  
    pickup_longitude  NUMERIC,  
    pickup_latitude   NUMERIC,  
    rate_code         INTEGER,  
    dropoff_longitude NUMERIC,  
    dropoff_latitude  NUMERIC,  
    payment_type INTEGER,  
    fare_amount NUMERIC,  
    extra NUMERIC,  
    mta_tax NUMERIC,  
    tip_amount NUMERIC,  
    tolls_amount NUMERIC,  
    improvement_surcharge NUMERIC,  
    total_amount NUMERIC  
);

这句话，将rides转换为时序表存储

        SELECT create_hypertable('rides', 'pickup_datetime', 'payment_type', 2, create_default_indexes=>FALSE);

创建索引

        CREATE INDEX ON rides (vendor_id, pickup_datetime desc);  
CREATE INDEX ON rides (pickup_datetime desc, vendor_id);  
CREATE INDEX ON rides (rate_code, pickup_datetime DESC);  
CREATE INDEX ON rides (passenger_count, pickup_datetime desc);

4、导入测试数据

        psql -c "\COPY rides FROM nyc_data_rides.csv CSV"  
COPY 10906858

5、对已转换为时序存储表的rides执行一些测试SQL，性能比PostgreSQL普通表要好。

每天同车超过2人的交易，平均计费多少？

        -- Average fare amount of rides with 2+ passengers by day  
  
SELECT date_trunc('day', pickup_datetime) as day, avg(fare_amount)  
  FROM rides  
  WHERE passenger_count > 1 AND pickup_datetime < '2016-01-08'  
  GROUP BY day ORDER BY day;  
  
        day         |         avg  
--------------------+---------------------  
2016-01-01 00:00:00 | 13.3990821679715529  
2016-01-02 00:00:00 | 13.0224687415181399  
2016-01-03 00:00:00 | 13.5382068607068607  
2016-01-04 00:00:00 | 12.9618895561740149  
2016-01-05 00:00:00 | 12.6614611935518309  
2016-01-06 00:00:00 | 12.5775245695086098  
2016-01-07 00:00:00 | 12.5868802584437019  
(7 rows)

6、某些查询的性能甚至超过20倍

每天有多少笔交易。

        -- Total number of rides by day for first 5 days  
  
SELECT date_trunc('day', pickup_datetime) as day, COUNT(*) FROM rides  
  GROUP BY day ORDER BY day  
  LIMIT 5;  
  
        day         | count  
--------------------+--------  
2016-01-01 00:00:00 | 345037  
2016-01-02 00:00:00 | 312831  
2016-01-03 00:00:00 | 302878  
2016-01-04 00:00:00 | 316171  
2016-01-05 00:00:00 | 343251  
(5 rows)

timescale增加了merge append的执行优化，因此在时间片上按小粒度聚合，效率非常高，数据量越大，性能提升的效果越明显。

For example, TimescaleDB introduces a time-based “merge append” optimization to minimize the number of
groups which must be processed to execute the following (given its knowledge that time is already ordered).

For our 100M row table, this results in query latency that is 396x faster than PostgreSQL (82ms vs. 32566ms).

        SELECT date_trunc('minute', time) AS minute, max(usage_user)  
  FROM cpu  
  WHERE time < '2017-01-01'  
  GROUP BY minute  
  ORDER BY minute DESC  
  LIMIT 5;

7、执行一些timescaleDB特有的功能函数，例如time_bucket，这里同样会用到timescaleDB内置的一些加速算法。

每5分钟间隔为一个BUCKET，输出每个间隔产生了多少笔订单。

        -- Number of rides by 5 minute intervals  
--   (using the TimescaleDB "time_bucket" function)  
  
SELECT time_bucket('5 minute', pickup_datetime) as five_min, count(*)  
  FROM rides  
  WHERE pickup_datetime < '2016-01-01 02:00'  
  GROUP BY five_min ORDER BY five_min;  
  
      five_min       | count  
---------------------+-------  
 2016-01-01 00:00:00 |   703  
 2016-01-01 00:05:00 |  1482  
 2016-01-01 00:10:00 |  1959  
 2016-01-01 00:15:00 |  2200  
 2016-01-01 00:20:00 |  2285  
 2016-01-01 00:25:00 |  2291  
 2016-01-01 00:30:00 |  2349  
 2016-01-01 00:35:00 |  2328  
 2016-01-01 00:40:00 |  2440  
 2016-01-01 00:45:00 |  2372  
 2016-01-01 00:50:00 |  2388  
 2016-01-01 00:55:00 |  2473  
 2016-01-01 01:00:00 |  2395  
 2016-01-01 01:05:00 |  2510  
 2016-01-01 01:10:00 |  2412  
 2016-01-01 01:15:00 |  2482  
 2016-01-01 01:20:00 |  2428  
 2016-01-01 01:25:00 |  2433  
 2016-01-01 01:30:00 |  2337  
 2016-01-01 01:35:00 |  2366  
 2016-01-01 01:40:00 |  2325  
 2016-01-01 01:45:00 |  2257  
 2016-01-01 01:50:00 |  2316  
 2016-01-01 01:55:00 |  2250  
(24 rows)

8、执行一些统计分析SQL

每个城市的打车交易量。

        -- Join rides with rates to get more information on rate_code  
  
SELECT rates.description, COUNT(vendor_id) as num_trips FROM rides  
  JOIN rates on rides.rate_code = rates.rate_code  
  WHERE pickup_datetime < '2016-01-08'  
  GROUP BY rates.description ORDER BY rates.description;  
  
      description      | num_trips  
-----------------------+-----------  
 JFK                   |     54832  
 Nassau or Westchester |       967  
 Newark                |      4126  
 group ride            |        17  
 negotiated fare       |      7193  
 standard rate         |   2266401  
(6 rows)

某些城市2016年1月的打车统计（最长、短距离、平均人数、时长等）

        -- Analysis of all JFK and EWR rides in Jan 2016  
  
SELECT rates.description, COUNT(vendor_id) as num_trips,  
    AVG(dropoff_datetime - pickup_datetime) as avg_trip_duration, AVG(total_amount) as avg_total,  
    AVG(tip_amount) as avg_tip, MIN(trip_distance) as min_distance, AVG(trip_distance) as avg_distance, MAX(trip_distance) as max_distance,  
    AVG(passenger_count) as avg_passengers  
  FROM rides  
  JOIN rates on rides.rate_code = rates.rate_code  
  WHERE rides.rate_code in (2,3) AND pickup_datetime < '2016-02-01'  
  GROUP BY rates.description ORDER BY rates.description;  
  
 description | num_trips | avg_trip_duration |      avg_total      |      avg_tip       | min_distance |    avg_distance     | max_distance |   avg_passengers  
-------------+-----------+-------------------+---------------------+--------------------+--------------+---------------------+--------------+--------------------  
 JFK         |    225019 | 00:45:46.822517   | 64.3278115181384683 | 7.3334228220728027 |         0.00 | 17.2602816651038357 |       221.00 | 1.7333869584346211  
 Newark      |     16822 | 00:35:16.157472   | 86.4633688027582927 | 9.5461657353465700 |         0.00 | 16.2706122934252764 |       177.23 | 1.7435501129473309  
(2 rows)

9、数据自动分片与执行计划

        postgres=# \d+ rides  
                                                     Table "public.rides"  
        Column         |            Type             | Collation | Nullable | Default | Storage  | Stats target | Description   
-----------------------+-----------------------------+-----------+----------+---------+----------+--------------+-------------  
 vendor_id             | text                        |           |          |         | extended |              |   
 pickup_datetime       | timestamp without time zone |           | not null |         | plain    |              |   
 dropoff_datetime      | timestamp without time zone |           | not null |         | plain    |              |   
 passenger_count       | numeric                     |           |          |         | main     |              |   
 trip_distance         | numeric                     |           |          |         | main     |              |   
 pickup_longitude      | numeric                     |           |          |         | main     |              |   
 pickup_latitude       | numeric                     |           |          |         | main     |              |   
 rate_code             | integer                     |           |          |         | plain    |              |   
 dropoff_longitude     | numeric                     |           |          |         | main     |              |   
 dropoff_latitude      | numeric                     |           |          |         | main     |              |   
 payment_type          | integer                     |           |          |         | plain    |              |   
 fare_amount           | numeric                     |           |          |         | main     |              |   
 extra                 | numeric                     |           |          |         | main     |              |   
 mta_tax               | numeric                     |           |          |         | main     |              |   
 tip_amount            | numeric                     |           |          |         | main     |              |   
 tolls_amount          | numeric                     |           |          |         | main     |              |   
 improvement_surcharge | numeric                     |           |          |         | main     |              |   
 total_amount          | numeric                     |           |          |         | main     |              |   
Indexes:  
    "rides_passenger_count_pickup_datetime_idx" btree (passenger_count, pickup_datetime DESC)  
    "rides_pickup_datetime_vendor_id_idx" btree (pickup_datetime DESC, vendor_id)  
    "rides_rate_code_pickup_datetime_idx" btree (rate_code, pickup_datetime DESC)  
    "rides_vendor_id_pickup_datetime_idx" btree (vendor_id, pickup_datetime DESC)  
Child tables: _timescaledb_internal._hyper_1_1_chunk,  
              _timescaledb_internal._hyper_1_2_chunk,  
              _timescaledb_internal._hyper_1_3_chunk,  
              _timescaledb_internal._hyper_1_4_chunk  
  
其中一个分片的约束如下  
Check constraints:  
    "constraint_1" CHECK (pickup_datetime >= '2015-12-31 00:00:00'::timestamp without time zone AND pickup_datetime < '2016-01-30 00:00:00'::timestamp without time zone)  
    "constraint_2" CHECK (_timescaledb_internal.get_partition_hash(payment_type) >= 1073741823)  
Inherits: rides

        -- Peek behind the scenes  
  
postgres=#  select count(*) from rides;  
  count     
----------  
 10906858  
(1 row)  
  
Time: 376.247 ms  
postgres=# explain select count(*) from rides;  
                                                 QUERY PLAN                                                   
------------------------------------------------------------------------------------------------------------  
 Finalize Aggregate  (cost=254662.23..254662.24 rows=1 width=8)  
   ->  Gather  (cost=254661.71..254662.22 rows=5 width=8)  
         Workers Planned: 5  
         ->  Partial Aggregate  (cost=253661.71..253661.72 rows=1 width=8)  
               ->  Append  (cost=0.00..247468.57 rows=2477258 width=0)  
                     ->  Parallel Seq Scan on rides  (cost=0.00..0.00 rows=1 width=0)  
                     ->  Parallel Seq Scan on _hyper_1_1_chunk  (cost=0.00..77989.57 rows=863657 width=0)  
                     ->  Parallel Seq Scan on _hyper_1_2_chunk  (cost=0.00..150399.01 rows=1331101 width=0)  
                     ->  Parallel Seq Scan on _hyper_1_3_chunk  (cost=0.00..6549.75 rows=112675 width=0)  
                     ->  Parallel Seq Scan on _hyper_1_4_chunk  (cost=0.00..12530.24 rows=169824 width=0)  
(10 rows)

10、也可以直接查分片

        postgres=# select count(*) from  _timescaledb_internal._hyper_1_1_chunk;  
  count    
---------  
 3454961  
(1 row)

分片对用户完全透明

分片元数据：

        postgres=# \dn  
         List of schemas  
         Name          |  Owner     
-----------------------+----------  
 _timescaledb_cache    | postgres  
 _timescaledb_catalog  | postgres  
 _timescaledb_internal | postgres  
 public                | postgres  
(4 rows)

timescaleDB + PostGIS 双剑合璧 - 时空数据库

结合时序数据库timescaleDB插件，空间数据库PostGIS插件。PostgreSQL可以很好的处理空间数据。

1、创建空间数据库PostGIS创建

        create extension postgis;

2、添加空间类型字段

http://postgis.net/docs/manual-2.4/AddGeometryColumn.html

        postgres=# SELECT AddGeometryColumn ('public','rides','pickup_geom',2163,'POINT',2);  
                   addgeometrycolumn                      
--------------------------------------------------------  
 public.rides.pickup_geom  SRID:2163 TYPE:POINT DIMS:2   
(1 row)  
  
postgres=# SELECT AddGeometryColumn ('public','rides','dropoff_geom',2163,'POINT',2);  
                    addgeometrycolumn                      
---------------------------------------------------------  
 public.rides.dropoff_geom  SRID:2163 TYPE:POINT DIMS:2   
(1 row)  
  
postgres=#   
postgres=# \d+ rides  
                                                     Table "public.rides"  
        Column         |            Type             | Collation | Nullable | Default | Storage  | Stats target | Description   
-----------------------+-----------------------------+-----------+----------+---------+----------+--------------+-------------  
 vendor_id             | text                        |           |          |         | extended |              |   
 pickup_datetime       | timestamp without time zone |           | not null |         | plain    |              |   
 dropoff_datetime      | timestamp without time zone |           | not null |         | plain    |              |   
 passenger_count       | numeric                     |           |          |         | main     |              |   
 trip_distance         | numeric                     |           |          |         | main     |              |   
 pickup_longitude      | numeric                     |           |          |         | main     |              |   
 pickup_latitude       | numeric                     |           |          |         | main     |              |   
 rate_code             | integer                     |           |          |         | plain    |              |   
 dropoff_longitude     | numeric                     |           |          |         | main     |              |   
 dropoff_latitude      | numeric                     |           |          |         | main     |              |   
 payment_type          | integer                     |           |          |         | plain    |              |   
 fare_amount           | numeric                     |           |          |         | main     |              |   
 extra                 | numeric                     |           |          |         | main     |              |   
 mta_tax               | numeric                     |           |          |         | main     |              |   
 tip_amount            | numeric                     |           |          |         | main     |              |   
 tolls_amount          | numeric                     |           |          |         | main     |              |   
 improvement_surcharge | numeric                     |           |          |         | main     |              |   
 total_amount          | numeric                     |           |          |         | main     |              |   
 pickup_geom           | geometry(Point,2163)        |           |          |         | main     |              |   
 dropoff_geom          | geometry(Point,2163)        |           |          |         | main     |              |   
Indexes:  
    "rides_passenger_count_pickup_datetime_idx" btree (passenger_count, pickup_datetime DESC)  
    "rides_pickup_datetime_vendor_id_idx" btree (pickup_datetime DESC, vendor_id)  
    "rides_rate_code_pickup_datetime_idx" btree (rate_code, pickup_datetime DESC)  
    "rides_vendor_id_pickup_datetime_idx" btree (vendor_id, pickup_datetime DESC)  
Child tables: _timescaledb_internal._hyper_1_1_chunk,  
              _timescaledb_internal._hyper_1_2_chunk,  
              _timescaledb_internal._hyper_1_3_chunk,  
              _timescaledb_internal._hyper_1_4_chunk

3、将数据更新到geometry字段（实际存储为两个自动，分别表示经度和纬度。实际上不更新也没关系，因为PG支持表达式索引，完全可以使用这两个字段，创建表达式空间索引）。

        -- Generate the geometry points and write to table  
--   (Note: These calculations might take a few mins)  
  
UPDATE rides SET pickup_geom = ST_Transform(ST_SetSRID(ST_MakePoint(pickup_longitude,pickup_latitude),4326),2163);  
UPDATE rides SET dropoff_geom = ST_Transform(ST_SetSRID(ST_MakePoint(dropoff_longitude,dropoff_latitude),4326),2163);  
  
  
vacuum full rides;

4、时空分析举例。

在(lat, long) (40.7589,-73.9851)附近400米范围内，每30分钟有多少辆车被叫（以上车位置来计算）。

        -- Number of rides on New Years Eve originating within  
--   400m of Times Square, by 30 min buckets  
--   Note: Times Square is at (lat, long) (40.7589,-73.9851)  
  
SELECT time_bucket('30 minutes', pickup_datetime) AS thirty_min, COUNT(*) AS near_times_sq  
  FROM rides  
  WHERE ST_Distance(pickup_geom, ST_Transform(ST_SetSRID(ST_MakePoint(-73.9851,40.7589),4326),2163)) < 400  
    AND pickup_datetime < '2016-01-01 14:00'  
  GROUP BY thirty_min ORDER BY thirty_min;  
  
     thirty_min      | near_times_sq  
---------------------+--------------  
 2016-01-01 00:00:00 |      74  
 2016-01-01 00:30:00 |     102  
 2016-01-01 01:00:00 |     120  
 2016-01-01 01:30:00 |      98  
 2016-01-01 02:00:00 |     112  
 2016-01-01 02:30:00 |     109  
 2016-01-01 03:00:00 |     163  
 2016-01-01 03:30:00 |     181  
 2016-01-01 04:00:00 |     214  
 2016-01-01 04:30:00 |     185  
 2016-01-01 05:00:00 |     158  
 2016-01-01 05:30:00 |     113  
 2016-01-01 06:00:00 |     102  
 2016-01-01 06:30:00 |      91  
 2016-01-01 07:00:00 |      88  
 2016-01-01 07:30:00 |      58  
 2016-01-01 08:00:00 |      72  
 2016-01-01 08:30:00 |      94  
 2016-01-01 09:00:00 |     115  
 2016-01-01 09:30:00 |     118  
 2016-01-01 10:00:00 |     135  
 2016-01-01 10:30:00 |     160  
 2016-01-01 11:00:00 |     212  
 2016-01-01 11:30:00 |     229  
 2016-01-01 12:00:00 |     244  
 2016-01-01 12:30:00 |     230  
 2016-01-01 13:00:00 |     235  
 2016-01-01 13:30:00 |     238

实例2 - 传感器数据、天气数据

http://docs.timescale.com/v0.8/tutorials/other-sample-datasets

不再赘述。

timescaleDB 常用API

http://docs.timescale.com/v0.8/api

1、创建时序表

create_hypertable()

Required Arguments

Name	Description
main_table	Identifier of table to convert to hypertable
time_column_name	Name of the column containing time values

Optional Arguments

Name	Description
partitioning_column	Name of an additional column to partition by. If provided, number_partitions must be set.
number_partitions	Number of hash partitions to use for partitioning_column when this optional argument is supplied. Must be > 0.
chunk_time_interval	Interval in event time that each chunk covers. Must be > 0. Default is 1 month.
create_default_indexes	Boolean whether to create default indexes on time/partitioning columns. Default is TRUE.
if_not_exists	Boolean whether to print warning if table already converted to hypertable or raise exception. Default is FALSE.
partitioning_func	The function to use for calculating a value’s partition.

2、添加多级分片字段

支持hash和interval分片

add_dimension()

Required Arguments

Name	Description
main_table	Identifier of hypertable to add the dimension to.
column_name	Name of the column to partition by.

Optional Arguments

Name	Description
number_partitions	Number of hash partitions to use on column_name. Must be > 0.
interval_length	Interval that each chunk covers. Must be > 0.
partitioning_func	The function to use for calculating a value’s partition (see create_hypertable instructions).

3、删除分片

删除指定时间点、多久之前的分片

drop_chunks()

Required Arguments

Name	Description
older_than	Timestamp of cut-off point for data to be dropped, i.e., anything older than this should be removed.

Optional Arguments

Name	Description
table_name	Hypertable name from which to drop chunks. If not supplied, all hypertables are affected.
schema_name	Schema name of the hypertable from which to drop chunks. Defaults to public.
cascade	Boolean on whether to CASCADE the drop on chunks, therefore removing dependent objects on chunks to be removed. Defaults to FALSE.

4、设置分片时间区间

set_chunk_time_interval()

Required Arguments

Name	Description
main_table	Identifier of hypertable to update interval for.
chunk_time_interval	Interval in event time that each new chunk covers. Must be > 0.

5、分析函数 - 第一条

first()

Required Arguments

Name	Description
value	The value to return (anyelement)
time	The timestamp to use for comparison (TIMESTAMP/TIMESTAMPTZ or integer type)

例如，查找所有传感器的最早上传的温度值。

        SELECT device_id, first(temp, time)  
  FROM metrics  
  GROUP BY device_id;

使用递归亦可实现：

《PostgrSQL 递归SQL的几个应用 - 极客与正常人的思维》

6、分析函数 - 最后一条

last()

Required Arguments

Name	Description
value	The value to return (anyelement)
time	The timestamp to use for comparison (TIMESTAMP/TIMESTAMPTZ or integer type)

例如，查找每5分钟时间区间内，每个传感器的最新温度值

        SELECT device_id, time_bucket('5 minutes', time) as interval,  
  last(temp, time)  
  FROM metrics  
  WHERE time > now () - interval '1 day'  
  GROUP BY device_id, interval  
  ORDER BY interval DESC;

使用递归亦可实现：

《PostgrSQL 递归SQL的几个应用 - 极客与正常人的思维》

7、分析函数 - 柱状图

histogram()

Required Arguments

Name	Description
value	A set of values to partition into a histogram
min	The histogram’s lower bound used in bucketing
max	The histogram’s upper bound used in bucketing
nbuckets	The integer value for the number of histogram buckets (partitions)

例如，

电池电量20到60，均分为5个BUCKET区间，返回5+2个值的数组（表示每个bucket区间的记录数），头尾分为别为边界外的记录数有多少。

        SELECT device_id, histogram(battery_level, 20, 60, 5)  
  FROM readings  
  GROUP BY device_id  
  LIMIT 10;  
  
 device_id  |          histogram  
------------+------------------------------  
 demo000000 | {0,0,0,7,215,206,572}  
 demo000001 | {0,12,173,112,99,145,459}  
 demo000002 | {0,0,187,167,68,229,349}  
 demo000003 | {197,209,127,221,106,112,28}  
 demo000004 | {0,0,0,0,0,39,961}  
 demo000005 | {12,225,171,122,233,80,157}  
 demo000006 | {0,78,176,170,8,40,528}  
 demo000007 | {0,0,0,126,239,245,390}  
 demo000008 | {0,0,311,345,116,228,0}  
 demo000009 | {295,92,105,50,8,8,442}

8、分析函数 - 时间区间

类似date_trunc，但是更强大，可以用任意interval进行时间截断。方便用户使用。

time_bucket()

Required Arguments

Name	Description
bucket_width	A PostgreSQL time interval for how long each bucket is (interval)
time	The timestamp to bucket (timestamp/timestamptz/date)

Optional Arguments

Name	Description
offset	The time interval to offset all buckets by (interval)

9、数据概貌查看函数 - 时序表概貌

hypertable_relation_size_pretty()

        SELECT * FROM hypertable_relation_size_pretty('conditions');  
  
 table_size | index_size | toast_size | total_size  
------------+------------+------------+------------  
 1171 MB    | 1608 MB    | 176 kB     | 2779 MB

10、数据概貌查看函数 - 分片大小

chunk_relation_size_pretty()

        SELECT * FROM chunk_relation_size_pretty('conditions');  
  
                chunk_table                 | table_size | index_size | total_size  
---------------------------------------------+------------+------------+------------  
 "_timescaledb_internal"."_hyper_1_1_chunk"  | 28 MB      | 36 MB      | 64 MB  
 "_timescaledb_internal"."_hyper_1_2_chunk"  | 57 MB      | 78 MB      | 134 MB  
 ...

11、数据概貌查看函数 - 索引大小

indexes_relation_size_pretty()

        SELECT * FROM indexes_relation_size_pretty('conditions');  
  
             index_name_              | total_size  
--------------------------------------+------------  
 public.conditions_device_id_time_idx | 1143 MB  
 public.conditions_time_idx           | 465 MB

12、导出时序元数据

https://raw.githubusercontent.com/timescale/timescaledb/master/scripts/dump_meta_data.sql

        psql [your connect flags] -d your_timescale_db < dump_meta_data.sql > dumpfile.txt

小结

timescaleDB是一个非常好用的时序数据处理插件，隐藏了分片逻辑（对用户透明），同时提供了大量的API函数接口，以及性能优化。在时序场景使用很赞。

结合PostGIS插件，PostgreSQL在时空处理这块，如虎添翼。

参考

《PostgreSQL 按需切片的实现(TimescaleDB插件自动切片功能的plpgsql schemaless实现)》

《时序数据库有哪些特点? TimescaleDB时序数据库介绍》

《PostgreSQL on Linux 最佳部署手册》

http://docs.timescale.com/v0.8/tutorials/tutorial-hello-nyc

http://docs.timescale.com/v0.8/introduction

《PostgrSQL 递归SQL的几个应用 - 极客与正常人的思维》

digoal’s 大量PostgreSQL文章入口

公有云运维福利：开源监控小工具 Open-Falcon 插件 cloud-mon

Thu, 04 Apr 2019 00:00:00 CST

本文介绍了一款基于Open-Falcon的公有云运维监控工具及使用说明。

上篇文章回顾： 使用python实现简单的共享锁和排他锁

背景

当你成为公有云的一名管理员，权限和安全之间的权衡便成为了始终萦绕在我们身边的一个话题。每天在我们专心解决问题，或者code的时候，一会儿有人来找你：能不能帮我们看看××× 机器所在的NAT网关带宽多大呀？目前使用量是什么情况呀？一会儿有人问：我们在做业务升级，帮我们关注下LB的流量情况呀？我们现在S3的增长趋势是什么样子的呀？

方案调研

崩溃一秒钟，这种没有“含金量”的事情，怎么能浪费我们的时间呢？毕竟程序员的使命是要拯救地球的，再不济也得做一个优秀的产品。可是，问题来了。机器的监控好做，可以装Agent、Zabbix、Open-Falcon等。这些东西怎么监控呢？而且公有云有很多：什么AWS、Azure 、阿里云、金山云等，自己重新开发一个监控系统么？

额，这个工作量有点大。干活当然得选最简单，高效，又合理的方案啦，哈哈。

小米内部都是用Open-Falcon做监控。Open-Falcon的GitHub地址：

https://github.com/open-falcon

Open-Falcon是基于Go开发的一款快速上手、高可用的监控系统，支持自定义Dashboard报警，可以用来监控机器各方面指标，还可以自定义插件，上报数据，获取自己想要的信息。

Open-Falcon是小米早期的开源工具，星星多，社区活跃，还支持插件。恩，显示、存储、画图表、保持数据有序，都交给TA了。方案已定，写个Open-Falcon插件。

架构设计

说了这么久，先上架构图：

需要支持的云：

（1）AWS

（2）阿里云

（3）金山云

监控的资源范围：

（1）ELB

（2）EIP

（3）NAT网关

（4）专线

每个资源都取哪些监控指标呢？当然全部取啦！控制台有啥就取啥。

具体指标信息和含义请自行参照官网：

金山云：

https://docs.ksyun.com/documents/42

阿里云：

https://help.aliyun.com/product/28572.html?spm=a2c4g.750001.list.212.49707b13EZbdDR

AWS：

https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CW_Support_For_AWS.html

代码思路：

通过读取配置文件，获取资源类型、监控指标、地区信息和账号信息；
获取相应资源的所有列表；
获取列表的相关监控信息；
生成Open-Falcon识别的格式数据，推送到Open-Falcon。

使用指北

该工具已经作为Open-Falcon的插件开源，开源地址：

https://github.com/open-falcon/cloud-mon

具体实现代码以及参考文档可以去github查看。

首先把代码clone下来，按照你们的实际情况配置文件，就可以使用啦。

配置文件实例：

cloud下面是一个list，可以写的很长很长，想配什么配什么。下面是各项参数说明：

至此，小工具分享完啦，希望帮助大家提高效率。

完

这么好用的工具，在看一下呗~

苏宁 Android App 插件化应用实践

Wed, 01 Aug 2018 00:00:00 CST

“

从大团队并肩作战到小团队带头冲锋，高效的研发模式使得 App 本身的整体崩溃率始终维持在 0.02% 以下。

简介

从大团队并肩作战到小团队带头冲锋，高效的研发模式使得 App 本身的整体崩溃率始终维持在 0.02% 以下。

本着以用户为中心、以开发者为出发点，根据现有开源方案取长补短，苏宁易购移动开发部于 2017 年初自主研发出了新型插件化技术——APNP（Android Plugin And Play），旨在让研发更敏捷，让发布更灵活，最终满足用户对产品的极速体验、按需下载、动态更新。

需求分析

技术的引入来自于实际业务场景对技术的需求，插件化亦是如此，那么到底是什么原因推动了苏宁易购 App 的插件化，又是什么原因让苏宁易购开发者走上自研插件化的道路？

为什么苏宁易购 App 需要插件化？

发布周期长，产品迭代跟不上市场需求

对于一个电商 App，不同的时间、地点，伴随着用户千变万化、稍纵即逝的消费需求，谁能在第一时间满足这些需求，谁就能把握住需求带来的销量。

而传统的 App 开发模式周期过长，我们需要更敏捷的发布方案，所以我们做了插件化，这也是苏宁易购对插件化最原始的需求。

单线研发，管理、协作成本过高

随着苏宁易购业务的不断拓展、项目参与人员数量的增多，单线 App 开发模式所隐藏的问题日益凸显：一面从需求分析到研发测试，需要监管的内容越来越多；另一方面从方案决策到流程审批，协作沟通越来越频繁，成本越来越高。

因此我们需要多线、小团队的研发模式，这让我们进一步确认了插件化。

安装包过大，运营推广效率走低

需求在日益增长的同时，安装包体积也在同步膨胀。面对耗时、耗流量的安装包下载，新用户体验、老用户升级的阻力也越来越大。

为了解决这个问题，我们需要拆包、需要动态下载、需要局部更新，因此我们正式引入了插件化。

什么选择自研而不是使用开源方案？

没有完美无暇的开源方案，却有层出不穷的接入问题

移动团队在一开始选择过几种开源方案，个别方案的可用性也比较高，但是在接入之后，测试环节总会出现些疑难杂症，修复起来相对困难，一方面是源码本身的掌握成本较高，另一方面就是开源方案本身存在的缺陷。

要么另起炉灶，要么藕断丝连

现有的开源方案，要么就是对现有工程的改造较大，开发有心无力；要么就是插件工程和宿主工程相互依赖，牵一发而动全身，成本、风险都很高。

插件方案选型

基于上述种种原因，我们决定自研插件化技术，于是就有了 APNP。APNP采用的插件方案是直接加载 APK 文件（APK 格式不变，内容有所修改），原因有如下几点：

兼容性高

APK 文件的格式非常稳定，它包含一个 App 正常运行的必要资源；任何版本的 Android 系统，都应该正常解析并运行任意版本匹配的 APK 文件，无论这个 APK 文件是何时产生的；我们只要正确模仿系统加载 APK 的行为，就可以加载任意一个插件 APK 文件。

研发隔离

既然是直接加载 APK 文件，所以在 APNP 的设计方案中，每个插件都是一个单独工程，这就意味着除了最后的集成测试阶段，插件对应的整个软件生命周期都是独立的，既降低了管理、协作成本，又促使插件产品的发布更加灵活。

接入简单

既然是独立工程，无论现有的工程是如何运转的，开发者唯一要做的就是把插件工程从现有工程中抽离出来。

核心手段及原理

如果直接加载一个原始插件的 APK 文件，绝大多数情况下是无法运行的，如 Class pre-verified 异常、ResourceNotFound 等。

因此 APNP 在保持 APK 格式不变的情况下，对APK里面的内容做了针对性修改，核心手段如下：

共同 Dependency 剔除

在研发过程中，经常需要第三方依赖 Library（Dependency），而当插件工程（以下简称 Plugin）和宿主工程（以下简称 Host）包含相同的 Dependency 时，就需要剔除 Plugin 中的 Dependency。

这样一方面可以避免 Class pre-verified 异常，另一方面也可以减少插件包的大小，提升插件包的下载 & 加载速度。

实现方案（以下都默认 IDE 为 Android Studio）：通过 Gradle 插件，在 Plugin 的 Transform 过程中，剔除与 Host 相同 Dependency 的所有资源。

Package ID 修改

在 Android 系统中，App 对应的 Package ID 是固定的，也就是说如果我们不人为干预，Plugin 和 Host 打包生产的 APK 文件中，所有 Resource ID 中的 Package ID 都是一样的，即（0x7f）。

这时如果直接加载 Plugin APK，必然会出现 Resource 类型不匹配、显示错乱等异常，所以我们修改 Plugin 的 APK 的 Package ID。（Package ID 满足 0x01 < PID < 0x7f 即可）

实现方案：业内关于修改 Package ID 的方案有很多（如修改 aapt 源码等），APNP 采用的方案是直接修改最后生成的 APK 文件。

先看下一个简单 APK 的文件结构，如下图：

涉及 Package ID 修改的地方有 3 处：

R.class（classes.dex）
resources.arsc
xml 文件

修改 R.class 中的 Package ID

在 Gradle assemble 之后，会在 build/generated/source/r 文件下生成相应的 R.java 文件，如下图：

此时我们将 R 文件中的 0x7f 直接替换成目标 Package ID ，然后继续交给 Gradle 做后续操作。

这样在最终的 classes.dex 中，里面的 R.class 文件对应的 Package ID 就是我们想要设置的 Package ID。

修改 arsc + xml 中的 Package ID

不同于上面通过 Hook Gradle 过程修改中间生成的 R 文件，arsc + xml 则是直接解压最终的 APK 并修改目标文件，然后重新签名。

首先我们需要对 APK 文件中的 arsc + xml 的文件格式有一定的认识，Android 为了充分减少 APK 自身的大小，在编译的过程中会对所有的资源进行重组 + 压缩。

例如 values 文件下的内容会被统一收集到 arsc 文件中，而不再以文件的形式存在；而 xml 也不再是原始的 xml 文件，xml 中内容会被进一步整合 + 复用。

而无论是 arsc 文件，还是 xml 文件，在它们内部都是 通过一个个固定数据结构的 ResChunk 以嵌套 + 组合的形式各自存储着。

资源信息：每段 ResChunk 的内容都以 8 字节的 ResChunk_header 开头，用于描述 ResChunk 的类型 + 长度，如下图：

也就是说 arsc + xml 中的所有内容都可以被反向解析出来，当充分了解每个 ResChunk 的数据结构以及掌握 ResChunk 中哪些内容是需要修改的 Package ID，就可以相对轻松的完成对二进制文件的修改。

Library Chunk 插入

修改完 Package ID 后，还需要在 resources.arsc 文件中插入一段 Library Chunk ，如下图：

Library Chunk 在 Android 5.0 之后才出现，对应的类型如下图：

那么为什么需要插入 Library Chunk？原因是在 Android 5.0 之后，ResTable在获取资源信息时，如果资源含有 Parent（ResTable_map_entry，如 style），会验证 Parent 的 Package ID 是否合法，也就是 Package ID 是不是已经注册过了。

如果 lookupResourceId 没有返回 NO_ERROR，则报错，继续跟进，如下图:

由于在上一环节中，我们已经把 Plugin 中的 Package ID 修改了，上图中的局部变量 packageId 肯定不会是 APP_PACKAGE_ID 。

最后会在 mLookupTable 数组中寻找 packageId 是否有对应的值，如果没有（值为 0）则抛出异常。

所以我们需要把自定义的 Package ID 注册到 mLookupTable 数组中，那么注册的动作是在什么时候发生的？

在 App 启动并资源首次加载时，会调用下面的方法去解析 arsc 文件，如下图：

如果发现是 Library Chunk 会调用 addMapping，如下图：

在 addMapping 中，我们会把 Library Chunk 中的 packageId 在 mLookupTable 数组中进行注册（就是简单的赋值），注册之后我们自定义的 Package ID 才会被系统认可，从而确保含有 Parent 资源的正常解析。

Attr ID 替换

完成上面 3 步后，APK 就已经可以加载了，但是插件涉及到自定义属性的 View ，自定义属性总是无法正常赋值，这又是什么原因呢？

以 ConstraintLayout 为例，假如 Plugin 和 Host 的 Layout 布局中都包含 ConstraintLayout，并同时都设置了 ConstraintLayout 的自定义属性如下：

那么在 App 运行的过程中，ConstraintLayout 会通过 android.support.constraint.R.class 获取解析自定义属性，如下图：

而 android.support.constraint.R.class 在内存中只有一份，并且会优先加载 Host，因此在实际的运行内存中，R.class 来自于 Host。

由于 Host 中 R.class 里面的 Package ID 都是 0x7f ，而在上面第二节的修改 Package ID 环节中，Plugin 里面的 xml 的 Package ID 已经被我们修改了（包括 xml 中所引用的 Attr ID）。

因此当 Plugin 通过 Host 的 R.class 去解析 ConstrainLayout 时，必然会出现自定义属性无法正常解析的异常。

所在 APNP 在修改 Plugin xml 文件 Package ID 的同时，如果发现 Attr 同样存在于 Host 中，会把 Plugin xml 文件中的 Attr ID 替换成 Host 中的 Attr ID，从而保证 Plugin 中所有的自定义属性能够正常解析（红框：0x7f01000f，0x7f010022，0x7f010026，0x7f01002b），如下图：

否则直接修改 Package ID（蓝框：0x7e010000，0x7e010001，0x7e010002）。

实践成果

在 APNP 实际应用之后，通过苏宁云迹平台的实时数据监控，并没有发现因 APNP 本身引起的明显异常。

从大团队并肩作战到小团队带头冲锋，高效的研发模式也使得 App 本身的整体崩溃率始终维持在 0.02% 以下。

相比之前的研发流程，APNP 带来的影响主要有下面几个点：

产品更精细、定位更明确

APNP 是产品精细划分和明确定位的技术支撑，小团队的研发模式，加快了产品的落实与升级。

研发周期短、发布更灵活

插件可单独升级、可独立发布的特征，配合独立团队的专人专职，单一产品可以达到一周一版本。

管理更轻松、研发更高效

同步产品线的精细划分，研发团队也趋于更小、更独立，管理也显得更加轻松；同时明确的责任分工，也促进了研发人员的工作效率。

发展前景

Google 在今年的 IO 大会上推出了一种动态加载方案——App Bundles，可以让用户通过 Google Play 动态下载应用功能，而且 App Bundles 采用的方案也是直接加载 APK 文件。

通过分析最终的 Feature Master APK 文件，你会发现 App Bundles 对 APK 做了和 APNP 相同的操作：剔除 Dependency、修改 Package ID、插入 Library Chunk、替换 Attr ID。

这看似巧合实则必然，因为 App Bundles 和 APNP 都是直接加载 APK 文件，所以面对的问题都是一样的。

在方案上 APNP 可以说有了官方保障，而且 APNP 在后面还可以借鉴 App Bundles 的实现细节，让插件加载更加高效、安全。

而由于 Android P 对隐藏 API 调用的限制，很多人认为插件化方案将不再可行。

但是 Google 也同时提供了 light greylist，并且国内手机厂商肯定不允许让主流 App 无法使用的情况发生，所以我觉得在很长一段时间内，插件化依然可以正常运转。

作者：李呈武

简介：苏宁易购前端技术专家，资深Android 开发者，深度掌握 Android 虚拟机、插件化、Weex 等技术，熟悉移动网络的特质，对移动端的架构设计有独特的见解，一直致力于通过优秀的架构设计，减少开发成本，提升开发质量。

编辑：关崇、孙淑娟

投稿：有投稿、寻求报道意向技术人请联络 editor@51cto.com

精彩文章推荐：

终于有人把Java内存模型说清楚了！

一文深入了解：分布式系统中的缓存架构

新手也能看懂的监控报警系统架构设计

12款堪称神器的 Chrome 插件，Max 你的工作效率！

Tue, 16 Jan 2018 08:47:32 CST

导语：好的工具插件是提高程序员生产力的法宝，本文介绍了 12 款Chrome 插件，非常高效实用，还附带下载地址，果断收藏~

文/ ABHIMANYU GHOSHAL

译/ 蛤佛-1

来源/ TNW

工欲善其事，必先利其器，程序员的日常工作根本就 离不开 Chrome 浏览器（还不知道的请面壁思过130s）！其他功能优达菌就不啰嗦了，今天来说说 Chrome 如何提高你的生产力—— Chrome 支持 大量扩展插件，能帮你短时间内完成更多工作，同时比一些 App 消耗更少的系统资源。

今天介绍 12个 Chrome 插件，不用关闭浏览器你就能：记笔记，规划日程，改善你的收件箱，Max 你的工作效率。 （注：这些插件在Opera 里也能使用）

写作与笔记类

无论你在准备报告，撰写文章还是听讲座，准备一款能随时上手的记笔插件，肯定有所帮助！

用来记笔记和待办事项的

Google Keep

推荐理由：

Google Keep 快速，轻便，完全符合快速工作节奏的需求—— 只需点击浏览器上的按钮即可快速添加笔记。

相对于 Evernote 和 Microsoft OneNote，我更喜欢 Keep：它不那么混乱，让我能专注于快速记下想法，而不是提供一大堆用于排版和外链的功能。

这并不意味着 Keep 只有这一个特点：它能帮你保存页面上的图像和文字，你还能在上面作笔记。如果你打算写点什么，你可以随时打开，记下文本、列表和提醒。

Keep 的 Panel view 功能很受我的青睐，我可以开着标签页的同时，建个小窗放在旁边。

➤ Google Keep 获取链接：https://chrome.google.com/webstore/detail/panel-view-for-keep/jccocffecajimkdjgfpjhlpiimcnadhb

用来头脑风暴的

Papier

推荐理由：

Papier 是个超级简单的记笔记工具， “随时待命”是它能胜过各种桌面应用的原因。

只要装上插件、打开一个新的标签页，一个即时记事本就出现在你面前。图能自动保存内容，支持基本的排版和快捷键。界面简洁明快，你能看到的就是一个空白页面，随时响应你的笔记和新想法，界面太刺眼的话还有夜晚模式可供选择。

因为它只是个单页的笔记本，没有文档储存功能，所以感觉更像是一个瞎记记思路的地方，而不能保存和检索单独的文档。 Papier 还提供基本的富文本格式，你可以用快捷键启动，转向基于 Web 的文本编辑器。

虽然看起来功能轻便，但由于几乎隐形的界面，Papier 追求的就是让你把想法即时呈现出来。当你需要头脑风暴、快速记下稍纵即逝的想法的时候，就显得很有用，看着浏览器就能记笔记。

➤ Papier获取链接：https://www.google.com/search?q=Papier&oq=Papier&aqs=chrome..69i57j69i60&sourceid=chrome&ie=UTF-8

任务管理类

有一大堆任务等着完成？不如在浏览器里列张表，一天下来你就能很方便的看到完成情况。

用来准备短事项的

Jot

推荐理由：

“新标签页”是众多插件的必争之地，Jot 就是其中又简单又好看的一种。每当你打开一个标签页时，它会显示一个漂亮的壁纸，还会让你用大字报列出今天的 To-Do list 和备注，每次打开空白标签页就能看到。

如果你不需要各种高级任务管理的功能，Jot 是你的不二之选。

➤ Jot 获取链接：https://chrome.google.com/webstore/detail/jot/mnemjleajnmodijhnibpekloajfdjjja

用来规划一天的

Momentu

推荐理由：

Momentum 为你的新标签页加了一些有用的小部件，可以帮你方便地规划日程、实现目标。

上面有时钟、当地天气、To-Do list 和一个自定义的快捷链接，背景图多到你看不过来。

界面中的所有元素都可以根据自己的喜好进行调整。最牛逼的是“focus”小部件，看到没，能在图片的 good afternoon 下面，显示你一天的主要目标。

每月支付 2 美元的话可以得到更多的自定义功能，比如同步 Todoist 和 Wunderlist 等各种应用，“foucus” 还能学会从你的 To-Do list 里抽选任务来显示。

➤ Momentum 获取链接：https://chrome.google.com/webstore/detail/momentum/laookkfknpbbblfpciffpaejjkokdgca?hl=en

用来安排任务的

Todois

推荐理由：

如果你常用 Chrome，但还没有一个默认的 To-Do list 管理器，不如试试Todoist 。它在浏览器工具栏里内置一个强悍的任务列表，在方寸之间提供大量功能。

对于新手，你可以简单地添加任务或将活动选项卡变为列表里的项目。它会让你设置优先级，并为每个待办事项设定到期时间或重复规律。接下来七天你的日程安排就会优雅地出现在你面前。

在同一个地方添加和浏览待办事项的功能，比起 Wunderlist 为每个功能都要加一个插件的方法做得要好， Todoist 还能通过 Zapier 与大量应用联动，把任务添加到 Google 日历，给 Slack 里的加星标消息设为待办事项。

➤ Todoist 获取链接：https://chrome.google.com/webstore/detail/todoist-to-do-list-and-ta/jldhpllghnbhlbpcmnajkpdmadaolakh?hl=en

用来掌控项目的

Taco

推荐理由：

如果你已经用过好几个 APP 来管理任务和项目，Taco 的新标签替换功能足以让他笑傲群雄。

和Taco联动的应用有：Wunderlist，印象笔记，Asana，Basecamp和Trello，你可以把所有的项目放进新标签页里，然后在不用打开各个应用的前提下，就可以在 “Up Next” 表里拖拽项目来优化。

它强在能按项目过滤任务，但也能像普通 To-Do list 一样简单地使用。我喜欢用Taco 的原因在于能让我工作摸鱼两不误。

➤ Taco 获取链接：https://chrome.google.com/webstore/detail/taco/aogabobfbepcehdkbfagdflinolncebh?hl=en

阅读与研究类

网络上充斥着各种有用没用的信息，没一会儿就迷失在里面。不如用这些工具充分利用时间，读读书，好好研究研究。

用来扫一眼文章的

Reading Tim

推荐理由：

Time 会在浏览器左上角显示要花多上时间阅读页面上的内容，这对于判断是马上扫一遍还是收藏以后再读是非常有用的。

如果你想研究点东西，想知道应该先读那几篇文章，这款插件能帮你迅速找到文章的主题要点。

Reading Time 默认人均阅读速度为 228 字每分钟，但为了结果准确，你得先在Staples 做个1分钟测试，然后在插件选项里输入你的阅读速度。

➤ Reading Time 获取地址：https://chrome.google.com/webstore/detail/reading-time/nccohhimobidpghgpnejnbkpoichbbml?hl=en

用来稍后阅读的

Pocket

推荐理由：

如果你偶然发现一篇有趣的文章，但没时间看，那可以用Pocket保存以后再读。

只要点击工具栏上的按钮或者按 Ctrl/Cmd+Shift+S，你正在浏览的页面就会被加到阅读队列中。有空的时候就可以打开 Pocket 的 web 应用和 APP，在没有其他干扰的情况下阅读。

如果 pocket 里的东西越来越多，你也可以装个 TimeToRead ：它给每篇文章加个 tag，显示得花多少时间来阅读这篇。

这可以帮你根据你有多少摸鱼时间来挑选阅读的内容，或者通过时间长短来排个序。有些人要读的东西越堆越多，它能帮你好好地整理一下阅读列表。

➤ Pocket 获取链接：https://chrome.google.com/webstore/detail/save-to-pocket/niloccemoadcdkdjlinkgdfekeahmflj?hl=en

用来速读的

Reedy

推荐理由：

当你时间紧急又得迅速熟悉一篇文章的时候，你就得速读内容。Reedy 可以让你选择页面上任意一段文章段落，然后在他清爽的界面上阅读。

要知道，信息过载是非常现实的问题，Reedy无疑能帮你弱化信息量。当我被冗长的电子邮件和新闻稿轰炸时，Reedy能让我大致浏览一遍，决定是否得花时间跟进处理。如果你经常需要阅读大量内容，他值得一试。

➤ Reedy 获取链接：https://chrome.google.com/webstore/detail/reedy/ihbdojmggkmjbhfflnchljfkgdhokffj

用来总结文章的

Highly

推荐理由：

这款插件通过高亮文本精华的方式来梳理一篇文章。在你选好文章重点、分享给朋友后，他们只会看到你选定的部分，同时会有数字显示你为他们节约了多少时间。

这个功能不只局限于分享：我后来发现，他能用于在文章或者播客里标记来源。我所作的高亮都被保存下来，可以随时检索，甚至在Pocket和Instapaper账户里得以显示。

➤ Highly 获取链接：https://chrome.google.com/webstore/detail/highly-highlighter/hjpahjhcglfdopbholajmhpamgblhjhg?hl=en

书签和搜索类

用来重新发现需要的在线资源的

Refind

推荐理由：

关于书签页的工具真是太多了，你换台电脑可能就忘了浏览器里都收藏了啥。Refind的出现就是为了解决这个问题。

他能把书签页保存在云端，你google搜到相关内容时他们也会被高亮出来，妈妈再也不用担心我一篇文章收藏个好多遍啦。

➤ Refind 获取链接：https://chrome.google.com/webstore/detail/refind/dlapbpopbcangbnjdhajdlanbfokjaja?hl=en

用来追踪页面变化的

Page Monitor

推荐理由：

RSS 阅读器可以聚合你关注的博客，但如果你想收到更新的实时提醒，你就得用用 Page Monitor 了。

这款插件需要你把想跟的页面加到列表里，然后他就会持续关注更改情况，如果有新内容放上来，他就会“叮”地一声提醒你。

作为一名记者，我用 Page Monitor 来快速跟进科技新闻——你也可以用它来追踪股票和汇率，产品发布和销售情况等。扩展的导出功能特别方便，我可以一次性把我看的网站地址分享给同事。

➤ Page Monitor 获取链接：https://chrome.google.com/webstore/detail/page-monitor/ogeebjpdeabhncjpfhgdibjajcajepgg?hl=en

以上就是 12 款能提高生产力的强悍 Chrome 插件。如果你试了一些，想必你再也不会离开他们，可能顺便还卸了几个多余的桌面 App。 在评论区告诉优达菌你最喜欢用的插件是什么吧！

— 完 —

《Android插件化技术——原理篇》

Sat, 13 Jan 2018 15:40:09 CST

| 导语插件化技术最早从2012年诞生至今，已经走过了5个年头。从最初只支持Activity的动态加载发展到可以完全模拟app运行时的沙箱系统，各种开源项目层出不穷，在此挑选了几个代表性的框架，总结其中的技术原理。由于本人水平有限，插件化框架又相当复杂，文中若有错误或者不准确的地方望高手指点。

内容概要

一、发展历史

插件化技术最初源于免安装运行apk的想法，这个免安装的apk可以理解为插件。支持插件化的app可以在运行时加载和运行插件，这样便可以将app中一些不常用的功能模块做成插件，一方面减小了安装包的大小，另一方面可以实现app功能的动态扩展。想要实现插件化，主要是解决下面三个问题：

插件中代码的加载和与主工程的互相调用
插件中资源的加载和与主工程的互相访问
四大组件生命周期的管理

下面是比较出名的几个开源的插件化框架，按照出现的时间排序。研究它们的实现原理，可以大致看出插件化技术的发展，根据实现原理我把这几个框架划分成了三代。

第一代：dynamic-load-apk最早使用ProxyActivity这种静态代理技术，由ProxyActivity去控制插件中PluginActivity的生命周期。该种方式缺点明显，插件中的activity必须继承PluginActivity，开发时要小心处理context。而DroidPlugin通过Hook系统服务的方式启动插件中的Activity，使得开发插件的过程和开发普通的app没有什么区别，但是由于hook过多系统服务，异常复杂且不够稳定。

第二代：为了同时达到插件开发的低侵入性（像开发普通app一样开发插件）和框架的稳定性，在实现原理上都是趋近于选择尽量少的hook，并通过在manifest中预埋一些组件实现对四大组件的插件化。另外各个框架根据其设计思想都做了不同程度的扩展，其中Small更是做成了一个跨平台，组件化的开发框架。

第三代：VirtualApp比较厉害，能够完全模拟app的运行环境，能够实现app的免安装运行和双开技术。Atlas是阿里今年开源出来的一个结合组件化和热修复技术的一个app基础框架，其广泛的应用与阿里系的各个app，其号称是一个容器化框架。

下面详细介绍插件化框架的原理，分别对应着实现插件化的三个核心问题。

二、基本原理

2.1 类加载

外部apk中类的加载

Android中常用的有两种类加载器，DexClassLoader和PathClassLoader，它们都继承于BaseDexClassLoader。

  // DexClassLoaderpublic class DexClassLoader extends BaseDexClassLoader {    public DexClassLoader(String dexPath, String optimizedDirectory,
            String libraryPath, ClassLoader parent) {        super(dexPath, new File(optimizedDirectory), libraryPath, parent);
    }
}   
// PathClassLoader   
   
public class PathClassLoader extends BaseDexClassLoader {    public PathClassLoader(String dexPath, ClassLoader parent) {        
   super(dexPath, null, null, parent);
    }    
       
 public PathClassLoader(String dexPath, String libraryPath,
            ClassLoader parent) {       
    super(dexPath, null, libraryPath, parent);
    }
}

区别在于调用父类构造器时，DexClassLoader多传了一个optimizedDirectory参数，这个目录必须是内部存储路径，用来缓存系统创建的Dex文件。而PathClassLoader该参数为null，只能加载内部存储目录的Dex文件。

所以我们可以用DexClassLoader去加载外部的apk，用法如下

  //第一个参数为apk的文件目录//第二个参数为内部存储目录//第三个为库文件的存储目录//第四个参数为父加载器new DexClassLoader(apk.getAbsolutePath(), dexOutputPath, libsDir.getAbsolutePath(), parent)

双亲委托机制

ClassLoader调用loadClass方法加载类

   protected Class<?> loadClass(String className, boolean resolve) throws ClassNotFoundException {    
       //首先从已经加载的类中查找
        Class<?> clazz = findLoadedClass(className);       
    if (clazz == null) {
            ClassNotFoundException suppressed = null;        
           try {      
                //如果没有加载过，先调用父加载器的loadClass
                clazz = parent.loadClass(className, false);
            } catch (ClassNotFoundException e) {
                suppressed = e;
            }         
        if (clazz == null) {           
                try {              
          
                  //父加载器都没有加载，则尝试加载
                    clazz = findClass(className);
                } catch (ClassNotFoundException e) {
                    e.addSuppressed(suppressed);          
                     throw e;
                }
            }
        }       
            return clazz;
    }

可以看出ClassLoader加载类时，先查看自身是否已经加载过该类，如果没有加载过会首先让父加载器去加载，如果父加载器无法加载该类时才会调用自身的findClass方法加载，该机制很大程度上避免了类的重复加载。

DexClassLoader的DexPathList

DexClassLoader重载了findClass方法，在加载类时会调用其内部的DexPathList去加载。DexPathList是在构造DexClassLoader时生成的，其内部包含了DexFile。如下图所示

DexPathList的loadClass会去遍历DexFile直到找到需要加载的类

  public Class findClass(String name, List<Throwable> suppressed) {    
       //循环dexElements，调用DexFile.loadClassBinaryName加载class
        for (Element element : dexElements) {
            DexFile dex = element.dexFile;       
        if (dex != null) {
                Class clazz = dex.loadClassBinaryName(name, definingContext, suppressed);      
                     if (clazz != null) {      
                       return clazz;
                }
            }
        }     
      if (dexElementsSuppressedExceptions != null) {
            suppressed.addAll(Arrays.asList(dexElementsSuppressedExceptions));
        }        
         return null;
    }

有一种热修复技术正是利用了DexClassLoader的加载机制，将需要替换的类添加到dexElements的前面，这样系统会使用先找到的修复过的类。

2.2 单DexClassLoader与多DexClassLoader

通过给插件apk生成相应的DexClassLoader便可以访问其中的类，这边又有两种处理方式，有单DexClassLoader和多DexClassLoader两种结构。

多DexClassLoader

对于每个插件都会生成一个DexClassLoader，当加载该插件中的类时需要通过对应DexClassLoader加载。这样不同插件的类是隔离的，当不同插件引用了同一个类库的不同版本时，不会出问题。RePlugin采用的是该方案。

单DexClassLoader

将插件的DexClassLoader中的pathList合并到主工程的DexClassLoader中。这样做的好处时，可以在不同的插件以及主工程间直接互相调用类和方法，并且可以将不同插件的公共模块抽出来放在一个common插件中直接供其他插件使用。Small采用的是这种方式。

互相调用

插件和主工程的互相调用涉及到以下两个问题

插件调用主工程

在构造插件的ClassLoader时会传入主工程的ClassLoader作为父加载器，所以插件是可以直接可以通过类名引用主工程的类。

主工程调用插件

若使用多ClassLoader机制，主工程引用插件中类需要先通过插件的ClassLoader加载该类再通过反射调用其方法。插件化框架一般会通过统一的入口去管理对各个插件中类的访问，并且做一定的限制。
若使用单ClassLoader机制，主工程则可以直接通过类名去访问插件中的类。该方式有个弊病，若两个不同的插件工程引用了一个库的不同版本，则程序可能会出错，所以要通过一些规范去避免该情况发生。

2.3 资源加载

Android系统通过Resource对象加载资源，下面代码展示了该对象的生成过程

  //创建AssetManager对象    
AssetManager assets = new AssetManager();   
 //将apk路径添加到AssetManager中   
  if (assets.addAssetPath(resDir) == 0){              
    return null;  
}   
 //创建Resource对象   
   
r = new Resources(assets, metrics, getConfiguration(), compInfo);

因此，只要将插件apk的路径加入到AssetManager中，便能够实现对插件资源的访问。

具体实现时，由于AssetManager并不是一个public的类，需要通过反射去创建，并且部分Rom对创建的Resource类进行了修改，所以需要考虑不同Rom的兼容性。

资源路径的处理

和代码加载相似，插件和主工程的资源关系也有两种处理方式

合并式：addAssetPath时加入所有插件和主工程的路径
独立式：各个插件只添加自己apk路径

合并式由于AssetManager中加入了所有插件和主工程的路径，因此生成的Resource可以同时访问插件和主工程的资源。但是由于主工程和各个插件都是独立编译的，生成的资源id会存在相同的情况，在访问时会产生资源冲突。

独立式时，各个插件的资源是互相隔离的，不过如果想要实现资源的共享，必须拿到对应的Resource对象。

Context的处理

通常我们通过Context对象访问资源，光创建出Resource对象还不够，因此还需要一些额外的工作。对资源访问的不同实现方式也需要不同的额外工作。以VirtualAPK的处理方式为例

第一步：创建Resource

  if (Constants.COMBINE_RESOURCES) {   
    //插件和主工程资源合并时需要hook住主工程的资源
    Resources resources = ResourcesManager.createResources(context, apk.getAbsolutePath());
    ResourcesManager.hookResources(context, resources);     
      return resources;
} else {     
      //插件资源独立，该resource只能访问插件自己的资源
    Resources hostResources = context.getResources();
    AssetManager assetManager = createAssetManager(context, apk);     
        return new Resources(assetManager, hostResources.getDisplayMetrics(), hostResources.getConfiguration());
}

第二步：hook主工程的Resource

对于合并式的资源访问方式，需要替换主工程的Resource，下面是具体替换的代码。

  public static void hookResources(Context base, Resources resources) {    
   try {
            ReflectUtil.setField(base.getClass(), base, "mResources", resources);
            Object loadedApk = ReflectUtil.getPackageInfo(base);
            ReflectUtil.setField(loadedApk.getClass(), loadedApk, "mResources", resources);

            Object activityThread = ReflectUtil.getActivityThread(base);
            Object resManager = ReflectUtil.getField(activityThread.getClass(), activityThread, "mResourcesManager");          
     if (Build.VERSION.SDK_INT < 24) {
                Map<Object, WeakReference<Resources>> map = (Map<Object, WeakReference<Resources>>) ReflectUtil.getField(resManager.getClass(), resManager, "mActiveResources");
                Object key = map.keySet().iterator().next();
                map.put(key, new WeakReference<>(resources));
            } else {                // still hook Android N Resources, even though it's unnecessary, then nobody will be strange.
                Map map = (Map) ReflectUtil.getFieldNoException(resManager.getClass(), resManager, "mResourceImpls");
                Object key = map.keySet().iterator().next();
                Object resourcesImpl = ReflectUtil.getFieldNoException(Resources.class, resources, "mResourcesImpl");
                map.put(key, new WeakReference<>(resourcesImpl));
            }
    } catch (Exception e) {
        e.printStackTrace();

注意下上述代码hook了几个地方，包括以下几个hook点

替换了主工程context中LoadedApk的mResource对象
将新的Resource添加到主工程ActivityThread的mResourceManager中，并且根据Android版本做了不同处理

第三步：关联resource和Activity

  Activity activity = mBase.newActivity(plugin.getClassLoader(), targetClassName, intent);
activity.setIntent(intent);   
//设置Activity的mResources属性，Activity中访问资源时都通过mResources   
   
ReflectUtil.setField(ContextThemeWrapper.class, activity, "mResources", plugin.getResources());

上述代码是在Activity创建时被调用的（后面会介绍如何hook Activity的创建过程），在activity被构造出来后，需要替换其中的mResources为插件的Resource。由于独立式时主工程的Resource不能访问插件的资源，所以如果不做替换，会产生资源访问错误。

做完以上工作后，则可以在插件的Activity中放心的使用setContentView，inflater等方法加载布局了。

资源冲突

合并式的资源处理方式，会引入资源冲突，原因在于不同插件中的资源id可能相同，所以解决方法就是使得不同的插件资源拥有不同的资源id。

资源id是由8位16进制数表示，表示为0xPPTTNNNN。PP段用来区分包空间，默认只区分了应用资源和系统资源，TT段为资源类型，NNNN段在同一个APK中从0000递增。如下表所示

所以思路是修改资源ID的PP段，对于不同的插件使用不同的PP段，从而区分不同插件的资源。具体实现方式有两种

修改aapt源码，编译期修改PP段。
修改resources.arsc文件，该文件列出了资源id到具体资源路径的映射。

具体实现可以分别参考Atlas框架和Small框架。推荐第二种方式，不用入侵原有的编译流程。

三、四大组件支持

Android开发中有一些特殊的类，是由系统创建的，并且由系统管理生命周期。如常用的四大组件，Activity，Service，BroadcastReceiver和ContentProvider。仅仅构造出这些类的实例是没用的，还需要管理组件的生命周期。其中以Activity最为复杂，不同框架采用的方法也不尽相同。下面以Activity为例详细介绍插件化如何支持组件生命周期的管理。大致分为两种方式：

ProxyActivity代理
预埋StubActivity，hook系统启动Activity的过程

3.1 ProxyActivity代理

ProxyActivity代理的方式最早是由dynamic-load-apk提出的，其思想很简单，在主工程中放一个ProxyActivy，启动插件中的Activity时会先启动ProxyActivity，在ProxyActivity中创建插件Activity，并同步生命周期。下图展示了启动插件Activity的过程。

首先需要通过统一的入口（如图中的PluginManager）启动插件Activity，其内部会将启动的插件Activity信息保存下来，并将intent替换为启动ProxyActivity的intent。
ProxyActivity根据插件的信息拿到该插件的ClassLoader和Resource，通过反射创建PluginActivity并调用其onCreate方法。
PluginActivty调用的setContentView被重写了，会去调用ProxyActivty的setContentView。由于ProxyActivity重写了getResource返回的是插件的Resource，所以setContentView能够访问到插件中的资源。同样findViewById也是调用ProxyActivity的。
ProxyActivity中的其他生命周期回调函数中调用相应PluginActivity的生命周期。

代理方式的关键总结起来有下面两点：

ProxyActivity中需要重写getResouces，getAssets，getClassLoader方法返回插件的相应对象。生命周期函数以及和用户交互相关函数，如onResume，onStop，onBackPressedon，KeyUponWindow，FocusChanged等需要转发给插件。

PluginActivity中所有调用context的相关的方法，如setContentView，getLayoutInflater，getSystemService等都需要调用ProxyActivity的相应方法。

该方式有几个明显缺点：

插件中的Activity必须继承PluginActivity，开发侵入性强。
如果想支持Activity的singleTask，singleInstance等launchMode时，需要自己管理Activity栈，实现起来很繁琐。
插件中需要小心处理Context，容易出错。
如果想把之前的模块改造成插件需要很多额外的工作。

该方式虽然能够很好的实现启动插件Activity的目的，但是由于开发式侵入性很强，dynamic-load-apk之后的插件化方案很少继续使用该方式，而是通过hook系统启动Activity的过程，让启动插件中的Activity像启动主工程的Activity一样简单。

3.2 hook方式

在介绍hook方式之前，先用一张图简要的介绍下系统是如何启动一个Activity的。

上图列出的是启动一个Activity的主要过程，具体步骤如下：

Activity1调用startActivity，实际会调用Instrumentation类的execStartActivity方法，Instrumentation是系统用来监控Activity运行的一个类，Activity的整个生命周期都有它的影子。
通过跨进程的binder调用，进入到ActivityManagerService中，其内部会处理Activity栈。之后又通过跨进程调用进入到Activity2所在的进程中。
ApplicationThread是一个binder对象，其运行在binder线程池中，内部包含一个H类，该类继承于类Handler。ApplicationThread将启动Activity2的信息通过H对象发送给主线程。
主线程拿到Activity2的信息后，调用Instrumentation类的newActivity方法，其内通过ClassLoader创建Activity2实例。

下面介绍如何通过hook的方式启动插件中的Activity，需要解决以下两个问题

插件中的Activity没有在AndroidManifest中注册，如何绕过检测。
如何构造Activity实例，同步生命周期

解决方法有很多种，以VirtualAPK为例，核心思路如下：

先在Manifest中预埋StubActivity，启动时hook上图第1步，将Intent替换成StubActivity。
hook第10步，通过插件的ClassLoader反射创建插件Activity\
之后Activity的所有生命周期回调都会通知给插件Activity

下面具体分析整个过程涉及到的代码：

替换系统Instrumentation

VirtualAPK在初始化时会调用hookInstrumentationAndHandler，该方法hook了系统的Instrumentaiton类，由上文可知该类和Activity的启动息息相关。

  private void hookInstrumentationAndHandler() {    
   try {     
         //获取Instrumentation对象
        Instrumentation baseInstrumentation = ReflectUtil.getInstrumentation(this.mContext);      
              //构造自定义的VAInstrumentation
        final VAInstrumentation instrumentation = new VAInstrumentation(this, baseInstrumentation);    
                     //设置ActivityThread的mInstrumentation和mCallBack
        Object activityThread = ReflectUtil.getActivityThread(this.mContext);
        ReflectUtil.setInstrumentation(activityThread, instrumentation);
        ReflectUtil.setHandlerCallback(this.mContext, instrumentation);    
         this.mInstrumentation = instrumentation;
    } catch (Exception e) {
        e.printStackTrace();
    }
 }

该段代码将主线程中的Instrumentation对象替换成了自定义的VAInstrumentation类。在启动和创建插件activity时，该类都会偷偷做一些手脚。

hook activity启动过程

VAInstrumentation类重写了execStartActivity方法，图 3.2中的第一步。

  public ActivityResult execStartActivity(
    //省略了无关参数
    Intent intent) {   
//转换隐式intent
    mPluginManager.getComponentsHandler().transformIntentToExplicitAsNeeded(intent);    
   if (intent.getComponent() != null) {     
      //替换intent中启动Activity为StubActivity
        this.mPluginManager.getComponentsHandler().markIntentIfNeeded(intent);
    }        

    //调用父类启动Activity的方法}   
public void markIntentIfNeeded(Intent intent) {    
   if (intent.getComponent() == null) {     
         return;
    }

    String targetPackageName = intent.getComponent().getPackageName();
    String targetClassName = intent.getComponent().getClassName();    // search map and return specific launchmode stub activity
    if (!targetPackageName.equals(mContext.getPackageName()) && mPluginManager.getLoadedPlugin(targetPackageName) != null) {
        intent.putExtra(Constants.KEY_IS_PLUGIN, true);
        intent.putExtra(Constants.KEY_TARGET_PACKAGE, targetPackageName);
        intent.putExtra(Constants.KEY_TARGET_ACTIVITY, targetClassName);
        dispatchStubActivity(intent);
    }
}

execStartActivity中会先去处理隐式intent，如果该隐式intent匹配到了插件中的Activity，将其转换成显式。之后通过markIntentIfNeeded将待启动的的插件Activity替换成了预先在AndroidManifest中占坑的StubActivity，并将插件Activity的信息保存到该intent中。其中有个dispatchStubActivity函数，会根据Activity的launchMode选择具体启动哪个StubActivity。VirtualAPK为了支持Activity的launchMode在主工程的AndroidManifest中对于每种启动模式的Activity都预埋了多个坑位。

hook Activity的创建过程

上一步欺骗了系统，让系统以为自己启动的是一个正常的Activity。当来到图 3.2的第10步时，再将插件的Activity换回来。此时调用的是VAInstrumentation类的newActivity方法。

  @Overridepublic Activity newActivity(ClassLoader cl, String className, Intent intent){   
    try {
        cl.loadClass(className);
    } catch (ClassNotFoundException e) {   
        //通过LoadedPlugin可以获取插件的ClassLoader和Resource
        LoadedPlugin plugin = this.mPluginManager.getLoadedPlugin(intent);   
                //获取插件的主Activity
        String targetClassName = PluginUtil.getTargetActivity(intent);   
                if (targetClassName != null) {    
                   //传入插件的ClassLoader构造插件Activity
            Activity activity = mBase.newActivity(plugin.getClassLoader(), targetClassName, intent);
            activity.setIntent(intent);   
                    //设置插件的Resource，从而可以支持插件中资源的访问
            try {
                ReflectUtil.setField(ContextThemeWrapper.class, activity, "mResources", plugin.getResources());
            } catch (Exception ignored) {    
                                   // ignored.
            }     
          return activity;
        }
    }    return mBase.newActivity(cl, className, intent);
}

由于AndroidManifest中预埋的StubActivity并没有具体的实现类，所以此时会发生ClassNotFoundException。之后在处理异常时取出插件Activity的信息，通过插件的ClassLoader反射构造插件的Activity。

一些额外操作

插件Activity构造出来后，为了能够保证其正常运行还要做些额外的工作。VAInstrumentation类在图3.2中的第11步中也做了一些处理。

  @Overridepublic void callActivityOnCreate(Activity activity, Bundle icicle) {    
   final Intent intent = activity.getIntent();   
       if (PluginUtil.isIntentFromPlugin(intent)) {
        Context base = activity.getBaseContext();   
               try {
            LoadedPlugin plugin = this.mPluginManager.getLoadedPlugin(intent);
            ReflectUtil.setField(base.getClass(), base, "mResources", plugin.getResources());
            ReflectUtil.setField(ContextWrapper.class, activity, "mBase", plugin.getPluginContext());
            ReflectUtil.setField(Activity.class, activity, "mApplication", plugin.getApplication());
            ReflectUtil.setFieldNoException(ContextThemeWrapper.class, activity, "mBase", plugin.getPluginContext());   
               // set screenOrientation
            ActivityInfo activityInfo = plugin.getActivityInfo(PluginUtil.getComponent(intent));    
              if (activityInfo.screenOrientation != ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED) {
                activity.setRequestedOrientation(activityInfo.screenOrientation);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    mBase.callActivityOnCreate(activity, icicle);
}

这段代码主要是将Activity中的Resource，Context等对象替换成了插件的相应对象，保证插件Activity在调用涉及到Context的方法时能够正确运行。

经过上述步骤后，便实现了插件Activity的启动，并且该插件Activity中并不需要什么额外的处理，和常规的Activity一样。那问题来了，之后的onResume，onStop等生命周期怎么办呢？答案是所有和Activity相关的生命周期函数，系统都会调用插件中的Activity。原因在于AMS在处理Activity时，通过一个token表示具体Activity对象，而这个token正是和启动Activity时创建的对象对应的，而这个Activity被我们替换成了插件中的Activity，所以之后AMS的所有调用都会传给插件中的Activity。

小结

VirtualAPK通过替换了系统的Instrumentation，hook了Activity的启动和创建，省去了手动管理插件Activity生命周期的繁琐，让插件Activity像正常的Activity一样被系统管理，并且插件Activity在开发时和常规一样，即能独立运行又能作为插件被主工程调用。

其他插件框架在处理Activity时思想大都差不多，无非是这两种方式之一或者两者的结合。在hook时，不同的框架可能会选择不同的hook点。如360的RePlugin框架选择hook了系统的ClassLoader，即图3.2中构造Activity2的ClassLoader，在判断出待启动的Activity是插件中的时，会调用插件的ClassLoader构造相应对象。另外RePlugin为了系统稳定性，选择了尽量少的hook，因此它并没有选择hook系统的startActivity方法来替换intent，而是通过重写Activity的startActivity，因此其插件Activity是需要继承一个类似PluginActivity的基类的。不过RePlugin提供了一个Gradle插件将插件中的Activity的基类换成了PluginActivity，用户在开发插件Activity时也是没有感知的。

3.3 其他组件

四大组件中Activity的支持是最复杂的，其他组件的实现原理要简单很多，简要概括如下

Service：Service和Activity的差别在于，Activity的生命周期是由用户交互决定的，而Service的生命周期是我们通过代码主动调用的，且Service实例和manifest中注册的是一一对应的。实现Service插件化的思路是通过在manifest中预埋StubService，hook系统startService等调用替换启动的Service，之后在StubService中创建插件Service，并手动管理其生命周期。
BroadCastReceiver：解析插件的manifest，将静态注册的广播转为动态注册。
ContentProvider：类似于Service的方式，对插件ContentProvider的所有调用都会通过一个在manifest中占坑的ContentProvider分发。

四、发展方向

通过对插件化技术的学习，可以看出目前插件化技术的两个发展方向

结合组件化技术，成为一个中大型app的基础框架

以Small和阿里的Atlas为代表，利用了插件化技术对复杂工程的模块进行解耦，将app分成主工程和多个插件模块。主工程在运行期间动态加载相应模块的插件运行，并负责插件模块的管理工作。各个插件可以独立开发和运行，也可以依赖主工程或者其他插件。下面是基于Atlas的手淘app的框架图

其中的独立bundle即是一个插件，手淘中的首页，详情页，扫码，支付等都做成了单独的bundle，并且首页bundle还可以依赖于定位bundle。而主工程中则包含了各种基础功能库供各个bundle调用，并且包含了对bundle的安装，运行，版本管理，安全校验等运行期的管理工作。

组件化技术是利用gradle脚本实现的编译期的功能解耦，而Atlas是利用插件化技术实现了一套运行期的功能解耦，所以其也号称是动态组件化技术。

app沙盒系统，完全模拟app的运行环境

以VirtualAPP为代表，在应用层构建了一个虚拟的app运行环境，实现了免安装运行apk，应用双开等黑科技。另外作为应用开发者也需要注意我们的应用可能会运行在一个虚拟的环境下，对于支付，登录等功能要特别注意其安全性。

最后用VirtualAPP的作者Lody的一句话结束本篇文章，相信插件化技术还会继续发展壮大下去。

“插件化技术的成熟程度虽然在最近几年呈上升趋势，但是总体而言仍然处于初、中级阶段。
App沙盒技术的出现就是插件化发展的创新和第一阶段的产物。在未来，我相信很多插件化技
术会被更多的应用，如果插件化稳定到了一定的程度，甚至可以颠覆App开发的方式。”

参考
1.Android插件化：从入门到放弃(http://www.infoq.com/cn/articles/android-plug-ins-from-entry-to-give-up)

2.Android apk动态加载机制的研究
(http://blog.csdn.net/singwhatiwanna/article/details/22597587)

3.Android插件化原理解析系列文章
(http://weishu.me/2016/01/28/understand-plugin-framework-overview/)

4. 深度 | 滴滴插件化方案 VirtualApk 源码解析

5.VirtualAPK资源加载原理解析
(https://www.notion.so/VirtualAPK-1fce1a910c424937acde9528d2acd537)

Android插件化方案 RePlugin/README_CN.md at dev · Qihoo360/RePlugin · GitHub

Thu, 19 Oct 2017 11:06:55 CST

RePlugin —— 历经三年多考验，数亿设备使用的，稳定占坑类插件化方案

RePlugin是一套完整的、稳定的、适合全面使用的，占坑类插件化方案，由360手机卫士的RePlugin Team研发，也是业内首个提出”全面插件化“（全面特性、全面兼容、全面使用）的方案。

其主要优势有：

极其灵活：主程序无需升级（无需在Manifest中预埋组件），即可支持新增的四大组件，甚至全新的插件
非常稳定：Hook点仅有一处（ClassLoader），无任何Binder Hook！如此可做到其崩溃率仅为“万分之一”，并完美兼容市面上近乎所有的Android ROM
特性丰富：支持近乎所有在“单品”开发时的特性。包括静态Receiver、Task-Affinity坑位、自定义Theme、进程坑位、AppCompat、DataBinding等
易于集成：无论插件还是主程序，只需“数行”就能完成接入
管理成熟：拥有成熟稳定的“插件管理方案”，支持插件安装、升级、卸载、版本管理，甚至包括进程通讯、协议版本、安全校验等
数亿支撑：有360手机卫士庞大的数亿用户做支撑，三年多的残酷验证，确保App用到的方案是最稳定、最适合使用的

截止2017年6月底，RePlugin的：

特性	描述
插件数	103（核心57个）
插件占应用比	高达83%
年发版次数	高达596次（工作日均2次）
崩溃率	万分之一（0.01%），极低
时间	2014年应用，3年验证

目前360公司几乎所有的亿级用户量的APP，以及多款主流第三方APP，都采用了RePlugin方案。

有关RePlugin的详细介绍，请点击这里阅读《RePlugin 官方 WiKi》。

我们还支持以下特性

特性	描述
组件	四大组件（含静态Receiver）
升级无需改主程序Manifest	完美支持
Android特性	支持近乎所有（包括SO库等）
TaskAffinity & 多进程	*支持（坑位方案）*
插件类型	*支持自带插件（自识别）、外置插件*
插件间耦合	支持Binder、Class Loader、资源等
进程间通讯	支持同步、异步、Binder、广播等
自定义Theme & AppComat	支持
DataBinding	支持
安全校验	支持
资源方案	独立资源 + Context传递（相对稳定）
Android 版本	API Level 9+ （2.3及以上）

愿景

让插件化能飞入寻常应用家，做到稳定、灵活、自由，大小项目兼用。

RePlugin 架构图

以360手机卫士为例：

系统层——Android：为Android Framework层。只有ClassLoader是Hook的，而AMS、Resources等都没有做Hook，确保了其稳定性。
框架层——RePlugin框架：RePlugin框架层，只有RePlugin是对“上层完全公开”的，其余均为Internal，或“动态编译方案”生效后的调用，对开发者而言是“无需关心”的。
插件层——各插件：“标蓝部分”是各插件，包括大部分的业务插件（如体检、清理、桌面插件等）。而其中“标黄部分”是支撑一个应用的各种基础插件，如WebView、Download、Share，甚至Protobuf都能成为基础插件。

使用方法

RePlugin的使用方法非常简单，大部分情况下和“单品”开发无异。

若您是第一次接触RePlugin，则请点击这里阅读《快速上手》，跟随我们的指引，了解更多的内容。

若您想**了解更多有关RePlugin的玩法，则请点击这里阅读《详细教程》，**了解更多好玩的玩法。

若您想看下RePlugin的Sample工程，进而了解框架的具体用法，则请点击这里查看Sample源代码。

若您在接入RePlugin中遇到了任何问题，则请点击这里阅读《FAQ》，相信会有您想要的答案。

已接入RePlugin的应用

我们诚挚期待您成为咱们RePlugin应用大家庭中的一员！

除了360集团旗下的亿级别应用以外，还有一些对稳定要求极其严苛的“金融类”产品，及第三方合作应用也接入了RePlugin（含SDK）：


360 手机卫士	360 手机助手	360 手机浏览器	花椒相机	360 清理大师

360 影视大全	J借钱吧	海淘1号	华润通	借了吗

360OS 系统应用	360 借条	(即将发布)	(即将发布)	(即将发布)

这里衷心感谢“360手机助手”，以及其它各App团队成员，帮助我们发现了很多需要改进的地方，并给予了非常积极的反馈。您们的鼓励与支持，让咱们的RePlugin能走的更远、更好！

已接入RePlugin的插件

目前已有的插件，可以分为以下几类，供各App开发者参考：

展示插件：如卫士首页（是的，你没看错）、体检、信息流等
业务插件：如清理、骚扰拦截、悬浮窗等
合作插件：如程序锁、免费WiFi、安全桌面等
后台插件：如Push、服务管理、Protobuf等
基础插件：如安全WebView、分享、定位等

截止2017年6月底，这样的插件，我们有103个。衷心希望您能成为这个数字中的新的一员！

贡献自己的力量

我们欢迎任何形式的贡献，并致以诚挚的感谢！

你可以贡献代码、提出问题、编写文档等。有关“贡献”相关的内容，请点击这里阅读《贡献力量》

与我们联系

欢迎您加入到我们的RePlugin微信群、QQ群大家庭。

微信群已超过上限，请进入我们的QQ群

QQ群：653205923

License

RePlugin isApache v2.0 licensed.

美团App 插件化实践

Thu, 12 Oct 2017 23:06:35 CST

背景

在Android开发行业里，插件化已经不是一门新鲜的技术了，在稍大的平台型App上早已是标配。进入2017年，Atlas、Replugin、VirtualAPK相继开源，标志着插件化技术进入了成熟阶段。但纵观各大插件框架，都是基于自身App的业务来开发的，目标或多或少都有区别，所以很难有一个插件框架能一统江湖解决所有问题。最后就是绕不开的兼容性问题，Android每次版本升级都会给各个插件化框架带来不少冲击，都要费劲心思适配一番，更别提国内各个厂商对在ROM上做的定制了，正如VirtualAPK的作者任玉刚所说：完成一个插件化框架的 Demo 并不是多难的事儿，然而要开发一款完善的插件化框架却并非易事。

早在2014年美团移动技术团队就开始关注插件化技术了，并且意识到插件化架构是美团这种平台型App最好的集成形式。但由于业务增长、迭代、演化太快，受限于业务耦合和架构问题，插件化一直无法落地。到了2016年底，经过一系列的代码架构调整、技术调研，我们终于能腾出手来让插件化技术落地了。

美团平台（与点评平台一起）目前承载了美团点评所有事业群近20条业务线的业务。其中有相对成熟的业务，比如外卖、餐饮，他们对插件的要求是稳定性高，不能因为上了插件导致业务出问题；也有迭代变化很快的业务，如交通、跑腿、金融等，他们要求能快速迭代上线；此外，由于美团App采用的二进制AAR依赖方式集成已经运转了两年，各种基础设施都很成熟了，我们不希望换成插件形式的接入之后还要改变开发模式。所以，美团平台对插件的诉求主要集中在兼容性和不影响开发模式这两个点上。

美团插件化框架的原理和特点

插件框架的兼容性体现在多个方面，由于Android机制的问题，有些写法在插件化之前运行的很正常，但是接入插件化之后就变得不再有效。如果不解决兼容性问题，插件化的口碑和推广都会很大阻碍。兼容性不仅仅指的是对Android系统、Android碎片化的兼容，还要对已有基础库和构建工具的兼容。特别是后者，我们经常看到Github上开源的插件化框架里面有大量Crash的Issue，就是这个方面原因导致的。每个App的基础库和既有构建工具都不太一样，所以为自己的App选择合适的方案显得尤为重要。

为了保证插件的兼容性，并能无缝兼容当前AAR开发模式，美团的插件化框架方案主要做了以下几点：：

插件的Dex加载使用类似MultiDex方案，保证对反射的兼容
替换所有的AssetManager，保证对资源访问的兼容
四大组件预埋，代理新增Activity
让构建系统来抹平AAR开发模式和插件化开发模式的差异

MultiDex和组件代理这里不细说，网上有很多这方面的博客可以参考。下面重点说一下美团插件化框架对资源的处理和支持AAR、插件一键切换的构建系统。

资源处理

了解插件化的读者都知道：如果希望访问插件的资源，需要使用AssetManager把插件的路径加入进去。但这样做是远远不够的。这是因为如果希望这个AssetManager生效，就得把它放到具体的Resources或ResourcesImpl里面，大部分插件化框架的做法是封装一个包含插件路径AssetManager的Resources，然后插件中只使用这一个Resources。

这样的做法大多数情况是有效的，但是有至少3个问题：

如果在插件中使用了宿主Resources，如： getApplicationContext().getResources()。这个Resources就无法访问插件的资源了
插件外的Resources 并不唯一，需要全局查找和替换
Resoureces在使用的过程中有很多中间产物，例如Theme、TypedArray等等。这些都需要清理才能正常使用

要完全解决这些问题，我们另辟蹊径，做了一个全局的资源处理方式：

新建或者使用已有AssetManger，加载插件资源
查找所有的Resources/Theme，替换其中的AssetManger
清理Resources缓存，重建Theme
AssetManager的重建保护，防止丢失插件路径

这个方案和InstantRun有点类似，但是原生InstantRun有太多的问题：

清理顺序错误，应该先清理Applicaiton后清理Activity
Resources/Theme找不全，没有极端情况应对机制
Theme光清理不重建
完全不适配 Support包里面自己埋的“雷”
等等

举个例子Theme找不全：InstantRun会替换Theme中的AssetManager，做法是从每个Activity里面获取。

  for (Activity activity : activities) {
    ... // 省略部分代码
    Resources.Theme theme = activity.getTheme();
    try {
        try {
            Field ma = Resources.Theme.class.getDeclaredField("mAssets");
            ma.setAccessible(true);
            ma.set(theme, newAssetManager);
        } catch (NoSuchFieldException ignore) {
            Field themeField = Resources.Theme.class.getDeclaredField("mThemeImpl");
            themeField.setAccessible(true);
            Object impl = themeField.get(theme);
            Field ma = impl.getClass().getDeclaredField("mAssets");
            ma.setAccessible(true);
            ma.set(impl, newAssetManager);
        }
        ...
    } catch (Throwable e) {
        Log.e(LOG_TAG, "Failed to update existing theme for activity " + activity,
                e);
    }
    pruneResourceCaches(resources);
}

这个思路是对的，但是远不够。例如，Google 自己的Support包里面的一个类 android.support.v7.view.ContextThemeWrapper会生成一个新的Theme保存：

  public class ContextThemeWrapper extends ContextWrapper {
    private int mThemeResource;
    private Resources.Theme mTheme;
    private LayoutInflater mInflater;
    ...
    private void initializeTheme() {
        final boolean first = mTheme == null;
        if (first) {
            mTheme = getResources().newTheme();
            final Resources.Theme theme = getBaseContext().getTheme();
            if (theme != null) {
                mTheme.setTo(theme);
            }
        }
        onApplyThemeResource(mTheme, mThemeResource, first);
    }
    ...
}

如果没有替换了这个ContextThemeWrapper的Theme，假如配合它使用的Reources/AssetManager是新的，就会导致Crash：
java.lang.RuntimeException: Failed to resolve attribute at index 0
这是大部分开源框架都存在的Issue。
为了解决这个问题，我们不仅清理所有Activity的Theme，还清理了所有View的Context。

  try {
    List<View> list = getAllChildViews(activity.getWindow().getDecorView());
    for (View v : list) {
        Context context = v.getContext();
        if (context instanceof ContextThemeWrapper
                && context != activity
                && !clearContextWrapperCaches.contains(context)) {
            clearContextWrapperCaches.add((ContextThemeWrapper) context);
            pruneSupportContextThemeWrapper((ContextThemeWrapper) context, newAssetManager); // 清理Theme
        }
    }
} catch (Throwable ignore) {
    Log.e(LOG_TAG, ignore.getMessage());
}

但是这些做法还是不能解决所有问题，有时候为了实现一个产品需求，Android工程师可能会采取一些非常规写法，导致变成插件之后资源加载失败。比如在一个自己的类里面保存了Theme。这种问题不可能一个个改业务代码，那能不能让插件兼容这种写法呢？
我们对这种行为也做了兼容： 修改字节码。

了解虚拟机指令的同学都知道，如果要保存一个类变量，对应的虚拟机的指令是PUTFIELD/PUTSTATIC，以此为突破口，用ASM写一个MethodVisitor：

  static class MyMethodVisitor extends MethodVisitor {
    int stackSize = 0;

    MyMethodVisitor(MethodVisitor mv) {
        super(Opcodes.ASM5, mv);
    }

    @Override
    public void visitFieldInsn(int opcode, String owner, String name, String desc) {
        if (opcode == Opcodes.PUTFIELD || opcode == Opcodes.PUTSTATIC) {
            if ("Landroid/content/res/Resources$Theme;".equals(desc)) {
                stackSize = 1;
                visitInsn(Opcodes.DUP);
                super.visitMethodInsn(Opcodes.INVOKESTATIC,
                        "com/meituan/hydra/runtime/Transformer",
                        "collectTheme",
                        "(Landroid/content/res/Resources$Theme;)V",
                        false);
            }
        }
        super.visitFieldInsn(opcode, owner, name, desc);
    }

    @Override
    public void visitMaxs(int maxStack, int maxLocals) {
        super.visitMaxs(maxStack + stackSize, maxLocals);
        stackSize = 0;
    }
}

这样可以保证所有被类保存的Theme都会被收集起来，在插件安装后，统一清理、重建就行了。

插件的构建系统

为了实现在AAR集成方式和插件集成方式之间一键切换，并解决插件化遇到的“API陷阱”的问题，我们把大量的时间花在构建系统的建设上面，我们的构建系统除了支持常规的构建插件之外，还支持已有构建工具和未来可能存在的构建工具。
我们将正常构建过程分为4个阶段：

收集依赖
处理资源
处理代码
打包签名

那么如何保证对已有Gradle插件的支持？最好的方式是不对这个构建过程做太多干涉，保证它们的正常、按顺序执行。所以我们的构建系统在不干扰这个顺序的基础上，把插件的构建过程插入进去，对应正常构建的4个阶段，主要做了如下工作。

宿主解析依赖之后，分析插件的依赖，进行依赖仲裁和引用计数分析
宿主处理资源之前，处理插件资源，规避了资源访问的陷阱，生成需要Merge的资源列表给宿主，开发美团AAPT 处理插件资源
宿主处理代码之中，规避插件API使用的陷阱，复用宿主的Proguard和Gradle插件，做到对原生构建过程的最大兼容。我们也修复了Proguard Mapping的问题，后续会有专门的博客介绍
宿主打包签名之前，构建插件APK，计算升级兼容的Hash特征，使用V2签名加快运行时的验证

构建系统的流程如下图

API陷阱

我们做插件化构建系统还有另外一个非常重要的目的，就是规避“API陷阱”。下面是接入 Atlas所需要注意的部分问题，我们称为“API陷阱”

Activity通过overridePendingTransition使用的切换动画的文件要放在主APK中；
Bundle内如果有用到自定义style，那么style的parent如果也是自定义的话，parent的定义必须位于主APK中，这是由于5.0以后系统内style查找的固有逻辑导致的，容器内暂不能完全兼容
Bundle内部如果有so，则安装时so由于无法解压到APK lib目录中，对于直接通过native层使用dlopen来使用so的情况，会存在一定限制，且会影响后续so动态部署，所以目前bundle内so不建议使用dlopen的方式来使用

那我们是怎么做的呢？
我们用构建工具自动对插件资源进行处理。先把插件独有的依赖从宿主处理的依赖里面抽离，然后为宿主单独准备一份资源目录，这个目录只包括需要merge的资源。
那么怎么抽离呢？我们看下处理资源的task是如何获得这些资源的。代码在 com.android.build.gradle.tasks.MergeResources$ConfigAction

  ConventionMappingHelper.map(mergeResourcesTask, "inputResourceSets",
        new Callable<List<ResourceSet>>() {
            @Override
            public List<ResourceSet> call() throws Exception {
                List<File> generatedResFolders = Lists.newArrayList(
                        scope.getRenderscriptResOutputDir(),
                        scope.getGeneratedResOutputDir());
                if (variantData.getExtraGeneratedResFolders() != null) {
                    generatedResFolders.addAll(
                            variantData.getExtraGeneratedResFolders());
                }
                if (scope.getMicroApkTask() != null &&
                        variantData.getVariantConfiguration().getBuildType()
                                .isEmbedMicroApp()) {
                    generatedResFolders.add(scope.getMicroApkResDirectory());
                }

                return variantData.getVariantConfiguration().getResourceSets(
                        generatedResFolders, includeDependencies, validateEnabled);
            }
        });

了解Groovy的同学都知道，设置这个inputResourceSets，其实就是重写了这个mergeResourcesTask的getInputResourceSets方法。那么我们也这可以这么做：

  ConventionMapping conventionMapping =
                (ConventionMapping) ((GroovyObject) variantData.mergeResourcesTask).getProperty("conventionMapping");
def srcMethod = conventionMapping._mappings.get("inputResourceSets");

conventionMapping.map("inputResourceSets", new Callable<List<ResourceSet>>() {
    @Override
    public List<ResourceSet> call() throws Exception {
        List<ResourceSet> res = srcMethod.getValue(null, null)
        ... // 处理这个res
        return res
    }
})

对于第一个问题：前面提到的插件为宿主提供的资源文件夹，如果是一个空的没有任何意义。我们会分析插件的AndroidManifest.xml文件，以此作为root，遍历被它引用的所有的资源，不管是文件，还是values文件夹下面的单个value，全部merge进这个文件夹。
但是只是AndroidManifest.xml文件是不够的，所有传给系统的文件，比如提到的“Activity通过overridePendingTransition使用的切换动画的文件”，也一并放进这个文件夹。这里需要使用ASM扫描插件的所有API调用，类似上面的Theme查找，不细展开了。

第二个问题：把插件values里面style的parent也作为检索的root，遍历merge。

第三个问题：API陷阱除了资源，还有大量的代码级别的，上面的插件so加载问题就是很典型的一个例子，正常使用System.loadLibrary(path)是不行的，但是可以把它转化成下面的写法：我们发现，如果插件dlopen来加载的so之前被加载过，就不会出现这个问题。

  private static Pattern compile = Pattern.compile("dlopen failed: library \"lib(.+).so\" not found");
public static void system_loadLibrary(String libname) {
    LinkedList<String> list = new LinkedList<>();
    list.add(libname);
    while (list.size() > 0) {
        try {
            System.loadLibrary(list.peekFirst());
            list.pop();
        } catch (UnsatisfiedLinkError error) {
            // dlopen failed: library "libglog_init.so" not found
            Matcher matcher = compile.matcher(error.getMessage());
            if (matcher.matches()) {
                String group = matcher.group(1);
                list.addFirst(group);
            } else {
                throw error;
            }
        }
    }
}

当然需要替换的API很多，如 getIdentifier、Notification、Glide等等，不一一列举。

总结

本文主要介绍美团插件化的设计思路和一些实现。经过我们这些努力，美团平台的业务集成模式可以平滑的在AAR集成模式和插件化集成模式之间无缝切换，且上线几乎没出现兼容问题。目前在美团App最近的几个版本上，搜索、收藏、订单等重要模块都是插件形式加载的。

作者简介

李挺，美团点评技术专家，2014年加入美团。先后负责过多个业务项目和技术项目，致力于推动AOP和字节码技术在美团的应用。曾独立负责美团App预装项目并推动预装实现自动化。主导了美团插件化框架的设计和开发工作，目前工作重心是美团插件化框架的布道和推广。

夏伟，美团点评资深工程师，2017年加入美团。目前从事美团插件化开发，美团平台的一些底层工具优化，如AAPT、ProGuard等，专注于Hook技术、逆向研究，习惯从源码中寻找解决方案。

美团平台客户端技术团队，负责美团平台的基础业务和移动基础设施的开发工作。基于海量用户的美团平台，支撑了美团点评多条业务线的快速发展。同时，我们也在移动开发技术方面做了一些积极的探索，在动态化、质量保障、开发模型等方面有一定积累。客户端技术团队积极采用开源技术的同时，也把我们的一些积累回馈给开源社区，希望跟业界一起推动移动开发效率、质量的提升。

谷歌中国开发者福利：这里有你需要的所有网站和插件

Wed, 25 Jan 2017 08:30:00 CST

在去年12月的Google开发者大会上，Google发布了几个Google Developers中国网站，它汇集了Google为开发者提供的开发技术资源，包括API 文档、开发案例、以及技术培训的视频。根据Google的官微，它涵盖了以下6个关键开发技术和平台产品信息：

1. Android: developer.android.google.cn

Android开发者官方网站面向应用开发者提供了Android SDK以及开发相关的各类文档。

2. Web: developers.google.cn/web

学习如何利用Progressive Web Apps等Web技术来开发新一代的网站或移动应用。

3. Tensor Flow: www.tensorflow.org

TensorFlow是一个大规模机器学习的开源框架，提供了对多种深度神经网络的支持。它可以运行在不同的平台上，从智能手机到数据中心，并已经广泛部署到Google多项服务的生产环境中。

4. Google Play: developer.android.com/distribute/googleplay/index.html

借助Google Play，开发者可以触达和服务全球190余个国家和地区的超10亿Android用户。

5. AdMob: firebase.google.cn/docs/admob

使用Google的AdMob, 即可通过精准投放的应用内置广告轻松盈利。

6. Firebase: firebase.google.cn

Firebase 是一个移动平台，可以帮助快速开发高品质应用，扩大用户群，并赚取更多收益。Firebase由多种互补功能组成，可以自行组合和匹配这些功能以满足自己的需求。

此外，一同发布的还有Android Wear 2.0中国开发者预览版。

在Android Wear 2.0系统中，应用可以由Android Wear手表直接连接至互联网。因此，对于大多数应用来说，手机端的配套应用也就变得不再必要。这也意味着，多数为Android Wear 2.0开发应用的开发者将不再需要引用Google Play services客户端库。

根据Google的信息，目前在两个情况下开发者仍然需要引入Google Play Services客户端库来为中国市场开发应用：

需要与手机直接进行通信的应用。有一些用例需要Android Wear手表与已配对手机直接连接。在这种情况下，Android Wear 1.0中引入的Data Layer API仍然可以继续使用。
使用FusedLocationProvider。最新的中国版SDK中加入了定位的支持。在用户的许可下，应用可以通过FusedLocationProvider来接收定位更新。

Android Wear 2.0开发者预览版包括最新的SDK套件，手表测试系统镜像（基于华为手表）。

以下是测试步骤：

更新到 Android Studio 至 v2.1.1 以上版本
访问 Android Wear 2.0 开发者预览版，那里的文件下载与文档下载部分: developer.android.google.cn/wear/preview/index.html
下载手表系统镜像: developer.android.google.cn/wear/preview/downloads.html
在手表上测试应用

由于每次要查询这些资料时都需要手动调整相关网址，近日，Google又体贴的为中国开发者做了一个简单的Chrome插件，自动将google.com上的开发者网站URL替换成google.cn上的对应 URL (如果有相对应的.CN域名上的页面)，这样只要点击就能直接打开页面。

此扩展可以在Chrome Web Store上进行下载：

https://chrome.google.com/webstore/detail/google-cn-devsites/lgfkdmijgggnkoocgaenihkioidaejhd

同时它的代码也已经在GitHub上开源了：

https://github.com/chenzhuo914/google-cn-devsites-extension

至于有读者问“要如何打开这个下载页面”，Google的攻城狮也给出了回答：Desire-Passion-Belief。

via 谷歌开发者官微（公众号：谷歌开发者）雷锋网

工作中经常用到github上优秀、实用、轻量级、无依赖的插件和库

Sun, 09 Apr 2017 11:09:41 CST

原文收录在我的 GitHub博客 ( https://github.com/jawil/blog) ，喜欢的可以关注最新动态，大家一起多交流学习，共同进步，以学习者的身份写博客，记录点滴。

按照格式推荐好用的插件有福利哦，说不定会送1024论坛邀请码，好自为之，你懂的，嘿嘿嘿。

由于github的issues没有TOC菜单栏导航，所以这里方便大家查看，先安利一款Chrome浏览器的插件，感谢github用户@BBcaptain 推荐。点击我呀，进入商店，自备梯子，如果不会翻墙，赶紧转行。。。

效果预览，是不是很方便，图片较多，建议等待一会或者多刷新几下：

Echo.js – 简单易用的图片延迟加载插件

github： https://github.com/toddmotto/...

官方网站： https://toddmotto.com/echo-js...

star：3k+

Install：

  npm:npm install echo-js
bower:bower install echojs

大小：2KB

功能介绍：
　　Echo.js 是一个独立的延迟加载图片的 JavaScript 插件。Echo.js 不依赖第三方库，压缩后不到1KB大小。延迟加载是提高网页首屏显示速度的一种很有效的方法，当图片元素进入窗口可视区域的时候，它就会改变图像的 src 属性，从服务端加载所需的图片，这也是一个异步的过程。
　　
Demo：
效果预览地址： https://jawil.github.io/demo/...
Demo源码： https://github.com/jawil/jawi...

Demo效果预览：
图片有点大，稍等片刻。建议上面Demo效果预览地址进行预览。

Lazyr.js – 延迟加载图片（Lazy Loading）

github： https://github.com/callmecavs...

官方网站： http://callmecavs.com/layzr.j...

star：5k+

Install：

  npm:npm install layzr.js --save

大小：2.75 KB

功能介绍：
　　Lazyr.js 是一个小的、快速的、现代的、相互间无依赖的图片延迟加载库。通过延迟加载图片，让图片出现在（或接近)）视窗才加载来提高页面打开速度。这个库通过保持最少选项并最大化速度。

Demo：
跟上面的Echo.js用法类似，喜欢的可以自行去尝试，这里就不再演示了，我一般用Echo.js。

better-scroll.js – 小巧，灵活的 JavaScript 模拟滚动条的插件

github： https://github.com/ustbhuangy...

官方网站： https://ustbhuangyi.github.io...

star：300+

Install：

  npm install better-scroll --save-dev
import BScroll from 'better-scroll';

大小：24 KB

功能介绍：
　　better-scroll 是一个只有24.8KB的 JavaScript 模拟浏览器自带滚动条的插件，是在 iscroll开源的基础上进行优化的一款插件，简单好用，轻巧高性能，功能强大，API通俗易懂，是一款优秀的scroll插件，抛弃原生滚动条，从现在做起。

Demo：
效果预览地址： https://jawil.github.io/demo/... (PC端切换到移动模式)
Demo源码： https://github.com/jawil/webp...
注：在ustbhuangyi的源码下改进了一下，做成多页面，技术栈：webpack2+vue.js2+sass+axios

Demo效果预览：
图片有点大，稍等片刻。建议上面Demo效果预览地址进行预览。

better-picker – 一款轻量级IOS风格的JavaScript选择器

github： https://github.com/ustbhuangy...

官方网站： http://ustbhuangyi.github.io/...

star：200+

Install：

  npm: npm install better-picker --save-dev
import Picker from 'better-picker'

大小：46.5 KB

功能介绍：
　移动端最好用的的筛选器组件，高仿 ios 的 UIPickerView ，非常流畅的体验，原生 JS 实现，不依赖任何插件和第三方库。
Demo：
效果预览地址： http://ustbhuangyi.github.io/...

Demo效果预览：
图片有点大，稍等片刻。建议上面Demo效果预览地址进行预览。

Sortable – 一款用于实现元素拖拽排序的功能的插件

github： https://github.com/RubaXa/Sor...

官方网站： http://rubaxa.github.io/Sorta...

star：9k+

Install：

  Bower: bower install sortablejs --save
npm: npm install sortablejs

大小：5 KB

功能介绍：
　Sortable：现代浏览器上用于实现元素拖拽排序的功能，支持 Meteor, AngularJS, React，不依赖 jQuery这玩意。

Demo：
效果预览地址： http://rubaxa.github.io/Sorta...

Demo效果预览：
图片有点大，稍等片刻。建议上面Demo效果预览地址进行预览。

slick – 功能异常强大的一个图片滑动切换效果库

github： https://github.com/kenwheeler...

官方网站： http://kenwheeler.github.io/s...

star：17k+

Install：

  Bower: bower install slick-carousel --save
npm: npm install slick-carousel
CDNs:
https://cdnjs.com/libraries/slick-carousel
https://www.jsdelivr.com/projects/jquery.slick

大小：40 KB

功能介绍：
　slick 是一个功能异常强大的一个图片滑动切换效果库，接口丰富，支持各种动画和各种样式的切换滑动，唯一的缺点就是 基于jQuery，基本废了，现在没人喜欢用jQuery，该淘汰了。。。支持 RequireJS 以及 Bower 安装。

Demo：
效果预览地址： http://kenwheeler.github.io/s...

Demo效果预览：
图片有点大，稍等片刻。建议上面Demo效果预览地址进行预览。

swipe – 非常轻量级的一个图片滑动切换效果库

github： https://github.com/lyfeyaj/Sw...

官方网站： http://lyfeyaj.github.io/swip...

star：200+

Install：

  Bower: bower install swipe-js  --save
npm: npm install swipe-js

大小：5 KB

功能介绍：
　swipe：非常轻量级的一个图片滑动切换效果库, 性能良好, 尤其是对手机的支持, 压缩后的大小约 5kb。可以结合 jQuery、RequireJS 使用。

Demo：
效果预览地址： http://lyfeyaj.github.io/swipe/

Demo效果预览：
图片有点大，稍等片刻。建议上面Demo效果预览地址进行预览。

Slideout.js – 触摸滑出式 Web App 导航菜单

github： https://github.com/mango/slid...

官方网站： https://slideout.js.org/https://github.com/t4t5/sweet...

官方网站： http://t4t5.github.io/sweetal...

star：15k+

Install：

  bower:bower install sweetalert
npm:npm install sweetalert
<script src="dist/sweetalert.min.js"></script>
<link rel="stylesheet" type="text/css" href="dist/sweetalert.css">

大小：16 KB

功能介绍：
　 Sweet Alert 是一个替代传统的 JavaScript Alert 的漂亮提示效果。SweetAlert 自动居中对齐在页面中央，不管您使用的是台式电脑，手机或平板电脑看起来效果都很棒。另外提供了丰富的自定义配置选择，可以灵活控制。

Demo：
效果预览地址： http://t4t5.github.io/sweetal...

Demo效果预览：
图片有点大，稍等片刻。建议上面Demo效果预览地址进行预览。

类似插件：limonte/sweetalert2，好像这个最近还在更新，这个感觉更漂亮，大同小异，这里不多做介绍。

github： https://github.com/limonte/sw...

官方网站： https://limonte.github.io/swe...

Awesomplete.js - 比datalist更强大更实用，零依赖的简单自动补全插件

github： https://github.com/leaverou/a...

官方网站： http://leaverou.github.io/awe...

star：5k+

Install：
`npm: npm install awesomplete
`

大小：5 KB

功能介绍：
　Awesomplete 是一款超轻量级的，可定制的，简单的自动完成插件，零依赖，使用现代化标准构建。你可以简单地添加 awesomplete 样式，让它自动处理（你仍然可以通过指定 HTML 属性配置更多选项），您可以用几行 JS 代码，提供更多的自定义。

Demo：
效果预览地址： http://leaverou.github.io/awe...

Demo效果预览：
图片有点大，稍等片刻。建议上面Demo效果预览地址进行预览。

Cleave.js – 自动格式化表单输入框的文本内容

github： https://github.com/nosir/clea...

官方网站： http://nosir.github.io/cleave...

star：6k+

Install：

  npm:npm install --save cleave.js
bower:bower install --save cleave.js

大小：11.1 KB

功能介绍：
　　Cleave.js 有一个简单的目的：帮助你自动格式输入的文本内容。这个想法是提供一个简单的方法来格式化您的输入数据以增加输入字段的可读性。通过使用这个库，您不需要编写任何正则表达式来控制输入文本的格式。然而，这并不意味着取代任何验证或掩码库，你仍应在后端验证数据。它支持信用卡号码、电话号码格式（支持各个国家）、日期格式、数字格式、自定义分隔符，前缀和块模式等，提供 CommonJS/AMD 模式以及ReactJS 组件端口。

Demo：
效果预览地址： http://nosir.github.io/cleave...

Demo效果预览：
图片有点大，稍等片刻。建议上面Demo效果预览地址进行预览。
输入201748自动格式化成2017-04-08，是不是很方便

Immutable.js – JavaScript 不可变数据集合（Facebook出品）

github： https://github.com/facebook/i...

官方网站： http://facebook.github.io/imm...

star：18k+

Install：

  npm install immutable --S-D

大小：60 KB

功能介绍：
　　不可变数据是指一旦创建就不能被修改的数据，使得应用开发更简单，允许使用函数式编程技术，比如惰性评估。Immutable JS 提供一个惰性 Sequence，允许高效的队列方法链，类似 map 和 filter ，不用创建中间代表。Immutable.js 提供持久化的列表、堆栈、Map，以及 OrderedMap 等，最大限度地减少需要复制或缓存数据。

Demo：

  <script src="immutable.min.js"></script>
<script>
var map1 = Immutable.Map({a:1, b:2, c:3});
var map2 = map1.set('b', 50);
map1.get('b'); // 2
map2.get('b'); // 50
</script>

更多信息和探讨请移步,这里不多做介绍： facebook immutable.js 意义何在，使用场景？

Popmotion.js – 小巧，灵活的 JavaScript 运动引擎

github： https://github.com/Popmotion/...

官方网站： https://popmotion.io/

star：3k+

Install：

  npm install --save popmotion
import { tween } from 'popmotion';

大小：12 KB

功能介绍：
　　Popmotion 是一个只有12KB的 JavaScript 运动引擎，可以用来实现动画，物理效果和输入跟踪。原生的DOM支持：CSS，SVG，SVG路径和DOM属性的支持，开箱即用。Popmotion 网站上有很多很赞的效果，赶紧去体验一下。

Demo：
效果预览地址： http://codepen.io/popmotion/p...

Demo效果预览：
图片有点大，稍等片刻。建议上面Demo效果预览地址进行预览。

Dynamics.js - 创建逼真的物理动画的 JS 库

github： https://github.com/michaelvil...

官方网站： http://dynamicsjs.com/

star：6k+

Install：

  npm: npm install dynamics.js
bower: bower install dynamics.js

大小：20 KB

Demo：
效果预览地址： http://dynamicsjs.com/

Demo效果预览：
图片有点大，稍等片刻。建议上面Demo效果预览地址进行预览。

Rainyday.js – 使用 JavaScript 实现雨滴效果

github： https://github.com/maroslaw/r...

官方网站： http://maroslaw.github.io/rai...

star：5k+

Install：

在github的dist目录下载rainyday.min.js

大小：10 KB

功能介绍：
　Rainyday.js 背后的想法是创建一个 JavaScript 库，利用 HTML5 Canvas 渲染一个雨滴落在玻璃表面的动画。Rainyday.js 有功能可扩展的 API，例如碰撞检测和易于扩展自己的不同的动画组件的实现。它是一个使用 HTML5 特性纯 JavaScript 库，支持大部分现代浏览器。

Demo：
效果预览地址： http://maroslaw.github.io/rai...

Demo效果预览：
图片有点大，稍等片刻。建议上面Demo效果预览地址进行预览。

Swiper – 经典的移动触摸滑块轮播插件

github： https://github.com/nolimits4w...

官方网站： http://idangero.us/swiper/https://github.com/daniel-lun...

官方网站： http://daniel-lundin.github.i...

star：5k+

Install：

  bower:bower install snabbt.js
npm:npm install snabbt.js
CDNs:
https://cdnjs.com/libraries/snabbt.js
http://www.jsdelivr.com/#!snabbt

大小：16 KB

功能介绍：
　Snabbt.js 是一个简约的 JavaScript 动画库。它会平移，旋转，缩放，倾斜和调整你的元素。通过矩阵乘法运算，变换等可以任何你想要的方式进行组合。最终的结果通过 CSS3 变换矩阵设置。

Demo：
效果预览地址： http://daniel-lundin.github.i...

Demo效果预览：
图片有点大，稍等片刻。建议上面Demo效果预览地址进行预览。

imagesLoaded – 检测网页中的图片是否加载完成

github： https://github.com/desandro/i...

官方网站： http://imagesloaded.desandro....

star：6k+

Install：

  Bower: bower install imagesloaded --save
npm: npm install imagesloaded
CDNs:
<script src="https://unpkg.com/imagesloaded@4.1/imagesloaded.pkgd.min.js"></script>
<script src="https://unpkg.com/imagesloaded@4.1/imagesloaded.pkgd.js"></script>

大小：5 KB

功能介绍：
　imagesLoaded 是一个用于来检测网页中的图片是否载入完成的 JavaScript 工具库。支持回调的获取图片加载的进度，还可以绑定自定义事件。可以结合 jQuery、RequireJS 使用。

Demo：
效果预览地址： http://codepen.io/desandro/fu...

Demo效果预览：
图片有点大，稍等片刻。建议上面Demo效果预览地址进行预览。

Fort.js – 时尚、现代的表单填写进度提示效果

github： https://github.com/idriskhenc...

官方网站： https://github.com/idriskhenc...

star：800+

Install：

  CDN:
css:
https://cdnjs.cloudflare.com/ajax/libs/Fort.js/2.0.0/fort.min.css
js:
https://cdnjs.cloudflare.com/ajax/libs/Fort.js/2.0.0/fort.min.js

大小：6 KB

功能介绍：
　　Fort.js 是一款用于时尚、现代的表单填写进度提示效果的 JavaScript 库，你需要做的就是添加表单，剩下的任务就交给 Fort.js 算法了，使用非常简单。提供了Default、Gradient、Sections 以及 Flash 四种效果，满足开发的各种场合需要。

Demo：
效果预览地址： http://idriskhenchil.github.i...

Demo效果预览：
图片有点大，稍等片刻。建议上面Demo效果预览地址进行预览。

MagicSuggest – Bootstrap 主题的多选组合框

github： https://github.com/nicolasbiz...

官方网站： http://nicolasbize.com/magics...

star：1k+

Install：

  github自行进行下载

大小：21.8 KB

功能介绍：
　　MagicSuggest 是专为 Bootstrap 主题开发的多选组合框。它支持自定义呈现，数据通过 Ajax 异步获取，使用组件自动过滤。它允许空间免费项目，也有动态加载固定的建议。

Demo：
效果预览地址： http://nicolasbize.com/magics...

Demo效果预览：
图片有点大，稍等片刻。建议上面Demo效果预览地址进行预览。

Numeral.js – 格式化和操作数字的 JavaScript 库

github： https://github.com/adamwdrape...

官方网站： http://numeraljs.com/

star：4k+

Install：

  npm: npm install numeral
CDNs:
<script src="//cdnjs.cloudflare.com/ajax/libs/numeral.js/2.0.6/numeral.min.js"></script>

大小：10 KB

功能介绍：
　　　Numeral.js 是一个用于格式化和操作数字的 JavaScript 库。数字可以格式化为货币，百分比，时间，甚至是小数，千位，和缩写格式，功能十分强大。支持包括中文在内的17种语言。

Demo：

  var myNumeral = numeral(1000);

var value = myNumeral.value();
// 1000

var myNumeral2 = numeral('1,000');

var value2 = myNumeral2.value();
// 1000

Draggabilly – 轻松实现拖放功能（Drag & Drop）

github： https://github.com/desandro/d...

官方网站： http://draggabilly.desandro.c...

star：2k+

Install：

  Bower: bower install draggabilly --save
npm: npm install draggabilly
CDNs:
<script src="https://npmcdn.com/draggabilly@2.1/dist/draggabilly.pkgd.min.js"></script>
<script src="https://npmcdn.com/draggabilly@2.1/dist/draggabilly.pkgd.js"></script>

大小：5 KB

功能介绍：
　Draggabilly 是一个很小的 JavaScript 库，专注于拖放功能。只需要简单的设置参数就可以在你的网站用添加拖放功能。兼容 IE8+ 浏览器，支持多点触摸。可以灵活绑定事件，支持 RequireJS 以及 Bower 安装。

Demo：
效果预览地址： http://draggabilly.desandro.com/

Demo效果预览：
图片有点大，稍等片刻。建议上面Demo效果预览地址进行预览。

Quill – 可以灵活自定义的开源的富文本编辑器

github： https://github.com/quilljs/qu...

官方网站： https://quilljs.com

star：12k+

Install：

  npm: npm install quill
CDNs:
<!-- Main Quill library -->
<script src="//cdn.quilljs.com/1.0.0/quill.js" type="text/javascript"></script>
<script src="//cdn.quilljs.com/1.0.0/quill.min.js" type="text/javascript"></script>

<!-- Theme included stylesheets -->
<link href="//cdn.quilljs.com/1.0.0/quill.snow.css" rel="stylesheet">
<link href="//cdn.quilljs.com/1.0.0/quill.bubble.css" rel="stylesheet">

<!-- Core build with no theme, formatting, non-essential modules -->
<link href="//cdn.quilljs.com/1.0.0/quill.core.css" rel="stylesheet">
<script src="//cdn.quilljs.com/1.0.0/quill.core.js" type="text/javascript"></script>

大小：需求不同，大小不同

功能介绍：
　　Quill 的建立是为了解决现有的所见即所得（WYSIWYG）的编辑器本身就是所见即所得（指不能再扩张）的问题。如果编辑器不正是你想要的方式，这是很难或不可能对其进行自定义以满足您的需求。

　　Quill 旨在通过把自身组织成模块，并提供了强大的 API 来构建额外的模块来解决这个问题。它也并没有规定你用样式来定义编辑器皮肤。Quill 还提供了所有你希望富文本编辑器说用于的功能，包括轻量级封装，众多的格式化选项，以及广泛的跨平台支持。

Demo：
效果预览地址： https://quilljs.com/

Demo效果预览：
图片有点大，稍等片刻。建议上面Demo效果预览地址进行预览。

basket.js – 基于 LocalStorage 的资源加载器

github： https://github.com/addyosmani...

官方网站： https://addyosmani.com/basket...

star：2k+

Install：

  Bower: bower install basket.js --save
npm: npm install basket.js

大小：4 KB

功能介绍：
　basket.js是一款基于 LocalStorage 的资源加载器，可以用来缓存 script 和 css, 手机端使用速度快于浏览器直接缓存。
　
Demo：
效果预览地址： https://addyosmani.com/basket...
更多示例请查看官方文档

scrollReveal.js – 使元素以非常酷帅的方式进入画布 (Viewpoint)

github： https://github.com/jlmakes/sc...

官方网站： https://scrollrevealjs.org/https://github.com/moment/mom...

官方网站： http://momentjs.com/

star：30k+

Install：

  bower install moment --save # bower
npm install moment --save   # npm
yarn add moment             # Yarn
Install-Package Moment.js   # NuGet
spm install moment --save   # spm
meteor add momentjs:moment  # meteor

大小：16.6 KB

功能介绍：
　 moment.js是一个轻量级的JavaScript库日期解析、验证操作,格式化日期的库。

Demo：
效果预览地址： http://momentjs.com/

Demo效果预览：
这是一个GIF动图，不信，你看第一行的日期，时间在走。

infinite-scroll – 一款滚动加载按需加载的轻量级插件

github： https://github.com/infinite-s...

官方网站： http://www.infinite-scroll.co...

star：4k+

Install：

  github自行下载

大小：20 KB

功能介绍：
　infinite-scroll是一款滚动加载，滚动到最下到自动加载的轻量级JavaScript插件，简单实用，按需加载提高用户体验，非常适合移动端使用，配合上面的图片懒加载如虎添翼。

Demo：
效果预览地址： http://www.dazeddigital.com/

Demo效果预览：
图片有点大，稍等片刻。建议上面Demo效果预览地址进行预览。

欢迎大家按照格式补充，持续更新，有什么好用的轮子赶紧滚起来吧！

推荐有福利，送1024论坛邀请码，嘿嘿嘿。

DexClassLoader 实现 Android 插件加载

Sun, 19 Apr 2015 12:00:00 CST

Java 中的 ClassLoader:

Java 中 ClassLoader 用于动态加载 Class 到 JVM，包含 BootstrapClassLoader（C++ 编写，用于加载系统核心类）、 ExtClassLoader（用于加载 lib/ext/ 目录的扩展 API）、 AppClassLoader（加载 CLASSPATH 目录下的类）。

双亲委托机制：

任何自定义 ClassLoader 都必须继承 ClassLoader 抽象类，并指定其 parent 加载器，默认为 BootstrapClassLoader;
任何自定义 ClassLoader 在加载一个类之前都会先委托其 parent 去加载，只有 parent 加载失败才会自己加载；
- 这样既可以防止重复加载，又可以排除安全隐患（防止用户替换系统核心类）；
- 所以一般只需要重写 findClass()方法即可（在 parent 加载失败时调用）；
双亲委托机制是在 loadClass() 方法实现的，要想避开（自己验证安全性，比如 Tomcat 的 WebAppClassLoader），必须重写 loadClass() 方法；

自定义 ClassLoader 用途：

在执行非置信代码前先做签名认证等；
从网络、数据库等动态加载类；

类的卸载：

只有当类的实例被回收，才会被 unload，但被 BootstrapClassLoader 加载的系统类除外；
重复加载类会报异常，只能重新定义新的 ClassLoader 再次加载；

Dalvik 的 ClassLoader:

Android 里 ClassLoader 的 defineClass() 方法直接抛出 UnsupportedOperationException 异常，必须借助 DexClassLoader 和 PathClassLoader；
DexClassLoader 和 PathClassLoader 都遵循双亲委托机制，因为只重写了 findClass() 方法，没有重写 loadClass() 方法；
Dalvik 虚拟机识别的是 DexFile 而不是 JarFile；且 DexFile.loadClass() 方法必须通过类加载器调用，否则无效；

利用 DexClassLoader 实现 Android 插件加载:

比如我们在主应用 HostApp 中需要调用视频插件 VideoPlayerPlugin 中的 playVideo() 方法。

给插件加入 Intent 标识:

HostApp 要查询插件信息，只能通过 PackageManager。这里我首先想到的是直接通过其 getPackageInfo() 方法。但是试想，可能插件有很多个，而且包名不同。所以最好还是通过在插件中定义空的 Activity 并加入 Intent 标识，然后调用 queryIntentActivities() 方法去查询插件信息:

<activity android:name=".plugin">     
  <intent-filter>     
    <action android:name="com.rincliu.videoplayerplugin"/>     
  </intent-filter>     
</activity>

查询插件信息:

首先使用 PackageMananer 查询到插件的 packageName 和 ApplicationInfo:

Intent intent = new Intent("com.rincliu.videoplayerplugin");     
List<ResolveInfo> plugins = getPackageManager().queryIntentActivities(intent, 0);     
ActivityInfo act = plugins.get(0).activityInfo;     
String packageName = act.packageName;     
ApplicationInfo app = act.applicationInfo;

上面是直接读取的第一条信息( plugins 要先判空)，如果有很多种插件，或者有好几个版本，这样就需要继续读取插件的版本号等配置信息作进一步区分：

1     
2     
3

Resources res = pm.getResourcesForApplication(packageName);     
int resId = res.getIdentifier("version", "string", packageName);     
String version = res.getString(resId);

使用 DexClassLoader 调用插件：

创建 DexClassLoader 对象：

String dexSourceDir = app.sourceDir;     
String dexOutputDir = getApplicationInfo().dataDir;     
String dexLibDir = app.nativeLibraryDir;     
ClassLoader parentLoader = this.getClass().getClassLoader();     
DexClassLoader loader = new DexClassLoader(dexSourceDir, dexOutputDir, dexLibDir, parentLoader);

使用反射调用插件中的方法：

try {     
  Class<?> clazz  = loader.loadClass(packageName + ".VideoPlayerPlugin");     
       
  //Object obj = clazz.newInstance();     
  Constructor<?> localConstructor = clazz.getConstructor();     
  Object obj = localConstructor.newInstance();     
       
  //Method method = ((Class<?>) obj).getMethod("play", String.class);     
  Method method = clazz.getDeclaredMethod("play", String.class);     
     
  method.invoke(obj, "/sdcard/demo.mp4");     
} catch (Exception e) {}

完整代码

Android插件化（一）：使用改进的MultiDex动态加载assets中的apk

Sun, 27 Dec 2015 18:41:47 CST

Android插件化（一）：使用改进的MultiDex动态加载assets中的apk

简介

为了解决65535方法数超标的问题，Google推荐使用MultiDex来加载classes2.dex,classes3.dex等等，其基本思想就是在运行时动态修改ClassLoader，以达到动态加载类的目的。为了更好的理解MultiDex的工作原理，可以先看一下ClassLoader的工作原理[1].然后参见PathClassLoader的源码，当然，它继承自BaseDexClassLoader，主要源码都在BaseDexClassLoader中。MultiDex加载离线apk的过程如下：

我们可以在Application的onCreate方法或者Activity的attachBaseContext方法中开发加载。

动态加载assets中的apk

根据MultiDex的源码，我们可以修改其install方法，然后从assets资源中解压出所需要加载的apk文件，然后调用installSecondaryDexes方法，将其加载到当前Application的ClassLoader当中，这样，在运行的时候，就可以通过当前的ClassLoader查找到离线apk中的类了。

[AssetsMultiDexLoader.class]

  package net.mobctrl.hostapk;

import java.io.File;
import java.io.FilenameFilter;
import java.io.IOException;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.ListIterator;
import java.util.Set;
import java.util.zip.ZipFile;

import android.content.Context;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageManager;
import android.content.pm.PackageManager.NameNotFoundException;
import android.os.Build;
import android.util.Log;
import dalvik.system.DexFile;

/**
 * @Author Zheng Haibo
 * @Mail mochuan.zhb@alibaba-inc.com
 * @Company Alibaba Group
 * @PersonalWebsite http://www.mobctrl.net
 * @version $Id: AssetsDex.java, v 0.1 2015年12月10日 下午5:36:23 mochuan.zhb Exp $
 * @Description ClassLoader
 */
public class AssetsMultiDexLoader {

    private static final String TAG = "AssetsApkLoader";

    private static boolean installed = false;

    private static final int MAX_SUPPORTED_SDK_VERSION = 20;

    private static final int MIN_SDK_VERSION = 4;

    private static final Set<String> installedApk = new HashSet<String>();

    private AssetsMultiDexLoader() {

    }

    /**
     * 安装Assets中的apk文件
     * 
     * @param context
     */
    public static void install(Context context) {
        Log.i(TAG, "install...");
        if (installed) {
            return;
        }
        try {
            clearOldDexDir(context);
        } catch (Throwable t) {
            Log.w(TAG,
                    "Something went wrong when trying to clear old MultiDex extraction, "
                            + "continuing without cleaning.", t);
        }
        AssetsManager.copyAllAssetsApk(context);
        Log.i(TAG, "install");
        if (Build.VERSION.SDK_INT < MIN_SDK_VERSION) {
            throw new RuntimeException("Multi dex installation failed. SDK "
                    + Build.VERSION.SDK_INT
                    + " is unsupported. Min SDK version is " + MIN_SDK_VERSION
                    + ".");
        }
        try {
            ApplicationInfo applicationInfo = getApplicationInfo(context);
            if (applicationInfo == null) {
                // Looks like running on a test Context, so just return without
                // patching.
                return;
            }
            synchronized (installedApk) {
                String apkPath = applicationInfo.sourceDir;
                if (installedApk.contains(apkPath)) {
                    return;
                }
                installedApk.add(apkPath);
                if (Build.VERSION.SDK_INT > MAX_SUPPORTED_SDK_VERSION) {
                    Log.w(TAG,
                            "MultiDex is not guaranteed to work in SDK version "
                                    + Build.VERSION.SDK_INT
                                    + ": SDK version higher than "
                                    + MAX_SUPPORTED_SDK_VERSION
                                    + " should be backed by "
                                    + "runtime with built-in multidex capabilty but it's not the "
                                    + "case here: java.vm.version=\""
                                    + System.getProperty("java.vm.version")
                                    + "\"");
                }
                /*
                 * The patched class loader is expected to be a descendant of
                 * dalvik.system.BaseDexClassLoader. We modify its
                 * dalvik.system.DexPathList pathList field to append additional
                 * DEX file entries.
                 */
                ClassLoader loader;
                try {
                    loader = context.getClassLoader();
                } catch (RuntimeException e) {
                    /*
                     * Ignore those exceptions so that we don't break tests
                     * relying on Context like a android.test.mock.MockContext
                     * or a android.content.ContextWrapper with a null base
                     * Context.
                     */
                    Log.w(TAG,
                            "Failure while trying to obtain Context class loader. "
                                    + "Must be running in test mode. Skip patching.",
                            e);
                    return;
                }
                if (loader == null) {
                    // Note, the context class loader is null when running
                    // Robolectric tests.
                    Log.e(TAG,
                            "Context class loader is null. Must be running in test mode. "
                                    + "Skip patching.");
                    return;
                }
                // 获取dex文件列表
                File dexDir = context.getDir(AssetsManager.APK_DIR, Context.MODE_PRIVATE);
                File[] szFiles = dexDir.listFiles(new FilenameFilter() {

                    @Override
                    public boolean accept(File dir, String filename) {
                        return filename.endsWith(AssetsManager.FILE_FILTER);
                    }
                });
                List<File> files = new ArrayList<File>();
                for (File f : szFiles) {
                    Log.i(TAG, "load file:" + f.getName());
                    files.add(f);
                }
                Log.i(TAG, "loader before:" + context.getClassLoader());
                installSecondaryDexes(loader, dexDir, files);
                Log.i(TAG, "loader end:" + context.getClassLoader());
            }
        } catch (Exception e) {
            Log.e(TAG, "Multidex installation failure", e);
            throw new RuntimeException("Multi dex installation failed ("
                    + e.getMessage() + ").");
        }
        installed = true;
        Log.i(TAG, "install done");
    }

    private static ApplicationInfo getApplicationInfo(Context context)
            throws NameNotFoundException {
        PackageManager pm;
        String packageName;
        try {
            pm = context.getPackageManager();
            packageName = context.getPackageName();
        } catch (RuntimeException e) {
            /*
             * Ignore those exceptions so that we don't break tests relying on
             * Context like a android.test.mock.MockContext or a
             * android.content.ContextWrapper with a null base Context.
             */
            Log.w(TAG,
                    "Failure while trying to obtain ApplicationInfo from Context. "
                            + "Must be running in test mode. Skip patching.", e);
            return null;
        }
        if (pm == null || packageName == null) {
            // This is most likely a mock context, so just return without
            // patching.
            return null;
        }
        ApplicationInfo applicationInfo = pm.getApplicationInfo(packageName,
                PackageManager.GET_META_DATA);
        return applicationInfo;
    }

    private static void installSecondaryDexes(ClassLoader loader, File dexDir,
            List<File> files) throws IllegalArgumentException,
            IllegalAccessException, NoSuchFieldException,
            InvocationTargetException, NoSuchMethodException, IOException {
        if (!files.isEmpty()) {
            if (Build.VERSION.SDK_INT >= 19) {
                V19.install(loader, files, dexDir);
            } else if (Build.VERSION.SDK_INT >= 14) {
                V14.install(loader, files, dexDir);
            } else {
                V4.install(loader, files);
            }
        }
    }

    /**
     * Locates a given field anywhere in the class inheritance hierarchy.
     *
     * @param instance
     *            an object to search the field into.
     * @param name
     *            field name
     * @return a field object
     * @throws NoSuchFieldException
     *             if the field cannot be located
     */
    private static Field findField(Object instance, String name)
            throws NoSuchFieldException {
        for (Class<?> clazz = instance.getClass(); clazz != null; clazz = clazz
                .getSuperclass()) {
            try {
                Field field = clazz.getDeclaredField(name);

                if (!field.isAccessible()) {
                    field.setAccessible(true);
                }

                return field;
            } catch (NoSuchFieldException e) {
                // ignore and search next
            }
        }

        throw new NoSuchFieldException("Field " + name + " not found in "
                + instance.getClass());
    }

    /**
     * Locates a given method anywhere in the class inheritance hierarchy.
     *
     * @param instance
     *            an object to search the method into.
     * @param name
     *            method name
     * @param parameterTypes
     *            method parameter types
     * @return a method object
     * @throws NoSuchMethodException
     *             if the method cannot be located
     */
    private static Method findMethod(Object instance, String name,
            Class<?>... parameterTypes) throws NoSuchMethodException {
        for (Class<?> clazz = instance.getClass(); clazz != null; clazz = clazz
                .getSuperclass()) {
            try {
                Method method = clazz.getDeclaredMethod(name, parameterTypes);

                if (!method.isAccessible()) {
                    method.setAccessible(true);
                }

                return method;
            } catch (NoSuchMethodException e) {
                // ignore and search next
            }
        }

        throw new NoSuchMethodException("Method " + name + " with parameters "
                + Arrays.asList(parameterTypes) + " not found in "
                + instance.getClass());
    }

    /**
     * Replace the value of a field containing a non null array, by a new array
     * containing the elements of the original array plus the elements of
     * extraElements.
     * 
     * @param instance
     *            the instance whose field is to be modified.
     * @param fieldName
     *            the field to modify.
     * @param extraElements
     *            elements to append at the end of the array.
     */
    private static void expandFieldArray(Object instance, String fieldName,
            Object[] extraElements) throws NoSuchFieldException,
            IllegalArgumentException, IllegalAccessException {
        Field jlrField = findField(instance, fieldName);
        Object[] original = (Object[]) jlrField.get(instance);
        Object[] combined = (Object[]) Array.newInstance(original.getClass()
                .getComponentType(), original.length + extraElements.length);
        System.arraycopy(original, 0, combined, 0, original.length);
        System.arraycopy(extraElements, 0, combined, original.length,
                extraElements.length);
        jlrField.set(instance, combined);
    }

    private static void clearOldDexDir(Context context) throws Exception {
        File dexDir = context.getDir(AssetsManager.APK_DIR, Context.MODE_PRIVATE);
        if (dexDir.isDirectory()) {
            Log.i(TAG, "Clearing old secondary dex dir (" + dexDir.getPath()
                    + ").");
            File[] files = dexDir.listFiles();
            if (files == null) {
                Log.w(TAG, "Failed to list secondary dex dir content ("
                        + dexDir.getPath() + ").");
                return;
            }
            for (File oldFile : files) {
                Log.i(TAG, "Trying to delete old file " + oldFile.getPath()
                        + " of size " + oldFile.length());
                if (!oldFile.delete()) {
                    Log.w(TAG, "Failed to delete old file " + oldFile.getPath());
                } else {
                    Log.i(TAG, "Deleted old file " + oldFile.getPath());
                }
            }
            if (!dexDir.delete()) {
                Log.w(TAG,
                        "Failed to delete secondary dex dir "
                                + dexDir.getPath());
            } else {
                Log.i(TAG, "Deleted old secondary dex dir " + dexDir.getPath());
            }
        }
    }

    /**
     * Installer for platform versions 19.
     */
    private static final class V19 {

        private static void install(ClassLoader loader,
                List<File> additionalClassPathEntries, File optimizedDirectory)
                throws IllegalArgumentException, IllegalAccessException,
                NoSuchFieldException, InvocationTargetException,
                NoSuchMethodException {
            /*
             * The patched class loader is expected to be a descendant of
             * dalvik.system.BaseDexClassLoader. We modify its
             * dalvik.system.DexPathList pathList field to append additional DEX
             * file entries.
             */
            Field pathListField = findField(loader, "pathList");
            Object dexPathList = pathListField.get(loader);
            ArrayList<IOException> suppressedExceptions = new ArrayList<IOException>();
            expandFieldArray(
                    dexPathList,
                    "dexElements",
                    makeDexElements(dexPathList, new ArrayList<File>(
                            additionalClassPathEntries), optimizedDirectory,
                            suppressedExceptions));
            if (suppressedExceptions.size() > 0) {
                for (IOException e : suppressedExceptions) {
                    Log.w(TAG, "Exception in makeDexElement", e);
                }
                Field suppressedExceptionsField = findField(loader,
                        "dexElementsSuppressedExceptions");
                IOException[] dexElementsSuppressedExceptions = (IOException[]) suppressedExceptionsField
                        .get(loader);

                if (dexElementsSuppressedExceptions == null) {
                    dexElementsSuppressedExceptions = suppressedExceptions
                            .toArray(new IOException[suppressedExceptions
                                    .size()]);
                } else {
                    IOException[] combined = new IOException[suppressedExceptions
                            .size() + dexElementsSuppressedExceptions.length];
                    suppressedExceptions.toArray(combined);
                    System.arraycopy(dexElementsSuppressedExceptions, 0,
                            combined, suppressedExceptions.size(),
                            dexElementsSuppressedExceptions.length);
                    dexElementsSuppressedExceptions = combined;
                }

                suppressedExceptionsField.set(loader,
                        dexElementsSuppressedExceptions);
            }
        }

        /**
         * A wrapper around
         * {@code private static final dalvik.system.DexPathList#makeDexElements}
         * .
         */
        private static Object[] makeDexElements(Object dexPathList,
                ArrayList<File> files, File optimizedDirectory,
                ArrayList<IOException> suppressedExceptions)
                throws IllegalAccessException, InvocationTargetException,
                NoSuchMethodException {
            Method makeDexElements = findMethod(dexPathList, "makeDexElements",
                    ArrayList.class, File.class, ArrayList.class);

            return (Object[]) makeDexElements.invoke(dexPathList, files,
                    optimizedDirectory, suppressedExceptions);
        }
    }

    /**
     * Installer for platform versions 14, 15, 16, 17 and 18.
     */
    private static final class V14 {

        private static void install(ClassLoader loader,
                List<File> additionalClassPathEntries, File optimizedDirectory)
                throws IllegalArgumentException, IllegalAccessException,
                NoSuchFieldException, InvocationTargetException,
                NoSuchMethodException {
            /*
             * The patched class loader is expected to be a descendant of
             * dalvik.system.BaseDexClassLoader. We modify its
             * dalvik.system.DexPathList pathList field to append additional DEX
             * file entries.
             */
            Field pathListField = findField(loader, "pathList");
            Object dexPathList = pathListField.get(loader);
            expandFieldArray(
                    dexPathList,
                    "dexElements",
                    makeDexElements(dexPathList, new ArrayList<File>(
                            additionalClassPathEntries), optimizedDirectory));
        }

        /**
         * A wrapper around
         * {@code private static final dalvik.system.DexPathList#makeDexElements}
         * .
         */
        private static Object[] makeDexElements(Object dexPathList,
                ArrayList<File> files, File optimizedDirectory)
                throws IllegalAccessException, InvocationTargetException,
                NoSuchMethodException {
            Method makeDexElements = findMethod(dexPathList, "makeDexElements",
                    ArrayList.class, File.class);

            return (Object[]) makeDexElements.invoke(dexPathList, files,
                    optimizedDirectory);
        }
    }

    /**
     * Installer for platform versions 4 to 13.
     */
    private static final class V4 {
        private static void install(ClassLoader loader,
                List<File> additionalClassPathEntries)
                throws IllegalArgumentException, IllegalAccessException,
                NoSuchFieldException, IOException {
            /*
             * The patched class loader is expected to be a descendant of
             * dalvik.system.DexClassLoader. We modify its fields mPaths,
             * mFiles, mZips and mDexs to append additional DEX file entries.
             */
            int extraSize = additionalClassPathEntries.size();

            Field pathField = findField(loader, "path");

            StringBuilder path = new StringBuilder(
                    (String) pathField.get(loader));
            String[] extraPaths = new String[extraSize];
            File[] extraFiles = new File[extraSize];
            ZipFile[] extraZips = new ZipFile[extraSize];
            DexFile[] extraDexs = new DexFile[extraSize];
            for (ListIterator<File> iterator = additionalClassPathEntries
                    .listIterator(); iterator.hasNext();) {
                File additionalEntry = iterator.next();
                String entryPath = additionalEntry.getAbsolutePath();
                path.append(':').append(entryPath);
                int index = iterator.previousIndex();
                extraPaths[index] = entryPath;
                extraFiles[index] = additionalEntry;
                extraZips[index] = new ZipFile(additionalEntry);
                extraDexs[index] = DexFile.loadDex(entryPath, entryPath
                        + ".dex", 0);
            }

            pathField.set(loader, path.toString());
            expandFieldArray(loader, "mPaths", extraPaths);
            expandFieldArray(loader, "mFiles", extraFiles);
            expandFieldArray(loader, "mZips", extraZips);
            expandFieldArray(loader, "mDexs", extraDexs);
        }
    }

}

[AssetsManager.java]

  package net.mobctrl.hostapk;

import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;

import android.content.Context;
import android.content.res.AssetManager;
import android.util.Log;

/**
 * @Author Zheng Haibo
 * @Mail mochuan.zhb@alibaba-inc.com
 * @Company Alibaba Group
 * @PersonalWebsite http://www.mobctrl.net
 * @version $Id: AssetsManager.java, v 0.1 2015年12月11日 下午4:41:10 mochuan.zhb Exp $
 * @Description
 */
public class AssetsManager {

    public static final String TAG = "AssetsApkLoader";

    //从assets复制出去的apk的目标目录
    public static final String APK_DIR = "third_apk";

    //文件结尾过滤
    public static final String FILE_FILTER = ".apk";


    /**
     * 将资源文件中的apk文件拷贝到私有目录中
     * 
     * @param context
     */
    public static void copyAllAssetsApk(Context context) {

        AssetManager assetManager = context.getAssets();
        long startTime = System.currentTimeMillis();
        try {
            File dex = context.getDir(APK_DIR, Context.MODE_PRIVATE);
            dex.mkdir();
            String []fileNames = assetManager.list("");
            for(String fileName:fileNames){
                if(!fileName.endsWith(FILE_FILTER)){
                    return;
                }
                InputStream in = null;
                OutputStream out = null;
                in = assetManager.open(fileName);
                File f = new File(dex, fileName);
                if (f.exists() && f.length() == in.available()) {
                    Log.i(TAG, fileName+"no change");
                    return;
                }
                Log.i(TAG, fileName+" chaneged");
                out = new FileOutputStream(f);
                byte[] buffer = new byte[2048];
                int read;
                while ((read = in.read(buffer)) != -1) {
                    out.write(buffer, 0, read);
                }
                in.close();
                in = null;
                out.flush();
                out.close();
                out = null;
                Log.i(TAG, fileName+" copy over");
            }
            Log.i(TAG,"###copyAssets time = "+(System.currentTimeMillis() - startTime));
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

以上就是从assets中加载apk的核心代码。

DEMO运行

打开BundleApk项目，编译成apk。然后将BundleApk.apk文件拷贝到HostApk项目的assets目录，在HostApk的MainActivity方法的onCreate当中，调用AssetsMultiDexLoader.install(getApplicationContext());加载BundleApk.apk。然后我们就可以通过如下两种方式调用BundleApk中的类：

Class.forName
由于我们的HostApk没有BundleApk类的引用，所以我们需要用反射的方式调用。

  private void loadClass(){
        try{
            Class<?> clazz = Class.forName("net.mobctrl.normal.apk.FileUtils");

            Constructor<?> constructor = clazz.getConstructor();
            Object bundleUtils = constructor.newInstance();

            Method printSumMethod = clazz.getMethod("print", Context.class,String.class);
            printSumMethod.setAccessible(true);
            printSumMethod.invoke(bundleUtils,
                    getApplicationContext(), "Hello");
        }catch(Exception e){
            e.printStackTrace();
        }

    }

loadClass
我们也可以直接获取当前的ClassLoader对象，然后调用其loadClass方法

  @TargetApi(Build.VERSION_CODES.ICE_CREAM_SANDWICH)
    private void loadApk() {
        try {
            Class<?> clazz = getClassLoader()
                    .loadClass("net.mobctrl.normal.apk.Utils");
            Constructor<?> constructor = clazz.getConstructor();
            Object bundleUtils = constructor.newInstance();

            Method printSumMethod = clazz.getMethod("printSum", Context.class,
                    int.class, int.class, String.class);
            printSumMethod.setAccessible(true);
            Integer sum = (Integer)printSumMethod.invoke(bundleUtils,
                    getApplicationContext(), 10, 20, "计算结果");
            System.out.println("debug:sum = " + sum);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SecurityException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }

参考文章

[1]. ClassLoader的工作原理
[2]. PathClassLoader源码
[3]. MultiDex源码

作者：NUPTboyZHB 发表于2015/12/27 10:41:47 原文链接

阅读：0 评论：0 查看评论

基于插件开发的Android实现流程

Tue, 11 Mar 2014 05:47:30 CST

转载请注明地址：http://blog.csdn.net/droyon/article/details/20951797

本文记述“柯元旦”Android内核剖析中基于类装载器的“插件”架构。

插件的概念：

1、插件不能独立运行，而必须运行于一个宿主程序中，即由宿主程序去调用插件程序。

2、插件一般可以独安装。

3、宿主程序中可以管理不同的插件，包括查看插件的数目，禁用或者使用某个插件。

4、宿主程序应该保证插件的向下兼容性，即新版本的宿主程序可以运行较老版本的插件。

下面详细看一下这种架构：

1、宿主程序：

新建Android项目PluginDevAndroid

2、插件项目1：Plugin1

3、插件项目2：

4、综述：

4.1、接口类一般定义在宿主项目中，比如本例中的IPluginDev.java

4.2、插件项目需要应用IPluginDev时，则必须通过一个外部的jar包，并且该jar包是以Library的形式被添加到Plugin项目的build Path，而不是以“外部的”jar方式添加。

如图：

4.3、宿主程序想要知道系统中有哪些插件，可以定义一个Action，本例中使用的是如下action。

这样的话，宿主程序就可以通过PackageManager类的queryIntentActivities函数查询相关的插件的列表了。

得到了插件的PackageName，就可以访问插件的资源内容。例如：

				Resources res = pm.getResourcesForApplication(packageName);
				int id = 0;
				id = res.getIdentifier("version", "string", packageName);
				String version = res.getString(id);
				Log.d("hlwang", "MainActivity test version is:"+version);

这段代码中，首先获取插件的Resource对象，接着得到名称为version字段的字符串id值，然后再调用getString获得该变量的值，于是宿主程序就知道插件程序中的资源内容了。

关键代码：

private void test(){
		Intent intent = new Intent("com.example.plugindevandroid.plugin",null);
		final PackageManager pm = getPackageManager();
		final List<ResolveInfo> plugins = pm.queryIntentActivities(intent, 0);
		
		for(ResolveInfo r:plugins){
			ActivityInfo activityInfo = r.activityInfo;
			
			String div = System.getProperty("path.separator");
			String packageName = activityInfo.packageName;
			String packageName0 = getPackageName();
			String dexPath = activityInfo.applicationInfo.sourceDir;
			String dexOutputDir1 = activityInfo.applicationInfo.dataDir;
			String dexOutputDir2 = getApplicationInfo().dataDir;
			String libPath = activityInfo.applicationInfo.nativeLibraryDir;
			
			Log.d("hlwang", "MainActivity test div is:"+div
					+",packageName is:"+packageName
					+",packageName0 is:"+packageName0
					+",dexPath is:"+dexPath
					+",dexOutputDir1 is:"+dexOutputDir1
					+",dexOutputDir2 is:"+dexOutputDir2
					+",libPath is:"+libPath);
			
			DexClassLoader dexCl = new DexClassLoader(dexPath, dexOutputDir2, libPath, getClassLoader());
			Log.d("hlwang", "MainActivity test clazzName is:"+packageName+".PluginVersion");
			try{
				Class clazz = dexCl.loadClass(packageName+".PluginVersion");
				IPluginDev plugin = (IPluginDev) clazz.newInstance();
				String name = plugin.getName();
				Log.d("hlwang", "MainActivity test name is:"+name);
				
				Resources res = pm.getResourcesForApplication(packageName);
				int id = 0;
				id = res.getIdentifier("version", "string", packageName);
				String version = res.getString(id);
				Log.d("hlwang", "MainActivity test version is:"+version);
				
				
				PluginObject p = new PluginObject();
				p.name = name;
				p.version = version;
				Log.d("hlwang", "MainActivity test p is:"+p);
				mList.add(p);
			}catch(Exception e){
				Log.d("hlwang", "MainActivity exception eeeeeeeeeeeee");
				e.printStackTrace();
			}
			
		}
		Log.d("hlwang", "MainActivity test list size is:"+mList.size());
		setListAdapter(new ArrayAdapter<PluginObject>(this,
                android.R.layout.simple_list_item_1, mList));
	}

这段代码中，首先得到插件的List<ResolverInfo>列表。

然后得到插件的packageName，以及插件的dexPath目录。

再次，得到dexOutputDir目录。

libPath一般只c/c++使用的库文件。

DexClassLoader的参数意义：

dexPath：插件apk或者jar包文件的路径

dexOutputDir：将目标apk或者jar包解压的文件的存放目录。因为宿主程序只对本应用程序所在的目录由存取权限。

运行截图：

作者：hailushijie 发表于2014-3-10 21:47:30 原文链接

阅读：30 评论：0 查看评论

Android 使用动态加载框架DL进行插件化开发

Mon, 20 Oct 2014 08:06:28 CST

如有转载，请声明出处: 时之沙: http://blog.csdn.net/t12x3456 （来自时之沙的csdn博客）

概述:

随着应用的不断迭代，应用的体积不断增大,项目越来越臃肿,冗余增加.项目新功能的添加，无法确定与用户匹配性，发生严重异常往往牵一发而动全身,只能紧急发布补丁版本，强制用户进行更新.结果频繁的更新，反而容易降低用户使用黏性.或者是公司业务的不断发展,同系的应用越来越多,传统方式需要通过用户量最大的主项目进行引导下载并安装.

怎么办?参考浏览器-插件开发模式:

一. 来可以将自己的应用分拆，某些功能可以在插件中实现，用到时再进行下载，而且不用安装. 如果有新功能的添加，不需要更新应用，只要预留插件管理，我们就可以通过添加插件的方式，动态更新自己的应用,该功能需要改进或扩展，更新插件即可，无需频繁安装或卸载(容易造成用户反感).

二. 对应同系应用，正常的引流方式只能引导用户进行新应用的下载和安装,如果使用插件化开发，则无需安装应用，关闭插件功能也十分方便，省去应用安装和卸载的过程,可以实现无缝引流.

这里要向大家推荐一个开源的动态加载框架 DL, 该项目由 singwhatiwanna发起,目前一共有三个人开发，我有幸成为了其中的contributor.

如果你对DL动态加载框架还不熟悉，建议先看一下这篇文章:

APK动态加载框架DL解析 http://blog.csdn.net/singwhatiwanna/article/details/39937639

如果你看过之后还会不太清晰，请看下DL插件化框架的全景图,如下

这里我主要向大家介绍一下利用DL框架进行开发的具体步骤:

1. 首先我们需要从github上获取项目代码:

https://github.com/singwhatiwanna/dynamic-load-apk

这里我们可以看到下载后的目录如下

lib目录就是我们的公共插件库

sample目录是对应的demo, 具体的工程可以参照上面的DL全景图中的三种模式:

由于一般项目中，代码管理和开发团队相对独立，一般插件工程的团队是很难接触主项目团队的代码.因此，这里主要以第一种，也是我们最为推荐的方式进行，采用插件不依赖宿主的方式进行开发. 不需要两个团队过多的交互，开发效率相对较高.

2 导入lib工程,如下所示:

可以看到bin目录下的dl-lib.jar, 如果我们需要对lib工程进行修改，重新build获取对应的dl-lib.jar即可

3. 插件工程的开发, 导入demo中的main-plugin工程

首先还是要强调插件开发的注意事项，以免出现不必要的错误

插件也需要引用DL的jar包，但是不能放入到插件工程的libs目录下面，换句话说，就是插件编译的时候依赖jar包但是打包成apk的时候不要把jar包打进去，这是因为，dl-lib.jar已经在宿主工程中存在了，如果插件中也有这个jar包，就会发生类链接错误，原因很简单，内存中有两份一样的类，重复了。至于support-v4也是同样的道理。对于eclipse很简单，只需要在插件工程中创建一个目录，比如external-jars，然后把dl-lib.jar和support-v4.jar放进去，同时在.classpath中追加如下两句即可：

<classpathentry kind="lib" path="external-jars/dl-lib.jar"/>
<classpathentry kind="lib" path="external-jars/android-support-v4.jar"/>

然后是插件开发中的具体步骤

(1) 如果原有的为Activity,这里需要改为继承DLBasePluginActivity,如果原来为FragmentActivity,那么需要继承DLBasePluginFragmentActivity, for example:

public class MainActivity extends DLBasePluginActivity

TestFragmentActivity extends DLBasePluginFragmentActivity

(2) 如果需要插件独立安装运行, 只要将jar放到libs下面即可,若支持动态加载，仍需按上述注意事项加入 exteral-jars中

(3)插件所需要权限需要在宿主工程中声明

如果是实际开发，一般为从服务器获取插件，这里我们方便自己调试演示,将运行生成对应的插件apk,放入sd卡上的DynamicLoadHost目录中

4. 宿主工程中将上述生成的dl-lib.jar加入libs即可,如下所示为demo中提供的宿主工程

在宿主工程中，首先我们需要获取要调用的插件apk对应的MainActivity,DL的demo中插件路径为 sd卡上的DynamicLoadHost目录,没有的话需要创建，或者根据自己需求进行修改.

        String pluginFolder = Environment.getExternalStorageDirectory() + "/DynamicLoadHost";
        File file = new File(pluginFolder);
        File[] plugins = file.listFiles();
        if (plugins == null || plugins.length == 0) {
            mNoPluginTextView.setVisibility(View.VISIBLE);
            return;
        }

        for (File plugin : plugins) {
            PluginItem item = new PluginItem();
            item.pluginPath = plugin.getAbsolutePath();
            item.packageInfo = DLUtils.getPackageInfo(this, item.pluginPath);
            if (item.packageInfo.activities != null && item.packageInfo.activities.length > 0) {
                item.launcherActivityName = item.packageInfo.activities[0].name;
            }
            mPluginItems.add(item);
        }

接着是调起响应的apk,这时需要使用dl-lib.jar:

(1)通过Class.forName的方式获取我们需要调用的插件apk中MainActivity的class对象

(2) 就上面提到的，我们需要判断该对象继承自DLProxActivity还是DLProxFragmentActivity,得到对应的代理class对象

(3)使用对应的代理class对象调起插件apk

 PluginItem item = mPluginItems.get(position);
        Class<?> proxyCls = null;

        try {
            Class<?> cls = Class.forName(item.launcherActivityName, false,
                    DLClassLoader.getClassLoader(item.pluginPath, getApplicationContext(), getClassLoader()));
            if (cls.asSubclass(DLBasePluginActivity.class) != null) {
                proxyCls = DLProxyActivity.class;
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
            Toast.makeText(this,
                    "load plugin apk failed, load class " + item.launcherActivityName + " failed.",
                    Toast.LENGTH_SHORT).show();
        } catch (ClassCastException e) {
            // ignored
        } finally {
            if (proxyCls == null) {
                proxyCls = DLProxyFragmentActivity.class;
            }
            Intent intent = new Intent(this, proxyCls);
            intent.putExtra(DLConstants.EXTRA_DEX_PATH,
                    mPluginItems.get(position).pluginPath);
            startActivity(intent);
        }

最后运行宿主工程 main-host,就可以看到最终的效果:

相信大家经过如上步骤，可以对DL动态加载框架进行开发有了一定了解.目前DL框架仍在不断扩展中，欢迎对我们的项目进行star,fork，或者提出宝贵的建议.，如有问题请及时反馈,我们会在后续版本中进行修复或者改进.

作者：t12x3456 发表于2014-10-20 0:06:28 原文链接

阅读：125 评论：1 查看评论

流行WordPress SEO插件曝高危SQL注入漏洞

Thu, 12 Mar 2015 17:16:54 CST

最新消息，全球最流行的CMS应用WordPress插件WordPress SEO by Yoast曝高危SQL注入漏洞，该插件使用频率相当高，用户高达可达千万。

漏洞简述

WordPress SEO by Yoast插件是WordPress平台下非常流行的SEO插件，看其在Yoast网站上高达1400万次的下载量就知道了。

该漏洞是WordPress漏洞扫描器“WPScan”开发者Ryan Dewhurst发现——1.7.3.3之前版本的WordPress SEO by Yoast都会受到SQL盲注web应用程序漏洞的影响。SQL注入漏洞之所以被标记为高危漏洞，是因为它可能会导致大量数据和敏感信息泄露。通常，在SQL注入攻击中，攻击者会通过客户端在应用程序中输入一个畸形的SQL请求。

‍

攻击详情

该漏洞仅影响WordPress内部用户，因为该漏洞存在于admin/class-bulk-editor-list-table.php文件中，而此文件只有WordPress管理员、编辑和特权作者才能访问。

为了成功利用这一漏洞，攻击者需要从授权用户（管理员、编辑、作者）处利用该漏洞。当然授权用户是不会乖乖帮你攻击东家的，这就需要社会工程学的帮助了，攻击者可以欺骗用户进入一个精心编写的URL中，如果授权用户成为了此次攻击的受害者，那么攻击者就可利用此漏洞在受害者的WordPress网站上执行任意SQL请求。

漏洞利用POC

Ryan提供了一个SQL盲注漏洞的poc：

http://victim-wordpress-website.com/wp-admin/admin.php?page=wpseo_bulk-editor&type=title&orderby=post_date%2c(select%20*%20from%20(select(sleep(10)))a)&order=asc

修复补丁

1.7.4版本的WordPress SEO by Yoast（最新版）已经修复了该漏洞，顺便还修复了其中的CSRF漏洞。

最新版本的WordPress已经废除了自动更新插件的功能，建议用户尽快手动更新WordPress SEO by Yoast。

[参考来源 thehackernews ，转载请注明来自FreeBuf黑客与极客（FreeBuf.COM）]

Activiti的Eclipse插件安装指南

Wed, 25 Mar 2015 10:08:47 CST

群里有一哥们儿安装Activiti的Eclipse插件安装了2天了还没装好，我看了都快急死了，好人做到底，特地为他写了这篇博客。

我个人不喜欢在线安装的方式，因为速度太慢，而且过于傻瓜式，我对于傻瓜式的东西不感兴趣，这也是为什么我喜欢Eclispe而不喜欢用MyEclipse的原因，当然MyEclipse更卡也有一部分原因，额，扯远了哈，回归正题，离线方式安装Activiti的Eclipse插件的话，首先你需要去下载Activiti-designer压缩包即Activiti的eclipse插件安装包，下载地址如下：

http://www.activiti.org/designer/archived/

如图下载：

下载完成后，你将得到一个zip压缩包如图：

然后在任意盘符新建一个文件夹用来存放解压后的文件，这里我是在E盘新建一个activiti-designer-0.6.0文件夹，如图：

然后选择下载得到的zip压缩包，鼠标右键解压文件，如图操作：

解压后如图：

删除artifacts.jar、content.jar、site.xml这3个文件，删除后如图：

接着在E:\activiti-designer-0.6.0下新建一个eclipse文件夹，如图：

接着把E:\activiti-designer-0.6.0文件夹下的文件以及目录(除了eclipse之外)全部剪切到eclipse文件夹下，如图操作：

点击进入eclipse文件夹，然后ctrl + v粘帖进去，操作完后效果如图：

然后切到你的eclipse安装根目录( 我不用MyEclipse,别问我为什么不以MyEclipse为例来做教程)，如图：

我的Eclipse安装在E盘根目录下，看到dropins文件夹了吗？我们的插件link文件就全部定义在这里，点击进入dropins文件夹，在里面新建一个activiti.link文件，如图操作：

然后使用任何一款文本编辑器打开activiti.link文件，比如记事本，NotePad++,EditPlus等都行，这里我使用的是Sublime text2,如图：

然后重启你的Eclipse，哦，忘了说了，我用的Eclipse版本是3.7.0，如图：

建议你Eclipse版本至少得是3.6.0版本及以上。

为了避免Eclipse缓存原因，在重启Eclipse之前，记得先clean下Eclipse的缓存，如图操作：

设置好后，双击打开你的Eclipse,然后检查是否安装成功，具体请如图操作，看图：

照着我的教程一步一步做，100%是可以安装成功的，不要再来问我为什么安装不成功，那问题肯定是你没有看仔细，没有按教程里的截图照葫芦画瓢。而且， 你学会了安装Activiti的Eclipse插件，其实以后安装其他的Eclipse插件步骤也是差不多的，大家要学会举一反三，这也是为什么我一向很反对在线方式安装，不仅仅是安装过程很漫长，更重要的是，采用links离线安装，更能锻炼你的动手实践能力，让你更了解Eclipse插件是如何安装的。就说这么多了，本来是要昨晚就要写完这篇的，结果昨晚写到12点的时候实在太困了，扛不住，写了一半就睡了，证明我老咯，连12点都熬不住了，2年前每天奋战到1-2点都跟打了鸡血似得，废话不多说了，Thanks all !!!

如果你还有什么问题请加我Ｑ-Q：7-3-6-0-3-1-3-0-5，

或者加裙
一起交流学习！

已有 0 人发表留言，猛击->> 这里<<-参与讨论

ITeye推荐

—软件人才免语言低担保赴美带薪读研！—

jQuery.bsgrid 1.30 发布，简易 jQuery Grid 插件

Fri, 26 Dec 2014 16:19:20 CST

jQuery.bsgrid 简单易用的jQuery Grid插件

jquery bsgrid，A simple jQuery Grid plugin with pagation, export and easy to expand. 一个简单易用的jQuery Grid插件，内置提供多套皮肤且非常容易扩展，支持分页或不分页，支持json、xml数据格式，对导出友好，扩展性友好。

本插件的目标是提供简洁实用、代码轻便、扩展性强的Grid功能。

本插件的早期及当前版本已在多个项目中使用。

开源协议：Apache Licence 2
插件版本：1.30
在线演示： http://bsgrid.oschina.mopaas.com/
本开源插件已提供交流群，详见演示页面或源码主页，欢迎交流提意见或对插件进行完善优化。

本次重大更新：

1，提供grid.extend扩展，推荐grid扩展接口使用方式，更方便扩展；
扩展示例1： http://bsgrid.oschina.mopaas.com/examples/grid/extend.html
效果图示如下，此示例中详细演示说明了grid.extend如何自定义扩展使用

扩展接口说明（使用参考上面的示例或grid.extend.js）：
extend config methos, use write see grid.extend.js(Note that it's advanced use with little difficult):
extend.initGridMethods: extend init grid methods
extend.beforeRenderGridMethods: extend before render grid methods
extend.renderPerRowMethods: extend render per row methods, no matter blank row or not blank row, before render per column methods
extend.renderPerColumnMethods: extend render per column methods, no matter blank column or not blank column
extend.afterRenderGridMethods: extend after render grid methods

2，grid表头可拖动列宽
示例： http://bsgrid.oschina.mopaas.com/examples/grid/move-column-extend.html

3，grid完整方法及属性演示说明，使用此grid强烈推荐熟悉此页面及代码、说明
http://bsgrid.oschina.mopaas.com/examples/grid/standard.html

4，版本API定型，对实现进行了一点优化；
5，较大的优化了示例展示

利用firebreath开发跨浏览器插件

Sun, 14 Sep 2014 22:33:42 CST

在研发ZCMS系统过程中，我们发现很多用户在上传截图时，需要先另存为图片文件然后再选择上传，过程操作复杂。于是我们想通过用户直接粘贴图片到编辑器并上传。要实现这一功能必须实现获取用户剪切板中的图片数据并保存到本地。浏览器本身没有相应的功能，因此我们考虑到用浏览器插件的方式实现。为了兼容各个浏览器，我们选择了frirebreath，实现插件在不同浏览器的通用。

首先介绍一下FireBreath。FireBreath 旨在提供一个跨平台支持的浏览器插件体系架构，面向：

NPAPI 浏览器（windows, mac, and linux）:
- Gecko/Firefox
- Google Chrome
- Apple Safari
ActiveX 架构:

Microsoft Internet Explorer 6, 7, and 8,9,10,11

下面将分步介绍开发过程。
1.下载最新的FireBreath代码 http://www.firebreath.org/display/documentation/Download
2.下载安装python 2.7 https://www.python.org/downloads/release/python-278/

3.解压FireBreath,并进入目录运行 python fbgen.py

运行后目录下将生成project目录，并生成相应的文件夹生成后，运行相应的prep*.cmd,比如prep2008.cmd，将生成适应vs2008版本的工程文件

4.打开sln文件

工程中生成了相应的npapi和activex的代码，主要修改对应项目名称目录下的文件即可。

其中***API.cpp和***API.h中定义了相关的示例方法，比如echo方法，我们可以直接编译。对应目录下会生成对应的np***.dll文件。我们可以打开FBControl.htm进行测试。在测试之前，需要注册到浏览器中，firefox和chrome需要通过注册表注册找到HKEY_LOCAL_MACHINE\Software\MozillaPlugins\ ，添加@zvingsoft/ZCMSPastePlugin，并设置path description，以及MimeTypes

在firefox和chrome地址栏中输入 about:plugins查看对应的插件是否已经成功安装

可以打开FBControl.htm进行测试

注意：在ie中需要通过regsvr32对dll注册

5.在***API.h和***API.cpp文件中增加图片保存方法

***API.h

//注册方法暴露到js方法中调用
registerMethod("saveClipImage", make_method(this, &ZCMSPastePluginAPI::saveClipImage));

......

FB::variant saveClipImage();

// Event helpers
 FB_JSAPI_EVENT(test, 0
FB_JSAPI_EVENT(saveClipImage, 0, ());

***API.cpp

FB::variant ZCMSPastePluginAPI::saveClipImage()
{
    if (!OpenClipboard(NULL))
  return "";
 
 HBITMAP hBitmap = (HBITMAP)GetClipboardData(CF_BITMAP);
 CloseClipboard();

 //HWND hWnd = GetDesktopWindow();
 if (hBitmap == NULL)
  return "";
 CImage image;
 image.Attach(hBitmap);
 TCHAR OutPath[MAX_PATH];
    int StrLen = GetTempPath(MAX_PATH, OutPath);
 CString str = CString((LPCTSTR)OutPath) + CString(_T("zcmspaste.png"));
 image.Save((LPCTSTR)str, Gdiplus::ImageFormatPNG); 
    // return "foobar";
    return str;
}

通过js调用相关方法

  function saveClipImage()
        {
            if(plugin().valid){
                var path = plugin().saveClipImage();
                if(!path){
                 alert("剪贴板中没有图片");
                }else{
                 alert("图片已保存："+path);
                 document.getElementById("test").src = path;
                }
            } else {
                alert("Plugin is not working :(");
            }
        }

6.为了能够让用户直接使用，建议使用innosetup制作安装文件，下面示例中将dll进行注册，并加入到注册表。

[Files]
Source: "G:\FireBreath1.7\build\bin\ZCMSPastePlugin\Debug\npZCMSPastePlugin.dll"; DestDir: "{app}"; Flags: regserver restartreplace noregerror replacesameversion uninsnosharedfileprompt sharedfile ignoreversion


[Registry]
Root: HKLM; Subkey: Software\MozillaPlugins\@zvingsoft/ZCMSPastePlugin; ValueType: string; Flags: uninsdeletekey
Root: HKLM; Subkey: Software\MozillaPlugins\@zvingsoft/ZCMSPastePlugin; ValueName: Path; ValueData: {app}\npZCMSPastePlugin.dll; ValueType: string
Root: HKLM; Subkey: Software\MozillaPlugins\@zvingsoft/ZCMSPastePlugin; ValueName: Description; ValueData: ZCMS paste image Plugin; ValueType: string
Root: HKLM; Subkey: Software\MozillaPlugins\@zvingsoft/ZCMSPastePlugin\MimeTypes; ValueType: string; Flags: uninsdeletekey
Root: HKLM; Subkey: Software\MozillaPlugins\@zvingsoft/ZCMSPastePlugin\MimeTypes\application/x-zcms-paste-plugin; ValueType: string; Flags: uninsdeletekey

已有 0 人发表留言，猛击->> 这里<<-参与讨论

ITeye推荐

—软件人才免语言低担保赴美带薪读研！—

40个Bootstrap的扩展和插件集合

Thu, 11 Sep 2014 09:33:27 CST

Bootstrap的出现可以说让很多程序员相当的兴奋。在漫长的过去，我们看到过很多呆板的原型网页，简单甚至粗暴，毫无设计感和色彩感可言。那是一个个技术大牛们痛苦的拉出的界面。随着网页设计师的出现，慢慢的网站建设开始从单一的程序员一条龙服务开始转变为网页设计师和程序员来共同完成。但是对于很多喜欢自己捣鼓的程序员来说，如果有一条完整统一的样式可以调用，那是多么美好的一件事情。于是，伟大的Bootstrap终于诞生啦。淡然，Bootstrap不仅仅是程序员的福音。很多前端设计师也开始使用起来。因为其高效的架构，通用的维护，甚至可以设计的相当时尚，还有很多插件和扩展可以直接调用。还有什么不爱的理由呢！今天我们要分享出的就是类似这样的一些优秀的Bootstrap扩展和插件。可以让你的网站架构更加高效。赶快来看看吧！

Bootstrap Calendar

Full view calendar with year, month, week and day views based on templates with Twitter Bootstrap.

Bootstrap Modal Carousel

A set of plugins to display a carousel into a fullscreen modal box.

Css3 Microsoft Metro Buttons

My CSS3 library for making Microsoft-metro themed buttons.

Bootstrap Prompts

BootStrap Alert with modal instead of Browser alert.

Pretty Checkable

This plugin replaces the default checkboxes and radio inputs for better looking ones.

Jquery Simplecolorpicker

Yet another jQuery color picker. This plugin is unobtrusive and integrates well with Twitter Bootstrap (it works just fine without).

Bootstrap Combobox

A combobox plugin that works with twitter bootstrap.

Bootstrap Datepicker

A Date Range Picker for Bootstrap

Clockpicker

A clock-style timepicker for Bootstrap (or jQuery).

Bootbox

Wrappers for JavaScript alert(), confirm() and other flexible dialogs using Twitter’s bootstrap framework.

Jquery Gridform

jQuery-Plugin for creating complex forms (table-based) with usage of bootstrap and (optional) Font-Awesome.

JqBootstrap Validation

A JQuery validation framework for bootstrap forms.

Table clothjs

A CSS and JS bootstrap to style and manipulate data tables.

Bootstrap Navigable Table

A Bootstrap plugin for elegant navigating along table inputs.

Bootstrap Confirmation

Javascript plug-in for Twitter bootstrap. Require JQuery and Bootstrap-Tooptip.js to run. This is in Beta state.

jQuery File Upload Demo

File Upload widget with multiple file selection, drag and drop support, progress bar, validation and preview images, audio and video for jQuery.

Bootstrap Image Gallery

Bootstrap Image Gallery is an extension to blueimp Gallery, a touch-enabled, responsive and customizable image and video gallery.

X-editable

In-place editing with Twitter Bootstrap, jQuery UI or pure jQuery.

jQDraw Bootstrap Grid

A simple jQuery plugin that draws grid columns to a twitter bootstrap enabled layout.

Bootstrap Magnify

Small bootstrap js plugin to enhance porte-folios and image galleries.

Bootstrap Markdown

Bootstrap plugin for markdown editing.

Bootstrap Modal

Extends the default Bootstrap Modal class. Responsive, stackable, ajax and more.

Bootstrap Scroll Modal

A modification of the Twitter Bootstrap Modal plugin – allows for any height modal with full page scrolling of said modal.

MetisMenu

Easy menu jQuery plugin for Twitter Bootstrap 3.

Bootstrap Contextmenu

Context menu plugin for Twitter’s Bootstrap framework.

Jquery Bootpag

This jQuery plugin helps you create dynamic pagination with Bootstrap or in any other html pages.

Twbs Pagination

Bootstrap Social

Social Buttons made in pure CSS based on Bootstrap and Font Awesome!

Bselect

The select decorator component that was missing for Twitter Bootstrap.

Bootstrap Multiselect

Bootstrap Multiselect is a JQuery based plugin to provide an intuitive user interface for using select inputs with the multiple attribute present.

Bootstrap Multisuggest Plugin

Bootstrap Tags

Bootstrap Tags is a jQuery plugin meant to extend Twitter Bootstrap to include tagging functionality.

Tocify

A jQuery Table of Contents plugin that can be themed with Twitter Bootstrap or jQueryUI.

Tokenfield

Tabcordion

A jQuery plugin that transforms Bootstrap tabs to an accordion and vice versa. Useful for responsive mobile sites.

Bootstrap Tabcollapse

Bootstrap Tab Collapse plugin. Switches bootstrap tabs component to collapse for small screens.

Easy Tree

A jquery and bootstrap basic tree view plugin, easily use.

BootstrapTreeNav

Tree navigation plugin for Twitter Bootstrap 3.0

Bootstrap Tour

Quick and easy product tours with Twitter Bootstrap Popovers.

猜您也喜欢：
15个最好的Bootstrap设计工具	Twitter Bootstrap所有样式PSD素材	40个有用的Bootstrap工具和WEB开发工具	iPhone6 & Apple Watch发布会总结之喜与忧
无觅

Eclipse常用的高效插件

Fri, 21 Nov 2014 10:35:50 CST

今天为使用Eclipse的程序员们，收集一些比较高效的插件，这些插件可以帮助你提高工作效率。

Properties Editor

Properties Editor 编辑java的属性文件，并可以自动存盘为Unicode格式，在写一下配置文件的时候，不用工具生成。

官网： http://propedit.sourceforge.jp/index_en.html

Fat Jar

Fat Jar 打包插件，可以方便的完成各种打包任务，可以包含外部的包等。这个插件比自带的好多很多。方便有第三方lib的程序员

官网： http://fjep.sourceforge.net/

Checkclipse

Checkclipse 是一个用来检查代码的风格、写法是否符合规范的Eclipse插件

官网： http://sourceforge.net/projects/checkclipse/

Maven 插件 m2eclipse

这是一个在Eclipse环境中集成的Maven插件，不过多解释，安装方法自行google

Git插件 EGit

EGit目前还是一个出于孵化期间的项目，因此EGit 0.7.1并没有提供对Git全部功能的支持，同时也无法保证没有bug(当然EGit 0.7.1是经过严格的测试之后才发布的正式版本)，但对于笔者这样的用户来说能满足基本的功能并且可以方便的享受Eclipse整合git功能即可。同时作者表示在Eclipse下一个发行版Eclipse Helios到来之际将发布EGit 0.8，届时EGit的功能将更加强大，同时提供更多的新特性支持。

安装地址： http://download.eclipse.org/egit/updates

Snowberry

Snowberry 是供Java开发者使用的Eclipse插件，Snowberry 能够将您编写的Java代码同步显示为“类图”，并展现类与类之间的关系。查看父类和接口、寻找已知的子类和实现，都以直观的类图操作呈现出来。

下载地址： http://pan.baidu.com/s/1c0eXLz6

Eclipse Color Themes

一个很赞的eclipse插件，可以简单方便地实现eclipse下的代码配色。另外插件作者还专门为此插件做了一个eclipse配色网站，配色多达728个，开发者们也可以在此网站分享自己的配色方案。

官网： http://eclipsecolorthemes.org/

最常用的Eclipse快捷键

欢迎来到IT江湖,加入我们官方群 383126909,学习更多,共同发展.

关注“IT江湖”微信公众号,每日推送优质文章,丰富大家的知识.

微信扫一扫或者搜索 “itjh0223” IT江湖,每一个IT人的江湖!

jQuery插件编写之三部曲

Sat, 02 Aug 2014 09:56:29 CST

1、选择一个jQuery框架，如：

/*!
 * jQuery.myPlugin
 *
 * @version  1.0.0
 * @date     2014/07/16
 * @author   Lime
 * @license  
 */
(function (jQuery) {

	//定义你的属性名myPlugin
    jQuery.fn.myPlugin = function (options) { 
		
		//替换默认参数
        var options = jQuery.extend({}, jQuery.fn.myPlugin.defaults, options);
        
		//使用return this.each运用在多个控件上并实现链式操作 
        return this.each(function () {
              //在这里实现你的方法
        });
    };

    //使用暴露方式设置插件默认参数，这对于让插件的使用者更容易用较少的代码覆盖和修改插件默认设置
    jQuery.fn.myPlugin.defaults = {
    };

})(jQuery);

2、添加引用编写好的插件

首先给你的插件起个名，推荐命名方法为：jquery.[插件名].js，如上面可以命名为jquery.myPlugin.js

然后在你的项目里添加引用<script src="jquery.myPlugin.js" type="text/javascript"></script>，当然在这之前你必须要引用jquery库。

3、插件的使用

<script type="text/javascript"> 
	$(document).ready(function () { 
		$("#div1").myPlugin(); 
	}); 
</script>

有木有发现简直简单到爆啊，是的，就这么简单！

附：select下拉绑定jQuery插件

/*!
 * jQuery.selectDataBind
 *
 * @version  1.0.0
 * @date     2014/07/16
 * @author   Lime<zhrjin@163.com>
 * @license  
 */
(function (jQuery) {
 
    jQuery.fn.selectDataBind = function (options) {
 
        var options = jQuery.extend({}, jQuery.fn.selectDataBind.defaults, options);
        return this.each(function () {
            var jOption = options.options;
            var jVaule = options.values;
            var bEmpty = options.empty;
            var j = 0;
            if (bEmpty) {
                this.options[0] = new Option("", "");
                j++;
            }
 
            for (var i = 0; i < jOption.length; i++) {
                var objOption = new Option(jOption[i], jVaule[i]);
                this.options[j++] = objOption;
            }
 
        });
    };
 
    jQuery.fn.selectDataBind.defaults = {
        options: [],
        values: [],
        empty: true
    };
 
})(jQuery);

已有 0 人发表留言，猛击->> 这里<<-参与讨论

ITeye推荐

—软件人才免语言低担保赴美带薪读研！—

IT瘾插件推荐

chrome 插件开发指南（Manifest V3） - 掘金

一、什么是 Chrome插件

1.1 概述

1.2 Chrome 插件是如何工作的

1.3 延伸阅读：插件和扩展的区别

二、Chrome 插件能做什么

三、主要构成

3.1 Manifest.json

3.1.1 Manifest V2

3.1.2 Manifest V3

3.2 popup

3.2.1 概述

3.2.2 简单例子

3.3 content-scripts

3.3.1 概述

3.3.2 特性

3.3.3 简单例子

3.3.4 延伸阅读：如何访问页面中的 JS

3.4 background

3.4.1 概述

3.4.2 简单例子

四、其他展现形式

4.1 homepage_url

4.2 Options页面

4.2.1 概述

4.2.2 配置

4.3 Devtools

4.4 override（覆盖特定页面）

4.5 Omnibox

五、通讯

5.1 简单的一次性请求

5.1.1 从 content-scripts 发起请求

5.1.2 发送消息到 content-scripts

5.1.3 接受消息

5.2 长链接

5.3 跨插件通讯

5.4 从网页发送信息

5.5 Native通讯

六、如何查看某个插件的源码

七、最佳实践推荐

八、适配其他浏览器

九、发布

十、未来

参考

OpenAI宣布为ChatGPT引入插件功能 解锁更多技能

Elasticsearch Head 插件使用小结

1 Elasticsearch Head是什么

2 本地安装

2.1 ES安装

2.2 head插件安装

3 基本查询

3.1 检索关键字

3.2 检索条件

4 复合查询

4.1 查询数据（GET）

4.2 插入数据（PUT、POST）

4.3 更新数据（PUT）

4.4 删除数据（DELETE）

4.5 给索引添加字段

5 具体实践

6 总结

看了我常用的IDEA插件，同事也开始悄悄安装了...

Key Promoter X

Lombok

MyBatisX

RestfulFastRequest

PlantUML

SequenceDiagram

GsonFormatPlus

Json Parser

String Manipulation

MapStruct support

Alibaba Java Coding Guidelines

Alibaba Cloud Toolkit

arthas idea

Docker

Maven Helper

Grep Console

Markdown

OpenAI宣布为ChatGPT引入插件功能解锁更多技能

PostgreSQL 时序数据库插件 timescaleDB 部署实践(含例子纽约TAXI数据透视分析) - PostGIS + timescaleDB => PG时空数据库 - Digoal.Zhou’s Blog