标签分类
当前位置:首页 > 程序设计电子书 > Java电子书网盘下载
OSGi与Equinox:创建高度模块化的Java系统 OSGi与Equinox:创建高度模块化的Java系统
hx0_0_8

hx0_0_8 提供上传

资源
20
粉丝
48
喜欢
147
评论
3

    OSGi与Equinox:创建高度模块化的Java系统 PDF 高清版

    Java电子书
    • 发布时间:

    给大家带来的一篇关于Java相关的电子书资源,介绍了关于OSGi、Equinox、模块化、Java系统方面的内容,本书是由人民邮电出版社出版,格式为PDF,资源大小21.8 MB,Jeff McAffer编写,目前豆瓣、亚马逊、当当、京东等电子书综合评分为:7.1,更多相关的学习资源可以参阅 程序设计电子书Java电子书、等栏目。

  • OSGi与Equinox:创建高度模块化的Java系统 PDF 下载
  • 下载地址:https://pan.baidu.com/s/1qNkex_V-s_-CFwovK7syXw
  • 分享码:pq21
  • OSGi与Equinox:创建高度模块化的Java系统 PDF

    阅读本书,首先你很快就会使用Eclipse bundle工具创建第一个基于OSGi的系统,进而转向复杂的产品开发。接下来,你将掌握一些用于创建具有特殊模块化、高效性和可维护性系统的最佳实践和技巧。你将了解所有的OSGi声明式服务,以及如何通过这些服务来解决各种现实问题。最后,你会发现所有这些都在本书所提供的完整案例(从早期的原型构建到最终的应用交付)中得以实现。

    目录

    • 第一部分 简介
    • 第1章 OSGi、Equinox和Eclipse  2
    • 1.1  简史  2
    • 1.2  合作  3
    • 1.3  实战的模块性和自由性  4
    • 1.4  平台  4
    • 1.5  生态系统  5
    • 1.6  OSGi的来龙去脉  5
    • 1.6.1  Java的谎言  5
    • 1.6.2  现状核实  6
    • 1.6.3  OSGi的寿命  6
    • 1.7  实践中的OSGi和Equinox  7
    • 1.8  总结  8
    • 第2章 OSGi基本概念  9
    • 2.1  bundle环境  9
    • 2.2  为何选择OSGi  10
    • 2.3  bundle剖析  13
    • 2.4  模块化  14
    • 2.4.1  导出包  14
    • 2.4.2  导入包  14
    • 2.4.3  需要的bundle  15
    • 2.4.4  强化模块化特性  16
    • 2.5  模块化设计概念  16
    • 2.6  生命周期  17
    • 2.7  协作  18
    • 2.7.1  服务  18
    • 2.7.2  扩展和扩展点  19
    • 2.8  OSGi框架  20
    • 2.9  安全性  20
    • 2.10  OSGi框架实现  21
    • 2.11  总结  21
    • 第二部分 OSGi示例
    • 第3章 教程介绍  24
    • 3.1  何为Toast  24
    • 3.2  Toast的演变  26
    • 3.3  开发环境安装  27
    • 3.4  示例代码  28
    • 3.4.1  在章与章之间切换  28
    • 3.4.2  比较  29
    • 3.5  目标平台设置  30
    • 3.5.1  预定义的目标  31
    • 3.5.2  定义目标平台  32
    • 3.6  通过示例进行学习  35
    • 3.7  总结  36
    • 第4章 你好,Toast  37
    • 4.1  简单的场景  37
    • 4.1.1  创建工程  37
    • 4.1.2  Gps  38
    • 4.1.3  Airbag和IAirbagListener  40
    • 4.1.4  EmergencyMonitor  41
    • 4.1.5  Main  43
    • 4.1.6  运行  43
    • 4.1.7  检查点  43
    • 4.2  将Toast划分为Bundle  43
    • 4.2.1  GPS bundle  45
    • 4.2.2  安全气囊bundle  47
    • 4.2.3  紧急情况监视器bundle  47
    • 4.2.4  启动  49
    • 4.3  总结  50
    • 第5章 服务  52
    • 5.1  转移到服务  52
    • 5.2  注册GPS服务  54
    • 5.3  注册安全气囊服务  58
    • 5.4  获取服务示例代码  61
    • 5.5  启动  64
    • 5.6  故障排解  64
    • 5.7  总结  65
    • 第6章 动态服务  66
    • 6.1  动态服务简介  66
    • 6.2  使用服务追踪器  67
    • 6.2.1  修改bundle激活器  67
    • 6.2.2  启动  70
    • 6.2.3  服务追踪器小结  72
    • 6.3  使用服务激活器工具包  73
    • 6.3.1  在目标平台上安装SAT  73
    • 6.3.2  修改GPS bundle激活器  73
    • 6.3.3  修改安全气囊bundle激活器  74
    • 6.3.4  修改紧急情况监视器bundle激活器  74
    • 6.3.5  启动  75
    • 6.3.6  SAT小结  76
    • 6.4  使用声明式服务  76
    • 6.4.1  修改GPS bundle  77
    • 6.4.2  修改安全气囊bundle  79
    • 6.4.3  修改紧急情况监视器bundle  80
    • 6.4.4  运行  82
    • 6.4.5  声明式服务总结  83
    • 6.5  总结  83
    • 第7章 客户端/服务器端交互  84
    • 7.1  后台  84
    • 7.1.1  核心bundle  84
    • 7.1.2  后台应急bundle  85
    • 7.2  客户端  88
    • 7.2.1  信道bundle  88
    • 7.2.2  紧急情况监视器bundle  92
    • 7.3  工具类  94
    • 7.3.1  常量  94
    • 7.3.2  属性  94
    • 7.3.3  日志  95
    • 7.4  运行Toast  95
    • 7.4.1  运行后台  96
    • 7.4.2  运行客户端  97
    • 7.5  总结  97
    • 第8章 测试  99
    • 8.1  使Toast具备可测试性  99
    • 8.2  对Toast进行单元测试  100
    • 8.2.1  测试方案  100
    • 8.2.2  编写测试用例  101
    • 8.2.3  运行单元测试  103
    • 8.3  系统测试Toast  104
    • 8.3.1  测试规划  104
    • 8.3.2  创建测试工具  105
    • 8.3.3  编写测试用例  107
    • 8.3.4  运行系统测试  110
    • 8.4  总结  111
    • 第9章 打包  112
    • 9.1  定义Toast产品  112
    • 9.1.1  创建产品配置  112
    • 9.1.2  概述页  114
    • 9.1.3  依赖页  115
    • 9.1.4  配置页  116
    • 9.1.5  启动页  116
    • 9.1.6  运行产品  118
    • 9.1.7  产品化客户端  118
    • 9.2  导出Toast  118
    • 9.3  为其他平台打包  121
    • 9.4  认真考虑组件定义  123
    • 9.4.1  版本和版本范围  123
    • 9.4.2  导出包和友元  124
    • 9.5  总结  126
    • 第10章 插件化服务  127
    • 10.1  分离接口与接口的实现  127
    • 10.1.1  将Fake Airbag与其接口相互分离  128
    • 10.1.2  将模拟GPS与其接口相分离  129
    • 10.1.3  回归测试  129
    • 10.2  设备模拟  130
    • 10.2.1  概念  130
    • 10.2.2  设备模拟器框架  131
    • 10.3  作为插件式服务的模拟设备  131
    • 10.3.1  模拟安全气囊  131
    • 10.3.2  模拟GPS  133
    • 10.4  运行模拟设备  134
    • 10.5  总结  135
    • 第11章 可扩展的用户界面  136
    • 11.1  Crust  136
    • 11.1.1  Crust shell  136
    • 11.1.2  Crust工具  137
    • 11.2  紧急情况处理  138
    • 11.2.1  创建可插拔的用户界面  138
    • 11.2.2  重构紧急情况处理业务逻辑  139
    • 11.2.3  紧急情况处理用户界面  140
    • 11.2.4  运行用户界面  141
    • 11.3  车载气候系统和音响系统  142
    • 11.3.1  车载气候系统与音响设备  142
    • 11.3.2  空调和音响屏幕  144
    • 11.3.3  运行用户界面  144
    • 11.4  OSGi应用模型  145
    • 11.5  导航和地图  148
    • 11.5.1  谷歌地球集成  148
    • 11.5.2  地图支持  151
    • 11.5.3  应用可扩展性和导航支持  152
    • 11.5.4  运行用户界面  152
    • 11.6  总结  154
    • 第12章 动态配置  155
    • 12.1  跟踪场景  155
    • 12.2  安装跟踪代码  156
    • 12.2.1  Core Tracking Bundle  156
    • 12.2.2  后台跟踪bundle  157
    • 12.2.3  客户端跟踪bundle  157
    • 12.3  运行基本的跟踪场景  158
    • 12.4  配置  159
    • 12.4.1  OSGi的管理控制  159
    • 12.4.2  客户端跟踪bundle  159
    • 12.4.3  运行可配置的Toast  161
    • 12.4.4  具备持久化配置的运行  162
    • 12.5  总结  162
    • 第13章 Web门户  163
    • 13.1  门户  163
    • 13.2  PortalServlet  164
    • 13.3  使用服务进行操作查询  165
    • 13.4  声明门户操作  168
    • 13.5  白板模式的利与弊  170
    • 13.6  总结  170
    • 第14章 使用p2进行系统开发  171
    • 14.1  Equinox p2 简介  171
    • 14.1.1  架构  172
    • 14.1.2  p2元数据——可安装的单元  172
    • 14.1.3  组件  173
    • 14.1.4  仓库  173
    • 14.1.5  模式  174
    • 14.1.6  指挥者  174
    • 14.1.7  引擎  174
    • 14.2  细化Toast结构  174
    • 14.2.1  使用特性定义产品  175
    • 14.2.2  后台特性  175
    • 14.2.3  客户端特性  177
    • 14.2.4  重构小结  180
    • 14.3  编写一个配置器  180
    • 14.3.1  配置器  181
    • 14.3.2  配置后台  184
    • 14.3.3  后台小结  184
    • 14.4  增加一个Web部署页面  184
    • 14.4.1  创建动作  185
    • 14.4.2  管理动作  185
    • 14.4.3  安装卸载动作  186
    • 14.4.4  安装配置UI  186
    • 14.5  导出、运行以及配置  186
    • 14.5.1  引入一个p2仓库  186
    • 14.5.2  运行Toast后台  189
    • 14.5.3  创建并配置汽车  190
    • 14.6  客户端动态部署  191
    • 14.7  总结  192
    • 第三部分 进阶篇
    • 第15章 声明式服务  194
    • 15.1  声明式服务模型  194
    • 15.2  常见场景  195
    • 15.2.1  最简单的组件  195
    • 15.2.2  引用服务  197
    • 15.2.3  提供服务  198
    • 15.2.4  引用和提供服务  199
    • 15.2.5  立刻激活组件  201
    • 15.2.6  白板模式  202
    • 15.2.7  工厂组件  207
    • 15.3  启动和调试DS应用  213
    • 15.4  PDE工具  214
    • 15.5  总结  216
    • 第16章 扩展  217
    • 16.1  扩展注册  217
    • 16.2  扩展点  219
    • 16.3  扩展  221
    • 16.4  高级扩展主题  222
    • 16.4.1  扩展ID  222
    • 16.4.2  命名扩展和匿名扩展  222
    • 16.4.3  扩展工厂  223
    • 16.5  扩展注册机制的生命周期  223
    • 16.6  动态扩展的应用场景  224
    • 16.6.1  场景一:没有缓存  225
    • 16.6.2  场景二:缓存扩展  225
    • 16.6.3  场景三:缓存对象  227
    • 16.7  服务与扩展  229
    • 16.8  扩展注册的神话  231
    • 16.9  总结  231
    • 第17章 日志  232
    • 17.1  日志服务规范  232
    • 17.1.1  日志级别  232
    • 17.1.2  记录日志  233
    • 17.1.3  读取日志  233
    • 17.1.4  监听日志  234
    • 17.2  在Toast中使用LogService  234
    • 17.3  使用LogReaderService  237
    • 17.4  Toast的LogUtility类  239
    • 17.5  Equinox的LogService实现  240
    • 17.6  总结  242
    • 第18章 HTTP支持  243
    • 18.1  HttpService  243
    • 18.2  注册和注销Servlet  245
    • 18.3  声明式HTTP内容注册  248
    • 18.4  使用Jetty  248
    • 18.5  HTTP上下文和JAAS集成  249
    • 18.5.1  基于HTTP的认证和登录  249
    • 18.5.2  运行具备安全机制的客户端  252
    • 18.6  疑难解答  253
    • 18.6.1  BindException  253
    • 18.6.2  HttpService在监听哪个端口  253
    • 18.7  总结  254
    • 第19章 服务器端  255
    • 19.1  服务器端和OSGi  255
    • 19.2  在Web应用中嵌入Toast后台系统  257
    • 19.2.1  更新产品  257
    • 19.2.2  Web应用的Root文件  259
    • 19.2.3  构建Web应用  261
    • 19.2.4  运行Web应用  262
    • 19.2.5  疑难解答  264
    • 19.2.6  <init-param>参数说明  265
    • 19.3  OSGi中的远程服务  265
    • 19.3.1  Eclipse通信框架  266
    • 19.3.2  远程服务  266
    • 19.3.3  分布式Toast  266
    • 19.3.4  远程服务主机  267
    • 19.3.5  远程服务客户端  268
    • 19.3.6  服务发现  269
    • 19.3.7  运行分布式系统  270
    • 19.4  总结  271
    • 第20章 发布工程  272
    • 20.1  什么是PDE构建  272
    • 20.2  build.properties bundle  273
    • 20.2.1  控制属性  274
    • 20.2.2  使用自定义构建脚本  275
    • 20.3  创建构建器  275
    • 20.3.1  调整PDE构建的目标  276
    • 20.3.2  build.properties  276
    • 20.4  运行构建器  279
    • 20.5  调整构建  282
    • 20.5.1  自定义构建脚本  282
    • 20.5.2  仓库和附加依赖项  283
    • 20.5.3  从SCM(软件配置管理)系统中提取内容  283
    • 20.5.4  获取map文件  285
    • 20.5.5  自动替换版本号  286
    • 20.5.6  设定版本号  286
    • 20.5.7  定位和放置根目录文件  287
    • 20.6  构建附加特征  288
    • 20.6.1  创建特征构建器  288
    • 20.6.2  build.properties  288
    • 20.6.3  运行特征构建  290
    • 20.7  构建WAR包  291
    • 20.8  总结  291
    • 第四部分 参考篇
    • 第21章 动态性的最佳实践  294
    • 21.1  动态性与你  294
    • 21.2  Toast的动态性  295
    • 21.3  动态性的挑战  296
    • 21.4  动态性意识  297
    • 21.4.1  对象处理  298
    • 21.4.2  bundle监听器  299
    • 21.5  扩展者模式和BundleTracker  300
    • 21.6  动态性启用  300
    • 21.7  启动和停止的动态性  302
    • 21.7.1  启动级别  303
    • 21.7.2  正确使用服务  304
    • 21.7.3  关闭也不总是易事  304
    • 21.8  总结  305
    • 第22章 整合代码库  306
    • 22.1  bundle形式的JAR  306
    • 22.2  采用注入的方式进行bundle化  307
    • 22.3  通过包装的方式进行bundle化  309
    • 22.4  通过引用的方式进行bundle化  310
    • 22.5  使用bnd进行bundle化  312
    • 22.6  解决类加载问题  312
    • 22.6.1  Class.forName()  312
    • 22.6.2  与上下文类加载器有关的问题  316
    • 22.6.3  管理JRE类  317
    • 22.6.4  序列化  318
    • 22.7  总结  318
    • 第23章 高级主题  319
    • 23.1  Equinox控制台  319
    • 23.2  OSGi中的角色  322
    • 23.3  bundle的形态  323
    • 23.4  片段  325
    • 23.5  单例  327
    • 23.6  bundle生命周期  328
    • 23.6.1  生命周期状态  328
    • 23.6.2  BundleActivator  329
    • 23.6.3  激活器的弊端  330
    • 23.6.4  激活器的使用  330
    • 23.7  bundle激活策略  331
    • 23.8  控制bundle启动  332
    • 23.8.1  持久化启动  332
    • 23.8.2  启用激活策略  333
    • 23.8.3  osgi.bundles  333
    • 23.9  类加载  334
    • 23.9.1  类查找算法  334
    • 23.9.2  声明导入和导出  335
    • 23.9.3  导入包与需要的bundle  335
    • 23.9.4  可选性  336
    • 23.9.5  use指令  336
    • 23.9.6  再导出  337
    • 23.9.7  x-internal和x-friends  337
    • 23.9.8  引导代理  337
    • 23.10  配置和运行Equinox  338
    • 23.10.1  config.ini  338
    • 23.10.2  可执行程序  339
    • 23.11  数据区  341
    • 23.12  总结  343
    • 第24章 声明式服务引用  344
    • 24.1  组件XML模式v1.0.0  344
    • 24.1.1  声明XML的命名空间和模式  344
    • 24.1.2  <component>元素  345
    • 24.1.3  <implementation>元素  347
    • 24.1.4  <property>元素  347
    • 24.1.5  <properties>元素  348
    • 24.1.6  <service>元素  349
    • 24.1.7  <provide>元素  349
    • 24.1.8  <reference>元素  349
    • 24.2  组件的生命周期  351
    • 24.2.1  满足组件的配置  351
    • 24.2.2  组件的激活、注销与修改  353
    • 24.2.3  访问引用服务  355
    • 24.2.4  组件的即时性  357
    • 24.2.5  组件属性  357
    • 24.3  总结  359

    上一篇:菜鸟成长之路:Java程序员职场全攻略  下一篇:项目管理知识体系指南(pmbok带批注)

    展开 +

    收起 -

    码小辫二维码
     ←点击下载即可登录

    Java相关电子书
    学习笔记
    网友NO.332717

    JavaScript模块管理的简单实现方式详解

    1. 为什么会有这个东西? 方便组织你的代码,提高项目的可维护性。一个项目的可维护性高不高,也体现一个程序员的水平,在如今越来越复杂的前端项目,这一点尤为重要。 2. 为什么不用requirejs,seajs等 它们功能强大,但是文件体积是个问题,此外还有就是业务有时候可能没那么复杂,正如开头所说的:keep it simple 3. 以下的实现从哪里来的? 这些借鉴了requirejs,seajs,commonjs等的实现,用于真实的项目,稳定运行,效果不错。 4. 适用场景 移动端页面,将js注入到html页面,这样就不用考虑模块加载的问题,从而节省了很多的代码,在实现上也更为的简单。 如果是多文件加载的话,需要手动执行文件加载顺序,那么其实最好用库来进行依赖管理会好一点。 实现1 (function(global){var modules = {};var define = function (id,factory) {if(!modules[id]){modules[id] = {id : id,factory : factory};}};var require = function (id) {var module = modules[id];if(!module){return;}if(!module.exports){module.exports = {};module.factory.call(module.exports,require,module.exports,module);}return module.exports;}global.define = define;global.require = require;})(this); 使用示例 define('Hello',function(require,exports,module){function sayHello() {console.log('hello modules');}module.exports = {sayHello : sayHello}});var Hello = require('Hello');Hello.sayHello(); 实现2 function Module……

    网友NO.622976

    JavaScript模块模式实例详解

    本文实例讲述了JavaScript模块模式。分享给大家供大家参考,具体如下: 在JS中没有Class的概念,那么如何体现Object的Public和Private属性呢,答案就是模块模式(Module Pattern)。 JS中有一个显著的特性: 匿名函数(anonymous function),通过匿名函数的建立和执行,匿名函数里的代码就形成了一个闭包(closure),从而形成,封装和控制一个对象的Private和Public的特性,避免了全局变量的泛滥和与其他脚本的冲突。 (function () { // 所有的变量和函数只在这个范围内有效 // 仍然可以使用全局变量}()); 经典的模块模式模板 var myNamespace = (function () { var myPrivateVar, myPrivateMethod; // A private counter variable myPrivateVar = 0; // A private function which logs any arguments myPrivateMethod = function( foo ) { console.log( foo ); }; return { // A public variable myPublicVar: "foo", // A public function utilizing privates myPublicFunction: function( bar ) { // Increment our private counter myPrivateVar++; // Call our private method using bar myPrivateMethod( bar ); } };})(); 通过闭包,可以看到,当我们使用myNamespace时,我们只能看到myPublic*的属性和方法,而myPrivate*的属性和方法是无法直接访问的。 基本模式扩展 Import mixins JS有一个重要特性叫隐式全局变量,也就是说无论什么时候,JS解释器都对一个变量寻找var声明,如果没有找到,就视为……

    网友NO.785079

    Java编程一个随机数产生模块代码分享

    java随机数的产生比较简单,可以通过 Random rand = new Random(47); System.out.println(rand.nextInt()); 产生,也可以通过以下产生: double d = Math.random(); 当然代码中前者由于使用了固定的种子47,所以每次的值都是一样的,也可以使用 Random rand = new Random(); System.out.println(rand.nextInt()); 而对于代码2则产生的是double的随机数。 下面说下关于3的方式,目前有个需求就是需要产生4为随机数,用于短信注册码的生成,那么就需要使用到随机数,于是使用代码3来实现。若之间使用该代码那么结果并不能满足条件,那么通过以下方式来实现: //方式一 Random rand = new Random();for (int i = 0; i 4; i++){System.out.print(Math.abs(rand.nextint() % 10));}//以上通过rand.next产生随机数,因可能存在负数,用Math.abs取绝对值,然后取模10,产生的结果在10以内 //方式二 Random rand = new Random();for (int i = 0; i 4; i++){System.out.print(rand2.nextint(10));}//以上使用api直接产生10以内的随机数 自己最近写的一个JAVA随机数模块,封装了各种与随机相关的实用方法,特拿来分享。 这里面没什么高科技的东西,函数命名也能看出来用途,所以就简单的注释一下好了,有什么问题可以留言。 源代码(RandomSet.java): import java.awt.Color;import java.util.Collection;import java.util.Iterator;import java.util.Random;public class RandomSet {s……

    网友NO.457577

    如何正确理解javascript的模块化

    模块化在项目中十分的重要,一个复杂的项目肯定有很多相似的功能模块,如果每次都需要重新编写模块肯定既费时又耗力。但是引用别人编写模块的前提是要有统一的“打开姿势”,如果每个人有各自的写法,那么肯定会乱套,下面介绍几种JS的模块化的规范。 一:模块化进程一:script标签 这是最原始的 JavaScript 文件加载方式,如果把每一个文件看做是一个模块,那么他们的接口通常是暴露在全局作用域下,也就是定义在 window 对象中,不同模块的接口调用都是一个作用域中,一些复杂的框架,会使用命名空间的概念来组织这些模块的接口。 缺点: 1、污染全局作用域 2、开发人员必须主观解决模块和代码库的依赖关系 3、文件只能按照script标签的书写顺序进行加载 4、在大型项目中各种资源难以管理,长期积累的问题导致代码库混乱不堪 二:模块化进程二:CommonJS规范 该规范的核心思想是允许模块通过require方法来同步加载所要依赖的其他模块,然后通过 exports 或 module.exports 来导出需要暴露的接口。 require("module");require("../file.js");exports.doStuff = function(){};module.exports = someValue; 优点: 1、简单并容易使用 2、服务器端模块便于重用 缺点: 1、同步的模块加载方式不适合在浏览器环境中,同步意味着阻塞加载,浏览器资源是异步加……

    Copyright 2018-2019 xz577.com 码农之家

    版权责任说明