coolfiry

认认真真做人,兢兢业业做事!
posts - 39, comments - 17, trackbacks - 0, articles - 0

2006年9月9日

在这篇文章中将我们一起来探讨当前的API网关的作用。 

一、API网关的用处

API网关我的分析中会用到以下三种场景。 

  1. Open API。 企业需要将自身数据、能力等作为开发平台向外开放,通常会以rest的方式向外提供,最好的例子就是淘宝开放平台、腾讯公司的QQ开放平台、微信开放平台。 Open API开放平台必然涉及到客户应用的接入、API权限的管理、调用次数管理等,必然会有一个统一的入口进行管理,这正是API网关可以发挥作用的时候。
  2. 微服务网关。微服务的概念最早在2012年提出,在Martin Fowler的大力推广下,微服务在2014年后得到了大力发展。 在微服务架构中,有一个组件可以说是必不可少的,那就是微服务网关,微服务网关处理了负载均衡,缓存,路由,访问控制,服务代理,监控,日志等。API网关在微服务架构中正是以微服务网关的身份存在。 
  3. API服务管理平台。上述的微服务架构对企业来说有可能实施上是困难的,企业有很多遗留系统,要全部抽取为微服务器改动太大,对企业来说成本太高。但是由于不同系统间存在大量的API服务互相调用,因此需要对系统间服务调用进行管理,清晰地看到各系统调用关系,对系统间调用进行监控等。 API网关可以解决这些问题,我们可以认为如果没有大规模的实施微服务架构,那么对企业来说微服务网关就是企业的API服务管理平台。

二、API网关在企业整体架构中的地位

一个企业随着信息系统复杂度的提高,必然出现外部合作伙伴应用、企业自身的公网应用、企业内网应用等,在架构上应该将这三种应用区别开,三种应用的安排级别、访问方式也不一样。 因此在我的设计中将这三种应用分别用不同的网关进行API管理,分别是:API网关(OpenAPI合伙伙伴应用)、API网关(内部应用)、API网关(内部公网应用)。

 

三、企业中在如何应用API网关

1、对于OpenAPI使用的API网关来说,一般合作伙伴要以应用的形式接入到OpenAPI平台,合作伙伴需要到 OpenAPI平台申请应用。 因此在OpenAPI网关之外,需要有一个面向合作伙伴的使用的平台用于合作伙伴,这就要求OpenAPI网关需要提供API给这个用户平台进行访问。 如下架构:

 

当然如果是在简单的场景下,可能并不需要提供一个面向合作伙伴的门户,只需要由公司的运营人员直接添加合作伙伴应用id/密钥等,这种情况下也就不需要合作伙伴门户子系统。 

2、对于内网的API网关,在起到的作用上来说可以认为是微服务网关,也可以认为是内网的API服务治理平台。 当企业将所有的应用使用微服务的架构管理起来,那么API网关就起到了微服务网关的作用。 而当企业只是将系统与系统之间的调用使用rest api的方式进行访问时使用API网关对调用进行管理,那么API网关起到的就是API服务治理的作用。 架构参考如下:

3、对于公司内部公网应用(如APP、公司的网站),如果管理上比较细致,在架构上是可能由独立的API网关来处理这部分内部公网应用,如果想比较简单的处理,也可以是使用面向合作伙伴的API网关。 如果使用独立的API网关,有以下的好处:

  • 面向合作伙伴和面向公司主体业务的优先级不一样,不同的API网关可以做到业务影响的隔离。
  • 内部API使用的管理流程和面向合作伙伴的管理流程可能不一样。
  • 内部的API在功能扩展等方面的需求一般会大于OpenAPI对于功能的要求。

基于以上的分析,如果公司有能力,那么还是建议分开使用合作伙伴OPEN API网关和内部公网应用网关。

四、API网关有哪些竞争方案

1、对于Open API平台的API网关,我分析只能选择API网关作为解决方案,业界没有发现比较好的可以用来作为Open API平台的入口的其他方案。 

2、对于作为微服务网关的API网关,业界的选择可以选择的解决方案比较多,也取决于微服务器的实现方案,有一些微服务架构的实现方案是不需要微服务网关的。

  • Service Mesh,这是新兴的基于无API网关的架构,通过在客户端上的代理完成屏蔽网络层的访问,这样达到对应用层最小的改动,当前Service Mesh的产品还正在开发中,并没有非常成熟可直接应用的产品。 发展最迅速的产品是Istio。 建议大家密切关注相关产品的研发、业务使用进展。

  • 基于duboo架构,在这个架构中通常是不需要网关的,是由客户端直接访问服务提供方,由注册中心向客户端返回服务方的地址。

五、API网关解决方案

私有云开源解决方案如下:

  • Kong kong是基于Nginx+Lua进行二次开发的方案, https://konghq.com/
  • Netflix Zuul,zuul是spring cloud的一个推荐组件,https://github.com/Netflix/zuul
  • orange,这个开源程序是国人开发的, http://orange.sumory.com/

公有云解决方案:

  • Amazon API Gateway,https://aws.amazon.com/cn/api-gateway/
  • 阿里云API网关,https://www.aliyun.com/product/apigateway/
  • 腾讯云API网关, https://cloud.tencent.com/product/apigateway

自开发解决方案:

  • 基于Nginx+Lua+ OpenResty的方案,可以看到Kong,orange都是基于这个方案
  • 基于Netty、非阻塞IO模型。 通过网上搜索可以看到国内的宜人贷等一些公司是基于这种方案,是一种成熟的方案。
  • 基于Node.js的方案。 这种方案是应用了Node.js天生的非阻塞的特性。
  • 基于java Servlet的方案。 zuul基于的就是这种方案,这种方案的效率不高,这也是zuul总是被诟病的原因。

六、企业怎么选择API网关

如果是要选择一款已有的API网关,那么需要从以下几个方面去考虑。 

1、性能与可用性
如果一旦采用了API网关,那么API网关就会作为企业应用核心,因此性能和可用性是必须要求的。

  • 从性能上来说,需要让网关增加的时间消耗越短越好,个人觉得需要10ms以下。 系统需要采用非阻塞的IO,如epoll,NIO等。网关和各种依赖的交互也需要是非阻塞的,这样才能保证整体系统的高可用性,如:Node.js的响应式编程和基于java体现的RxJava和Future。
  • 网关必须支持集群部署,任务一台服务器的crash都应该不影响整体系统的可用性。
  • 多套网关应该支持同一管理平台和同一监控中心。 如: 一个企业的OpenAPI网关和内部应用的多个系统群的不同的微服务网关可以在同一监控中心进行监控。

2、可扩展性、可维护性
一款产品总有不能满足生产需求的地方,因此需求思考产品在如何进行二次开发和维护,是否方便公司团队接手维护产品。 
3、需求匹配度
需要评估各API网关在需求上是否能满足,如: 如果是OpenAPI平台需要使用API网关,那么需要看API网关在合作伙伴应用接入、合作伙伴门户集成、访问次数限额等OpenAPI核心需求上去思考产品是否能满足要求。 如果是微服务网关,那么要从微服务的运维、监控、管理等方面去思考产品是否足够强大。
4、是否开源?公司是否有自开发的能力?
现有的开源产品如kong,zuul,orange都有基础的API网关的核心功能,这些开源产品大多离很好的使用有一定的距离,如:没有提供管理功能的UI界面、监控功能弱小,不支持OpenAPI平台,没有公司运营与运维的功能等。 当然开源产品能获取源代码,如果公司有比较强的研发能力,能hold住这些开源产品,经过二次开发kong、zuul应该还是适应一些公司,不过需求注意以下一些点:

  • kong是基于ngnix+lua的,从公司的角度比较难于找到能去维护这种架构产品的人。 需求评估当前公司是否有这个能力去维护这个产品。
  • zuul因为架构的原因在高并发的情况下性能不高,同时需要去基于研究整合开源的适配zuul的监控和管理系统。
  • orange由于没有被大量使用,同时是国内个人在开源,在可持续性和社区资源上不够丰富,出了问题后可能不容易找到人问。

另外kong提供企业版本的API网关,当然也是基于ngnix+lua的,企业版本可以购买他们的技术支持、培训等服务、以及拥有界面的管理、监控等功能。

5、公有云还是私有云
现在的亚马逊、阿里、腾讯云都在提供基础公有云的API网关,当然这些网关的基础功能肯定是没有问题,但是二次开发,扩展功能、监控功能可能就不能满足部分用户的定制需求了。另外很多企业因为自身信息安全的原因,不能使用外网公有网的API网关服务,这样就只有选择私有云的方案了。 
在需求上如果基于公有云的API网关只能做到由内部人员为外网人员申请应用,无法做到定制的合作伙伴门户,这也不适合于部分企业的需求。 
如果作为微服务网关,大多数情况下是希望网关服务器和服务提供方服务器是要在内网的,在这里情况下也只有私有云的API网关才能满足需求。 

综合上面的分析,基础公有云的API网关只有满足一部分简单客户的需求,对于很多企业来说私有云的API网关才是正确的选择。


文章作者介绍:
来自于小豹科技的架构师-专注于软件研发基于平台性软件的研发,目前我正在研发一款基于Netty、响应式架构的插件式的API网关,希望能对行业带来一些改变。 我希望与对OpenAPI、微服务、API网关、Service Mesh等感兴趣的朋友多交流。 有兴趣的朋友请加我的QQ群244054462。

posted @ 2018-01-05 13:42 Coolfiry 阅读(4677) | 评论 (0)编辑 收藏

虞美人 李煜
春花秋月何时了,往事知多少?小楼昨夜又东风,故国不堪回首月明中。雕栏玉砌应犹在,只是朱颜改。问君能有几多愁,恰似一江春水向东流。 

posted @ 2009-01-19 10:49 Coolfiry 阅读(254) | 评论 (0)编辑 收藏

雨霖铃 ·柳永


寒蝉凄切。对长亭晚,骤雨初歇。都门帐饮无绪,留恋处、兰舟催发。执手相看泪眼,竟无语凝噎。念去去、千里烟波,暮霭沉沉楚天阔。
多情自古伤离别,更那堪冷落清秋节!今宵酒醒何处?杨柳岸、晓风残月。此去经年,应是良辰好景虚设。便纵有千种风情,更与何人说?

posted @ 2009-01-19 10:48 Coolfiry 阅读(247) | 评论 (0)编辑 收藏

1、python的入门级内容。
2、java mail的使用基本用法和注意事项。
3、CXF中相关BUG的解决方法。
4、UNIX 网络编程步步提升系列。

posted @ 2008-12-11 15:48 Coolfiry 阅读(1057) | 评论 (5)编辑 收藏

转自:http://bbs.chinaunix.net/viewthread.php?tid=691982&extra=&page=1
snoop 抓包
solaris自带snoop抓包工具,抓所有数据流

# snoop
Using device /dev/pcn0 (promiscuous mode)
192.168.8.18 -> 192.168.255.255 NBT NS Query Request for WORKGROUP[1c], Success
192.168.253.35 -> solaris      TELNET C port=1246
     solaris -> 192.168.253.35 TELNET R port=1246 Using device /dev/pc
     solaris -> 192.168.253.35 TELNET R port=1246 Using device /dev/pc
192.168.4.150 -> (broadcast)  ARP C Who is 192.168.4.200, 192.168.4.200 ?
192.168.4.200 -> (broadcast)  ARP C Who is 192.168.4.150, 192.168.4.150 ?
#

抓源地址或目的为 202.101.98.55的数据流:

# snoop 202.101.98.55
Using device /dev/pcn0 (promiscuous mode)
192.168.253.35 -> dns.fz.fj.cn DNS C www.163.com. Internet Addr ?
dns.fz.fj.cn -> 192.168.253.35 DNS R www.163.com. Internet CNAME www.cache.split.netease.com.

#

说明:internet cname 后的为解析www.163.com的名字时,代表www.163.com回答的主机的域名。

抓 192.168.253.35和202.101.98.55之间的数据流(双向都抓)

# snoop 192.168.253.35 202.101.98.55
Using device /dev/pcn0 (promiscuous mode)
192.168.253.35 -> dns.fz.fj.cn DNS C www.google.com. Internet Addr ?
dns.fz.fj.cn -> 192.168.253.35 DNS R www.google.com. Internet CNAME www.l.google.com.
#

抓完存在当前目录下的cap文件中并查看

# snoop -o cap1 -P      -P表示处在非混杂模式抓数据,只抓广播、主播、目的为本机的数据
Using device /dev/pcn0 (non promiscuous)
15 ^C                           15的含义是:显示目前抓了多少个数据流
#

# snoop -i cap1
  1   0.00000 192.168.253.35 -> solaris      TELNET C port=1246
  2   0.18198 192.168.253.35 -> solaris      TELNET C port=1246
  3   0.37232 192.168.4.199 -> 192.168.255.255 NBT Datagram Service Type=17 Source=WB-200[20]
  4   0.00016            ? -> (multicast)  ETHER Type=EF08 (Unknown), size = 180bytes
  5   0.62546 192.168.253.35 -> solaris      TELNET C port=1246
  6   0.13822            ? -> (multicast)  ETHER Type=0000 (LLC/802.3), size = 52 bytes
  7   0.06283 192.168.253.35 -> solaris      TELNET C port=1246
  8   0.90301 192.168.253.35 -> solaris      TELNET C port=1246
  9   0.19781 192.168.253.35 -> solaris      TELNET C port=1246
10   0.81493            ? -> (multicast)  ETHER Type=0000 (LLC/802.3), size = 52 bytes
11   0.07018 192.168.253.35 -> solaris      TELNET C port=1246
12   0.19939 192.168.253.35 -> solaris      TELNET C port=1246
13   0.90151 192.168.253.35 -> solaris      TELNET C port=1246
14   0.18904 192.168.253.35 -> solaris      TELNET C port=1246
15   0.68422            ? -> (multicast)  ETHER Type=0000 (LLC/802.3), size = 52 bytes
#snoop -i cap1 -p 10,12            只看10-12条记录

#snoop -i cap1 -p10                  只看第10条记录

# snoop -i cap1 -v -p101            查看第10条数据流的包头的详细内容

#snoop -i cap1 -v -x 0 -p101   查看第10条数据流的全部的详细内容

抓主机192.168.253.35和202.101.98.55之间的tcp或者udp端口53的数据

# snoop 192.168.253.35 and 202.101.98.55 and \(tcp or udp\) and port 53

输入(的时候要加转义符号\


snoop的详细参数
Snoop 是Solaris 系统中自带的工具, 是一个用于显示网络通讯的程序, 它可捕获IP 包并将其显示或保存到指定文件. (限超级用户使用snoop)
Snoop 可将捕获的包以一行的形式加以总结或用多行加以详细的描述(有调用不同的参数–v -V来实现). 在总结方式下(-V ) , 将仅显示最高层的相关协议, 例如一个NFS 包将仅显示NFS 信息, 其低层的RPC, UDP, IP, Ethernet 帧信息将不会显示, 但是当加上相应的参数(-v ), 这些信息都能被显示出来.

-C

-D

-N

-P 在非混杂模式下抓包

-S 抓包的时候显示数据包的大小

-V 半详细的显示抓的数据的信息

-t [ r | a | d ] 显示时间戳,-ta显示当前系统时间,精确到毫秒

-v 最详细的显示数据的信息

-x offset [ , length] 以16进制或ACSII方式显示某数据的部分内容,比如 -x 0,10 只显示0-10字节

#snoop -i cap1 -v -x 0 -p101 查看被抓获的第101个数据流的全部内容


表达式:

根据地址:

#snoop x.x.x.x         IPV4的IP

#snoop 0XX:XX:XX:XX    ETHERNET的MAC地址

数据的方向:

from x.x.x.x 或者 src x.x.x.x

to x.x.x.x 或者 dst x.x.x.x

可用的数据类型的关键词:

ip, ip6, arp, rarp, pppoed, pppoes,pppoe,broadcast,multicast,apple,decnet

udp, tcp, icmp, icmp6, ah, esp

greater length
      True if the packet is longer than length.

less length
      True if the packet is shorter than length.

net net

# snoop from net 192.168.1.0 抓来自192.168.1.0/24的数据

# snoop from net 192.168.0.0 抓来自192.168.0.0/16的数据

port xx XX为TCP或者UDP的端口号或者 /etc/services里定义的名字

#snoop to udp and port 53    抓到UDP53的数据

posted @ 2008-10-21 21:30 Coolfiry 阅读(709) | 评论 (0)编辑 收藏

在项目使用CXF的过程中,遇到了有关List作为传输参数的时候,如果WebService端没有明确给出List的泛型类型会报错。
例如
CXF的WebService端口接口的一个方法为为:
1 public boolean updateMessageStatus(List batchIds);

客户端的的调用为:
1 //预先初始化cxf对象cxfObj
2 List<String> list=new ArrayList<String>();
3 list.add("1");
4 cxfObj.updateMessageStatus(list);


在客户端进行调用WebService时会发生错误,错误为:unexpected element (uri:"", local:"arg0")等,据分析生成的wsdl,这是因为CXF在进行数据marshal时不知道要将要转换的类型。

解决办法是:在WebService端的接口必须用List的泛型类型参数,如:

1 public boolean updateMessageStatus(List<String> batchIds);

这样就完全解决问题了。

posted @ 2008-08-05 20:09 Coolfiry 阅读(4938) | 评论 (1)编辑 收藏

现在正在学习linux shell编程
first.sh
while read line
do
        echo 
"$line"
done 
<"$1"
这是第一个shell程序小例子,就相当于一个学习其他语言的hello world了吧。用法first.sh test,将test文件中的每一行输出到stdout中。

second.sh
number=0;
while [ "$number" -lt 100 ]
do
        echo 
"$number"
        number
='expr $number + 1'
done
echo
这是第二个shell程序小例子,作用是输出0到99的数字到stdout中。其中用到的expr的作用是使expr的参数转化为数字并相加。两个单引号的作用是引号所包围的命令被命令的标准输出替换,并输出赋值给我number,得到了如同java中number=number+1的效果。


posted @ 2008-07-20 20:34 Coolfiry 阅读(574) | 评论 (2)编辑 收藏

在项目开发过程中,遇到在本机和windows环境中部署用CXF框架开发的的webService没有任何问题,但是当将工程部署到solaris 的SUN ONE application上时,再用本机的cxf Web服务客户端访问对应的web服务时,如果传输的数据量小于大约4K不会出问题,否则则会报一些数据绑定的异常如:
Marshalling Error: Error writing request body to server。
解决这个问题花了我足足两天时间,原因是有关CXF的资料太少了,而且有关于这个错误的解决都必须使用google才能search到,用baidu完全search不到相关的资料。
解决方案:
在客户端的class-path中加上cxf.xml。cxf.xml的配置如下:
<?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:http
="http://cxf.apache.org/transports/http/configuration"
    xmlns:jaxws
="http://cxf.apache.org/jaxws"
    xsi:schemaLocation
="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd
 http://cxf.apache.org/transports/http/configuration
http://cxf.apache.org/schemas/configuration/http-conf.xsd"
>
    
<http:conduit name="*.http-conduit">
        
<http:client AutoRedirect="true" />
    
</http:conduit>
</beans>
这个问题的解决方案是我在cxf的官网上找了很久才找到的,虽然问题解决了,但是我感到很迷惑。主要在windows tomcat环境下没有问题,而到了SUN ONE的环境就有问题,经过的思考和找了一资料,我认为问题出于solaris对于HTTP数据传输的某些限制,如果真要去搞清楚的话可能要去参看cxf的source code了,但是我不想花这个时间去研究这个问题了。

我把这个解决方案写出来,希望可以帮助到使用CXF的网友,也希望高手们能帮我解决我的迷惑。



posted @ 2008-07-18 19:11 Coolfiry 阅读(2533) | 评论 (0)编辑 收藏

Internet的快速增长使多媒体网络服务器,特别是Web服务器,面对的访问者数量快速增加,网络服务器需要具备提供大量并发访问服务的能力。 例如Yahoo每天会收到数百万次的访问请求,因此对于提供大负载Web服务的服务器来讲,CPU、I/O处理能力很快会成为瓶颈。

简单的 提高硬件性能并不能真正解决这个问题,因为单台服务器的性能总是有限的,一般来讲,一台PC服务器所能提供的并发访问处理能力大约为1000个,更为高档 的专用服务器能够支持3000-5000个并发访问,这样的能力还是无法满足负载较大的网站的要求。尤其是网络请求具有突发性,当某些重大事件发生时,网 络访问就会急剧上升,从而造成网络瓶颈,例如在网上发布的克林顿弹劾书就是很明显的例子。必须采用多台服务器提供网络服务,并将网络请求分配给这些服务器 分担,才能提供处理大量并发服务的能力。

当使用多台服务器来分担负载的时候,最简单的办法是将不同的服务器用在不同的方面。 按提供的内容进行分割时,可以将一台服务器用于提供新闻页面,而另一台用于提供游戏页面;或者可以按服务器的功能进行分割,将一台服务器用于提供静态页面 访问,而另一些用于提供CGI等需要大量消耗资源的动态页面访问。然而由于网络访问的突发性,使得很难确定那些页面造成的负载太大,如果将服务的页面分割 的过细就会造成很大浪费。事实上造成负载过大的页面常常是在变化中的,如果要经常按照负载变化来调整页面所在的服务器,那么势必对管理和维护造成极大的问 题。因此这种分割方法只能是大方向的调整,对于大负载的网站,根本的解决办法还需要应用负载均衡技术。

负载均衡的思路下多台 服务器为对称方式,每台服务器都具备等价的地位,都可以单独对外提供服务而无须其他服务器的辅助。然后通过某种负载分担技术,将外部发送来的请求均匀分配 到对称结构中的某一台服务器上,而接收到请求的服务器都独立回应客户机的请求。由于建立内容完全一致的Web服务器并不复杂,可以使用服务器同步更新或者 共享存储空间等方法来完成,因此负载均衡技术就成为建立一个高负载Web站点的关键性技术。

  1. 基于特定服务器软件的负载均衡

    很 多网络协议都支持“重定向”功能,例如在HTTP协议中支持Location指令,接收到这个指令的浏览器将自动重定向到Location指明的另一个 URL上。由于发送Location指令比起执行服务请求,对Web服务器的负载要小的多,因此可以根据这个功能来设计一种负载均衡的服务器。任何时候 Web服务器认为自己负载较大的时候,它就不再直接发送回浏览器请求的网页,而是送回一个Locaction指令,让浏览器去服务器集群中的其他服务器上 获得所需要的网页。

    在这种方式下,服务器本身必须支持这种功能,然而具体实现起来却有很多困难,例如一台服务器如何能保证它重定向过的服务 器是比较空闲的,并且不会再次发送Location指令?Location指令和浏览器都没有这方面的支持能力,这样很容易在浏览器上形成一种死循环。因 此这种方式实际应用当中并不多见,使用这种方式实现的服务器集群软件也较少。有些特定情况下可以使用CGI(包括使用FastCGI或mod_perl扩 展来改善性能)来模拟这种方式去分担负载,而Web服务器仍然保持简洁、高效的特性,此时避免Location循环的任务将由用户的CGI程序来承担。

  2. 基于DNS的负载均衡

    由 于基于服务器软件的负载均衡需要改动软件,因此常常是得不偿失,负载均衡最好是在服务器软件之外来完成,这样才能利用现有服务器软件的种种优势。最早的负 载均衡技术是通过DNS服务中的随机名字解析来实现的,在DNS服务器中,可以为多个不同的地址配置同一个名字,而最终查询这个名字的客户机将在解析这个 名字时得到其中的一个地址。因此,对于同一个名字,不同的客户机会得到不同的地址,他们也就访问不同地址上的Web服务器,从而达到负载均衡的目的。

    例如如果希望使用三个Web服务器来回应对www.exampleorg.org.cn的HTTP请求,就可以设置该域的DNS服务器中关于该域的数据包括有与下面例子类似的结果:

    www1		IN		A 		192.168.1.1
    www2		IN		A 		192.168.1.2
    www3		IN		A 		192.168.1.3
    www		IN		CNAME		www1
    www		IN		CNAME		www2
    www		IN		CNAME		www3

    此后外部的客户机就可能随机的得到对应www的不同地址,那么随后的HTTP请求也就发送给不同地址了。

    DNS 负载均衡的优点是简单、易行,并且服务器可以位于互联网的任意位置上,当前使用在包括Yahoo在内的Web站点上。然而它也存在不少缺点,一个缺点是为 了保证DNS数据及时更新,一般都要将DNS的刷新时间设置的较小,但太小就会造成太大的额外网络流量,并且更改了DNS数据之后也不能立即生效;第二点 是DNS负载均衡无法得知服务器之间的差异,它不能做到为性能较好的服务器多分配请求,也不能了解到服务器的当前状态,甚至会出现客户请求集中在某一台服 务器上的偶然情况。

  3. 反向代理负载均衡

    使用代理服务器可以将请求转发给内部的Web服务器,使用这种加速 模式显然可以提升静态网页的访问速度。因此也可以考虑使用这种技术,让代理服务器将请求均匀转发给多台内部Web服务器之一上,从而达到负载均衡的目的。 这种代理方式与普通的代理方式有所不同,标准代理方式是客户使用代理访问多个外部Web服务器,而这种代理方式是多个客户使用它访问内部Web服务器,因 此也被称为反向代理模式。

    实现这个反向代理能力并不能算是一个特别复杂的任务,但是在负载均衡中要求特别高的效率,这样实现起来就不是十分 简单的了。每针对一次代理,代理服务器就必须打开两个连接,一个为对外的连接,一个为对内的连接,因此对于连接请求数量非常大的时候,代理服务器的负载也 就非常之大了,在最后反向代理服务器会成为服务的瓶颈。例如,使用Apache的mod_rproxy模块来实现负载均衡功能时,提供的并发连接数量受 Apache本身的并发连接数量的限制。一般来讲,可以使用它来对连接数量不是特别大,但每次连接都需要消耗大量处理资源的站点进行负载均衡,例如搜寻。

    使 用反向代理的好处是,可以将负载均衡和代理服务器的高速缓存技术结合在一起,提供有益的性能,具备额外的安全性,外部客户不能直接访问真实的服务器。并且 实现起来可以实现较好的负载均衡策略,将负载可以非常均衡的分给内部服务器,不会出现负载集中到某个服务器的偶然现象。

  4. 基于NAT的负载均衡技术

    网 络地址转换为在内部地址和外部地址之间进行转换,以便具备内部地址的计算机能访问外部网络,而当外部网络中的计算机访问地址转换网关拥有的某一外部地址 时,地址转换网关能将其转发到一个映射的内部地址上。因此如果地址转换网关能将每个连接均匀转换为不同的内部服务器地址,此后外部网络中的计算机就各自与 自己转换得到的地址上服务器进行通信,从而达到负载分担的目的。

    地 址转换可以通过软件方式来实现,也可以通过硬件方式来实现。使用硬件方式进行操作一般称为交换,而当交换必须保存TCP连接信息的时候,这种针对OSI网 络层的操作就被称为第四层交换。支持负载均衡的网络地址转换为第四层交换机的一种重要功能,由于它基于定制的硬件芯片,因此其性能非常优秀,很多交换机声 称具备400MB-800MB的第四层交换能力,然而也有一些资料表明,在如此快的速度下,大部分交换机就不再具备第四层交换能力了,而仅仅支持第三层甚 至第二层交换。

    然而对于大部分站点来讲,当前负载均衡主要是解决Web服务器处理能力瓶颈的,而非网络传输能力,很多站点的互联网连接带宽总共也不过10MB,只有极少的站点能够拥有较高速的网络连接,因此一般没有必要使用这些负载均衡器这样的昂贵设备。

    使 用软件方式来实现基于网络地址转换的负载均衡则要实际的多,除了一些厂商提供的解决方法之外,更有效的方法是使用免费的自由软件来完成这项任务。其中包括 Linux Virtual Server Project中的NAT实现方式,或者本文作者在FreeBSD下对natd的修订版本。一般来讲,使用这种软件方式来实现地址转换,中心负载均衡器存 在带宽限制,在100MB的快速以太网条件下,能得到最快达80MB的带宽,然而在实际应用中,可能只有40MB-60MB的可用带宽。

  5. 扩展的负载均衡技术

上 面使用网络地址转换来实现负载分担,毫无疑问所有的网络连接都必须通过中心负载均衡器,那么如果负载特别大,以至于后台的服务器数量不再在是几台、十几 台,而是上百台甚至更多,即便是使用性能优秀的硬件交换机也回遇到瓶颈。此时问题将转变为,如何将那么多台服务器分布到各个互联网的多个位置,分散网络负 担。当然这可以通过综合使用DNS和NAT两种方法来实现,然而更好的方式是使用一种半中心的负载均衡方式。

在这种半中心的负载均衡方式下,即当客户请求发送给负载均衡器的时候,中心负载均衡器将请求打包并发送给某个服务器,而服务器的回应请求不再返回给中心负载均衡器,而是直接返回给客户,因此中心负载均衡器只负责接受并转发请求,其网络负担就较小了。

上图来自Linux Virtual Server Project,为他们使用IP隧道实现的这种负载分担能力的请求/回应过程,此时每个后台服务器都需要进行特别的地址转换,以欺骗浏览器客户,认为它的回应为正确的回应。

同样,这种方式的硬件实现方式也非常昂贵,但是会根据厂商的不同,具备不同的特殊功能,例如对SSL的支持等。

由于这种方式比较复杂,因此实现起来比较困难,它的起点也很高,当前情况下网站并不需要这么大的处理能力。

比 较上面的负载均衡方式,DNS最容易,也最常用,能够满足一般的需求。但如果需要进一步的管理和控制,可以选用反向代理方式或NAT方式,这两种之间进行 选择主要依赖缓冲是不是很重要,最大的并发访问数量是多少等条件。而如果网站上对负载影响很厉害的CGI程序是由网站自己开发的,也可以考虑在程序中自己 使用Locaction来支持负载均衡。半中心化的负载分担方式至少在国内当前的情况下还不需要。
http://galaxystar.javaeye.com/blog/50546

posted @ 2008-07-18 14:23 Coolfiry 阅读(242) | 评论 (0)编辑 收藏

在Java版发表这篇文章,似乎有点把矛头指向Java了。其实不是,GC是所有新一代语言共有的特征,
Python, Eiffel,C#,Roby等无一例外地都使用了GC机制。但既然Java中的GC最为著名,所以天塌
下来自然应该抗着。

这篇短文源于comp.lang.java.programmer跟comp.lang.c++上发生的一场大辩论,支持C++和Java
的两派不同势力展开了新世纪第一场冲突,跟贴发言超过350,两派都有名角压阵。C++阵营的擂主是
Pete Becker,ACM会员,Dinkumware Ltd. 的技术副总监。此君精通C++和Java,开发过两种语言的
核心类库,但是却对C++狂热之极,而对于Java颇不以为然。平时谈到Java的时候还好,一旦有人胆
敢用Java来批判C++,立刻忍不住火爆脾气跳将出来,以坚韧不拔的毅力和大无畏精神与对手周旋,
舌战群儒,哪怕只剩下一个人也要血战到底。这等奇人当真少见!我真奇怪他整天泡在usenet上,
不用工作么?他的老板P.J. Plauger如此宽宏大量?Java阵营主角是一个网名Razzi的兄弟,另外有
Sun公司大名鼎鼎的Peter van der Linden助阵,妙语连珠,寸土必争,加上人多势众,一度占据优势。
C++阵营里大拿虽然很多,但是大多数没有Pete那么多闲工夫,例如Greg Comeau,Comeau公司老板,
每次来个只言片语,实在帮不了Pete多大忙。但是自从C++阵营中冒出一个无名小子,网名Courage(勇气),
发动对Java GC机制的批判,形势为之一变。C++阵营眼下处于全攻之势,Java阵营疲于防守,只能
招架说:“你们没有证据,没有统计资料”,形势很被动。

垃圾收集(GC)不是一直被Java fans用来炫耀,引以为傲的优点么?怎么成了弱点了?我大惑不解,定睛
一看,才觉得此中颇有道理。

首先,Java Swing库存在大量资源泄漏问题,这一点SUN非常清楚,称之为bugs,正在极力修正。但是看来
这里的问题恐怕不仅是库编写者的疏忽,可能根源在于深层的机制,未必能够轻易解决,搞不好要伤筋动骨。
不过这个问题不是那么根本,C++阵营觉得如果抓住对方的弱点攻击,就算是占了上风也没什么说服力。谁
没有缺点呢?于是反其道而行之,猛烈攻击Java阵营觉得最得意的东西,Java的GC机制本身。

首先来想一想,memory leak到底意味着什么。在C++中,new出来的对象没有delete,这就导致了memory
leak。但是C++早就有了克服这一问题的办法——smart pointer。通过使用标准库里设计精致的auto_ptr
以及各种STL容器,还有例如boost库(差不多是个准标准库了)中的四个smart pointers,C++
程序员只要
花上一个星期的时间学习最新的资料,就可以拍着胸脯说:“我写的
程序没有memory leak!”。

相比之下,Java似乎更优秀,因为从一开始你就不用考虑什么特殊的机制,大胆地往前new,自有GC替你
收拾残局。Java的GC实际上是
JVM中的一个独立线程,采用不同的算法策略来收集heap中那些不再有
reference指向的垃圾对象所占用的内存。但是,通常情况下,GC线程的优先级比较低,只有在当前
程序
空闲的时候才会被调度,收集垃圾。当然,如果JVM感到内存紧张了,JVM会主动调用GC来收集垃圾,获取
更多的内存。请注意,Java的GC工作的时机是:1. 当前
程序不忙,有空闲时间。2. 空闲内存不足。
现在我们考虑一种常见的情况,
程序在紧张运行之中,没哟空闲时间给GC来运行,同时机器内存很大,
JVM也没有感到内存不足,结果是什么?对了,GC形同虚设,得不到调用。于是,内存被不断吞噬,而那些
早已经用不着的垃圾对象仍在在宝贵的内存里睡大觉。例如:

class BadGc {

    public void job1() {
        String garbage = "I am a garbage, and just sleeping in your precious memory, " +
                  "how do you think you can deal with me? Daydreaming! HAHA!!!";
        ....
    }

    public void job2() {...}

    ...
    ...

    public void job1000() {...}

    public static void main(String[] args) {
        bgc = new BadGc();
 bgc.job1();
 bgc.job2();
 ...
 bgc.job1000();
    }
}

运行中,虽然garbage对象在离开job1()之后,就再也没有用了。但是因为程序忙,内存还够用,所以GC得
不到调度,garbage始终不会被回收,直到
程序运行到bgc.job1000()时还躺在内存里嘲笑你。没辙吧!

好了,我承认这段程序很傻。但是你不要以为这只是理论上的假设,恰恰相反,大多数实用中的Java程序都有
类似的效应。这就是为什么Java
程序狂耗内存,而且好像给它多少内存吃都不够。你花上大笔的银子把内存
从128升到256,再升到512,结果是,一旦执行复杂任务,内存还是被轻易填满,而且多出来的这些内存只是
用来装垃圾,GC还是不给面子地千呼万唤不出来。等到你的内存终于心力交瘁,GC才姗姗来迟,收拾残局。而
且GC工作的方式也很不好评价,一种方法是一旦有机会回收内存,就把所有的垃圾都回收。你可以想象,这要
花很长时间(几百M的垃圾啊!),如果你这时侯正在压下开炮的按钮,GC却叫了暂定,好了,你等死吧!另一
种方法,得到机会之后,回收一些内存,让JVM感到内存不那么紧张时就收手。结果呢,内存里始终有大批垃
圾,
程序始终在半死不活的荡着。最后,GC可以每隔一段时间就运行一次,每次只回收一部分垃圾,这是现在
大部分JVM的方式,结果是内存也浪费了,还动不动暂停几百毫秒。难啊!

反过来看看C++利用smart pointer达成的效果,一旦某对象不再被引用,系统刻不容缓,立刻回收内存。这
通常发生在关键任务完成后的清理(cleanup)时期,不会影响关键任务的实时性,同时,内存里所有的对象
都是有用的,绝对没有垃圾空占内存。怎么样?传统、朴素的C++是不是更胜一筹?

据统计,目前的Java程序运行期间占用的内存通常为对应C++程序的4-20倍。除了其它的原因,上面所说的是一个
非常主要的因素。我们对memory leak如此愤恨,不就是因为它导致大量的内存垃圾得不到清除吗?如果有了
GC之后,垃圾比以前还来势汹汹,那么GC又有什么好处呢?

当然,C++的smart pointer现在会使用的人不多,所以现在的C++程序普遍存在更严重的memory leak问题。
但是,如果我奶奶跟舒马赫比赛车输掉了,你能够埋怨那辆车子么?
http://www.594k.com/java/html/y2007m1/12051/

posted @ 2007-10-12 10:43 Coolfiry 阅读(626) | 评论 (1)编辑 收藏

从LiveJournal后台发展看大规模网站性能优化方法

一、LiveJournal发展历程

LiveJournal是99年始于校园中的项目,几个人出于爱好做了这样一个应用,以实现以下功能:

  • 博客,论坛
  • 社会性网络,找到朋友
  • 聚合,把朋友的文章聚合在一起

LiveJournal采用了大量的开源软件,甚至它本身也是一个开源软件。

在上线后,LiveJournal实现了非常快速的增长:

  • 2004年4月份:280万注册用户。
  • 2005年4月份:680万注册用户。
  • 2005年8月份:790万注册用户。
  • 达到了每秒钟上千次的页面请求及处理。
  • 使用了大量MySQL服务器。
  • 使用了大量通用组件。

二、LiveJournal架构现状概况

livejournal_backend.png

三、从LiveJournal发展中学习

 

LiveJournal从1台服务器发展到100台服务器,这其中经历了无数的伤痛,但同时也摸索出了解决这些问题的方法,通过对LiveJournal的学习,可以让我们避免LJ曾经犯过的错误,并且从一开始就对系统进行良好的设计,以避免后期的痛苦。

下面我们一步一步看LJ发展的脚步。

1、一台服务器

一 台别人捐助的服务器,LJ最初就跑在上面,就像Google开始时候用的破服务器一样,值得我们尊敬。这个阶段,LJ的人以惊人的速度熟悉的Unix的操 作管理,服务器性能出现过问题,不过还好,可以通过一些小修小改应付过去。在这个阶段里LJ把CGI升级到了FastCGI。

最终问题出现了,网站越来越慢,已经无法通过优过化来解决的地步,需要更多的服务器,这时LJ开始提供付费服务,可能是想通过这些钱来购买新的服务器,以解决当时的困境。
毫无疑问,当时LJ存在巨大的单点问题,所有的东西都在那台服务器的铁皮盒子里装着。

LJ-backend-7.png

2、两台服务器

用付费服务赚来的钱LJ买了两台服务器:一台叫做Kenny的Dell 6U机器用于提供Web服务,一台叫做Cartman的Dell 6U服务器用于提供数据库服务。

LJ-backend-8.png

LJ有了更大的磁盘,更多的计算资源。但同时网络结构还是非常简单,每台机器两块网卡,Cartman通过内网为Kenny提供MySQL数据库服务。

暂时解决了负载的问题,新的问题又出现了:

  • 原来的一个单点变成了两个单点。
  • 没有冷备份或热备份。
  • 网站速度慢的问题又开始出现了,没办法,增长太快了。
  • Web服务器上CPU达到上限,需要更多的Web服务器。

3、四台服务器

又买了两台,Kyle和Stan,这次都是1U的,都用于提供Web服务。目前LJ一共有3台Web服务器和一台数据库服务器。这时需要在3台Web服务器上进行负载均横。

LJ-backend-9.png

LJ把Kenny用于外部的网关,使用mod_backhand进行负载均横。

然后问题又出现了:

  • 单点故障。数据库和用于做网关的Web服务器都是单点,一旦任何一台机器出现问题将导致所有服务不可用。虽然用于做网关的Web服务器可以通过保持心跳同步迅速切换,但还是无法解决数据库的单点,LJ当时也没做这个。
  • 网站又变慢了,这次是因为IO和数据库的问题,问题是怎么往应用里面添加数据库呢?

4、五台服务器

又买了一台数据库服务器。在两台数据库服务器上使用了数据库同步(Mysql支持的Master-Slave模式),写操作全部针对主数据库(通过Binlog,主服务器上的写操作可以迅速同步到从服务器上),读操作在两个数据库上同时进行(也算是负载均横的一种吧)。

LJ-backend-10.png

实现同步时要注意几个事项:

  • 读操作数据库选择算法处理,要选一个当前负载轻一点的数据库。
  • 在从数据库服务器上只能进行读操作
  • 准备好应对同步过程中的延迟,处理不好可能会导致数据库同步的中断。只需要对写操作进行判断即可,读操作不存在同步问题。

5、更多服务器

有钱了,当然要多买些服务器。部署后快了没多久,又开始慢了。这次有更多的Web服务器,更多的数据库服务器,存在 IO与CPU争用。于是采用了BIG-IP作为负载均衡解决方案。

LJ-backend-11.png

6、现在我们在哪里:

LJ-backend-1.png

现在服务器基本上够了,但性能还是有问题,原因出在架构上。

数据库的架构是最大的问题。由于增加的数据库都是以Slave模式添加到应用内,这样唯一的好处就是将读操作分布到了多台机器,但这样带来的后果就是写操作被大量分发,每台机器都要执行,服务器越多,浪费就越大,随着写操作的增加,用于服务读操作的资源越来越少。

LJ-backend-2.png

由一台分布到两台

LJ-backend-3.png

最终效果

现在我们发现,我们并不需要把这些数据在如此多的服务器上都保留一份。服务器上已经做了RAID,数据库也进行了备份,这么多的备份完全是对资源的浪费,属于冗余极端过度。那为什么不把数据分布存储呢?

问题发现了,开始考虑如何解决。现在要做的就是把不同用户的数据分布到不同的服务器上进行存储,以实现数据的分布式存储,让每台机器只为相对固定的用户服务,以实现平行的架构和良好的可扩展性。

为 了实现用户分组,我们需要为每一个用户分配一个组标记,用于标记此用户的数据存放在哪一组数据库服务器中。每组数据库由一个master及几个slave 组成,并且slave的数量在2-3台,以实现系统资源的最合理分配,既保证数据读操作分布,又避免数据过度冗余以及同步操作对系统资源的过度消耗。

LJ-backend-4.png

由一台(一组)中心服务器提供用户分组控制。所有用户的分组信息都存储在这台机器上,所有针对用户的操作需要先查询这台机器得到用户的组号,然后再到相应的数据库组中获取数据。

这样的用户架构与目前LJ的架构已经很相像了。

在具体的实现时需要注意几个问题:

  • 在数据库组内不要使用自增ID,以便于以后在数据库组之间迁移用户,以实现更合理的I/O,磁盘空间及负载分布。
  • 将userid,postid存储在全局服务器上,可以使用自增,数据库组中的相应值必须以全局服务器上的值为准。全局服务器上使用事务型数据库InnoDB。
  • 在数据库组之间迁移用户时要万分小心,当迁移时用户不能有写操作。

7、现在我们在哪里

LJ-backend-5.png

问题:

  • 一个全局主服务器,挂掉的话所有用户注册及写操作就挂掉。
  • 每个数据库组一个主服务器,挂掉的话这组用户的写操作就挂掉。
  • 数据库组从服务器挂掉的话会导致其它服务器负载过大。

对于Master-Slave模式的单点问题,LJ采取了Master-Master模式来解决。所谓Master-Master实际上是人工实现的,并不是由MySQL直接提供的,实际上也就是两台机器同时是Master,也同时是Slave,互相同步。

Master-Master实现时需要注意:

  • 一个Master出错后恢复同步,最好由服务器自动完成。
  • 数字分配,由于同时在两台机器上写,有些ID可能会冲突。

解决方案:

  • 奇偶数分配ID,一台机器上写奇数,一台机器上写偶数
  • 通过全局服务器进行分配(LJ采用的做法)。

 

Master-Master模式还有一种用法,这种方法与前一种相比,仍然保持两台机器的同步,但只有一台机器提供服务(读和写),在每天晚上的时候进行轮换,或者出现问题的时候进行切换。

8、现在我们在哪里

LJ-backend-6.png

现在插播一条广告,MyISAM VS InnoDB。

使用InnoDB:

  • 支持事务
  • 需要做更多的配置,不过值得,可以更安全的存储数据,以及得到更快的速度。

使用MyISAM:

  • 记录日志(LJ用它来记网络访问日志)
  • 存储只读静态数据,足够快。
  • 并发性很差,无法同时读写数据(添加数据可以)
  • MySQL非正常关闭或死机时会导致索引错误,需要使用myisamchk修复,而且当访问量大时出现非常频繁。

9、缓存

去年我写过一篇文章介绍memcached,它就是由LJ的团队开发的一款缓存工具,以key-value的方式将数据存储到分布的内存中。LJ缓存的数据:

  • 12台独立服务器(不是捐赠的)
  • 28个实例
  • 30GB总容量
  • 90-93%的命中率(用过squid的人可能知道,squid内存加磁盘的命中率大概在70-80%)

如何建立缓存策略?

想缓存所有的东西?那是不可能的,我们只需要缓存已经或者可能导致系统瓶颈的地方,最大程度的提交系统运行效率。通过对MySQL的日志的分析我们可以找到缓存的对象。

缓存的缺点?

  • 没有完美的事物,缓存也有缺点:
  • 增大开发量,需要针对缓存处理编写特殊的代码。
  • 管理难度增加,需要更多人参与系统维护。
  • 当然大内存也需要钱。

10、Web访问负载均衡

在数据包级别使用BIG-IP,但BIG-IP并不知道我们内部的处理机制,无法判断由哪台服务器对这些请求进行处理。反向代理并不能很好的起到作用,不是已经够快了,就是达不到我们想要的效果。

所以,LJ又开发了Perlbal。特点:

  • 快,小,可管理的http web 服务器/代理
  • 可以在内部进行转发
  • 使用Perl开发
  • 单线程,异步,基于事件,使用epoll , kqueue
  • 支持Console管理与http远程管理,支持动态配置加载
  • 多种模式:web服务器,反向代理,插件
  • 支持插件:GIF/PNG互换?

11、MogileFS

LJ使用开源的MogileFS作为分布式文件存储系统。MogileFS使用非常简单,它的主要设计思想是:

  • 文件属于类(类是最小的复制单位)
  • 跟踪文件存储位置
  • 在不同主机上存储
  • 使用MySQL集群统一存储分布信息
  • 大容易廉价磁盘

到目前为止就这么多了,更多文档可以在http://www.danga.com/words/找到。Danga.comLiveJournal.com的 同学们拿这个文档参加了两次MySQL Con,两次OS Con,以及众多的其它会议,无私的把他们的经验分享出来,值得我们学习。在web2.0时代快速开发得到大家越来越多的重视,但良好的设计仍是每一个应 用的基础,希望web2.0们在成长为Top500网站的路上,不要因为架构阻碍了网站的发展。

 http://blog.csdn.net/xmr_gxcfe/archive/2007/09/14/1785292.aspx

 

posted @ 2007-09-29 21:26 Coolfiry 阅读(544) | 评论 (0)编辑 收藏

posted @ 2007-09-25 14:30 Coolfiry 阅读(351) | 评论 (0)编辑 收藏

UML类图的各种标识法
关键字:   UML    
·------>虚线箭头表示依赖关系(dependency),一个类需要与另外一个类一起工作,是它一种最弱的关联关系,常见于各种工具类之间的关系
·——实线表示联合关系(association),一个类包含对另外一个类对象的引用,这个通常是使用属性来实现的,为了表明之间的包含关系,有时候会在实线的一端加上箭头(navigability arrow)来表示导航关系,如果关联的双方又都和第三个类有关联关系,那么可以在实线的中间加一个虚线和第三个类关联来表示这种association classes关系
·◇——空心菱形加实线表示聚合关系(aggregation),它是一种更强的关联关系,表示一个类可以拥有或者享有一个类的实例对象,在java代码表现上跟联合是一样的。
·◆——实心菱形加实线表示组合关系(composition),它的关联性比聚合更强,被组合的对象是组合对象的一部分,没法跟其他的对象共享,而且如果组合对象销毁的话,被组合的对象也会同时被销毁,其表现形式跟联合一样
·空心箭头加实线,表示泛化generalization(继承inheritance)关系,这个很简单
·在rose中要建立enumeration,只需要在建立的class中将其stereotype设置为enumeration即可。stereotype只是用来做一个标记,并不包含别的意义

posted @ 2007-06-10 18:03 Coolfiry 阅读(475) | 评论 (0)编辑 收藏

明天18号,要从沈阳回成都了

posted @ 2007-05-17 09:46 Coolfiry 阅读(209) | 评论 (0)编辑 收藏

PO BO VO DTO POJO DAO概念及其作用(附转换图)

   J2EE开发中大量的专业缩略语很是让人迷惑,尤其是跟一些高手讨论问题的时候,三分钟就被人家满口的专业术语喷晕了,PO VO BO DTO POJO DAO,一大堆的就来了(听过老罗对这种现象的批判的朋友会会心一笑)。

    首先声明偶也不是什么高手,以下总结都是自己的体会。不对之处请您多指教。

PO:
persistant object持久对象

最形象的理解就是一个PO就是数据库中的一条记录。
好处是可以把一条记录作为一个对象处理,可以方便的转为其它对象。

 



BO:
business object业务对象

主要作用是把业务逻辑封装为一个对象。这个对象可以包括一个或多个其它的对象。
比如一个简历,有教育经历、工作经历、社会关系等等。
我们可以把教育经历对应一个PO,工作经历对应一个PO,社会关系对应一个PO。
建立一个对应简历的BO对象处理简历,每个BO包含这些PO。
这样处理业务逻辑时,我们就可以针对BO去处理。

 



VO :
value object值对象
ViewObject表现层对象

主要对应界面显示的数据对象。对于一个WEB页面,或者SWT、SWING的一个界面,用一个VO对象对应整个界面的值。

 



DTO :
Data Transfer Object数据传输对象
主要用于远程调用等需要大量传输对象的地方。
比如我们一张表有100个字段,那么对应的PO就有100个属性。
但是我们界面上只要显示10个字段,
客户端用WEB service来获取数据,没有必要把整个PO对象传递到客户端,
这时我们就可以用只有这10个属性的DTO来传递结果到客户端,这样也不会暴露服务端表结构.到达客户端以后,如果用这个对象来对应界面显示,那此时它的身份就转为VO

 



POJO :
plain ordinary java object 简单java对象
个人感觉POJO是最常见最多变的对象,是一个中间对象,也是我们最常打交道的对象。

一个POJO持久化以后就是PO
直接用它传递、传递过程中就是DTO
直接用来对应表示层就是VO

 


DAO:
data access object数据访问对象
这个大家最熟悉,和上面几个O区别最大,基本没有互相转化的可能性和必要.
主要用来封装对数据库的访问。通过它可以把POJO持久化为PO,用PO组装出来VO、DTO


      总结下我认为一个对象究竟是什么O要看具体环境,在不同的层、不同的应用场合,对象的身份也不一样,而且对象身份的转化也是很自然的。就像你对老婆来说就是老公,对父母来说就是子女。设计这些概念的初衷不是为了唬人而是为了更好的理解和处理各种逻辑,让大家能更好的去用面向对象的方式处理问题.

      大家千万不要陷入过度设计,大可不必为了设计而设计一定要在代码中区分各个对象。一句话技术是为应用服务的。

欢迎指正。



画了个图,感觉没有完全表达出自己的意思。。。。。谁帮忙完善下,最好能体现各个O在MVC中的位置
snap20070108.jpg 


转自:http://www.blogjava.net/vip01/archive/2007/01/08/92430.html

posted @ 2007-05-17 09:44 Coolfiry 阅读(328) | 评论 (0)编辑 收藏

I love English from then on.I study English hard form then on.I love it.It is very lovely.

posted @ 2006-11-26 14:13 Coolfiry 阅读(265) | 评论 (0)编辑 收藏

一、引言

  随着Internet的飞速发展,人们越来越依靠网络来 查找他们所需要的信息,但是,由于网上的信息源多不胜数,也就是我们经常所说的"Rich Data, Poor Information"。所以如何有效的去发现我们所需要的信息,就成了一个很关键的问题。为了解决这个问题,搜索引擎就随之诞生。

   现在在网上的搜索引擎也已经有很多,比较著名的有AltaVista, Yahoo, InfoSeek, Metacrawler, SavvySearch等等。国内也建立了很多的搜索引擎,比如:搜狐、新浪、北极星等等,当然由于它们建立的时间不长,在信息搜索的取全率和取准率上都 有待于改进和提高。

  Alta Vista是一个速度很快的搜索引擎,由于它强大的硬件配置,使它能够做及其复杂的查询。它主要是基于关键字进行查询,它漫游的领域有Web和 Usenet。支持布尔查询的"AND","OR"和"NOT",同时还加上最相近定位"NEAR",允许通配符和"向后"搜索(比如:你可以查找链接到 某一页的所有Web站点)。你可以决定是否对搜索的短语加上权值,在文档的什么部位去查找它们。能够进行短语查询而不是简单的单词查询的优点是很明显的, 比如,我们想要查找一个短语"to be or not to be",如果只是把它们分解成单词的话,这些单词都是属于Stop Word,这样这个查询就不会有任何结果,但是把它当作一个整体来查询,就很容易返回一些结果,比如关于哈姆雷特或者是莎士比亚等等的信息。系统对查询结 果所得到的网页的打分是根据在网页中所包含的你的搜索短语的多少,它们在文档的什么位置以及搜索短语在文档内部之间的距离来决定的。同时可以把得到的搜索 结果翻译成其他的语言。

  Exite是称为具有"智能"的搜索引擎,因为它建立了一个基于概念的索引。当然,它所谓的"智能"是基 于对概率统计的灵活应用。它能够同时进行基于概念和关键字的索引。它能够索引Web,Usenet和分类的广告。支持"AND","OR","NOT"等 布尔操作,同时也可以使用符号"+"和"-"。缺点是在返回的查询结果中没有指定网页的尺寸和格式。

  InfoSeek是一个简单 但是功能强大的索引,它的一个优点是有一个面向主题搜索的可扩展的分类。你可以把你的搜索短语和相似的分类目录的主题短语相互参照,而那些主题短语会自动 加到你的查询中去。使你的搜索有更好的主题相关性。同时它也支持对图象的查询。它能够漫游Web,Usenet,Usenet FAQs等等。不支持布尔操作,但是可以使用符号"+"和"-"(相当于"AND"和"NOT")

  Yahoo实际上不能称为是一 个搜索引擎站点,但是它提供了一个分层的主题索引,使你能够从一个通常的主题进入到一个特定的主题,Yahoo对Web进行了有效的组织和分类。比如你想 要建立一个网页,但是你不知道如何操作,为了在Yahoo上找到关于建立网页的信息,你可以先在Yahoo上选择一个主题:计算机和Internet,然 后在这个主题下,你可以发现一些子主题,比如:Web网页制作,CGI编程,JAVA,HTML,网页设计等,选择一个和你要找的相关的子主题,最终你就 可以得到和该子主题相关的所有的网页的链接。也就是说,如果你对要查找的内容属于哪个主题十分清楚的话,通过目录查询的方法要比一般的使用搜索引擎有更好 的准确率。你可以搜索Yahoo的索引,但是事实上,你并没有在搜索整个Web。但是Yahoo提供了选项使你可以同时搜索其他的搜索引擎,比如: Alta Vista。但是要注意的是Yahoo实际上只是对Web的一小部分进行了分类和组织,而且它的实效性也不是很好。

  搜索引擎的基本原理是通过网络机器人定期在web网页上爬行,然后发现新的网页,把它们取回来放到本地的数据库中,用户的查询请求可以通过查询本地的数据库来得到。如yahoo每天会找到大约500万个新的网页。

   搜索引擎的实现机制一般有两种,一种是通过手工方式对网页进行索引,比如yahoo的网页是通过手工分类的方式实现的,它的缺点是Web的覆盖率比较 低,同时不能保证最新的信息。查询匹配是通过用户写入的关键字和网页的描述和标题来进行匹配,而不是通过全文的匹配进行的。第二种是对网页进行自动的索 引,象AltaVista则是完全通过自动索引实现的。这种能实现自动的文档分类,实际上采用了信息提取的技术。但是在分类准确性上可能不如手工分类。

  搜索引擎一般都有一个Robot定期的访问一些站点,来检查这些站点的变化,同时查找新的站点。一般站点有一个robot.txt文 件用来说明服务器不希望Robot访问的区域,Robot 都必须遵守这个规定。如果是自动索引的话,Robot在得到页面以后,需要对该页面根据其内容进行索引,根据它的关键字的情况把它归到某一类中。页面的信 息是通过元数据的形式保存的,典型的元数据包括标题、IP地址、一个该页面的简要的介绍,关键字或者是索引短语、文件的大小和最后的更新的日期。尽管元数 据有一定的标准,但是很多站点都采用自己的模板。文档提取机制和索引策略对Web搜索引擎的有效性有很大的关系。高级的搜索选项一般包括:布尔方法或者是 短语匹配和自然语言处理。一个查询所产生的结果按照提取机制被分成不同的等级提交给用户。最相关的放在最前面。每一个提取出来的文档的元数据被显示给用 户。同时包括该文档所在的URL地址。

  另外有一些关于某一个主题的专门的引擎,它们只对某一个主题的内容进行搜索和处理,这样信息的取全率和精度相对就比较高。

   同时,有一类搜索引擎,它本身不用Robot去定期的采集网页。象SavvySearch 和 MetaCrawler是通过向多个搜索引擎同时发出询问并对结果进行综合返回给用户实现搜索功能。当然实际上象SavvySearch能够对各个搜索引 擎的功能进行分析和比较,根据不同的用户查询提交给不同的搜索引擎进行处理,当然用户自己也可以指定利用哪一个搜索引擎。

  一个优秀的搜索引擎必须处理以下几个问题:1 网页的分类2 自然语言的处理3 搜索策略的调度和协作 4 面向特定用户的搜索。所以很多搜索引擎不同程度的使用了一些人工智能的技术来解决这些方面的问题。

  二、网络Spider的实现描述

   现在有很多文章对Web引擎做了大量的介绍和分析,但是很少有对它们的实现做一个详细的描述,这里我们主要来介绍一个具有基本功能的Web引擎的实现。 本文,我们以类C++语言的形式来描述Web引擎如何采集网页并存放到数据库中的过程。同时描述了如何根据用户输入的关键字查询数据库并得到相关网页的过 程。

  2.1数据库结构

  首先,我们要建立一个数据库表用来存放我们得到的网页。这里一般需要建立如下的表:

  1.字典表的建立,事实上这里是用文档中有意义的单词和它们的出现频率来代表一个文档。

  该表(WordDictionaryTbl)主要要包括三个字段,主要是用来存放和一个网页相关的单词的情况

    url_id    对每一个URL的唯一的ID号
    word      该URL中的经过stem的单词
    intag    该单词在该网页中的出现的次数

  2.存储每一个URL信息的表

  该表(URLTbl)中主要的关键字段有:

  rec_id        每一条记录的唯一的ID号
  status    得到该URL内容的状态,比如HTTP_STATUS_TIMEOUT表示
            下载网页的最大允许超时
  url        URL的字符串名称
  content_type      内容的类型
  last_modified    最新的更改时间
  title            该URL的标题
  docsize          该URL的文件的尺寸
  last_index_time  最近一次索引的时间
  next_index_time  下一次索引的时间
  tag    对于网页,用来表示它的类型,比如:是text,或者是html,
                    或者是图片等等
  hops              得到文件时候的曾经失败的次数
  keywords          对于网页,和该网页相关的关键字
  description      对于网页,指网页的内容的描述
  lang              文档所使用的语言

   3.因为网页中有很多单词是一些介词和语气助词或者是非常常用的常用词,它们本身没有多少意义。比如:英语中的about,in,at,we,this 等等。中文中的如"和","一起","关于"等等。我们统一的把它们称为停止词(stop word)。所以我们要建立一个表,来包括所有这些停止词。该表(StopWordTbl)主要有两个字段。
word char(32)    表示那些停止词
lang char(2)      表示所使用的语言

  4.我们要建立一个关于robot的表,我们在前面说过,所有的网站一般都有一个robot.txt文件用来表示网络上的robot可以访问的权限。该表(RobotTbl)主要有以下字段。
    hostinfo          Web站点主机的信息
    path              不允许robot访问的目录

  5.建立我们需要屏蔽的那些网页(比如一些内容不健康的或者没有必要去搜索的站点)的一张表(ForbiddenWWWTbl),主要的字段就是网页的URL。

   6.另外我们需要建立一个我们所要得到的文件类型的表(FileTypeTbl),比如,对于一个简单的Web搜索引擎,我们可能只需要得到后缀为. html,htm,.shtml和txt的类型文件。其他的我们只是简单的忽略它们。主要的字段就是文件的类型和说明。

  其中关于停止词的表的内容是我们要实现要根据各种语言的统计结果,把那些意义不大的单词放进去。关于文档单词、URL和Robot的表的内容都是在获取Web网页的时候动态增加记录的。

  2.2 具体网页获取算法描述

  具体的网页的获取步骤是这样的:

   我们可以设定我们的搜索程序最大可以开的线程的数目,然后这些线程可以同时在网上进行搜索,它们根据数据库中已有的关于网页的信息,找出那些需要更新的 网页(如何判断哪些网页需要更新是一个值得研究的过程,现在有很多启发式和智能的算法,基本上是基于统计规律进行建模。最简单的当然是设定一个时间范围, 在某个时间范围以前的网页被重新去搜索一遍),然后判断那些网页是否在屏蔽表中,如果是的话,就从关于URL的表中删除该条记录。否则,我们就到相应的 WWW站点去得到URL指定的文件(这里需要注意的是根据不同的URL的特点,需要使用不同的协议,比如对于FTP站点要采用FTP协议,对于HTTP站 点要采用HTTP协议,新闻站点要采用NNTP协议等等)事实上,我们先得到关于该网页的头信息,如果该网页的最新修改时间和我们最近提取的时间是一样的 话,表示该网页内容没有任何更新,则我们就不必去得到它的内容,只需要修改最近一次更新它的时间为当前的时间就可以了。如果该网页最近做了修改,我们就要 得到该网页,并对它的内容进行分析,主要要包括和它相关的链接,把它们加到相应的数据库中,同时判断网页所包含的各种其他的文件,如文本文件、图形文件、 声音文件和其他多媒体文件是否是我们所需要的文件,如果是的话,就把它加到我们响应的数据库中。同时要根据网页的内容提取所有的有意义的单词和它们的出现 的次数,放到相应的数据库中。为了更好的描述这个过程,我们来看跟这个过程相关的主要的几个对象和数据结构。对象主要是针对三个层次来讲的。第一层是针对 WWW服务器,第二层是针对每一个页面,第三层是针对每一个页面的全文的索引。

  2.3 和实现相关的主要类对象和功能描述下面的结构是针对一个站点来说的。

    Class  CServer {
    主要的属性有:
    char *url;            //WWW站点的URL名称
    char *proxy;          //使用的代理的名称
    char *basic_auth;      //进行基本的HTTP认证
    int  proxy_port;      //代理的端口号
    int  period;          //再次索引的周期
    int  net_errors;      //网络连接不通的次数
    int  max_net_errors;  //可以允许的最大的网络错误
    int  read_timeout;    //下载文件允许的最大的延迟
    int  maxhops;          //表示URL可以最大跳转的深度
    int  userobots;        //是否遵守robot.txt中的约定
    int  bodyweight;  // 在< body >....< /body >之间的单词的权重
    int  titleweight; // 在< title >....< /title >之间的单词的权重
    int  urlweight;  // 在文档的URL中的单词的权重
    int descweight;//在    < META
NAME="Description"        Content="..." >之间单词的权重
    int  keywordweight; //在< META NAME="Keywords" Content="..." >
  之间的单词的权重

  主要方法有:
FindServer();//用来查找该服务器是否存在并可以连接
FillDefaultAttribute() //用来针对所有的WWW服务器填写默认的属};

以上的对象中的成员变量是和一个站点相关的参数的设置,我们对所有的站点有一个默认的设置,但是可以对某些站点做一些特殊的设置。这些设置可以在配置文件中设定。
  下面是关于文档的结构的主要的数据成员:

Class CNetDocument
    主要属性有:
    int    url_id; //该URL的ID号
    int    status;  //获取该文档时候的状态
    int    size;  //文档的尺寸
int    tag;  //和该文档相关的标签,表示该文档是
HTML,TEXT或者是其他类型
    int    hops;    //URL跳转的次数
    char    *url; //和该文档相关的URL的名称
    char    *content_type;      //该内容的类型
    char    *last_modified;    //最近一次的更新时间
    char    *title;            //该文档的标题
    char    *last_index_time;  //上次索引的时间
    char    *next_index_time;  //下次索引的时间
    char    *keywords;          //该文档中的关键字
    char    *description;      //该文档的描述

  主要方法有:
  FillDocInfo(…) //根据数据库,得到该文档相关信息
  AddHerf(…)    //加入网页中存在的新的链接的网址
  DeleteURL(…)  //删除一个存在的网址
  CanGetThisURL(…) //根据配置决定是否去得到该网页
  //下面三个方法是根据不同的URL,用不同的协议去获得文档
  NNTPGet(…)     
  FTPGet(….)
  HTTPGet(….)
  ParseHead(…)  //如果是HTTP协议得到的话,分析头信息
  ParseMainBody(…)    //对获得的文档的主体进行分析
  ServerResponseType (….)  //得到服务器端的响应消息
  UpdateURLDB(….)  //更新的数据入库
} ;

  事实上,我们在要提取一个网页的时候,都要建立一个CNetDocument对象,然后再对这个网页进行分析的时候,把相关的内容放到这个CNetDocument的成员变量里面。下面是关于页面全文索引的结构的主要数据成员:
Class CIndexer {
主要属性有:
  char    *url;      //我们要处理的文档相关的URL的名称
  int mwords;      //  我们事先设定的一个网页的最大的单词数目
    int nwords;          // 实际的得到的单词的数目
    int swords;          // 我们已经排序的单词的数目
    WORD *Word;      //所有单词的内容
    char *buf;      //我们为文档所分配的空间
主要方法有:
  InitIndexer(…)    //进行初始设置和分配
  ParseGetFile(…)  //对得到的网页进行全文索引
  AddWord(…)    //把网页的可以索引的单词加到Word数组中去
  InToDB(….)    //关于网页全文索引的信息入库
};

  进行网页提取前,我们要建立一个CIndexer对象,它主要是用来对网页进行全文的索引。一般来说我们只对两种类型的URL进行全文索引,一个是text/html,另外一个是text/plain。其中WORD的数据结构如下:
        typedef struct word_struct {
    int count;  //该单词出现的次数
    int code;  //该单词的正常的形式,
比如单词可能为 encouraging,它的正常的形式应该为
encourage,这其实是一种对单词的stem。
即我们只取单词的主干部分。
    char *word;  //该单词的内容
} WORD;

  以下的结构是和网页中的一些链接的对象相关的一个数据结构
    typedef struct href_struct {
    char *href;    //该链接的名称
    int hops;      //发生的跳转次数
    int stored;    //是否已经存储到数据库中
} HREF;
 

  所有需要更新的和新产生的URL都被放到这个结构中,当它的数量超过一定的范围以后,被一次性的存入数据库。
  关于URL的一个数据结构如下:

typedef struct url {
char *schema; //表示该URL是通过什么协议得到的,比如HTTP,
              FTP,NNTP等。
char *specific;    //主机的名称加上路径
char *hostinfo;    //主机的名称加上相关的协议端口
char *hostname;    //主机的名称
char *path;        //在主机的具体的路径
char *filename;    //文件的名称
char *anchor;      //相关的anchor
int  port;        //协议相关的端口
} URL;

  这是针对URL的一些相关的属性的描述的一个数据结构。事实上在数据库中,我们存储的只是对网页的描述和对一些文本和HTML页面的关键词的索引信息。我们并不存储网页的实际的内容。

  三、用户查询实现描述

  关于对用户提交的查询请求的实现分析:

  用户想要查询某一方面的信息一般都是通过提供和该领域相关的几个关键字来进行的。

  我们来看一下关于用户查询的相关的数据结构和类:

  下面是一个关于单词和它的权值的基本结构:

  typedef struct word_weight_pair
    {
      char word[WORD_LEN];
      int weight;
    }word_weight_pair;
   

  下面的类主要是用来对用户的查询进行处理和分析:
    Class CUserQuery
    {
char m_UserQuery[MAX_QUERYLEN];  //用户的查询表达式
CPtrArray word_weight_col;
//是关于结构word_weight_pair的动态数组
int m_maxReturnSum;  //用户希望返回的最多的网页数
int search_mode;
CObArray m_returnDoc;  //是关于CNetDocument对象的一个动态数组
NormalizeWord(char* OneWord);  //对单词进行归整化,即Stem.
Find(char* odbcName);  //进行数据库查找和匹配
};

  系统实现的基本的步骤如下:

  1.对用户输入的查询表达式进行分析。事实上,我们在前面的Spider搜索过程中对文档的表示是通过关键字形式描述的,每一个文档可以表示为这样的一个集合

    其中 ::=< 单词或短语名称 >< 单词或短语的权值 >

  实际上就是采用矢量空间的表示方法来表示的文档。

   我们对用户输入的查询表达式也采用矢量空间的表示方法。我们认为用户输入的关键字的顺序代表了它的重要性的程度,所以对于位置靠前的单词有相对比较高的 优先级,同时我们对所有的内容以短语或者是单词为最小原子,进行Stem操作,即象前面所提到的:比如单词Encouraging就转化成 Encourage的格式。然后去掉那些Stop Word,比如is ,as等等的单词,这些单词存放在StopWordTbl表中。 然后把所有归整化后的内容放入动态数组word_weight_col中去。

  2.对于动态数组word_weight_col中 的每一个元素,即结构word_weight_pair(包括单词和该单词的权重),我们从表WordDictionaryTbl中可以找到和这些单词相 关的记录,这些记录应该是包括了所有的在word_weight_col中的单词。

  进行网页是否和查询相匹配的计算。匹配计算的 过程如下:首先我们对所有的记录按URL地址进行排序。因为可能好几条记录对应的是一个URL,然后对每一个网页进行打分,每一条记录的单词权值为 INITSCORE*WEIGHT+(TOTALTIMES-1)*WEIGHT* INCREMENT。其中INITSCORE为每一个单词的基准分数,TOTALTIMES为该单词在网页中的出现的次数,WEIGHT是该单词在不同的 内容段出现有不同的权值(比如在KEYWORD段,或者是标题段,或者是内容段等等)。INCREMENT是该单词每多出现一次所增加的分数。

  3.根据用户指定的m_maxReturnSum,显示匹配程度最高的前m_maxReturnSum页。

  四、结束语

   我们利用上面所讨论的机制,在WINDOWS NT操作系统下,用VC++和SQL SERVER实现了一个Web搜索引擎的网页搜集过程。在建立了一个基本的搜索引擎的框架以后,我们可以基于这个框架,实现一些我们自己设计的算法,比如 如何更好的进行Spider的调度,如何更好的进行文档的归类,如何更好的理解用户的查询,用来使Web搜索引擎具有更好的智能性和个性化的特点。

posted @ 2006-11-11 21:37 Coolfiry 阅读(462) | 评论 (0)编辑 收藏

     摘要: 1.   目标 使用 apache 和 tomcat 配置一个可以应用的 web 网站,要达到以下要求: 1、  Apache 做为 HttpServer ,后面连接多个 tomcat...  阅读全文

posted @ 2006-11-06 17:20 Coolfiry 阅读(717) | 评论 (0)编辑 收藏

JDBC学习笔记
2004-9-13     星期一     小雨

l. 连接到数据库的方法
答:1) ODBC(Open Database Connectivity)
       一个以C语言为基础访问SQL为基础数据库引擎的接口,它提供了一致的接口用于和数据库沟通以及访问数据。
    2) JDBC
       Java版本的ODBC

2. JDBC应用编程接口
答:JDBC应用编程接口是:
    1) 标准的数据访问接口,可以连到不同的数据库;
    2) JAVA编程语言的一组类和接口。
    JDBC应用编程接口能够:
    1) 连接到数据库;
    2) 发SQL查询字符串到数据库;
    3) 处理结果。
    JDBC应用编程接口有二个主要的部分:
    1) JAVA应用程序开发接口面向JAVA应用程序开发者;
    2) JDBC驱动程序开发接口
    
3. JDBC Driver
答:1) 一大堆实现了JDBC类和接口的类;
    2) 提供了一个实现java.sql.Driver接口的类。

4. JDBC Driver的四种类型
答:1) JDBC-ODBC桥
    由ODBC驱动提供JDBC访问
    2) 本地API
    部分Java driver把JDBC调用转化成本地的客户端API
    3) JDBC-net
    纯的Java driver,将JDBC调用转入DBMS,与网络协议无关。然后通过服务器将调用转为DBMS协议。
    4) 本地协议
    纯的java driver,将JDBC调用直接转为DBMS使用的网络协议

5. JDBC开发者接口
答:1) java.sql--java 2平台下JDBC的主要功能,标准版(J2SE)
    2) javax.sql--java 2平台下JDBC增强功能,企业版(J2EE)

6. 使用URL确认数据库
答:我们使用URL来确定一个数据库(正确的Driver,正确的主机,正确的协议,正确的协议,正确的用户名和密码);
    语法:protocol:subprotocol:subname
    范例:jdbc:db2:MyTest
          jdbc:db2://localhost:6789/MyTest

7. javax.sql包JDBC2.0的增强功能
答:1) 数据源接口;
    2) 连接池;
    3) 分布式交易;
    4) 行集;

8. 创建一个基本的JDBC应用
答:1) 步骤一:注册一个driver;
    2) 步骤二:建立一个到数据库的连接;
    3) 步骤三:创建一个statement;
    4) 步骤四:执行SQL语句;
    5) 步骤五:处理结果;
    6) 步骤六:关闭JDBC对象

9. 注册一个Driver(步骤一)
答:1) driver被用于连接到数据库;
    2) JDBC应用编程接口使用第一个能成功连接到给定URL的driver;
    3) 在同一时间可以装载多个driver

10.注册一个driver的方法:
答:1) 使用类loader(装载;实例化;注册入DriverManager)
       a. Class.forName("Com.ibm.db2.jdbc.app.DB2Driver");
       b. Class.forName("Com.ibm.db2.jdbc.net.DB2Driver");
       c. Class.forName("Com.microsoft.jdbc.sqlServer.SQLServerDriver);
       d. Class.forName("oracl.jdbc.driver.OracleDriver");
       e. Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
    2) 实例化一个Driver
       a. Driver drv = new COM.cloudscape.core.RmiJdbcDriver();

2004-9-14     星期二     阴

1. 建立一个到数据库的连接(步骤二)
答:DriverManager调用getConnection(urlString)方法,实际上调用的是driver的connect(urlString)方法;
    1) 当一个driver肯定地对应到一个数据库URL,DriverManager建立一个连接;
    2) 当没有driver匹配,返回null然后下一个driver被检验;
    3) 假如没有建立连接,抛出一个SQLExcepiton异常

2. 经常使用的一些JDBC URL
答:1) JDBC-ODBC: jdbc:odbc:<DB>
    2) Oracle: jdbc:oracle:oci:@<sid> or jdbc:oracle:thin:@<SID>
    3) Weblogic MS-SQL: jdbc:weblogic:mssqlserver4:<DB>@<HOST>:<PORT>
    4) DB2: jdbc:db2:MyTest or jdbc.db2://localhost:6789/MyTest(需要用户名和密码)

3. Driver连接方法
答:1) 创建一个到指定Driver实例的直接调用;
    2) 避免一般访问的问题
       Driver drv = new COM.ibm.db2.jdbc.app.DB2Driver();
       Connection con = null;
       try {con = drv.connect("jdbc:db2:MyTest",new Properties())}
       catch(SQLException e){}

4. 创建一个Statement(步骤三)
答:1) Statement的三个接口:
       a. Statement;
       b. PreparedStatement(继承自Statement);
       c. CallableStatement(继承自PreparedStatement);
    2) 使用方法Connection.createStatement()得到一个Statement对象

5. PreparedStatement对象
答:1) 调用ProparedStatement比statement更为高效;
    2) 继承自Statement;
    3) 语法:PreparedStatement pstm = connection.prepareStatement(sqlString);

6. CallableStatement对象
答:1) 通过CallableStatement调用数据库中的存储过程;
    2) 继承自PreparedStatement;
    3) CallableStatement cstm = connection.prepareCall("{call return_student[?,?]}");
       cstm.setString(1,"8623034");
       cstm.registerOutparameter(2, Types.REAL);
       cstm.execute();
       float gpa = cstm.getFloat(2);

7. Statement接口的比较
答:             | Statement           | PreparedStatement         |  CallableStatement
    ------------------------------------------------------------------------------
    写代码位置   |   客户端            | 客户端                    |  服务器端
    ------------------------------------------------------------------------------
    写代码位置   |   客户端            | 服务器端                  |  服务器端
    ------------------------------------------------------------------------------
    编写代码技术 |Java,SQL操作        |Java,SQL操作              |  数据库的程序语言,如PL/SQL
    ------------------------------------------------------------------------------
    可配置性     |   高                |第一次高,以后低           |  低
    ------------------------------------------------------------------------------
    可移植性     |   高                |假设支持PreparedStatement的话高    
    ------------------------------------------------------------------------------
    传输效率     |   低                |第一次低,以后高           |  高

8. 执行SQL Statement(步骤四)
答:通过接口方法将SQL语句传输至?认的数据库连接,返回结果可能是一个数据表,可以通过java.sql.ResultSet访问。
    1) Statement的接口方法:
    a. executeQuery(sqlString): 执行给定的SQL声明,返回一个结果集(ResultSet)对象;
    b. executeUpdate(sqlString): 执行给定的SQL声明,可以是INSERT、UPDATE或DELETE声明,也可以是SQL DDL声明;
    c. execute(sqlString): 执行给定的SQL声明。

9. 处理结果(步骤五)
答:1) 使用结果集(ResultSet)对象的访问方法获取数据;
       a. next():下一个记录
       b. first():第一个记录
       c. last():最后一个记录
       d. previous():上一个记录
    2) 通过字段名或索引取得数据
    3) 结果集保持了一个指向了当前行的指针,初始化位置为第一个记录前。

10. 关闭JDBC对象(步骤六)
答:1) 首先关闭记录集;
    2) 其次关闭声明;
    3) 最后关闭连接对象。

11. 数据表和类对应的三种关系:
答:1) 一个表对应一个类;
    2) 一个表对应相关类;
    3) 一个表对应整个类关系层

12. 类间关系的几种表设计:
答:1) 多对一,
    2) 一对一: 
    3) 一对多:
    4) 多对多:

13. SQL数据类型及其相应的Java数据类型
答:SQL数据类型                     Java数据类型              说明
    ------------------------------------------------------------------
    INTEGER或者INT                  int                     通常是个32位整数
    SMALLINT                        short                   通常是个16位整数
    NUMBER(m,n) DECIMAL(m,n)        Java.sql.Numeric        合计位数是m的定点十进制数,小数后面有n位数
    DEC(m,n)                        Java.sql.Numeric        合计位数是m的定点十进制数,小数后面有n位数
    FLOAT(n)                        double                  运算精度为n位二进制数的浮点数
    REAL                            float                   通常是32位浮点数
    DOUBLE                          double                  通常是64位浮点数
    CHARACTER(n)或CHAR(n)           String                  长度为n的固定长度字符串
    VARCHAR(n)                      String                  最大长度为n的可变长度字符串
    BOOLEAN                         boolean                 布尔值
    DATE                            Java.sql.Date           根据具体设备而实现的日历日期
    TIME                            Java.sql.Time           根据具体设备而实现的时戳
    TIMESTAMP                       Java.sql.Timestamp      根据具体设备而实现的当日日期和时间
    BLOB                            Java.sql.Blob           二进制大型对象
    CLOB                            Java.sql.Clob           字符大型对象
    ARRAY                           Java.sql.Array
    

2004-9-15     星期三      阴

1. 元数据
答:关于数据的信息,例如类型或者容量。通过JDBC API可以访问:
    1) 数据库元数据;
       a. 使用connection.getMetadata方法返回DataMetaData引用
       b. 能够使用isReadOnly此类方法获取信息
    2) 结果集元数据;
       a. 使用ResultSet.getMetadata方法返回ResultSetMetaData引用
       b. 能够使用getColumnCount此类方法获取信息

2. 事务处理
答:1) 一系列的动作作为一个不可分的操作;
    2) JDBC API中使用事务处理步骤:
       a. 用false作为参数调用setAutoCommit方法;
       b. 执行一或多个关于数据库的操作;
       c. 调用commit方法完成改变;
       d. 恢复上次提交后的改变,调用rollback方法.

       try
       {
          con.setAutoCommit(false);
          Statement stm = con.createStatement();
          stm.executeUpdate("insert into student(name, age, gpa) values('gzhu', 30, 4.8)");
          stm.commit();
       }
       catch(SQLException e)
       {
          try
          {
             con.rollback();
          }
          catch(Exception e)
          {
          }
       }

3. 并发控制
答:1) 设置隔离级别方法:setTransactionIsolation
    2) 隔离级别静态变量
       a. TRANSACTION_NONE:只读的数据字典;
       b. TRANSACTION_READ_UNCOMMITTED:只读未提交数据;
       c. TRANSACTION_READ_COMMITTED:只读未提交数据;
       d. TRANSACTION_REPEATABLE_READ:重复读取数据;
       e. TRANSACTION_SERIALIZABLE:无论做什么操作都不许别人动。
    3) 示例:con.setTransactionIsolation(Connection.TRANSACTION_READ_UNCOMMITTED);

4. JDBC 2.0 应用程序编程接口增强功能
答:1) ResultSet增强:
       a. 可以回卷;
       b. 可以修改;
       设置示例:Statement stm = con.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE);
    2) Statement增强了批量修改能力(batch updates);
    3) 更高级的数据类型(例:Struct)。

5. JDBC 2.0标准扩展
答:1) JNDI(Java Naming and Directory Interface): 解决离散状态下Object的查找;
    2) 连接池:在内存中保存了一个数据库连接,不需要注册驱动器,提高性能的重要方法。

posted @ 2006-11-03 10:14 Coolfiry 阅读(229) | 评论 (0)编辑 收藏

问题引入:
在实习过程中发现了一个以前一直默认的错误,同样char *c = "abc"和char c[]="abc",前者改变其内

容程序是会崩溃的,而后者完全正确。
程序演示:
测试环境Devc++
代码
#include <iostream>
using namespace std;

main()
{
   char *c1 = "abc";
   char c2[] = "abc";
   char *c3 = ( char* )malloc(3);
   c3 = "abc";
   printf("%d %d %s\n",&c1,c1,c1);
   printf("%d %d %s\n",&c2,c2,c2);
   printf("%d %d %s\n",&c3,c3,c3);
   getchar();
}  
运行结果
2293628 4199056 abc
2293624 2293624 abc
2293620 4199056 abc

参考资料:
首先要搞清楚编译程序占用的内存的分区形式:
一、预备知识—程序的内存分配
一个由c/C++编译的程序占用的内存分为以下几个部分
1、栈区(stack)—由编译器自动分配释放,存放函数的参数值,局部变量的值等。其操作方式类似于

数据结构中的栈。
2、堆区(heap)—一般由程序员分配释放,若程序员不释放,程序结束时可能由OS回收。注意它与数据

结构中的堆是两回事,分配方式倒是类似于链表,呵呵。
3、全局区(静态区)(static)—全局变量和静态变量的存储是放在一块的,初始化的全局变量和静态

变量在一块区域,未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。程序结束后由系统

释放。
4、文字常量区—常量字符串就是放在这里的。程序结束后由系统释放。
5、程序代码区
这是一个前辈写的,非常详细
//main.cpp
  int a=0;    //全局初始化区
  char *p1;   //全局未初始化区
  main()
  {
   int b;栈
   char s[]="abc";   //栈
   char *p2;         //栈
   char *p3="123456";   //123456\0在常量区,p3在栈上。
   static int c=0;   //全局(静态)初始化区
   p1 = (char*)malloc(10);
   p2 = (char*)malloc(20);   //分配得来得10和20字节的区域就在堆区。
   strcpy(p1,"123456");   //123456\0放在常量区,编译器可能会将它与p3所向"123456"优化成一个

地方。
}
二、堆和栈的理论知识
2.1申请方式
stack:
由系统自动分配。例如,声明在函数中一个局部变量int b;系统自动在栈中为b开辟空间
heap:
需要程序员自己申请,并指明大小,在c中malloc函数
如p1=(char*)malloc(10);
在C++中用new运算符
如p2=(char*)malloc(10);
但是注意p1、p2本身是在栈中的。
2.2
申请后系统的响应
栈:只要栈的剩余空间大于所申请空间,系统将为程序提供内存,否则将报异常提示栈溢出。
堆:首先应该知道操作系统有一个记录空闲内存地址的链表,当系统收到程序的申请时,
会遍历该链表,寻找第一个空间大于所申请空间的堆结点,然后将该结点从空闲结点链表中删除,并将

该结点的空间分配给程序,另外,对于大多数系统,会在这块内存空间中的首地址处记录本次分配的大

小,这样,代码中的delete语句才能正确的释放本内存空间。另外,由于找到的堆结点的大小不一定正

好等于申请的大小,系统会自动的将多余的那部分重新放入空闲链表中。
2.3申请大小的限制
栈:在Windows下,栈是向低地址扩展的数据结构,是一块连续的内存的区域。这句话的意思是栈顶的地

址和栈的最大容量是系统预先规定好的,在WINDOWS下,栈的大小是2M(也有的说是1M,总之是一个编译

时就确定的常数),如果申请的空间超过栈的剩余空间时,将提示overflow。因此,能从栈获得的空间

较小。
堆:堆是向高地址扩展的数据结构,是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地

址的,自然是不连续的,而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的

虚拟内存。由此可见,堆获得的空间比较灵活,也比较大。
2.4申请效率的比较:
栈:由系统自动分配,速度较快。但程序员是无法控制的。
堆:是由new分配的内存,一般速度比较慢,而且容易产生内存碎片,不过用起来最方便.
另外,在WINDOWS下,最好的方式是用Virtual Alloc分配内存,他不是在堆,也不是在栈,而是直接在进

程的地址空间中保留一块内存,虽然用起来最不方便。但是速度快,也最灵活。
2.5堆和栈中的存储内容
栈:在函数调用时,第一个进栈的是主函数中后的下一条指令(函数调用语句的下一条可执行语句)的

地址,然后是函数的各个参数,在大多数的C编译器中,参数是由右往左入栈的,然后是函数中的局部变

量。注意静态变量是不入栈的。
当本次函数调用结束后,局部变量先出栈,然后是参数,最后栈顶指针指向最开始存的地址,也就是主

函数中的下一条指令,程序由该点继续运行。
堆:一般是在堆的头部用一个字节存放堆的大小。堆中的具体内容由程序员安排。
2.6存取效率的比较
char s1[]="aaaaaaaaaaaaaaa";
char *s2="bbbbbbbbbbbbbbbbb";
aaaaaaaaaaa是在运行时刻赋值的;
而bbbbbbbbbbb是在编译时就确定的;
但是,在以后的存取中,在栈上的数组比指针所指向的字符串(例如堆)快。
比如:
#include
voidmain()
{
char a=1;
char c[]="1234567890";
char *p="1234567890";
a = c[1];
a = p[1];
return;
}
对应的汇编代码
10:a=c[1];
004010678A4DF1movcl,byteptr[ebp-0Fh]
0040106A884DFCmovbyteptr[ebp-4],cl
11:a=p[1];
0040106D8B55ECmovedx,dwordptr[ebp-14h]
004010708A4201moval,byteptr[edx+1]
004010738845FCmovbyteptr[ebp-4],al
第一种在读取时直接就把字符串中的元素读到寄存器cl中,而第二种则要先把指针值读到edx中,在根据

edx读取字符,显然慢了。
2.7小结:
堆和栈的区别可以用如下的比喻来看出:
使用栈就象我们去饭馆里吃饭,只管点菜(发出申请)、付钱、和吃(使用),吃饱了就走,不必理会

切菜、洗菜等准备工作和洗碗、刷锅等扫尾工作,他的好处是快捷,但是自由度小。
使用堆就象是自己动手做喜欢吃的菜肴,比较麻烦,但是比较符合自己的口味,而且自由度大。

自我总结:
char *c1 = "abc";实际上先是在文字常量区分配了一块内存放"abc",然后在栈上分配一地址给c1并指向

这块地址,然后改变常量"abc"自然会崩溃

然而char c2[] = "abc",实际上abc分配内存的地方和上者并不一样,可以从
4199056
2293624 看出,完全是两块地方,推断4199056处于常量区,而2293624处于栈区

2293628
2293624
2293620 这段输出看出三个指针分配的区域为栈区,而且是从高地址到低地址

2293620 4199056 abc 看出编译器将c3优化指向常量区的"abc"


继续思考:
代码:
#include <iostream>
using namespace std;

main()
{
   char *c1 = "abc";
   char c2[] = "abc";
   char *c3 = ( char* )malloc(3);
   //  *c3 = "abc" //error
   strcpy(c3,"abc");
   c3[0] = 'g';
   printf("%d %d %s\n",&c1,c1,c1);
   printf("%d %d %s\n",&c2,c2,c2);
   printf("%d %d %s\n",&c3,c3,c3);
   getchar();
}  
输出:
2293628 4199056 abc
2293624 2293624 abc
2293620 4012976 gbc
写成注释那样,后面改动就会崩溃
可见strcpy(c3,"abc");abc是另一块地方分配的,而且可以改变,和上面的参考文档说法有些不一定,

而且我不能断定4012976是哪个区的,可能要通过算区的长度,希望高人继续深入解释,谢谢
 

posted @ 2006-10-16 19:06 Coolfiry 阅读(1135) | 评论 (2)编辑 收藏

 和 'f'标志指定的相同顺序。

示例1:将两个class文件存档到一个名为 'classes.jar' 的存档文件中:
 & nbsp;     jar cvf& nbsp;classes.jar Foo.class Bar.class
示例2:用一个存在的清单(manifest)文件 'mymanifest' 将 foo/& nbsp;目录下的所有
            文件存档到一个名为  'classes.jar' 的存档文件中:
        jar cvfm  classes.jar mymanifest -C foo/ .

来个小例子试试看:
我们只有一个HelloWorld,如下:
public& nbsp; class  HelloWorld{
 public& nbsp;static void main(String[] args){
 System.out.println(“Hi, Hello World!”);
}
}
我将这个java文件存到C盘跟目录下,ok,接下来,
在先前打开的命令提示符下(跳转到C盘提示符下),我们输入javac HelloWorld.java,然后继续输入:jar & nbsp;cvf  hello.jar  HelloWorld.class,回车后去你的C盘看看,多了什么,没错 hello.jar 。
基本的步骤我们现在都知道了,你可以自己去尝试一下随着jar后面的参数的不同,结果有什么变化。
紧接着我们看看如何运行我们的jar包。
在进入正题之前,你要先打开我们刚刚做好的jar包看看,多了什么呢,META-INF目录?再看看里面是什么,还有一个MANIFEST.MF文件是不是?用文本编辑器(我这里是UltraEdit)打开它看看:
Manifest-Version:  1.0
Created-By: 1.4.2 (Sun Microsystems& nbsp;Inc.)
就是这样。这里我们对它进行修改,加一句:Main-Class:  HelloWorld (在第三行)。这个就是我们之前写的那个类,也就是我们的入口类。也即,
Manifest -Version: 1.0
Created-By: 1.4.2 (Sun& nbsp;Microsystems Inc.)
Main-Class: HelloWorld< BR>接下来,我们在命令提示符里执行:
jar umf  MANIFEST.MF app.jar
这样我们使用了我们自己的MANIFEST.MF文件对原来默认的进行了更新。你不妨可以再进去看看是不是添上了Main-Class: HelloWorld这一句。
Ok,这个最后的一步了,来验证我们做的一切,在命令提示符中输入:
java -jar hello.jar (执行)
出现了什么,――Hi, Hello World!
我们再来看看 jar文件在tomcat中发布,注意:在tomcat中我们就不能再用jar这种格式,而改war格式,它是专门用于web应用的,其实整个过程下来基本上和jar是类似的:
先准备我们要打包的资源。
找到存放tomcat的webapps目录,进到其中,新建一个文件夹,这里命名为hello,再进去新建WEB-INF文件夹,再进去新建classes文件夹,此时我们也将我们唯一的servlet, HelloWorld.java放到这里,在与classes目录同级下建立一文件web.xml。Ok,目前我们初步建立了一个简单的web应用。
这是HelloWorld.java:
import java.io.*;< BR>import javax.servlet.*;
import javax.servlet.http.*;
public class HelloWorld extends& nbsp;HttpServlet {
 public void  doGet(HttpServletRequest req, HttpServletResponse  res)
              & nbsp;               & nbsp; throws ServletException, IOException& nbsp;{
  res.setContentType("text/html");
  PrintWriter out = res.getWriter ();
  out.println("<HTML>");< BR>  out.println("<HEAD><TITLE& gt;Hello, World!</TITLE></HEAD>");< BR>  out.println("<BODY>");
& nbsp; out.println("Hello, World!");
   out.println("</BODY></HTML>");
 }
}//end here!
对它编译。下面是web.xml:< BR><?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE web-app PUBLIC
  '-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN'
  'http://java.sun.com/j2ee/dtds/web-app_2_3.dtd&< /FONT>#39;>
<web-app>
  <servlet>
     <servlet-name>hello</servlet-name& gt;
    <servlet-class& gt;HelloWorld</servlet-class>
   </servlet>
  <servlet-mapping& gt;
 <servlet-name>hello</servlet- name>
 <url-pattern>/HelloWorld& lt;/url-pattern>
  </servlet-mapping& gt;
</web-app>
开始压缩,形成war档:
在命令提示符下进到先前创制的hello目录下,执行 jar  cvf   hello.war  * ,我们便得到hello.war。将它拷贝至 webapps目录下,ok,来看最后一步,打开tomcat的目录conf中的server.xml,加入:
   <Context path="/hello" docBase="hello.war"& nbsp;debug="0"
    reloadable ="true"/>
大功告成!运行它,启动tomcat,后在浏览器中输入http://localhost:8080/hello/HelloWorld,有了吗?
最后,如果你想用ant来完成以上的打包活动,下面就告诉你:
对于jar来说。在build.xml 中,
 <target name="jar">< BR>  <jar destfile="${app_home}/hello.jar"& gt;
   <fileset dir=" ${dest}" includes="**"/>
  & nbsp;   <!--fileset dir="${dest} " includes="**/action.properties"/-->
     </jar>
 & lt;/target>

对于war,
<war& nbsp;warfile="hello.war" webxml="./WEB-INF/web.xml">
    <fileset dir="html"/& gt;
    <lib  dir="lib/">
    & nbsp;   <exclude name="oracle*.jar"/& gt;
    </lib>
    <classes  dir="build/servlets">
   & nbsp;     <include& nbsp;name="**/*.class"/>
  </classes& gt;
</war> 
好了,就这么多,希望对你有点帮助。:)
我上传了上面打过的两个包,hello.jar和hello.war。『 点击下载』
『 点击下载』
第一rar文件对应的是hello.jar,下载后将其名改为 hello.jar
第二rar文件对应hello.war,下载后改为hello.war。
这是由于上传不了 jar格式和war格式的文件,你只好照我上面说的去做了 :)

补充:
############
jar基本操作:
############
1.& nbsp;创建jar文件
  jar cf jar- file input-file(s)
c---want to Create& nbsp;a JAR file.
f---want the  output to go to a file  rather than to stdout.
eg: 1) jar cf myjar.jar query_maintain_insert.htm< BR>    2)jar cvf  myjar.jar query_maintain_insert.htm
       v---Produces verbose(详细的) output.
    3)jar& nbsp;cvf myjar.jar query_maintain_insert.htm mydirectory< BR>    4)jar cv0f  myjar.jar query_maintain_insert.htm mydirectory
      0---don't& nbsp;want the JAR file to be& nbsp;compressed.
    5)jar& nbsp;cmf MANIFEST.MF myjar.jar yahh.txt
      m---Used& nbsp;to include manifest information  from an existing manifest file.
    6)jar cMf MANIFEST.MF& nbsp;myjar.jar yahh.txt
   & nbsp;  M---the default manifest  file should not be produced.
    7)jar cvf myjar.jar& nbsp;*
       *---create all contents in current& nbsp;directory.
2. 察看jar文件
 & nbsp;jar tf jar-file
t---want to& nbsp;view the Table of contents  of the JAR file.
eg: 1)jar& nbsp;vft yahh.jar
       v---Produces verbose(详细的)  output.
3. 提取jar文件
   jar xf jar-file [archived-file(s)]
x- --want to extract files from  the JAR archive.
eg: 1)jar xf& nbsp;yahh.jar yahh.txt(仅提取文件yahh.txt)
 & nbsp;  2)jar xf yahh.jar alex/yahhalex.txt (仅提取目录alex下的文件yahhalex.txt)
   & nbsp;3)jar xf yahh.jar(提取该jar包中的所有文件或目录)
4. 修改Manifest文件
  jar  cmf manifest-addition jar-file input-file(s)< BR>m---Used to include manifest information& nbsp;from an existing manifest file.< BR>5. 更新jar文件
  jar  uf jar-file input-file(s)
u---want to update a

posted @ 2006-10-12 18:40 Coolfiry 阅读(341) | 评论 (0)编辑 收藏

发布Java应用程序时你会感到困难?好在Java提供了一系列打包和发布工具,可以显著的简化发布过程
  
  该文章提供了打包Java code的几种方法,我们将会探讨Java manifest 文件,给出用于管理JAR文件所依赖文件、估计跨平台发布所需的CLasspath的合适方法.我也会解释如何使用manifest包版本特性来确认包的兼容性...
  
  什么是JAR文件?
  
  在开发过程中,我们可以直接使用Java class文件来运行程序,但这并不是一个好方式,好在Java 提供了 JAR(Java Archive)文件来提供发布和运行。
  
  jar 文件实际上是class 文件的ZIP压缩存档,这种格式被广泛使用,因此易与使用,有很多中工具可以操作这种格式的文件。也正是因为这个原因,jar文件本身并不能表达所包含应用程序的标签信息。
  
  Manifest 因此得以出现
  
   为了要提供存档的标签信息,jar 文件指定了一个特定目录来存放标签信息:META-INF 目录,其中我们来关注该目录中的MANIFEST.MF文件,他就是JAR的manifest文件,他包含了JAR文件的内容描述,并在运行时向JVM提 供应用程序的信息,大多数JAR文件含有一个默认生成的manifest 文件,执行JAR命令或使用zip工具,都可以产生它
  
  如果是由jar命令产生的 manifest 文件,形如:
  Manifest-Version: 1.0
  Created-By:1.4.0-beta
  (Sun Microsystems Inc.)
  
   这些信息没甚么用,仅仅告诉我们使用的是1.0的manifest文件,第一行定义manifest的格式,第二行说明使用 SUN 的JDK1.4的jar工具生成该文件,如果manifest文件是由其他 (如ant) 创建的,那将会出现 “Created-By: Ant 1.2” 之类的内容,如果你是自己创建manifest文件,你可以加入自己的一些相关信息.
  
  基础格式
  
  manifest 文件的格式 是很简单的,每一行都是 名-值 对应的:属性名开头,接着是 ":" ,然后是属性值,每行最多72个字符,如果需要增加,你可以在下一行续行,续行以空格开头,以空格开头的行都会被视为前一行的续行。
  
  所有在开头的属性都是全局的,你也可以定义特定class 或package的属性,稍后将介绍这种
  
  把manifest文件插入JAR文件
  
  使用 m 选项,把指定文件名的manifest文件 传入,例如
  jar cvfm myapplication.jar myapplication.mf -C classdir
  
  如果你使用ant来创建时,在ant 的build.xml 加入如下条目
  <target name="jar">
  <jar jarfile ="myapplication.jar"
  manifest="myapplication.mf">
  <fileset dir="classdir"
  includes="**/*.class"/>
  </jar>
  </target>
  
  运行Java程序
  
  现在我们来体验一下manifest文件的作用,如果现在我们有一个Java 应用程序打包在myapplication.jar中, main class为 com.example.myapp.MyAppMain ,那么我们可以用以下的命令来运行
  java -classpath myapplication.jar com.example.myapp.MyAppMain
  
  这显然太麻烦了,现在我们来创建自己的manifest文件,如下:
  Manifest-Version: 1.0
  Created-By: JDJ example
  Main-Class: com.example.myapp.MyAppMain
  
  这样我们就可以使用如下的命令来运行程序了:(明显简单多了,也不会造成无谓的拼写错误)
  java -jar myapplication.jar
  
  管理JAR的依赖资源
  
   很少Java应用会仅仅只有一个jar文件,一般还需要 其他类库。比如我的应用程序用到了Sun 的 Javamail classes ,在classpath中我需要包含activation.jar 和 mail.jar,这样在运行程序时,相比上面的例子,我们要增加一些:
  java -classpath mail.jar:activation.jar -jar myapplication.jar
  
  在不同的操作系统中,jar包间的分隔符也不一样,在UNIX用“:”,在window中使用 “;”,这样也不方便
  
  同样,我们改写我们的manifest文件,如下
  Manifest-Version: 1.0
  Created-By: JDJ example
  Main-Class: com.example.myapp.MyAppMain
  Class-Path: mail.jar activation.jar
  
  (加入了Class-Path: mail.jar activation.jar,用空格分隔两个jar包)
  
  这样我们仍然可以使用和上例中相同的命令来执行该程序:
  java -jar myapplication.jar
  
   Class-Path属性中包含了用空格分隔的jar文件,在这些jar文件名中要对特定的字符使用逃逸符,比如空格,要表示成"%20",在路径的表 示中,都采用“/”来分隔目录,无论是在什么操作系统中,(即使在window中),而且这里用的是相对路径(相对于本身的JAR文件):
  Manifest-Version: 1.0
  Created-By: JDJ example
  Main-Class: com.example.myapp.MyAppMain
  Class-Path: ext/mail.jar ext/activation.jar
  Multiple Main Classes(多主类)
  
   还有一种Multiple Main Classes情况,如果你的应用程序可能有命令行版本 和GUI版本,或者一些不同的应用却共享很多相同的代码,这时你可能有多个Main Class,我们建议你采取这样的策略:把共享的类打成lib包,然后把不同的应用打成不同的包,分别标志主类:如下
  Manifest for myapplicationlib.jar:
  Manifest-Version: 1.0
  Created-By: JDJ example
  Class-Path: mail.jar activation.jar
  Manifest for myappconsole.jar:
  Manifest-Version: 1.0
  Created-By: JDJ example
  Class-Path: myapplicationlib.jar
  Main-Class: com.example.myapp.MyAppMain
  Manifest for myappadmin.jar:
  Manifest-Version: 1.0
  Created-By: JDJ example
  Class-Path: myapplicationlib.jar
  Main-Class: com.example.myapp.MyAdminTool
  在myappconsole.jar 和 myappadmin.jar的manifest文件中分别注明各自的 Main Class
  Package Versioning
  
  完成发布后,如果使用者想了解 ,哪些代码是谁的?目前是什么版本?使用什么版本的类库?解决的方法很多 ,manifest提供了一个较好的方法,你可以在manifest文件中描述每一个包的信息。
  
   Java 秉承了实现说明与描述分离的原则,package 的描述 定义了package 是什么,实现说明 定义了谁提供了描述的实现,描述和实现包含 名、版本号和提供者。要得到这些信息,可以查看JVM的系统属性(使用 java.lang.System.getProperty() )
  
  在manifest文件中,我可以为每个package定义描述和实现版本,声明名字,并加入描述属性和实现属性,这些属性是
  
  Specification-Title
  Specification-Version
  Specification-Vendor
  Implementation-Title
  Implementation-Version
  Implementation-Vendor
  
  当要提供一个类库或编程接口时,描述信息显得是很重要,见以下范例:
  
  Manifest-Version: 1.0
  Created-By: JDJ example
  Class-Path: mail.jar activation.jar
  Name: com/example/myapp/
  Specification-Title: MyApp
  Specification-Version: 2.4
  Specification-Vendor: example.com
  Implementation-Title: com.example.myapp
  Implementation-Version: 2002-03-05-A
  Implementation-Vendor: example.com
  
  Package Version 查询
  
  在manifest文件中加入package描述后,就可以使用Java提供的java.lang.Package class进行Package 的信息查询,这里列举3个最基本的获取package object的方法
  
  1.Package.getPackages():返回系统中所有定义的package列表
  
  2.Package.getPackage(String packagename):按名返回package
  
  3.Class.getPackage():返回给定class所在的package
  
  使用者这方法就可以动态的获取package信息.
  
  需要注意的是如果给定的package中没有class被加载,则也无法获得package 对象
  
  Manifest 技巧
  
  总是以Manifest-Version属性开头
  
  每行最长72个字符,如果超过的化,采用续行
  
  确认每行都以回车结束,否则改行将会被忽略
  
  如果Class-Path 中的存在路径,使用"/"分隔目录,与平台无关
  
  使用空行分隔主属性和package属性
  
  使用"/"而不是"."来分隔package 和class ,比如 com/example/myapp/
  
  class 要以.class结尾,package 要以 / 结尾

posted @ 2006-10-12 18:38 Coolfiry 阅读(287) | 评论 (0)编辑 收藏

下面就来看看什么是 JAR 文件包吧:

1. JAR 文件包

JAR 文件就是 Java Archive File,顾名思意,它的应用是与 Java 息息相关的,是 Java 的一种文档格式。JAR 文件非常类似 ZIP 文件——准确的说,它就是 ZIP 文件,所以叫它文件包。JAR 文件与 ZIP 文件唯一的区别就是在 JAR 文件的内容中,包含了一个 META-INF/MANIFEST.MF 文件,这个文件是在生成 JAR 文件的时候自动创建的。举个例子,如果我们具有如下目录结构的一些文件:

  ==

  `-- test

    `-- Test.class

把它压缩成 ZIP 文件 test.zip,则这个 ZIP 文件的内部目录结构为:

  test.zip

  `-- test

    `-- Test.class

如果我们使用 JDK 的 jar 命令把它打成 JAR 文件包 test.jar,则这个 JAR 文件的内部目录结构为:

  test.jar

  |-- META-INF

  |  `-- MANIFEST.MF

  `-- test

    `--Test.class

2. 创建可执行的 JAR 文件包

制作一个可执行的 JAR 文件包来发布你的程序是 JAR 文件包最典型的用法。

Java 程序是由若干个 .class 文件组成的。这些 .class 文件必须根据它们所属的包不同而分级分目录存放;运行前需要把所有用到的包的根目录指定给 CLASSPATH 环境变量或者 java 命令的 -cp 参数;运行时还要到控制台下去使用 java 命令来运行,如果需要直接双击运行必须写 Windows 的批处理文件 (.bat) 或者 Linux 的 Shell 程序。因此,许多人说,Java 是一种方便开发者苦了用户的程序设计语言。

其实不然,如果开发者能够制作一个可执行的 JAR 文件包交给用户,那么用户使用起来就方便了。在 Windows 下安装 JRE (Java Runtime Environment) 的时候,安装文件会将 .jar 文件映射给 javaw.exe 打开。那么,对于一个可执行的 JAR 文件包,用户只需要双击它就可以运行程序了,和阅读 .chm 文档一样方便 (.chm 文档默认是由 hh.exe 打开的)。那么,现在的关键,就是如何来创建这个可执行的 JAR 文件包。

创建可执行的 JAR 文件包,需要使用带 cvfm 参数的 jar 命令,同样以上述 test 目录为例,命令如下:

jar cvfm test.jar manifest.mf test

这里 test.jar 和 manifest.mf 两个文件,分别是对应的参数 f 和 m,其重头戏在 manifest.mf。因为要创建可执行的 JAR 文件包,光靠指定一个 manifest.mf 文件是不够的,因为 MANIFEST 是 JAR 文件包的特征,可执行的 JAR 文件包和不可执行的 JAR 文件包都包含 MANIFEST。关键在于可执行 JAR 文件包的 MANIFEST,其内容包含了 Main-Class 一项。这在 MANIFEST 中书写格式如下:

Main-Class: 可执行主类全名(包含包名)

例如,假设上例中的 Test.class 是属于 test 包的,而且是可执行的类 (定义了 public static void main(String[]) 方法),那么这个 manifest.mf 可以编辑如下:

Main-Class: test.Test <回车>

这个 manifest.mf 可以放在任何位置,也可以是其它的文件名,只需要有 Main-Class: test.Test 一行,且该行以一个回车符结束即可。创建了 manifest.mf 文件之后,我们的目录结构变为:

  ==

  |-- test

  |  `-- Test.class

  `-- manifest.mf

这时候,需要到 test 目录的上级目录中去使用 jar 命令来创建 JAR 文件包。也就是在目录树中使用“==”表示的那个目录中,使用如下命令:

jar cvfm test.jar manifest.mf test

之后在“==”目录中创建了 test.jar,这个 test.jar 就是执行的 JAR 文件包。运行时只需要使用 java -jar test.jar 命令即可。

需要注意的是,创建的 JAR 文件包中需要包含完整的、与 Java 程序的包结构对应的目录结构,就像上例一样。而 Main-Class 指定的类,也必须是完整的、包含包路径的类名,如上例的 test.Test;而且在没有打成 JAR 文件包之前可以使用 java <类名> 来运行这个类,即在上例中 java test.Test 是可以正确运行的 (当然要在 CLASSPATH 正确的情况下)。

3. jar 命令详解

jar 是随 JDK 安装的,在 JDK 安装目录下的 bin 目录中,Windows 下文件名为 jar.exe,Linux 下文件名为 jar。它的运行需要用到 JDK 安装目录下 lib 目录中的 tools.jar 文件。不过我们除了安装 JDK 什么也不需要做,因为 SUN 已经帮我们做好了。我们甚至不需要将 tools.jar 放到 CLASSPATH 中。

使用不带任何的 jar 命令我们可以看到 jar 命令的用法如下:

jar {ctxu}[vfm0M] [jar-文件] [manifest-文件] [-C 目录] 文件名 ...

其中 {ctxu} 是 jar 命令的子命令,每次 jar 命令只能包含 ctxu 中的一个,它们分别表示:

-c 创建新的 JAR 文件包

-t 列出 JAR 文件包的内容列表

-x 展开 JAR 文件包的指定文件或者所有文件

-u 更新已存在的 JAR 文件包 (添加文件到 JAR 文件包中)

[vfm0M] 中的选项可以任选,也可以不选,它们是 jar 命令的选项参数

-v 生成详细报告并打印到标准输出

-f 指定 JAR 文件名,通常这个参数是必须的

-m 指定需要包含的 MANIFEST 清单文件

-0 只存储,不压缩,这样产生的 JAR 文件包会比不用该参数产生的体积大,但速度更快

-M 不产生所有项的清单(MANIFEST〕文件,此参数会忽略 -m 参数

[jar-文件] 即需要生成、查看、更新或者解开的 JAR 文件包,它是 -f 参数的附属参数

[manifest-文件] 即 MANIFEST 清单文件,它是 -m 参数的附属参数

[-C 目录] 表示转到指定目录下去执行这个 jar 命令的操作。它相当于先使用 cd 命令转该目录下再执行不带 -C 参数的 jar 命令,它只能在创建和更新 JAR 文件包的时候可用。  

文件名 ... 指定一个文件/目录列表,这些文件/目录就是要添加到 JAR 文件包中的文件/目录。如果指定了目录,那么 jar 命令打包的时候会自动把该目录中的所有文件和子目录打入包中。

下面举一些例子来说明 jar 命令的用法:

1) jar cf test.jar test

该命令没有执行过程的显示,执行结果是在当前目录生成了 test.jar 文件。如果当前目录已经存在 test.jar,那么该文件将被覆盖。

2) jar cvf test.jar test

该命令与上例中的结果相同,但是由于 v 参数的作用,显示出了打包过程,如下:

标明清单(manifest)

增加:test/(读入= 0) (写出= 0)(存储了 0%)

增加:test/Test.class(读入= 7) (写出= 6)(压缩了 14%)

3) jar cvfM test.jar test

该命令与 2) 结果类似,但在生成的 test.jar 中没有包含 META-INF/MANIFEST 文件,打包过程的信息也略有差别:

增加:test/(读入= 0) (写出= 0)(存储了 0%)

增加:test/Test.class(读入= 7) (写出= 6)(压缩了 14%)

4) jar cvfm test.jar manifest.mf test

运行结果与 2) 相似,显示信息也相同,只是生成 JAR 包中的 META-INF/MANIFEST 内容不同,是包含了 manifest.mf 的内容

5) jar tf test.jar

在 test.jar 已经存在的情况下,可以查看 test.jar 中的内容,如对于 2) 和 3) 生成的 test.jar 分别应该此命令,结果如下;

对于 2)

META-INF/

META-INF/MANIFEST.MF

test/

test/Test.class

对于 3)

test/

test/Test.class

6) jar tvf test.jar

除显示 5) 中显示的内容外,还包括包内文件的详细信息,如:

0 Wed Jun 19 15:39:06 GMT 2002 META-INF/

86 Wed Jun 19 15:39:06 GMT 2002 META-INF/MANIFEST.MF

0 Wed Jun 19 15:33:04 GMT 2002 test/

7 Wed Jun 19 15:33:04 GMT 2002 test/Test.class

7) jar xf test.jar

解开 test.jar 到当前目录,不显示任何信息,对于 2) 生成的 test.jar,解开后的目录结构如下:

  ==

  |-- META-INF

  |  `-- MANIFEST

  `-- test

    `--Test.class

.net/forum/images/smiles/icon_cool.gif border=0> jar xvf test.jar

运行结果与 7) 相同,对于解压过程有详细信息显示,如:

创建:META-INF/

展开:META-INF/MANIFEST.MF

创建:test/

展开:test/Test.class

9) jar uf test.jar manifest.mf

在 test.jar 中添加了文件 manifest.mf,此使用 jar tf 来查看 test.jar 可以发现 test.jar 中比原来多了一个 manifest。这里顺便提一下,如果使用 -m 参数并指定 manifest.mf 文件,那么 manifest.mf 是作为清单文件 MANIFEST 来使用的,它的内容会被添加到 MANIFEST 中;但是,如果作为一般文件添加到 JAR 文件包中,它跟一般文件无异。

10) jar uvf test.jar manifest.mf

与 9) 结果相同,同时有详细信息显示,如:

增加:manifest.mf(读入= 17) (写出= 19)(压缩了 -11%)

4. 关于 JAR 文件包的一些技巧

1) 使用 unzip 来解压 JAR 文件

在介绍 JAR 文件的时候就已经说过了,JAR 文件实际上就是 ZIP 文件,所以可以使用常见的一些解压 ZIP 文件的工具来解压 JAR 文件,如 Windows 下的 WinZip、WinRAR 等和 Linux 下的 unzip 等。使用 WinZip 和 WinRAR 等来解压是因为它们解压比较直观,方便。而使用 unzip,则是因为它解压时可以使用 -d 参数指定目标目录。

在解压一个 JAR 文件的时候是不能使用 jar 的 -C 参数来指定解压的目标的,因为 -C 参数只在创建或者更新包的时候可用。那么需要将文件解压到某个指定目录下的时候就需要先将这具 JAR 文件拷贝到目标目录下,再进行解压,比较麻烦。如果使用 unzip,就不需要这么麻烦了,只需要指定一个 -d 参数即可。如:

unzip test.jar -d dest/

2) 使用 WinZip 或者 WinRAR 等工具创建 JAR 文件

上面提到 JAR 文件就是包含了 META-INF/MANIFEST 的 ZIP 文件,所以,只需要使用 WinZip、WinRAR 等工具创建所需要 ZIP 压缩包,再往这个 ZIP 压缩包中添加一个包含 MANIFEST 文件的 META-INF 目录即可。对于使用 jar 命令的 -m 参数指定清单文件的情况,只需要将这个 MANIFEST 按需要修改即可。

3) 使用 jar 命令创建 ZIP 文件

有些 Linux 下提供了 unzip 命令,但没有 zip 命令,所以需要可以对 ZIP 文件进行解压,即不能创建 ZIP 文件。如要创建一个 ZIP 文件,使用带 -M 参数的 jar 命令即可,因为 -M 参数表示制作 JAR 包的时候不添加 MANIFEST 清单,那么只需要在指定目标 JAR 文件的地方将 .jar 扩展名改为 .zip 扩展名,创建的就是一个不折不扣的 ZIP 文件了,如将上一节的第 3) 个例子略作改动:

jar cvfM test.zip test

posted @ 2006-10-12 15:54 Coolfiry 阅读(349) | 评论 (0)编辑 收藏

     摘要: 周 登朋 (zhoudengpeng@yahoo.com.cn), 软件工程师, 上海交通大学 2006 年 9 月 06 日  在本篇文章中,你会学习到如何利用 Lucene 实现高级搜索功能以及如何利用 Lucene 来创建 Web 搜索应用程序。通过这些学习,你就可以利用 Lucene 来创建自己的搜索应用程序。 ...  阅读全文

posted @ 2006-10-03 20:11 Coolfiry 阅读(358) | 评论 (1)编辑 收藏

一、闲聊

  今天要谈的话题是COM,稍微深入一点,不知道大家用过C++Test或者Visual Assistant之类的软件没有,它们都有个非常引人注目的功能,那就是把它们自身嵌入到VC开发环境中去。这个功能让我痴迷不已,原因只有一个:我想做一个可以嵌入VC开发环境的VC工程解析器,这样用户在VC开发环境中就可以直接对当前或所有工程进行各种分析,统计。那么实现它简单吗?简单,Next和Copy即可轻松完成;仅仅这些吗?不是,它的背后还有博大精深的COM做支撑。不管困难与否,还是让我们先试为快。

  二、效果图

 

  三、实现步骤:

  <3.1>新建一个<DevStudio Add-in Wizard>类型工程,输入工程名称"CodeAnalyser".

  <3.2>进入第二个画面,系统要求用户输入插件的名称和描述信息。并且要求用户选择是否需要生成工具栏以及是否自动添加VC事件响应代码。


  <3.3>点击"Finish"结束向导,进入代码编辑窗口。

  在这里我们要说的一点是:该工程引用了ICommands接口,并从该接口上派生出 CCommands类。该类完成了所有用户自定义函数接口,VC应用程序消息响应和VC调试动作的消息响应工作。当我们真正为CCommands类添加成员函数之前我们必须先为ICommands接口添加相应的函数接口声明。在本工程中我总共为ICommands接口添加了两个函数接口,它们名字分别为:GetCurDirCommandMethod和QuitCommandMethod声明如下:(在CodeAnalyer.odl文件中)

interface ICommands : IDispatch
{
 // methods
 [id(1)] //在Vtable中的函数索引号
 HRESULT GetCurDirCommandMethod(); //得到VC当前工作目录

 [id(2)] //在Vtable中的函数索引号
 HRESULT QuitCommandMethod (); //退出VC编辑器
};

  在接口ICommands添加接口函数,那么相应的我们也要在类CCommands中声明和实现ICommands接口函数,函数的内部代码和普通工程代码没什么区别。

//Implement(CCommands类内部接口函数的声明)
public:
STDMETHOD(GetCurDirCommandMethod)(THIS);
STDMETHOD(QuitCommandMethod)(THIS);

//Function Code(Ccommands类内部接口函数的实现)
//得到当前VC开发环境的工作目录[您也可以让它成为你想要实现的功能代码]
STDMETHODIMP CCommands::GetCurDirCommandMethod()
{
 AFX_MANAGE_STATE(AfxGetStaticModuleState());
 VERIFY_OK(m_pApplication->EnableModeless(VARIANT_FALSE));
 BSTR bstrCurDir;
 m_pApplication->get_CurrentDirectory(&bstrCurDir);
 CString str(bstrCurDir);
 ::MessageBox(NULL, str, "VC工作目录", MB_OK | MB_ICONINFORMATION);
 VERIFY_OK(m_pApplication->EnableModeless(VARIANT_TRUE));
 return S_OK;
}

//退出VC开发环境

STDMETHODIMP CCommands::QuitCommandMethod()
{
 AFX_MANAGE_STATE(AfxGetStaticModuleState());
 VERIFY_OK(m_pApplication->EnableModeless(VARIANT_FALSE));
 if(::MessageBox(NULL,"您想退出VC++编辑器吗(Y/N)?","询问信息...", MB_YESNO | MB_ICONQUESTION) == IDYES)
  m_pApplication->Quit();
  VERIFY_OK(m_pApplication->EnableModeless(VARIANT_TRUE));
 return S_OK;
}

  <3.4> 创建工具栏,连接工具栏按钮事件

  所有的幕后工作已经准备就绪,只差个工具栏界面就一切OK了。打开类CDSAddIn,它里面有三个成员函数,其中OnConnection和OnDisconnection成员函数的意义非常重要。它们的意义如下:

  <1>OnConnection:插件的初始化任务都在这里完成。如COM服务的启动,工具栏/菜单栏的创建,工具栏按钮/菜单项的添加与修改等等。

  <2>OnDisconnection:插件的卸载工作都在这里完成。如COM服务的卸载,工具栏/菜单栏的销毁,释放等等。

  了解了它们各自的用途之后我们就可以在相应的消息事件中添加代码了。很显然工具栏的初始化应该在OnConnection事件中完成。

  在OnConnection事件中系统首先获得了VC应用程序接口,然后调用一个接口函数:AddCommand来为插件添加命令和命令影射函数。然后再使用另外一个接口函数AddCommandBarButton向工具栏中添加工具栏按钮,其中每个工具栏按钮会和一个命令标志符号相连接,这样就能实现按钮和命令(消息)之间的一一对应。下面是添加一个命令和一个工具栏按钮的代码(如果你要添加多个工具栏按钮只要重复此步骤即可):

LPCTSTR szCommand = _T("GetCurDirCommand");
VARIANT_BOOL bRet;
CString strCmdString;
strCmdString.LoadString(IDS_CMD_STRING);
strCmdString = szCommand + strCmdString;
CComBSTR bszCmdString(strCmdString);
CComBSTR bszMethod(_T("GetCurDirCommandMethod"));

CComBSTR bszCmdName(szCommand); //和下面添加工具栏按钮对应

VERIFY_OK(pApplication->AddCommand(bszCmdString,bszMethod,0,dwCookie,&bRet));
//AddCommand 参数含义:
//bszCmdString:命令字符串。
//bszMethod:Icommands接口函数名。
//第三个参数代表位图偏移量。
//第四和第五个参数分贝为系统参数和返回值(参照MSDN的IApplication介绍)

if (bRet == VARIANT_FALSE)
{
 *OnConnection = VARIANT_FALSE;
 return S_OK;
}

//添加工具栏按钮
if (bFirstTime == VARIANT_TRUE)
{
 VERIFY_OK(pApplication->AddCommandBarButton(dsGlyph, bszCmdName, m_dwCookie));
}

  <3.5> 编译,连接及在VC中引入插件

  以上就是我们所有的代码工作,接下来赶快Build以下吧。编译通过的话,在你的工程Debug目录下会有个dll文件。然后打开VC编辑器,在VC任何一个工具栏上点击鼠标右键,弹出如下图所示菜单。然后选择”Customize”子菜单,打开如下图所示的工具栏定制窗口:


  接着选择该窗口的最后一页"Add-Ins and Macro Files"出现下图所示窗口。


  然后点击”Browse...”按钮,这时打开你工程下的Debug目录中的DLL文件,这样你就可以看到你制作的工具栏了。同样你再次打开上面的菜单,这次可以看到多了一个工具栏,并且名字乱七八糟的,怎么改变工具栏的名字呢?方法很简单:打开上面窗口中的”Toolbars”选项页,在工具栏列表框中找到你的工具栏,然后在”Toolbar name”编辑框中输入你想要的名字即可。再打开上面的菜单看看名字是不是变了,哈哈!


  OK,今天的话题就聊到这里。

posted @ 2006-09-30 22:58 Coolfiry 阅读(267) | 评论 (0)编辑 收藏

  插件式设计近年来非常流行,其中eclipse起了推波助澜的作用,提到插件式就会不由自主的想到eclipse。其实插件式设计并不是什么新事物,早在几十年前就有了。像X Server就是基于插件式设计的,除了核心功能外,它所有的扩展功能和设备驱动都是以插件方式加入进来的。

  基于插件的设计好处很多:把扩展功能从框架中剥离出来,降低了框架的复杂度,让框架更容易实现。扩展功能与框架以一种很松的方式耦合,两者在保持接口不变的情况下,可以独立变化和发布。公开插件接口,让第三方有机会扩展应用程序的功能,有财大家一起发。另外,还可以让开源与闭源共存于一套软件,你的插件是开源还是闭源,完全由你自己决定。

  基于插件设计并不神秘,相反它比起一团泥的设计更简单,更容易理解。各种基于插件设计的架构都有自己的特色,但从总体架构上看,其模型都大同小异。这里我们介绍一个简单的模型,并给出几个实例,希望对新手有所启发。

  1. 基本架构

plugin.jpg

  插件式设计的应用程序,基本上可以用上图来表示。当然,此图是一种较高层次的表示,实际的设计会更复杂一些。我们在这里为了阐述方便,不用故意搞得那么复杂。

  应用程序由应用程序框架、插件接口、插件和公共函数库四部分组成。

  应用程序框架负责应用程序的整体运作,它清楚程序整个流程,但并不知道每个过程具体要做什么。它在适当的时候调用一些插件,来完成真正的功能。

  插件接口是一个协议,可能用IDL描述,可能是头文件,也可能一段文字说明。插件按照这个协议实现出来,就可以加入到应用程序中来。当然,对于复杂的系统,插件接口可能有多个,各自具有独立的功能。

  插件是完成实际功能的实体,实现了要求的插件接口。尽管实现什么以及怎么实现,完全是插件自己的自由。在实际情况来,一般还是有些限制,因为插件接口本身可能就是一个限制。如,实现编译功能的插件,自然不能实现成一个聊天功能的插件。

  公共函数库是一组函数或者类,应用程序框架和插件都可以调用。它通常是一个独立的动态库(DLL)。应用程序框架本身是公用的,是代码复用的一种方式。但并不是所有可复用代码都可以放在框架中,特别是插件会用到的公共代码,那会造成插件对框架的依赖。把这些公共代码提取到一个独立的库中,是一种好的方法。

  另外,值得补充说明一下的是插件接口。插件接口通常有两种:

  通用插件接口:这一类插件接口是通用的,你无法从接口函数看出这个插件的功能。它的接口函数通常有这些函数:

  init : 用于初始化插件,通常在插件被加载时调用。

  deinit:用于反初始化插件,通常在插件被卸载时调用。

  run:让插件起动。

  stop:让插件停止。

  至于插件要完成什么功能,要插到哪里,在init函数里决定,它调用公共函数库里的函数把自己注册到框架中某个位置。

  专用插件接口:这一类插件接口是专用的,看到它的接口函数说明,你就可以大致了解它的功能了。

  加入插件的方式通常采用配置信息来实现,配置信息可以是注册表,也可以配置文件。也可以动态注册进来,或者把插件放到指定的位置。

  下面我们来看几个实例:

  2. 桌面设计

  最近一段时间完成了桌面模块的设计和实现。按照以往的经验,桌面模块通常是变化最多的一个模块,SPEC总是在不断的调整的效果,不同客户要求实现具有个性化的桌面,直到产品快发布了,桌面的SPEC还在不停的修改。另外,在智能手机中,桌面占有特殊的地位,很多东西都可能往桌面里塞,桌面不但是各种功能的大杂烩,还是一些系统消息的中转站。

  这个任务比较棘手,所以在设计时就分外小心。首先想到的就是采用插件式设计,把外围功能独立出来,尽量简化框架的实现。

  插件:每一个最小功能单元都是一个插件,它可以是可见的,也可以是不可的,也可以是动态变化的。比如时间、电池电量、网络连接、信号强弱、新事件(如SMS、MMS、EMAL、ALARM和未接电话等)、应用程序快捷方式、左右操作按钮和其它处理系统事件的功能单元。每个插件都用一个.desktop来描述,这是遵循freedesktop.org的标准的。

  桌面框架包括:状态栏、开始菜单、操作栏、桌面区、事件管理器和主题管理器。而状态栏、开始菜单、操作栏、桌面区和事件管理器都是容器,容纳各种插件。对于可见的插件,可以有自己的表现方式,也可以采用通用的表现方式。

  公共函数库:一些抽象的类、实现插件的辅助类以及其它一些可能被公用的类。

  插件接口:对于不可见的插件要求实现事件处理功能,可见的插件还要求实现绘制功能。

  3. 模拟器设计

  一个同事负责设计另外一个平台的PC模拟环境设计。在我的建议下,他对架构作了调整。调整后的架构非常简单,也可以认为是插件式的设计,它由下面几部分组成:

  应用程序框架:负责模拟器基本功能,如模拟键盘和显示设备、换肤功能等。

  插件:就是被模拟的平台,如microwindow及相应的手机应用程序。尽管运行时通常只有一个插件运行,这样做仍然有意义,如果要换成minigui或者其它平台时,模拟器不需要作任何修改。

  公共函数库:它由应用程序框架初始化一些信息和回调函数,然后供插件(即microwindow)调用,插件利用它来实现显示和输入等驱动程序。

  插件接口:如起动和停止模拟平台等。

  4. GIMP

  GIMP是一个功能强大的图形图像编辑器,典型的基于插件式的设计,在《unix编程艺术》中,作为插件式设计示例介绍过。

  应用程序框架:GUI

  插件:完成图像的各种转换和处理功能,如模糊、去斑和色彩调整等。

  公共函数库:放在libgimp.so里。

  插件接口:对GIMP感兴趣的朋友,可以到官方网站上去阅读更多的文档。

posted @ 2006-09-30 22:57 Coolfiry 阅读(698) | 评论 (0)编辑 收藏

  Google推荐的开发环境是VS 2003,GoogleDesktop的插件是基于COM的,而COM是语言无关的,所以你可以用任何能开发COM的工具(语言)开发。

  如果你使用的VS 2003或者VS 2005,建立开发环境非常容易。不过,如果你像我一样恋旧,还是喜爱VC6的简洁快速,排斥庞大缓慢的VS 2003或者VS 2005,可能就要费一点周折了。

  这里只讨论VC6的环境设置。

  Google没有为VC6 提供开发向导,也就是说,所有代码你都得手工就编写。如果是出于学习的目的,手工去写这些代码,付出的劳动会有所回报的。另外,VC6所带的ATL版本也有点老,一些类只有在新版本中才有,在VC6中无法使用,所以有时你不得不面对一些COM的细节问题。同样,同样如果出于学习的目的,所花费的时间也是值得的。

  建立开发环境的第一步就是下载GoogleDesktop的SDK,下载地址为http://desktop.google.com/。

  解开之后,GD_SDK\api目录下有下面几个目录:

documentation
samples
tools
wizards

  建议先大概看一下documentation中的文档,然后阅读samples中的部分代码,找一下感觉。

  GoogleDesktop提供全部接口都在三个IDL文件中声明:

GoogleDesktopActionAPI.idl
GoogleDesktopAPI.idl
GoogleDesktopDisplayAPI.idl

  开发GoogleDesktop的插件,有以上文件已经足够(当然你要安装GoogleDesktop本身)了。但是C++中不能直接使用idl文件,要通过midl.exe编译成头文件,才能使用。其实不用这么麻烦,GD_SDK\api\samples\common目录中已经有相关头文件了:

GoogleDesktopDisplayAPI.h

GoogleDesktopComponentRegistration.h

GoogleDesktopAPI.h

GoogleDesktopActionAPI.h

  直接使用这几个头文件,可以省去用midl编译步骤。只要修改VC6的设置,让它可以找到上述头文件就行了。有两种方式可以做到这一点。一种方式是针对当前项目的:

  1. 打开菜单Project->Settings

  2. 打开属性页的C/C++标签

  3. 选择Categary的Preprocessor项

  4. 在Additional Include directories一栏加入上述文件所在的目录

  另一种方式是针对VC6所有的项目的:

  1. 打开菜单Tool->Options…

  2. 打开属性页的Directories标签

  3. 选择Show directories for中的include files项

  4. 在Directories中加上述文件所在的目录

  至于选择哪一种方式,完全看你个人爱好,后者会方便一点,对懒人比较适用,但它会影响所有的VC6项目,或许会有某些副作用。

posted @ 2006-09-30 22:55 Coolfiry 阅读(242) | 评论 (0)编辑 收藏

 

原文地址:http://www.blogjava.net/BlueDavy/archive/2006/05/28/48593.html

摘要:插件开发框架其实和目前开源界流行的MVC框架之类的相同,都决定了基于这个框架的开发方式,如基于MVC框架,就会按照MVC思想来进行开发,而插件开发框架呢,也是同样如此,就要求基于插件的方式来进行开发,不过插件开发框架和MVC框架又有不同,插件开发框架是一个可以成为系统基础架构的框架,而MVC框架通常来讲不足以成为,如在目前的MVC框架Webwork、Struts上我们通常都需要加上Spring、Hibernate来构成系统完整的基础架构,这个时候由于MVC框架的实现是没有标准可参照的,就造成了在各种系统中形成了不同的但很类似的基础架构,但却造成了无法复用的现象;插件开发框架则是作为统一系统基础架构的一种开发方式,它使得系统的复用成为了可能,而同时由于插件开发框架对于动态性的支持,使得系统更加的灵活和可扩展。来看看一个插件开发框架,应该提供些什么东西,作为改变系统架构思想的框架,插件框架需要考虑很多方面,如开发、测试、部署等,总结下来一个插件框架应提供插件的开发规范;插件开发、调试的IDE;

posted @ 2006-09-30 22:53 Coolfiry 阅读(265) | 评论 (0)编辑 收藏

     摘要: N皇后问题是一个典型的需要用回溯算法来解决的问题。回溯算法可以用递归方法来实现,也可以用非递归方法来实现。用递归的方法来解决回溯的问题思路很清晰,但是耗费的内存资源较多,速度也较慢;非递归方法具有速度快和耗费较少内存资源的优点,但是程序的逻辑结构却很复杂——不过搞懂之后觉得也很简单。   在写非递归算法之前,参考了网上的一些文章,但是觉得那些程序都很晦涩难懂,而且存在一些问题,我索性自己写了一个,...  阅读全文

posted @ 2006-09-27 22:20 Coolfiry 阅读(461) | 评论 (0)编辑 收藏

烦的很啊,但要认认真真做人,兢兢业业做事哦

posted @ 2006-09-27 22:15 Coolfiry 阅读(260) | 评论 (0)编辑 收藏

网站如何做分布式(集群)的大纲

何时要用分布式

  • 单台服务器无法承受压力。
  • 需要实现发生错误时候,自动切换
  • 学习或者测试分布式技术

应用分布式的场景


一、提供多个对外的接口,按照一定规则,分派不同请求由不同接口来处理。
这时候需要考虑:
  • 如何实现负载均衡
    • 在哪个层次实现转移负载
    • 负载的均衡如何实现
  • 如何实现故障转移
    • 如何监控故障
    • 如何切换服务

二、把一个功能拆分成多个功能,不同功能分布部署到不同服务器上

  • 对外功能的拆分 
    • http://news.sina.com.cn/ http://sports.sina.com.cn/ http://mobile.sina.com.cn/
    • http://www.microsoft.com/china/  http://www.microsoft.com/downloads/
    • SOA
  • n层架构,其中的一些层分布到不同服务器上
    • WEB + DB 模式

网站请求中的分布式

按照请求流程,我们可以在以下环节按照一定规则,把用户的请求分流到不同服务器上:

  • Web Client Level
    • 例子:QQ 设置中你可以选择登陆的服务器IP
  • DNS Based Selection
    • 优点:
    • 缺点:
      • 不能区分服务器的差异,也不能反映服务器的当前运行状态。
      • DNS 的刷新需要时间,无法及时故障切换。
  • TCP balancing proxies
    • 硬件
    • 软件
  • HTTP-aware routers

  • URL重定向

网站应用中的分布式

  • 代理服务器实现请求的分离
    • Squid是Linux下一个缓存Internet数据的代理服务器软件
  • 拆分网站对外功能
    • 不同域名前、后缀
    • URL 重写
  • SOA
    • 每个Service 分布到一台服务器上
  • n 层架构
    • 缓存分布式部署
      • 文件Cache
      • 内存Cache (memcached )
        • http://www.danga.com/memcached/
        • https://sourceforge.net/projects/memcacheddotnet/
    • DB分布式集群部署
      • 故障转移
      • 发布订阅
      • 分布式分区视图
    • 应用服务器(比如定时发送邮件通知的服务)

    • 相关技术:
      • 企业服务
      • .net Remoting
      • WCF
      • Web Service

 

如何判断一个应用是否支持分布式

如果发现某一部分应用需要做分布式了,就可以按照以下思路来考虑如何改造:

从应用所用数据看是否支持分布式

  • 多份并存数据(一个数据存在多份)最大多长时间同步一次是可接受的。
    • 内存缓存的数据跟数据库的数据(页面级缓存和业务逻辑缓存)
    • 静态文件跟数据库
    • 查询数据库跟业务变更数据库
  • 数据按照一定规则拆分(一个数据只存在一份)对业务是否有影响
    • 过去每年的数据迁移到一个对应历史库中。
    • 专用的图片服务器 http://pics.ebaystatic.com/

此处可分析:QQ的在线用户数据,会是如何处理的呢?

从应用逻辑过程看是否支持分布式

  • 是否可以并行执行这个逻辑过程

  • 这个逻辑过程是否可以拆分成几个松耦合的过程

微软技术支持的5种分布式

夏桅的这篇博客中的图表就可以很详细的对比这5种分布式:

Windows的第五种群集方案 - CCS

posted @ 2006-09-21 15:34 Coolfiry 阅读(786) | 评论 (0)编辑 收藏

http://www.tiobe.com/index.htm?tiobe_index

这次 vb 和 vb.net 的数据再次合并了。C 系的语言 (java, c, c++, C#) 总体占了 50% 强。在 .net 环境中,vb 大概还是多过新生代的 C# 。
这次仔细了看了看。才发觉这个升降是去年同期的比较。是能够使用此语言的工程师,课程,独立软件生产商的相关比例。不直接代表用语言出了多少代码。

原来 Ruby 和 Java 基本上是同时代的东西。http://www.ruby-lang.org/  http://rubycn.ce-lab.net/ 由日本人发明、流行的东西。
从运行效率、性能上来看,C/C++ 比 Java 强。Java 比 Ruby 强。在比较简单的功能中,Java 和 C/C++ 可以相当接近。当程序的算法比较复杂,涉及大量数据的时候,Java 速度还是会落后近一个数量级。此时,内存使用也会有几倍的差异。
http://blog.csdn.net/rmartin/archive/2006/08/30/1143161.aspx
http://www.butunclebob.com/ArticleS.UncleBob.SpeedOfJavaCppRuby

不知道 D 是什么东东了。倒是在许久以前,从公司的首设博士那里听到过一耳朵。感觉语法结构还是 C like 的。http://www.digitalmars.com/d/index.htmlhttp://www.soho-works.net/BLOG/326.asp http://libai.math.ncu.edu.tw/bcc16/user/forum/read.php?f=15&i=14

http://www.tiobe.com/index.htm?tiobe_index

TIOBE Programming Community Index for September 2006

September Headline: Ruby and D are the hot languages of today

tiobe language 200609

tpci trends 200609

posted @ 2006-09-14 13:35 Coolfiry 阅读(595) | 评论 (0)编辑 收藏

摘要:

近日, Sun 宣布收购 JRuby 项目.Sun终于开始表露出让不仅仅是Java运行在JVM上的兴趣了.

 
近日, Sun 宣布收购 JRuby 项目.

Sun终于开始表露出让不仅仅是Java运行在JVM上的兴趣了.

近日,SUN迈出了重要的一步.

Charles Nutter, JRuby 的核心开发者之一, 宣布: Sun 已经整体收购了JRuby 项目. 他与JRuby的另外一个核心开发者
Thomas Enobo 都将会加入Sun.


从这次动作看的出来Ruby在Sun战略中的地位,  看来Ruby很有可能成为JVM支持的第一个非Java语言.

动态语言, 已经不遥远了.

官方站点:
http://jruby.sourceforge.net/
(http://www.matrix.org.cn/resource/news/JRuby+Sun_954.html)

posted @ 2006-09-11 13:58 Coolfiry 阅读(210) | 评论 (0)编辑 收藏

     摘要: 用 JNI 调用 C 或 C++ 动态联接库原来如此简单 ...  阅读全文

posted @ 2006-09-09 16:30 Coolfiry 阅读(543) | 评论 (0)编辑 收藏