（二）服务器
1、web服务器nginx和apache的对比分析
①nginx相对于apache的优点：
轻量级，同样起web 服务，比apache 占用更少的内存及资源 ，抗并发，nginx 处理请求是异步非阻塞的，而apache 则是阻塞型的，在高并发下nginx 能保持低资源低消耗高性能，高度模块化的设计，编写模块相对简单。
apache相对于nginx 的优点：A.rewrite ，比nginx 的rewrite 强大；B.动态页面，模块超多，基本想到的都可以找到；C.少bug ，nginx 的bug 相对较多；D.超稳定.
一般来说，需要性能的web 服务，用nginx 。如果不需要性能只求稳定，那就apache.
②作为 Web 服务器：相比 Apache，Nginx 使用更少的资源，支持更多的并发连接，体现更高的效率。Nginx采用C进行编写, 不论是系统资源开销还是CPU使用效率都比 Perlbal 要好很多.
③Nginx 配置简洁,Apache 复杂。Nginx 静态处理性能比 Apache 高 3倍以上，Apache 对PHP支持比较简单，Nginx 需要配合其他后端用。Apache 的组件比 Nginx 多，现在 Nginx 才是Web 服务器的首选。
④最核心的区别在于apache是同步多进程模型，一个连接对应一个进程；nginx是异步的，多个连接（万级别）可以对应一个进程。
⑤nginx处理静态文件好,耗费内存少.但无疑apache仍然是目前的主流,有很多丰富的特性.所以还需要搭配着来.当然如果能确定nginx就适合需求,那么使用nginx会是更经济的方式。
⑥nginx处理动态请求是鸡肋，一般动态请求要apache去做，nginx只适合静态和反向。
⑦Nginx优于apache的主要两点：A.Nginx本身就是一个反向代理服务器 B.Nginx支持7层负载均衡；其他的当然，Nginx可能会比 apache支持更高的并发。
（三）数据库
1、数据库优化：
①方法：MySQL可以建分表，读写分离，建索引，一般经常更新的字段不适合建索引，建索引会降低数据非查询操作的效率。主键是一种特殊的索引。
②导致索引失效的情况：
A、如果条件中有or，即使其中有条件带索引也不会使用到。
B、对于多列索引，不是使用的第一部分，则不会使用索引。
C、like查询是以%开头，而不是以%结尾的。
D、如果索引列类型是字符串，一定要在条件中将数据使用引号引用起来,否则不使用索引。
E、如果mysql估计使用全表扫描要比使用索引快,则不使用索引。
2、MySQL引擎的种类和区别
①种类：MyISAM、InnoDB、MEMORY、MERGE、Archive、Blackhole、CSV、Federate、Merge、NDB集群引擎，第三方引擎：OLTP类引擎、面向列的存储引擎、社区存储引擎。
②区别：
A、MyISAM是MySQL5.1及之前的默认存储引擎。MyISAM不支持事务、也不支持外键，但其访问速度快，对事务完整性没有要求。MyISAM表还支持3中不同的存储格式：
1 静态表
2 动态表
3 压缩表
B、InnoDB存储引擎提供了具有提交、回滚和崩溃恢复能力的事务安全。但是比起MyISAM存储引擎，InnoDB写的处理效率差一些并且会占用更多的磁盘空间以保留数据和索引。 InnoDB存储方式为两种：1 使用共享表空间存储 2 使用多表空间
C、MEMORY存储引擎使用存在内存中的内容来创建表。每个MEMORY表只实际对应一个磁盘文件。MEMORY类型的表访问非常得快，因为它的数据是放在内存中的，并且默认使用HASH索引。但是一旦服务关闭，表中的数据就会丢失掉。
D、MERGE存储引擎是一组MyISAM表的组合，这些MyISAM表必须结构完全相同。MERGE表本身没有数据，对MERGE类型的表进行查询、更新、删除的操作，就是对内部的MyISAM表进行的。
3、数据库事务
（1）四个特性：ACID，原子性，一致性，隔离性，持久性。
（2）四个隔离级别：
............
Read Uncommitted（读取未提交内容）
在该隔离级别，所有事务都可以看到其他未提交事务的执行结果。本隔离级别很少用于实际应用，因为它的性能也不比其他级别好多少。读取未提交的数据，也被称之为脏读（Dirty Read）。
Read Committed（读取提交内容）
这是大多数数据库系统的默认隔离级别（但不是MySQL默认的）。它满足了隔离的简单定义：一个事务只能看见已经提交事务所做的改变。这种隔离级别
也支持所谓的不可重复读（Nonrepeatable
Read），因为同一事务的其他实例在该实例处理其间可能会有新的commit，所以同一select可能返回不同结果。
Repeatable Read（可重读）
这是MySQL的默认事务隔离级别，它确保同一事务的多个实例在并发读取数据时，会看到同样的数据行。不过理论上，这会导致另一个棘手的问题：幻读
（Phantom
Read）。简单的说，幻读指当用户读取某一范围的数据行时，另一个事务又在该范围内插入了新行，当用户再读取该范围的数据行时，会发现有新的“幻影”
行。InnoDB和Falcon存储引擎通过多版本并发控制（MVCC，Multiversion Concurrency
Control）机制解决了该问题。
Serializable（可串行化）
这是最高的隔离级别，它通过强制事务排序，使之不可能相互冲突，从而解决幻读问题。简言之，它是在每个读的数据行上加上共享锁。在这个级别，可能导致大量的超时现象和锁竞争。
这四种隔离级别采取不同的锁类型来实现，若读取的是同一个数据的话，就容易发生问题。例如：
i. 脏读(Drity Read)：某个事务已更新一份数据，另一个事务在此时读取了同一份数据，由于某些原因，前一个RollBack了操作，则后一个事务所读取的数据就会是不正确的。
ii. 不可重复读(Non-repeatable read):在一个事务的两次查询之中数据不一致，这可能是两次查询过程中间插入了一个事务更新的原有的数据。
iii. 幻读(Phantom Read):在一个事务的两次查询中数据笔数不一致，例如有一个事务查询了几列(Row)数据，而另一个事务却在此时插入了新的几列数据，先前的事务在接下来的查询中，就会发现有几列数据是它先前所没有的。
（3）一致性处理：
A、开启事务。B、申请写权限，也就是给对象(表或记录)加锁。C、假如失败，则结束事务，过一会重试。D、假如成功，也就是给对象加锁成功，防止其他用户再用同样的方式打开。E、进行编辑操作。F、写入所进行的编辑结果。G、假如写入成功，则提交事务,完成操作。
H、假如写入失败，则回滚事务，取消提交。I、(G、H)两步操作已释放了锁定的对象，恢复到操作前的状态。
（4）基于事务的数据库引擎的选型：如果考虑到事务，推荐选用MySQL
INNODB引擎；如果考虑速度，建议考虑MySQL
MyISAM引擎，并且需要在代码层面做比较复杂的处理，如通过多线程、异步、非阻塞等方式对数据库进行清理，同时需要信号量、栏栅、数据库标志位等工具保证数据一致性。
4、海量数据处理
（1）数据库扩展：
①纵向扩展：基于业务的高度隔离性和数据的安全性，对业务和数据进行合理的切分，进行主-备机分离，主-主同步，主-从同步（对于MySQL数据库是单向异步同步机制），主-从热备等操作。
②横向扩展：对数据表进行横向切分，按一定的规则（hash取模分、user_id尾数、自定义算法等）对数据表进行横向切分。
关于数据库架构和扩展方面的文章请见：Mysql在大型网站的应用架构演变。
（2）分布式数据方案：
①提供分库规则和路由规则（RouteRule简称RR），将上面的说明中提到的三中切分规则直接内嵌入本系统，具体的嵌入方式在接下来的内容中进行详细的说明和论述；
②引入集群（Group）的概念，保证数据的高可用性；
③引入负载均衡策略（LoadBalancePolicy简称LB）；
④引入集群节点可用性探测机制，对单点机器的可用性进行定时的侦测，以保证LB策略的正确实施，以确保系统的高度稳定性；
⑤引入读/写分离，提高数据的查询速度。
具体描述请参见博文：MySQL 海量数据的存储和访问解决方案。
（3）数据库切分策略介绍，请见博文：数据库Sharding的基本思想和切分策略。
（4）随着数据量随着业务的发展不断增大，传统的关系型数据库RDB已经无法满足需要，这时需要引入新的海量数据处理解决方案：Apache HBase。
（四）框架
1、Struts2
①工作原理
A、在Struts2框架中的处理大概分为以下几个步骤：
1）客户端初始化一个指向Servlet容器（例如Tomcat）的请求
2）这个请求经过一系列的过滤器（Filter）（这些过滤器中有一个叫做ActionContextCleanUp的可选过滤器，这个过滤器对于Struts2和其他框架的集成很有帮助，例如：SiteMesh Plugin）
3）接着FilterDispatcher被调用，FilterDispatcher询问ActionMapper来决定这个请是否需要调用某个Action
4）如果ActionMapper决定需要调用某个Action，FilterDispatcher把请求的处理交给ActionProxy
5）ActionProxy通过Configuration Manager询问框架的配置文件，找到需要调用的Action类
6）ActionProxy创建一个ActionInvocation的实例。
7）ActionInvocation实例使用命名模式来调用，在调用Action的过程前后，涉及到相关拦截器（Intercepter）的调用。
8）一旦Action执行完毕，ActionInvocation负责根据struts.xml中的配置找到对应的返回结果。返回结果通常是（但不总是，也可
能是另外的一个Action链）一个需要被表示的JSP或者FreeMarker的模版。在表示的过程中可以使用Struts2
框架中继承的标签。在这个过程中需要涉及到ActionMapper。
②工作流程：
1）客户端在浏览器中输入一个url地址。
2）这个url请求通过http协议发送给tomcat。
3）tomcat根据url找到对应项目里面的web.xml文件。
4）在web.xml里面会发现有struts2的配置。
5）然后会找到struts2对应的struts.xml配置文件。
6）根据url解析struts.xml配置文件就会找到对应的class。
7）调用完class返回一个字String，根据struts.xml返回到对应的jsp。
2、spring原理
①IoC(Inversion of control): 控制反转，依赖注入
1）IoC：
概念：控制权由对象本身转向容器；由容器根据配置文件去创建实例并创建各个实例之间的依赖关系
2）依赖IoC容器负责管理bean，有两种，一种是BeanFactory，另一种是ApplicationContext，但是ApplicationContext继承与BeanFactory。
核心：bean工厂；在Spring中，bean工厂创建的各个实例称作bean
②AOP(Aspect-Oriented Programming): 面向方面编程
1）代理的两种方式：
静态代理：
针对每个具体类分别编写代理类；
针对一个接口编写一个代理类；
动态代理：
针对一个方面编写一个InvocationHandler，然后借用JDK反射包中的Proxy类为各种接口动态生成相应的代理类
2） AOP的主要原理：动态代理
实现：有两种：JDK
Proxy和Cglib，Spring规定对于有接口的类用JDK
Proxy，对于无接口和抽象类用Cglib，虽然Cglib均可以代理，但是Cglib复杂，效率低。但是Cglib有例外，就是代理的类中不能是final修饰的类或者类中有final方法。
3、Spring、Struts2、Servlet对比
①Servlet原理：Tomcat 的容器等级中，Context 容器是直接管理 Servlet 在容器中的包装类 Wrapper，所以 Context 容器如何运行将直接影响 Servlet 的工作方式。
A、Servlet生命周期详解
Servlet的生命周期可以分为四个阶段，即装载类及创建实例阶段、初始化阶段、服务阶段和实例销毁阶段。下面针对每个阶段的编程任务及注意事项进行详细的说明。
B、Servlet创建过程
在默认情况下Servlet实例是在第一个请求到来的时候创建，以后复用。一旦Servlet实例被创建，Web服务器会自动调用init(ServletConfig config)方法来初始化该Servlet。其中方法参数config中包含了Servlet的配置信息，比如初始化参数，该对象由服务器创建。init方法在Servlet生命周期中只执行一次，而且该方法执行在单线程的环境下，因此开发者不用考虑线程安全的问题。
C、服务
一旦Servlet实例成功创建及初始化，该Servlet实例就可以被服务器用来服务于客户端的请求并生成响应。在服务阶段Web服务器会调用该实例的service(ServletRequest
request,ServletResponse
response)方法，request对象和response对象有服务器创建并传给Servlet实例。request对象封装了客户端发往服务器端的信息，response对象封装了服务器发往客户端的信息。
为了提高效率，Servlet规范要求一个Servlet实例必须能够同时服务于多个客户端请求，即service()方法运行在多线程的环境下，Servlet开发者必须保证该方法的线程安全性。
Serlvet接口只定义了一个服务方法就是service，而HttpServlet类实现了该方法并且要求调用下列的方法之一：
doGet：处理GET请求
doPost：处理POST请求
当发出客户端请求的时候，调用service
方法并传递一个请求和响应对象。Servlet首先判断该请求是GET 操作还是POST 操作。然后它调用下面的一个方法：doGet 或
doPost。如果请求是GET就调用doGet方法，如果请求是POST就调用doPost方法。
②对比：Spring主要有IoC和AOP，Spring中IoC管理的bean为单例模式的，可以配置成原型模式。如果用Spring管理struts2的bean，必须要设置成原型模式，因为struts2封装来了servlet，隔离了servlet的特性，Action不同于Spring，已经是原型模式了。
4、memcached和Redis区别
①Memcached出现于2003年，key支持250bytes，value支持1MB；redis出现于2009年，key和value都是支持512MB的。
持久化方面，memcached过期失效，redis可以缓存回收（6种回收机制），有存储，可算为NOSQL，有优化，支持190多种命令。
集群方面，memcached不支持集群，基于两次哈希，第一次哈希找到服务器节点，第二次哈希找到存储的值。
1）Redis不仅仅支持简单的k/v类型的数据，同时还提供list，set，hash等数据结构的存储。
2）Redis支持数据的备份，即master-slave模式的数据备份。
3）Redis支持数据的持久化，可以将内存中的数据保持在磁盘中，重启的时候可以再次加载进行使用。
Redis只会缓存所有的key的信息，如果Redis发现内存的使用量超过了某一个阀值，将触发swap的操作，Redis根据“swappability=
age*log(size_in_memory)”计算出哪些key对应的value需要swap到磁盘。然后再将这些key对应的value持久化到磁盘中，同时在内存中清除。这种特性使得Redis可以保持超过其机器本身内存大小的数据。当然，机器本身的内存必须要能够保持所有的key，毕竟这些数据是不会进行swap操作的。
②memcached、redis和mongoDB三者之间的对比：
1）性能
都比较高，性能对我们来说应该都不是瓶颈
总体来讲，TPS（每秒事务处理量）方面redis和memcache差不多，要大于mongodb
2）操作的便利性
memcache数据结构单一
redis丰富一些，数据操作方面，redis更好一些，较少的网络IO次数
mongodb支持丰富的数据表达，索引，最类似关系型数据库，支持的查询语言非常丰富
3）内存空间的大小和数据量的大小
redis在2.0版本后增加了自己的VM特性，突破物理内存的限制；可以对key value设置过期时间（类似memcache）
memcache可以修改最大可用内存,采用LRU算法
mongoDB适合大数据量的存储，依赖操作系统VM做内存管理，吃内存也比较厉害，服务不要和别的服务在一起
4）可用性（单点问题）
对于单点问题，
redis，依赖客户端来实现分布式读写；主从复制时，每次从节点重新连接主节点都要依赖整个快照,无增量复制，因性能和效率问题，
所以单点问题比较复杂；不支持自动sharding,需要依赖程序设定一致hash 机制。
一种替代方案是，不用redis本身的复制机制，采用自己做主动复制（多份存储），或者改成增量复制的方式（需要自己实现），一致性问题和性能的权衡
Memcache本身没有数据冗余机制，也没必要；对于故障预防，采用依赖成熟的hash或者环状的算法，解决单点故障引起的抖动问题。
mongoDB支持master-slave,replicaset（内部采用paxos选举算法，自动故障恢复）,auto sharding机制，对客户端屏蔽了故障转移和切分机制。
5）可靠性（持久化）
对于数据持久化和数据恢复，
redis支持（快照、AOF）：依赖快照进行持久化，aof增强了可靠性的同时，对性能有所影响；memcache不支持，通常用在做缓存,提升性能；MongoDB从1.8版本开始采用binlog方式支持持久化的可靠性。
6）数据一致性（事务支持）
Memcache 在并发场景下，用cas保证一致性。
redis事务支持比较弱，只能保证事务中的每个操作连续执行。
mongoDB不支持事务
7）数据分析
mongoDB内置了数据分析的功能(mapreduce),其他不支持。
8）应用场景
redis：数据量较小的更性能操作和运算上。
memcache：用于在动态系统中减少数据库负载，提升性能;做缓存，提高性能（适合读多写少，对于数据量比较大，可以采用sharding）。
MongoDB:主要解决海量数据的访问效率问题。
5、设计一个缓存
A、过期时间
B、多态实现访问量
C、弱引用、软引用。
D、WeakHashMap的使用。
缓存技术的实现原理：LRU（Least Recently Used）缓存技术
可以使用两个标准的数据结构来实现，Map和Queue。因为需要支持多线程，需要使用实现了java.util.concurrent.*的Map和Queue。主要思路是使用一个Queue来维护FIFO和Map来对数据进行排序，当向缓存添加新的元素时，共有以下三种可能：
①如果该元素已经在Cache中存在（Map），我们会从Queue中删除元素并将其添加到Queue的第一个位置；
②如果缓存已经无法满足新增新的元素，我们会从Queue和Map中删除最后面的那个元素并把新元素添加进来；
③同时在Map和Queue中增加新的元素。
参考代码：
[java]view plaincopy
正在上传...取消
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedQueue;
public class LRUCache{
// LRU 缓存的最大容量.
private final int capacity;
// 用来保持最近使用的元素的 Queue.
private ConcurrentLinkedQueuequeue;
private ConcurrentHashMapmap;
/**
* 初始化 LRU 缓存
*
* @param capacity
*/
public LRUCache(final int capacity) {
this.capacity = capacity;
this.queue = new ConcurrentLinkedQueue();
this.map = new ConcurrentHashMap(capacity);
}
/**
* 检查该元素释放在缓存中存在，如果不存在则返回 null
*
* @param key
* @return
*/
public V get(final K key) {
return map.get(key);
}
/**
* 将元素添加到 LRU 缓存。如果 Key 已存在，则将其放到缓存的第一位置
*
* @param key
* @param value
* @throws NullPointerException
*/
public synchronized void put(final K key, final V value) {
if (key == null || value == null) {
throw new NullPointerException();
}
if (map.containsKey(key)) {
queue.remove(key);
}
while (queue.size() >= capacity) {
K expiredKey = queue.poll();
if (expiredKey != null) {
map.remove(expiredKey);
}
}
queue.add(key);
map.put(key, value);
}
}
6、RPC
7、序列化
8、新技术
（1）Netty：
Netty是由JBOSS提供的一个java开源框架。Netty提供异步的、事件驱动的网络应用程序框架和工具，用以快速开发高性能、高可靠性的网络服务器和客户端程序。
也就是说，Netty 是一个基于NIO的客户，服务器端编程框架，使用Netty
可以确保你快速和简单的开发出一个网络应用，例如实现了某种协议的客户，服务端应用。Netty相当简化和流线化了网络应用的编程开发过程，例如，TCP和UDP的socket服务开发。
“快速”和“简单”并不意味着会让你的最终应用产生维护性或性能上的问题。Netty
是一个吸收了多种协议的实现经验，这些协议包括FTP,SMTP,HTTP，各种二进制，文本协议，并经过相当精心设计的项目，最终，Netty
成功的找到了一种方式，在保证易于开发的同时还保证了其应用的性能，稳定性和伸缩性。
（2）MongoDB：
Mongo
DB 是目前在IT行业非常流行的一种非关系型数据库(NoSql),其灵活的数据存储方式备受当前IT从业人员的青睐。Mongo
DB很好的实现了面向对象的思想(OO思想),在Mongo DB中 每一条记录都是一个Document对象。Mongo
DB最大的优势在于所有的数据持久操作都无需开发人员手动编写SQL语句,直接调用方法就可以轻松的实现CRUD操作。
（3）Hadoop：
Hadoop是一个由Apache基金会所开发的分布式系统基础架构。
用户可以在不了解分布式底层细节的情况下，开发分布式程序。充分利用集群的威力进行高速运算和存储。Hadoop实现了一个分布式文件系统（Hadoop
Distributed File
System），简称HDFS。HDFS有高容错性的特点，并且设计用来部署在低廉的（low-cost）硬件上；而且它提供高吞吐量（high
throughput）来访问应用程序的数据，适合那些有着超大数据集（large data
set）的应用程序。HDFS放宽了（relax）POSIX的要求，可以以流的形式访问（streaming access）文件系统中的数据。
Hadoop的框架最核心的设计就是：HDFS和MapReduce。HDFS为海量的数据提供了存储，则MapReduce为海量的数据提供了计算。
（4）Solr：
Solr是一个高性能，采用Java5开发，SolrSolr基于Lucene的全文搜索服务器。同时对其进行了扩展，提供了比Lucene更为丰富的查询语言，同时实现了可配置、可扩展并对查询性能进行了优化，并且提供了一个完善的功能管理界面，是一款非常优秀的全文搜索引擎。
（5）ActiveMQ：
ActiveMQ
是Apache出品，最流行的，能力强劲的开源消息总线。ActiveMQ 是一个完全支持JMS1.1和J2EE 1.4规范的 JMS
Provider实现，尽管JMS规范出台已经是很久的事情了，但是JMS在当今的J2EE应用中间仍然扮演着特殊的地位。
（6）Velocity：Velocity是一个基于java的模板引擎（template engine）。它允许任何人仅仅使用简单的模板语言（template language）来引用由java代码定义的对象。
（7）Openfire ：Openfire 采用Java开发，开源的实时协作（RTC）服务器基于XMPP（Jabber）协议。Openfire安装和使用都非常简单，并利用Web进行管理。单台服务器可支持上万并发用户。
（8）Node.js：
Node.js是一个基于Chrome
JavaScript运行时建立的平台， 用于方便地搭建响应速度快、易于扩展的网络应用。Node.js 使用事件驱动， 非阻塞I/O
模型而得以轻量和高效，非常适合在分布式设备上运行的数据密集型的实时应用。 V8引擎执行Javascript的速度非常快，性能非常好。
Node是一个Javascript运行环境(runtime)。实际上它是对Google V8引擎进行了封装。V8引
擎执行Javascript的速度非常快，性能非常好。Node对一些特殊用例进行了优化，提供了替代的API，使得V8在非浏览器环境下运行得更好。
（9）Ruby on Rails：
Ruby
on Rails 是一个可以使你开发，部署，维护 web 应用程序变得简单的框架。ruby on
rails使用的实时映射技术和元编程技术，免去了开发人员在开发过程中编写大量样板文件代码的烦恼。在少数需要使用样板文件代码的时候，开发人员可以通过ruby
on
rails内建的生成器脚本实时创建，而不再是通过手工编写。rails的这个特点可以使开发人员更专注于系统的逻辑结构，而不必为一些琐碎的细节所烦扰。
（10）Docker：
Docker 是一个开源的应用容器引擎，让开发者可以打包他们的应用以及依赖包到一个可移植的容器中，然后发布到任何流行的Linux机器上，也可以实现虚拟化。容器是完全使用沙箱机制，相互之间不会有任何接口（类似 iPhone 的 app）。几乎没有性能开销,可以很容易地在机器和数据中心中运行。最重要的是,他们不依赖于任何语言、框架或包括系统。
（11）ElasticSearch：
ElasticSearch是一个基于Lucene的搜索服务器。它提供了一个分布式多用户能力的全文搜索引擎，基于RESTful web接口。Elasticsearch是用Java开发的，并作为Apache许可条款下的开放源码发布，是第二最流行的企业搜索引擎。设计用于云计算中，能够达到实时搜索，稳定，可靠，快速，安装使用方便。
（12）RESTful WebService：
RESTful WebService是比基于SOAP消息的WebService简单的多的一种轻量级Web服务，RESTful WebService是没有状态的，发布和调用都非常的轻松容易。
（13）Hessian：
Hessian是一个轻量级的remoting onhttp工具，使用简单的方法提供了RMI的功能。 相比WebService，Hessian更简单、快捷。采用的是二进制RPC协议，因为采用的是二进制协议，所以它很适合于发送二进制数据。
（14）WebLogic：
WebLogic是美国Oracle公司出品的一个application server，确切的说是一个基于JAVAEE架构的中间件，WebLogic是用于开发、集成、部署和管理大型分布式Web应用、网络应用和数据库应用的Java应用服务器。将Java的动态功能和Java Enterprise标准的安全性引入大型网络应用的开发、集成、部署和管理之中。
（15）OSGi：
OSGi(Open
Service Gateway
Initiative)技术是面向Java的动态模型系统。OSGi服务平台向Java提供服务，这些服务使Java成为软件集成和软件开发的首选环境。Java提供在多个平台支持产品的可移植性。OSGi技术提供允许应用程序使用精炼、可重用和可协作的组件构建的标准化原语。这些组件能够组装进一个应用和部署中。
