Vue插件写、用详解（附demo）
转载 &发布时间：日 16:15:12 & 作者：qq
本篇文章主要介绍了Vue插件写、用详解（附demo），插件就是指对Vue的功能的增强或补充。有兴趣的可以了解一下。
简单来说，插件就是指对Vue的功能的增强或补充。
比如说，让你在每个单页面的组件里，都可以调用某个方法，或者共享使用某个变量，或者在某个方法之前执行一段代码等
2、使用方法
总体流程应该是：
【声明插件】——【写插件】——【注册插件】——【使用插件】
写插件和声明插件是同步的，然后注册到Vue对象中（不用担心重复注册），最后在写Vue组件的时候使用写的插件
先写一个js文件，这个js文件就是插件文件，里面的基本内容如下：
插件文件：service.js
作者：王冬
export default {
install: function (Vue, options) {
// 添加的内容写在这个函数里面
其中install的第一个参数Vue表示的是Vue的实例，第二个参数表示的是一些设置选项。
Vue实例好理解，就是Vue对象。
而options设置选项就是指，在调用这个插件时，可以传一个对象。
例如这个对象有一个属性float，然后在写插件的一个方法/变量时，我需要输出一个数字，然后写一个if判断语句，
假如options.float为true时，输出浮点数；
假如为false或undefined（即没传参）时，输出为整数。
具体怎么添加，之后再说。
如果使用过Vue-router，就很好理解，通过import引入后，然后通过 Vue.use(插件名) 注册插件；
例如，我们通常在main.js里引入各种东西，并且组件的根实例也在这里
import Vue from 'vue'
import App from './App.vue'
//关键是这两行
import service from './service.js'
Vue.use(service)
el: '#app',
render: (h) =& h(App)
如代码中注释所说，关键是通过import导入service文件，然后在创建根组件之前，让Vue对象通过use方法来注册插件service。
通过这样简单的两步，就可以使用插件了。
3、写插件、使用插件
按照官方文档，写插件有四种方法，先给出官方的代码：
//以下内容都是添加到上面install的函数里面的
// 1. 添加全局方法或属性
Vue.myGlobalMethod = function () {
// 逻辑...
// 2. 添加全局资源
Vue.directive('my-directive', {
bind (el, binding, vnode, oldVnode) {
// 逻辑...
// 3. 注入组件
Vue.mixin({
created: function () {
// 逻辑...
// 4. 添加实例方法
Vue.prototype.$myMethod = function (options) {
// 逻辑...
先给出最常用的：【4. 添加实例方法】的写法和使用方法
3.1【添加实例方法或属性】
1、核心思想：
通过prototype来添加方法和属性。
//让输出的数字翻倍，如果不是数字或者不能隐式转换为数字，则输出null
Vue.prototype.doubleNumber = function (val) {
if (typeof val === 'number') {
return val * 2;
} else if (!isNaN(Number(val))) {
return Number(val) * 2;
return null
假设有这样一个组件：
&template&
&button @click="double"&点击后让左边的数字翻倍&/button&
&/template&
export default{
methods: {
double: function () {
//这里的this.doubleNumber()方法就是上面写的组件里的方法
this.num = this.doubleNumber(this.num);
我们便可以通过点击button按钮，让num的值，在每次点击都翻倍了。
4、假如添加的是属性：
Vue.prototype.number = 1;
会发生什么事情呢？
1、不管是【按值传递类型】还是【按引用传递类型】，该变量都不会被不同组件所共享，更准确的说，假如有A、B两个组件。A组件里的number数值改变，B组件里的number数值是不会跟着改变的。因此不要想着引用这样一个变量，然后修改了A中的值，B里也自动跟着改变了；
2、当组件里没有该属性时，调用时，显示的是通过插件获取的值；
当组件里有该属性时，调用时，显示的是组件里该属性的值；
由此而推，函数也是这样的，组件里的同名函数总是会覆盖插件提供的函数。
也就是说，当插件提供一个属性时，组件里没这个属性，就用插件的属性；组件有，就用组件自己的。
3.2【添加全局方法或属性】
1、核心思想：
就是给Vue对象添加一个属性。
初次接触很容易和上面3.1弄混，实际上，3.1是给组件里使用的，而3.2是给Vue对象使用的。
例如，假如添加一个方法test()，那么：
通过3.1添加，是在组件里，通过this.test()来调用
通过3.2添加，是在外面，通过Vue实例，如Vue.test()来调用
//放在哪里参考上面
Vue.test = function () {
alert("123")
//注意先导入Vue对象才能使用
Vue.test()
使用时会执行对应的方法，比如这里就是alert弹窗
别问我如果和Vue本身属性同名会发生什么事情，我没试过=.=
3.3【注入组件】
1、核心思想：
就像写Vue组件时，那样写，方法名保持一致，其会在执行组件对应的方法名之前执行。
Vue.mixin({
created: function () {
console.log("组件开始加载")
然后这里的代码会在每个组件（包括根组件）的created执行之前执行。
可以自行在每个组件的created方法里写一段console.log来查看测试
可以和【实例属性】配合使用，用于调试或者控制某些功能
// 注入组件
Vue.mixin({
created: function () {
if (this.NOTICE)
console.log("组件开始加载")
// 添加注入组件时，是否利用console.log来通知的判断条件
Vue.prototype.NOTICE =
【注入给非Vue实例本身就有的方法】：
假如是写给例如methods属性的某个方法，例如以下注入：
Vue.mixin({
methods: {
test: function () {
console.log("mixin test");
那么，组件里若本身有test方法，并 不会 先执行插件的test方法，再执行组件的test方法。
而是只执行其中一个，并且优先执行组件本身的同名方法。这点需要注意
不需要手动调用，在执行对应的方法时会被自动调用的（并且先调用插件里的，再调用组件本身的）
1、如果同时有多个插件注入一个方法（例如created，那么会先执行先注入的那个方法，再依次执行后注入的，最后执行组件本身的）
2、注意，像methods属性下的方法，并不会在组件注入后每个都执行，而是只执行一个，并且优先执行组件本身的。
3.4【添加全局资源】
1、核心思想：
添加方法和正常添加方法类似，甚至几乎一样。
可以添加【自定义指令】、【过滤器】、【过渡等】，这里以【过滤器】为例
//时间格式化过滤器，输入内容是number或者Date对象，输出是YYYY-MM-DD HH-MM-SS
Vue.filter('formatTime', function (value) {
Date.prototype.Format = function (fmt) { //author: meizz
"M+": this.getMonth() + 1, //月份
"d+": this.getDate(), //日
"h+": this.getHours(), //小时
"m+": this.getMinutes(), //分
"s+": this.getSeconds(), //秒
"q+": Math.floor((this.getMonth() + 3) / 3), //季度
"S": this.getMilliseconds() //毫秒
if (/(y+)/.test(fmt))
fmt = fmt.replace(RegExp.$1, (this.getFullYear() + "").substr(4 - RegExp.$1.length));
for (var k in o)
if (new RegExp("(" + k + ")").test(fmt))
fmt = fmt.replace(RegExp.$1, (RegExp.$1.length == 1) ? (o[k]) : (("00" + o[k]).substr(("" + o[k]).length)));
return new Date(value).Format("yyyy-MM-dd hh:mm:ss");
和正常使用一样用就行了，so easy。例如：
{{num|formatTime}}
可以用这个找各种有意思的功能，作为插件写好，然后需要的地方导入就行，超级方便！
4、示例demo
附一个有简单功能的示例demo，提供参考使用
* 插件demo，供学习使用
* 本页面用于提供各种处理服务
* 作者：王冬
export default {
install: function (Vue, options) {
// 1. 添加全局方法或属性
// 2. 添加全局资源
// 时间格式化过滤器，输入内容是number或者Date对象，输出是YYYY-MM-DD HH-MM-SS
Vue.filter('formatTime', function (value) {
Date.prototype.Format = function (fmt) { //author: meizz
"M+": this.getMonth() + 1, //月份
"d+": this.getDate(), //日
"h+": this.getHours(), //小时
"m+": this.getMinutes(), //分
"s+": this.getSeconds(), //秒
"q+": Math.floor((this.getMonth() + 3) / 3), //季度
"S": this.getMilliseconds() //毫秒
if (/(y+)/.test(fmt))
fmt = fmt.replace(RegExp.$1, (this.getFullYear() + "").substr(4 - RegExp.$1.length));
for (var k in o)
if (new RegExp("(" + k + ")").test(fmt))
fmt = fmt.replace(RegExp.$1, (RegExp.$1.length == 1) ? (o[k]) : (("00" + o[k]).substr(("" + o[k]).length)));
return new Date(value).Format("yyyy-MM-dd hh:mm:ss");
// 2. 添加全局资源
// 添加注入组件时，是否利用console.log来通知的判断条件，也是组件实例属性
Vue.prototype.NOTICE =
// 3. 注入组件
// 注入组件，插件加载开始前提示
Vue.mixin({
created: function () {
if (this.NOTICE)
console.log("组件开始加载")
methods: {
test: function () {
console.log("mixin test");
// 4. 添加实例方法
// 返回数字是输入数字的两倍，如果不是数字或者不能隐式转换为数字，则输出null
// 组件实例方法
Vue.prototype.doubleNumber = function (val) {
if (typeof val === 'number') {
return val * 2;
} else if (!isNaN(Number(val))) {
return Number(val) * 2;
return null
// 4. 添加实例方法
// 服务组，将实例方法整合到$service中，避免命名冲突
Vue.prototype.$service = {
//电话号码合法性检查
telNumberCheck: function (tel) {
var pattern = /(^(([0\+]\d{2,3}-)?(0\d{2,3})-)(\d{7,8})(-(\d{3,}))?$)|(^0{0,1}1[3|4|5|6|7|8|9][0-9]{9}$)/;
return pattern.test(tel)
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持脚本之家。
您可能感兴趣的文章:
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具求解一个C++小程序，求高手指点void Demo::func(Demo d)这后面在函数参数里可以是Demo d？整个程序如下：_百度知道
求解一个C++小程序，求高手指点void Demo::func(Demo d)这后面在函数参数里可以是Demo d？整个程序如下：
# include &iostream.h&class Demo{public: Demo(); static void func(Demo d);private: };Demo::Demo(){i=10;}void Demo::func(Demo d){cout&&d.i;}void main(){ D Demo::func(a);}
我有更好的答案
可以的，当你定义了一个类名之后，编译器就知道它已经声明过了，就可以拿来用了。比如定义了class
A{public: A（）;////其他函数;private:A
m_a;//A类型变量}也是可以的，就像是在定义链表节点时一样struct node{node *}c++就是这样规定的，声明之后就可以直接拿来用。
采纳率：66%
为什么啊？可以说具体一点吗？我才开始学这个，很多都不懂。
你觉得为什么不可以？
d在这里是什么意思啊？d是一个对象？还是一个数据成员？
为您推荐：
其他类似问题
小程序的相关知识
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。【图文】脱机SDKDemo培训_百度文库
赠送免券下载特权
10W篇文档免费专享
部分付费文档8折起
每天抽奖多种福利
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
脱机SDKDemo培训
阅读已结束，下载本文到电脑
想免费下载本文？
登录百度文库，专享文档复制特权，积分每天免费拿！
你可能喜欢一个简单的 dubbo demo 服务原文参见这篇文章将简单的介绍如何写一个 dubbo 服务。dubbo 的准备工作请参照。从此图可知，当注册中心和监控已经工作起来之后，我们需要写的就是消费方和服务方的代码了。一个简单的一对一提供服务的代码结构如下~/IdeaProjects/dubbox/dubbo-demo master
dubbo-demo-api
dubbo-demo-provider pom.xml
dubbo-demo-consumer dubbo-demo.iml
其中 api 部分定义了 provider 和 consumer 都需要用到的接口，这样 provider 实现这些接口，consumer 就可以像本地调用一样来调用这些接口了。接口定义与步骤该 dubbo 服务将实现获取权限数组的功能，即调用PermissionService.getPermissions获取权限数组。在本文的例子中，我们将实现 1) 直接返回字符串的数组；2) 返回 java 对象（POJO） 的 json/xml 序列化的结果。# 直接返回字符串的数组
['permission_1', 'permission_2', 'permission_3']
# 返回 json/xml 序列化的结果
"name": "x1_permission",
"name": "x2_permission",
协议分类dubbo 的服务方和提供方通信支持多种协议，默认的是 dubbo 协议。官方给出的协议建议为：协议优势劣势Dubbo采用NIO复用单一长连接，并使用线程池并发处理请求，减少握手和加大并发效率，性能较好（推荐使用）在大文件传输时，单一连接会成为瓶颈Rmi可与原生RMI互操作，基于TCP协议偶尔会连接失败，需重建StubHessian可与原生Hessian互操作，基于HTTP协议需hessian.jar支持，http短连接的开销大除此之外，当当还通过扩展 dubbo 得到 dubbox，支持了 HTTP 的 Rest 接口。关于 Rest 的优缺点参见 dubbox 的。本文使用的就是 dubbox。步骤我们将循序渐进的实现一个获取权限数组的服务。代码最终结果在 。通过 dubbo 协议实现获取权限数组的服务通过 rest 规范实现获取权限数组的服务将提供方以服务的形式部署到服务器dubbo 协议简例代码参见 。创建 maven 项目 dubbo-test，编辑 pom 文件，并仿照官方示例，在 maven 项目下分别创建 3 个 module：api, provider 和 consumer。&!-- dubbo test 的 pom 文件直接用默认生成的即可 --&
&?xml version="1.0" encoding="UTF-8"?&
&project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"&
&modelVersion&4.0.0&/modelVersion&
&groupId&dubbotest&/groupId&
&artifactId&dubbotest&/artifactId&
&version&1.0-SNAPSHOT&/version&
&/project&
创建 api module通过 IDE 创建 api 子模块（或者手动创建文件夹），并创建 api.PermissionService 类：package api;
import java.util.List;
public interface PermissionService {
List&String& getPermissions(Long id);
文件夹结构如下：.
├── api
├── pom.xml
└── src
├── main
├── java
└── api
└── PermissionService.java
└── resources
└── test...
├── pom.xml
└── src...
创建 provider module用同样的方式创建子模块，并编辑 pom 文件，引入 dubbo 等必要的依赖包：...
&dependencies&
&!-- 引入 api，在 provider 中实现 api 定义的接口 --&
&dependency&
&groupId&dubbotest&/groupId&
&artifactId&api&/artifactId&
&version&1.0-SNAPSHOT&/version&
&/dependency&
&!-- 引入 dubbo --&
&dependency&
&groupId&com.alibaba&/groupId&
&artifactId&dubbo&/artifactId&
&version&2.8.4&/version&
&/dependency&
&!-- 引入 log4j --&
&dependency&
&groupId&log4j&/groupId&
&artifactId&log4j&/artifactId&
&version&1.2.17&/version&
&/dependency&
&!-- 引入 zookeeper client --&
&dependency&
&groupId&com.github.sgroschupf&/groupId&
&artifactId&zkclient&/artifactId&
&version&0.1&/version&
&/dependency&
&/dependencies&
阿里的 Dubbo 框架已经集成了 Zookeeper、Spring 等框架的依赖，但是有一个例外就是 zkclient，如果没有引用将会抛出如下异常信息：Exception in thread "main" java.lang.NoClassDefFoundError: org/I0Itec/zkclient/exception/ZkNoNodeException
创建 provider.DemoProvider 类：
import java.io.IOE
public class DemoProvider {
public static void main(String[] args) throws IOException {
// 如果 spring 配置文件的位置是默认的，则可以直接这样启动服务
com.alibaba.dubbo.container.Main.main(args);
如果 spring 配置文件在默认的 resources/META-INF/spring 下，则可以直接这样启动服务，否则需要声明指定其位置：// 建议使用上一种方法
package provider;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import java.io.IOException;
public class DemoProvider {
public static void main(String[] args) throws IOException {
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath*:META-INF/spring/*.xml");
System.out.println(context.getDisplayName() + ": here");
context.start();
System.out.println("服务已经启动...");
System.in.read();
创建 api 中定义 api.PermissionService 接口的实现类 provider.PermissionServiceImpl：package provider;
import api.PermissionService;
import java.util.ArrayList;
import java.util.List;
public class PermissionServiceImpl implements PermissionService {
public List&String& getPermissions(final Long id) {
// 该函数应该实现 getPermissions 的业务逻辑，这里简单返回一个 list
List&String& permissions = new ArrayList&String&();
permissions.add(String.format("Permission_%d", id - 1));
permissions.add(String.format("Permission_%d", id));
permissions.add(String.format("Permission_%d", id + 1));
return permissions;
创建 spring 配置文件，重点是 dubbo 相关服务的配置：&?xml version="1.0" encoding="UTF-8"?&
&beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://code.alibabatech.com/schema/dubbo
http://code.alibabatech.com/schema/dubbo/dubbo.xsd"&
&!--定义了提供方应用信息，用于计算依赖关系；在 dubbo-admin 或 dubbo-monitor 会显示这个名字，方便辨识--&
&dubbo:application name="demotest-provider" owner="programmer" organization="dubbox"/&
&!--使用 zookeeper 注册中心暴露服务，注意要先开启 zookeeper--&
&dubbo:registry address="zookeeper://localhost:2181"/&
&!-- 用dubbo协议在20880端口暴露服务 --&
&dubbo:protocol name="dubbo" port="20880" /&
&!--使用 dubbo 协议实现定义好的 api.PermissionService 接口--&
&dubbo:service interface="api.PermissionService" ref="permissionService" protocol="dubbo" /&
&!--具体实现该接口的 bean--&
&bean id="permissionService" class="provider.PermissionServiceImpl"/&
最后，在 resources 目录下创建 log4j 的配置文件：&?xml version="1.0" encoding="UTF-8"?&
&!DOCTYPE log4j:configuration SYSTEM "log4j.dtd"&
&log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/" debug="false"&
&appender name="CONSOLE" class="org.apache.log4j.ConsoleAppender"&
&layout class="org.apache.log4j.PatternLayout"&
&param name="ConversionPattern" value="[%d{dd/MM/yy hh:mm:ss:sss z}] %t %5p %c{2}: %m%n" /&
&/appender&
&level value="INFO" /&
&appender-ref ref="CONSOLE" /&
&/log4j:configuration&
文件创建完毕，接下来在根目录下执行mvn clean package，然后执行 provider.DemoProvider 的 main 函数，即可启动该服务了。查看 monitor/admin，看我们定义的 demotest-provider 这个名称的提供者是否出现在服务列表中；或者在 console 输出中发现如下信息，即表示成功启动：...
[05/03/17 11:56:43:043 CST] main
INFO container.Main:
[DUBBO] Dubbo SpringContainer started!, dubbo version: 2.8.4, current host: 127.0.0.1
[ 23:56:43] Dubbo service server started!
provider 的文件结构如下：.
├── pom.xml
├── src
├── main
├── java
└── provider
├── DemoProvider.java
└── PermissionServiceImpl.java
└── resources
├── META-INF
└── spring
└── dubbotest-provider.xml
└── log4j.xml
└── test...
└── target...
创建 consumer moduleconsumer 子模块的创建和 provider 很像。pom 文件：
&dependencies&
&dependency&
&!-- 引入 api，在 consumer 中调用 api 定义的接口 --&
&groupId&dubbotest&/groupId&
&artifactId&api&/artifactId&
&version&1.0-SNAPSHOT&/version&
&/dependency&
&dependency&
&groupId&com.alibaba&/groupId&
&artifactId&dubbo&/artifactId&
&version&2.8.4&/version&
&/dependency&
&dependency&
&groupId&log4j&/groupId&
&artifactId&log4j&/artifactId&
&version&1.2.17&/version&
&/dependency&
&dependency&
&groupId&com.github.sgroschupf&/groupId&
&artifactId&zkclient&/artifactId&
&version&0.1&/version&
&/dependency&
&/dependencies&
创建 spring 配置文件：&?xml version="1.0" encoding="UTF-8"?&
&beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd"&
&dubbo:application name="demotest-consumer" owner="programmer" organization="dubbox"/&
&!--向 zookeeper 订阅 provider 的地址，由 zookeeper 定时推送--&
&dubbo:registry address="zookeeper://localhost:2181"/&
&!--使用 dubbo 协议调用定义好的 api.PermissionService 接口--&
&dubbo:reference id="permissionService" interface="api.PermissionService"/&
创建 consumer.DemoConsumer 类：package consumer;
import api.PermissionService;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class DemoConsumer {
public static void main(String[] args) {
//测试常规服务
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath*:META-INF/spring/*.xml");
context.start();
PermissionService permissionService = context.getBean(PermissionService.class);
System.out.println(permissionService.getPermissions(1L));
log4j 配置相同。执行mvn clean package，然后执行 consumer.DemoConsumer 的 main 函数，即可启动该服务了。查看 monitor/admin，看我们定义的 demotest-consumer 这个名称的提供者是否出现在服务列表中；或者在 console 输出中发现如下信息，即表示成功启动（输出的数组即为调用的结果）：...
[Permission_0, Permission_1, Permission_2]
可见，在 consumer 中调用 provider 的实现，代码上看起来和本地调用一样，即 provider 相对于 consumer 来说是透明的。consumer 文件结构如下：.
├── pom.xml
├── src
├── main
├── java
└── consumer
└── DemoConsumer.java
└── resources
├── META-INF
└── spring
└── dubbotest-consumer.xml
└── log4j.xml
└── test...
└── target...
dubbo rest 接口代码参见 。需要在 api 中定义 rest 接口，并在 provider 中实现这个接口。api module添加 api.PermissionRestService 类：package api;
import javax.validation.constraints.Min;
import java.util.List;
public interface PermissionRestService {
List&String& getPermissions(@Min(value = 1L, message = "User ID must be greater than 1") Long id);
pom 文件添加依赖：
&dependency&
&groupId&javax.validation&/groupId&
&artifactId&validation-api&/artifactId&
&version&2.0.0.Alpha1&/version&
&/dependency&
provider module在 pom 文件中添加依赖：
&!--rest 规范，比如 Get, Path, MediaType 等--&
&dependency&
&groupId&javax.ws.rs&/groupId&
&artifactId&javax.ws.rs-api&/artifactId&
&version&2.0.1&/version&
&/dependency&
&!--使用 netty 启动 rest 服务--&
&dependency&
&groupId&org.jboss.resteasy&/groupId&
&artifactId&resteasy-netty&/artifactId&
&version&3.0.7.Final&/version&
&/dependency&
&!--rest json 输出--&
&dependency&
&groupId&org.jboss.resteasy&/groupId&
&artifactId&resteasy-jackson-provider&/artifactId&
&version&3.0.7.Final&/version&
&/dependency&
&!--rest 需要的依赖--&
&dependency&
&groupId&org.jboss.resteasy&/groupId&
&artifactId&resteasy-client&/artifactId&
&version&3.0.7.Final&/version&
&/dependency&
&!--验证--&
&dependency&
&groupId&org.hibernate&/groupId&
&artifactId&hibernate-validator&/artifactId&
&version&4.2.0.Final&/version&
&/dependency&
&!--slf4j 和其依赖--&
&dependency&
&groupId&org.slf4j&/groupId&
&artifactId&slf4j-api&/artifactId&
&version&1.7.5&/version&
&/dependency&
&dependency&
&groupId&org.slf4j&/groupId&
&artifactId&slf4j-log4j12&/artifactId&
&version&1.7.5&/version&
&/dependency&
其中 slf4j 的问题参见 。创建 provider.PermissionRestServiceImpl 实现 上面的接口：package provider;
import api.PermissionRestService;
import api.PermissionService;
import com.alibaba.dubbo.rpc.RpcContext;
import com.alibaba.dubbo.rpc.protocol.rest.support.ContentType;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.ws.rs.*;
import javax.ws.rs.core.MediaType;
import java.util.List;
@Path("permissions")
@Consumes({MediaType.APPLICATION_JSON})
@Produces({ContentType.APPLICATION_JSON_UTF_8})
public class PermissionRestServiceImpl implements PermissionRestService {
private PermissionService permissionService;
public void setPermissionService(PermissionService permissionService) {
this.permissionService = permissionService;
@Path("{id : \\d+}")
public List&String& getPermissions(@PathParam("id") Long id) {
if (RpcContext.getContext().getRequest(HttpServletRequest.class) != null) {
System.out.println("Client IP address from RpcContext: " + RpcContext.getContext().getRequest(HttpServletRequest.class).getRemoteAddr());
if (RpcContext.getContext().getResponse(HttpServletResponse.class) != null) {
System.out.println("Response object from RpcContext: " + RpcContext.getContext().getResponse(HttpServletResponse.class));
// 上面是输出相应的测试信息的，真实的实现只有下面这句
return permissionService.getPermissions(id);
编辑 spring 配置：
&!--使用 netty 服务，将 rest 服务暴露在 4567 端口--&
&dubbo:protocol name="rest" port="4567" threads="500" contextpath="services" server="netty" accepts="500" extension="com.alibaba.dubbo.rpc.protocol.rest.support.LoggingFilter"/&
&!--使用 rest 规范实现定义好的 api.PermissionRestService 接口--&
&dubbo:service interface="api.PermissionRestService" ref="permissionRestService" protocol="rest"
validation="true"/&
&!--具体实现该接口的 bean--&
&bean id="permissionRestService" class="provider.PermissionRestServiceImpl"&
&property name="permissionService" ref="permissionService"/&
启动 DemoProvider 的 main 函数，此时输入
即可访问提供者的 rest 接口了。consumer module编辑 DemoConsumer 类，添加 rest 调用：public class DemoConsumer {
public static void main(String[] args) {
// 测试常规服务
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath*:META-INF/spring/*.xml");
context.start();
// dubbo 协议
PermissionService permissionService = context.getBean(PermissionService.class);
System.out.println(permissionService.getPermissions(1L));
// rest 规范
PermissionRestService permissionRestService = context.getBean(PermissionRestService.class);
System.out.println(permissionRestService.getPermissions(2L));
在当当的 dubbox 中，rest 调用分 3 种场景：非 dubbo 的消费端调用 dubbo 的 REST 服务（non-dubbo –& dubbo）dubbo 消费端调用 dubbo 的 REST 服务 （dubbo –& dubbo）dubbo的消费端调用非 dubbo 的 REST 服务 （dubbo –& non-dubbo）我们直接通过 rest 的 uri 调用就是第 1 种，上面实现的是第 2 种。注意到第 1 种调用实际上是直接访问的地址，所以就不具备 dubbo 提供的服务发现功能了。编辑 spring 配置，添加 permissionRestService：
&!--使用 dubbo 协议调用定义好的 api.PermissionRestService 接口--&
&dubbo:reference id="permissionRestService" interface="api.PermissionRestService"/&
执行 DemoConsumer 的 main 函数，报错：java.lang.IllegalStateException: Unsupported protocol rest in notified url: ...
中指明，这种调用方式必须把 JAX-RS 的 annotation 添加到服务接口上，这样在 dubbo 在消费端才能共享相应的 REST 配置信息，并据之做远程调用，编辑 api.PermissionRestService 类：// 注意这里编辑的是 api module 下的文件
package api;
import com.alibaba.dubbo.rpc.protocol.rest.support.ContentType;
import javax.validation.constraints.Min;
import javax.ws.rs.*;
import javax.ws.rs.core.MediaType;
import java.util.List;
@Path("permissions")
@Consumes({MediaType.APPLICATION_JSON})
@Produces({ContentType.APPLICATION_JSON_UTF_8})
public interface PermissionRestService {
@Path("{id : \\d+}")
List&String& getPermissions(@PathParam("id") @Min(value = 1L, message = "User ID must be greater than 1") Long id);
同时需要在 api module 的 pom 文件下添加对应的依赖：
&dependencies&
&dependency&
&groupId&javax.validation&/groupId&
&artifactId&validation-api&/artifactId&
&version&RELEASE&/version&
&/dependency&
&dependency&
&groupId&javax.ws.rs&/groupId&
&artifactId&javax.ws.rs-api&/artifactId&
&version&2.0.1&/version&
&/dependency&
&dependency&
&groupId&com.alibaba&/groupId&
&artifactId&dubbo&/artifactId&
&version&2.8.4&/version&
&/dependency&
&/dependencies&
再次mvn clean package，遇到错误 ：1. org.springframework.beans.factory.BeanCreationException...
2. ERROR integration.RegistryDirectory: Unsupported protocol rest in notified url...
来看是 consumer 缺少相关依赖，添加上：
&!--使用 netty 启动 rest 服务--&
&dependency&
&groupId&org.jboss.resteasy&/groupId&
&artifactId&resteasy-netty&/artifactId&
&version&3.0.7.Final&/version&
&/dependency&
&!--rest json 输出--&
&dependency&
&groupId&org.jboss.resteasy&/groupId&
&artifactId&resteasy-jackson-provider&/artifactId&
&version&3.0.7.Final&/version&
&/dependency&
&!--rest 需要的依赖--&
&dependency&
&groupId&org.jboss.resteasy&/groupId&
&artifactId&resteasy-client&/artifactId&
&version&3.0.7.Final&/version&
&/dependency&
&!--验证--&
&dependency&
&groupId&org.hibernate&/groupId&
&artifactId&hibernate-validator&/artifactId&
&version&4.2.0.Final&/version&
&/dependency&
&!--slf4j 和其依赖--&
&dependency&
&groupId&org.slf4j&/groupId&
&artifactId&slf4j-api&/artifactId&
&version&1.7.5&/version&
&/dependency&
&dependency&
&groupId&org.slf4j&/groupId&
&artifactId&slf4j-log4j12&/artifactId&
&version&1.7.5&/version&
&/dependency&
再次执行，发现一切正常了，输出的结果也是对的：[Permission_0, Permission_1, Permission_2]
[Permission_1, Permission_2, Permission_3]
打包代码参见 。按照 dubbo 推荐的方式打包成一个 .tar.gz 文件。在 provider 的 pom 文件中添加打包的依赖插件（或直接看最终结果 ）： &!-- 前面是 dependencies --&
&artifactId&maven-dependency-plugin&/artifactId&
&executions&
&execution&
&id&unpack&/id&
&phase&package&/phase&
&goal&unpack&/goal&
&configuration&
&artifactItems&
&artifactItem&
&groupId&com.alibaba&/groupId&
&artifactId&dubbo&/artifactId&
&version&2.8.4&/version&
&outputDirectory&${project.build.directory}/dubbo&/outputDirectory&
&includes&META-INF/assembly/**&/includes&
&/artifactItem&
&/artifactItems&
&/configuration&
&/execution&
&/executions&
&artifactId&maven-assembly-plugin&/artifactId&
&configuration&
&descriptor&src/main/assembly/assembly.xml&/descriptor&
&/configuration&
&executions&
&execution&
&id&make-assembly&/id&
&phase&package&/phase&
&goal&single&/goal&
&/execution&
&/executions&
&/plugins&
在 src/main 下创建文件夹 assembly，并创建相应文件，如下所示：.
├── pom.xml
├── src
├── main
├── assembly
├── assembly.xml
└── conf
└── dubbo.properties
├── java...
└── resources...
└── test...
└── target...
其中 dubbo.properties 留空即可，dubbo 的配置已经写在了 spring 的配置中。assembly.xml 内容为：&assembly&
&id&assembly&/id&
&format&tar.gz&/format&
&/formats&
&includeBaseDirectory&true&/includeBaseDirectory&
&fileSets&
&directory&${project.build.directory}/dubbo/META-INF/assembly/bin&/directory&
&outputDirectory&bin&/outputDirectory&
&fileMode&0755&/fileMode&
&/fileSet&
&directory&src/main/assembly/conf&/directory&
&outputDirectory&conf&/outputDirectory&
&fileMode&0644&/fileMode&
&/fileSet&
&/fileSets&
&dependencySets&
&dependencySet&
&outputDirectory&lib&/outputDirectory&
&/dependencySet&
&/dependencySets&
&/assembly&
完成之后，执行 maven 的清理和打包。打包结果为 provider-1.0-SNAPSHOT-assembly.tar.gz，解压，其文件结构为：~/IdeaProjects/dubbotest/provider/target/provider-1.0-SNAPSHOT
执行 bin/start.sh，查看 logs/stdout.log，并访问 ，确认启动成功。如此一来，一个简单的 dubbo 服务搭建成功。远程调试微服务化后，远程调试必然是一个刚需。java 的远程调试比较简单，这里就以 intellij 为例说明。服务端配置将打包好的服务 .tar.gz 传到阿里云服务器上，并解压，进入文件夹，编辑 bin/start.sh 文件：# 调整调试的端口号
if [ "$1" = "debug" ]; then
JAVA_DEBUG_OPTS=" -Xdebug -Xnoagent -Djava.compiler=NONE -Xrunjdwp:transport=dt_socket,address=8000,server=y,suspend=n "
然后按照 start.sh 的提示，执行bin/start.sh debug，启动服务。intellij 配置接下来就可以在 intellij 里打断点调试了。P.S.: 从 dubbo 包引入的脚本内存需求是 2G，服务器可能不够用，应调小对应数值；P.S.: java8 打包的结果不能在 java7 上运行。如果遇到错误：could not be instantiated: java.util.concurrent.ConcurrentHashMap.keySet()Ljava/util/concurrent/ConcurrentHashMap$KeySetV
请考虑将依赖的包全部以 jdk7 的 maven 重新安装一遍，尤其是 dubbo 的。mac 下 java 环境的管理可以参考这篇；P.S.: 如果你是从阿里云的服务器访问另一台阿里云的服务器，可能会遇到 'no route to host' 错误，这种情况一般都是 ip 和 host 问题，注意阿里云互相访问需要使用它们的内网 ip。可以参考这个，'no route to host' 不是来自目标主机的回复，是网络问题。4添加评论分享收藏文章被以下专栏收录}