BlogJava-xpsir-文章分类-转载区http://www.blogjava.net/xpsir/category/5455.html下君尽己之能，中君尽人之力，上君尽人之智；zh-cnSat, 10 Jul 2010 14:26:34 GMTSat, 10 Jul 2010 14:26:34 GMT60Quartz任务调度CronTrigger配置格式详细说明http://www.blogjava.net/xpsir/articles/325188.html小P小PSun, 04 Jul 2010 04:12:00 GMThttp://www.blogjava.net/xpsir/articles/325188.htmlhttp://www.blogjava.net/xpsir/comments/325188.htmlhttp://www.blogjava.net/xpsir/articles/325188.html#Feedback0http://www.blogjava.net/xpsir/comments/commentRss/325188.htmlhttp://www.blogjava.net/xpsir/services/trackbacks/325188.html

小P 2010-07-04 12:12 发表评论
]]>项目管理系统模块http://www.blogjava.net/xpsir/articles/271247.html小P小PMon, 18 May 2009 02:16:00 GMThttp://www.blogjava.net/xpsir/articles/271247.htmlhttp://www.blogjava.net/xpsir/comments/271247.htmlhttp://www.blogjava.net/xpsir/articles/271247.html#Feedback0http://www.blogjava.net/xpsir/comments/commentRss/271247.htmlhttp://www.blogjava.net/xpsir/services/trackbacks/271247.html

信息交流

  • 信息交流用来发布各种信息文件，企业可以根据自己的实际需要自行进行栏目的分级设置。
  • 可设定各栏目相关的发布、管理权限，实现内部新闻、公告、规章制度等公用信息的统一上传管理。
  • 可以根据实际情况定义信息栏目名称（如新闻、公告、规章制度、通报...），系统支持多层次目录结构，同时支持按目录授权访问。
  • 文档的授权可以按人员、部门、职务、分组、角色、项目组等多种方式指定，更方便企业管理。
  • 内部消息：与内部成员的沟通交流、文件传递，也用于系统的事务消息发送，如工作跟踪督办。
  • 常用链接：可以将单位经常使用的各类相关站点进行设置。
  • 企业论坛：可以随时发表相关的意见或针对某一问题进行讨论。

Shenzhen Hiblue Software

事件日程

  • 事件日程以成员、部门、或团队为单位，按时间顺序，将相关的工作任务、工作计划、待办事务、流程事务以图表方式显示出来。
  • 成员通过事件日程可明确自己的工作目标，经理也可以使用事件日程工具对员工的工作做出合理统筹的安排。
  • 此外，事件日程功能也支持创建日程安排，如创建约会、会议计划或其他日程计划。
  • 可根据时间、日、周、月查询日程信息，并在日程中添加备忘。
  • 事件日程还具有冲突检查功能，以及到期提醒功能。

ｈｉ－ｂｌｕｅ．ｃｏｍ

项目管理

  • 项目管理管理项目的整个生命周期，包括项目的启动、计划、执行、控制和结束。
  • 企业可以根据实际情况实现合理的项目运作，对项目的任务、成员、财务、资源进行恰当的分配和管理，系统可自动启动相关的工作流。
  • 通过项目管理，项目经理可以掌控所有的项目信息（计划，资金，物质，人员，进程），跟踪整个项目的生命周期，全程监控项目的进展，管理与项目相关的活动，并从矩阵视图观察组织的效能。
  • 项目管理系统适用于：市场工程、软件工程、开发过程、项目实施、以及各种特定的项目工程。
  • 项目管理可针对整个组织机构、部门或具体的工程项目进行管理。项目的发布人员可以使用本功能制订整个机构的项目工作计划，同时将这些计划分配到具 体的执行人员； 掌握项目的执行情况及其相关的工作进度、项目文档、工作任务、项目进度信息，进行项目统计、任务统计、工时统计等分析查看。
  • 机构成员根据参于的项目工作，可以定期上传相应的工作报告并可上传多个相应的附件。
  • 项目管理制定工作流程是：首先设置、建立相应的项目类别和任务类别，项目类别建立时将指定相应的工作流程。
  • 可制订相应的项目并可针对需要进行指定相应的负责人及执行人，根据项目类别的选定，就会拥有项目类别事先定义好的工作流程。根据工作流程可一步一步实施执行到结束。
  • 项目管理模块里还提供了对项目文档的管理、知识共享、工作交办等功能。

H i b l u e S o f t w a r e

工作任务

  • 工作任务是企业日常工作任务或项目的工作计划任务，系统通过工作任务流程，实现工作流程自动化。
  • 工作任务可设定分类、优先级、重要性、紧急程度等属性，可按项目、部门、成员等对象进行任务分配。
  • 通过工作流程的自动化，实现更好、更快的进行任务的过程。
  • 工作任务的计划安排：计划安排实现对日常工作计划的安排、下达、负责人员的指定，同时支持进行计划的再分解操作。实现工作由上到下，由总到分的统一安排管理。
  • 工作任务的跟踪检查：系统对已经安排的工作任务自动跟踪检查，对于提交完成的工作申请进行核准，从而实现对于工作任务时间进度、工时进度、任务进度的多种跟踪检查。
  • 工作任务的报告日志：系统提供的报告日志可以使工作任务负责人方便的进行相关报告的提交，为将来的工作考评提供了准确、翔实的数据。
  • 工作任务的费用管理：通过与费用报销模块的连接，方便管理者对于相关工作任务的费用投入情况进行直接管理。
  • 工作任务的查询功能：可以使管理者对于任务进展情况进行直接、准确的监控管理。

深 圳 市 升 蓝 软 件 开 发 有 限 公 司

审批流程

  • 审批流程就是根据审批的规则集，利用信息技术以及现代化的管理手段，实现一个审批流程的自动化，在这个过程中文档、信息在参与者之间传递。
  • 流程审批用于企业用户之间进行的各种办公申请、公文流转、合同会签、立项审批、事务审批的过程自动化处理，通常由发起者（如文件起草人）发起流程，经过本部门以及其他部门的处理（如签署、会签），最终到达流程的终点（如发出文件、归档、批准）。
  • 企业可以根据单位的实际情况定义审批流程，从简单流程（如请假申请）到复杂流程（如立项审批）均可以PMS系统中定义和实施。
  • PMS系统的审批流程具备三种应用流程模式：自定义流程、预定义流程、固定流程，满足企业的不同流程处理的需要。
  • PMS系统的审批流程可以使用用流程模板制定，可方便批量地快速布署和实施工作流程。
  • PMS系统的审批流程支持多种方式指定对象，可使用绝对对象和相对对象，在定义和实施中具有非常方便高效的意义。
  • PMS系统的审批流程支持会签功能，支持多节点和多线程，在流程中支持使用子程序。

S h e n z h e n H i b l u e

文档管理

  • 文档管理是存储企业电子数据的基础，它可以让所有的知识文档在同一个平台上运作，在一个中央数据库中统一存储和管理各种信息和现有业务。
  • 在文档管理模块中，可以轻松创建，存储，搜索你需要的文档（合同，方案书，产品说明书等任何可以以文字表达下来的信息），并组织创建企业整个的知识管理库。
  • 文档管理还可以管理公司的内部网站和外部网站，并可设计灵活多样的信息门户。
  • 文档管理还提供多种知识管理工具以提升企业对知识的分享、积累、创新和利用。
  • 文档管理是对组织机构中的各类电子文档实现统一存储和管理，支持加密、权限定义、分类定义。
  • 全文检索功能使查找文件更加方便快捷，工作效率明显提高。
  • 文件的流通流转更加便捷，员工间文档的协作更加方便。
  • 降低纸质文档的依赖，节省文档管理的成本。
  • 重复利用历史的文档，发挥知识财富的价值。

深 圳 升 蓝 版 权 所 有

公文流转

  • 公文流转以用于处理工作中的单位内外部的各种电子公文/审批公文/通知公文，应用审批流程控制的原理实现准确、及时的公文的处理。
  • 公文流程的特点：
  • 公文流转可自动控制公文的拟定、审核、阅读、办理、完成等公文流程的全过程工作。
  • 公文管理模块相对传统公文处理而言，在很大程度上提高了公文处理效率和准确性。
  • 公文管理使用软件自主开发的符合XPDL标准的工作流程控制模块，支持多线程、多条件的工作和审批流程。
  • 公文流程支持会签功能，可适用于复杂的重大合同或文件的审批。
  • 公文流程支持预定义流程、自定义流程、固定流程。
  • 公文流程的主要作业：
  • 发文收文：发文起草、发布来文登记的功能，通过系统提供的在线编辑、附件上传功能可以与其它文档编辑工具进行结合。
  • 公文办理：根据预先设置的公文办理流程，实现公文的过程的流程控制，支持多种流程模型，支持会签、退签、修改后续流程等操作，可满足了各种复杂的公文办理流程的要求。
  • 催办跳转：对于超过办理期限或需特殊办理的公文，可以进行发送催办通知、邮件，跳转操作等功能实现，对于办理流程的跟踪检查、特殊流转的要求。提高公文流转办理的工作效率。
  • 归档销毁：通过与系统文档管理的连接，对于已完成流转办理的公文，可以进行相应的归档、销毁操作。

Ｈ ｉ － Ｂ ｌ ｕ ｅ ． Ｃ ｏ ｍ

知识管理

  • 知识仓库利用其广泛的数据知识资源，经过严密、科学的分析整理，根据条件的不同，可利用于各行各业，指导各行各业的单位实体或个人能够沿正确的发展方向发展，能够将最先进的理论、最新的技术运用到最实际的生产生活中去。
  • 知识管理模块，帮助企业构造适合自身的知识库：指出重要的知识对象，设计出知识管理的基础设施，评估并导入最适合企业的技术平台，发挥知识价值的功能。
  • 提供知识库的检索功能：用户可以按照知识树或知识项目的名称、知识项目中包含得内容进行检索。
  • 应用系统的整合：它可以同企业门户进行完美的整合，帮助企业减少系统管理维护的工作量。
  • 提供分析报表，方便优化管理：图形化的报表分析，提供各个部门、人员一段时间内的发布文章的状况，并且各篇文章的点击率。 能为某个部门或用户推荐相关的知识

人事管理

  • 人力资源是对组织中的人事工作进行管理：括人员的基本信息、履历信息管理、人员的调动分配、人员信息查询统计、绩效考核、培训等，。
  • 人力资源管理除了传统的人力资源管理的功能外，更为重要的是通过与其他模块的协同工作，实现人力资源管理的全方位化和个性化。
  • 集中的工作信息：在PMS 项目管理系统中，如果找到某一个员工，那么这个员工在公司内的所有痕迹都能被提取出来，例如有关的文档，客户，资产，产品，服务，项目，工作任务以及有关 的财务信息在相关权限控制下展现在你的面前，为科学的分析人员的情况，制订人力资源策略提供强大的工具。
<!-- r.t-->

客户管理

  • 客户关系管理自动化并改善与销售、市场营销、客户服务和支持等领域的客户关系有关的商业流程。
  • 客户管理的核心是客户价值管理，它将客户价值分为既成价值、潜在价值和模型价值，通过一对一营销原则，满足不同价值客户的个性化需求，提高客户忠诚度和保有率，实现客户价值持续贡献，从而全面提升企业盈利能力。
  • 找到并成交一位新客户需要投入很大的努力，企业80%的利润来自20%的老客户，完善的客户管理是企业利润的源泉。
  • 客户管理是为企业在激烈市场竞争中，提供一套方便有力的管理工具，可以帮助企业为客户提供更加完备周到的服务，通过有效地进行客户资源管理，使企业的产品和服务更加满足客户的实际需要，从而给企业带来更加丰厚的效益。
  • PMS 项目管理系统的客户关系管理模块，以数据仓库、商业智能、知识发现等技术方法，使得收集、整理、加工和利用客户信息的质量大大提高。
  • PMS 项目管理系统还支持数据挖掘技术，根据企业客户档案的特点建立合理的数据挖掘分析模型和挖掘方法，从大量客户档案原始资料中通过数据选择和检测，揭示出隐含的具有潜在价值的信息。
<!-- r.t-->

销售管理

  • 销售管理系统主要用来处理与企业的销售活动相关的业务内容，比如与客户签订销售订单、发货、办理出库、退货、收取销售货款等，而且还可以处理应收款、预收款以及现收款等往来款业务。
  • 通过销售订单录入与变更，跟踪管理销售情况；
  • 根据货品报价和销售数量开出销售发票，根据发货单产生结算凭证和收货单；
  • 提供实际销售商品金额与帐面金额核对功能；
  • 提供了客户信用额度控制功能，可以达到降低销售风险，减少应收呆账的目的，还可以实现业务员销售业绩、销售指标完成情况的考核功能。
  • 销售计划：销售计划的制定、额度管理、销售力量管理和地域管理。
  • 销售管理：为现场销售人员设计，主要功能包括联系人和客户管理、机会管理、日程安排、佣金预测、报价、报告和分析。
  • 销售佣金：允许销售经理创建和管理销售队伍的奖励和佣金计划，并帮助销售代表形象地了解各自的销售业绩。
<!-- r.t-->

订单管理

  • 订单管理是处理订单从录入到结清的整个过程的业务流程，主要包括：
  • 订单的情况的记录、跟踪和控制，包括针对销售合同的执行；
  • 控制订货价格、数量和客户、业务员信用管理；
  • 随时对订单完成情况的跟踪、控制订单的实际执行；
  • 根据实际补货情况实现追加执行订单；
  • 进行比较并显示订单执行差异，并通过业务和分析报表进行订单执行情况的反映。
  • 通过订单管理的工作流程程序，订单管理控制整个交易过程，并形成记录和报告。
<!-- r.t-->

合同管理

  • 合同管理是指企业对以自身为当事人的合同依法进行订立、履行、变更、解除、转让、终止以及审查、监督、控制等一系列行为的总称。
  • 合同管理的订立、履行、变更、解除、转让、终止是合同管理的内容；审查、监督、控制是合同管理的手段。
  • 合同管理是全过程的、系统性的、动态性的。
  • 合同管理的全过程就是由洽谈、草拟、签订、生效开始，直至合同失效为止，不仅要管理签订前的管理，更要进行签订后的管理。
  • 合同管理的系统性就是凡涉及合同条款内容的各部门都要一起来管理。
  • 合同管理的动态性就是注重履约全过程的情况变化，特别要掌握对我方不利的变化，及时对合同进行修改、变更、补充或中止和终止。
<!-- r.t-->

财务管理

  • 用款管理：对于单位内部的各种用款进行在线提交、审批、借出登记、归还登记的管理，降低日常用款管理工作的工作强度，提高工作效率。
  • 报销管理：对于单位内部的各种用款进行在线提交、审批、报销登记的管理，降低日常报销管理工作的工作强度，提高工作效率。
  • 应收款管理：对订单的应收款进行统计和查询，并自动提醒经办人员跟踪回款。
  • 应付款管理：对费用产生的应付款进行统计和查询，并自动提醒经办人员及时跟踪付款。
  • 统计查询：支持用户按部门、款项类别、相关计划进行相应的统计查询。
  • 与财务软件的接口：本系统可与财务管理系统进行数据交换，实现财务管理扩展功能。
<!-- r.t-->

自定义表单

  • 自定义表单很象我们平时使用的印刷好的表格，可以用来：1.填写表格，2.通过表格执行办理或审批流程。例如：
  • 《请假条》表格，由申请人填表，主管批准，人事部备案，这是一种审批流程表单，包含申请、流程、审批三种应用。
  • 《质量问题报告》表格，由客服填写，技术部/品质部调查，仓库补货，财务核销费用，包含填表、流程两种应用（没有审批）。
  • 《出库单》等各种数据表和电子表格。
  • 自定义表单主要有两种使用场合：
  • 数据自定义表单：这种表单的条目可以任意制定，并可设置权限，没有流程控制；
  • 流程自定义表单：可以灵活实现各种流程功能，流程又分为：1.工作流程，2.审批流程两种应用方式；
  • 自定义表单特点：
  • 具备完整的流程控制和权限管理功能，可以直接应用在审批流程或工作流程控制上；
  • 支持使用明细表，在一项记录中带有多项子记录时，可以使用明细表；
  • 字段可使用系统中的数据表记录建立关系（相当于数据库外键），如产品、客户、成员、项目、订单、采购单等；
  • 可创建流程类型的自定义表单（如生产流程表），或用于数据类型的自定义表单（如销售计划表）
  • 项目管理系统对自定义表单的定义和设置可使用模板来定义，避免管理员花费大量的时间在系统设置工作上。
  • 自定义表单提供直观的自定义表单设计器，用户可以创建无限数量的表单，实现扩充系统初期未设计的各种功能，以适应企业未来的发展需求。
  • 自定义表单极大的扩展了PMS 项目管理系统的应用，通过将各种纸质表格使用PMS系统的表单进行登记、管理，实现规范的表格的填写和存储，通过表单的流程对相关作业进行管理控制，通过报表进行统计、查询。
  • 客户在当前的开发的基础上，可以自己使用自定义表单、自定义字段进行功能的扩充，迅速升级系统的功能，而无须重写代码，也无须了解原来系统的设计细节。
<!-- r.t-->

个人工具

  • 个人办公提供个性化的工作界面，方便用户处理日常的工作事务。
  • 个人设置：
  • 修改系统登录密码；
  • 用户桌面设置、常用菜单设置、风格选择和设置；
  • 个性化定义，包括讨论区昵称、头像、签名文件等的设置；
  • 编辑用户的个人资料，其他用户可以查询用户公开信息（不公开敏感资料）；
  • 个人工作平台：
  • 用户桌面：集中显示成员工作相关的主要信息摘要，使员工及时了解需要办理的各项事务，进行自己的工作日程安排。
  • 邮件收发：通过邮件和短信功能、实现与内部或外部联系人的工作交流。具备的POP3邮件管理功能，可以实现对外部邮箱的管理功能。
  • 个人通讯录：通过个人通讯录可以方便、快捷的实现对于常用联系人的分类管理、综合查询等功能。
  • 内部消息管理：实时短消息功能可以实现员工之间在线实时交流，也可以使用短消息进行提醒闹钟设置功能。
  • 个人日程管理：显示个人日程相关的事件条目，便于用户对日常工作计划进行安排管理。
  • 流程操作：可执行流程申请提交、填写表单、上传附件、流程审批、协办、委办等操作，并可查看流程图。
  • 个人知识库：用来收集和管理个人关心的知识文档。
<!-- r.t-->

邮件系统

  • 邮件系统实现内部、外部邮件收发功能。
  • 与日常使用普通Outlook、Foxmail或Gmail、MSN等常见的邮件收发方式有显著的不同：本系统除了实现内、外邮件的收发外，关键是实现邮件信息的与内部系统的事务相关联，并实现邮件信息的共享。
  • 使用数据库统一存储邮件，收发的邮件自动与客户目录、联系人目录、订单、采购单、项目等系统内部表记录关联起来。
  • 邮件系统的信息共享：避免因某个成员请假或其他原因造成客户邮件丢失或工作停顿的风险。
  • 邮件系统的工作协同：与外部的邮件通常是一项事务（如报价、服务、咨询等事务），统一的邮件系统可以实现事务过程的跟踪、记录和协调。
  • 邮件系统支持使用邮件模板和群发，模板可实现邮件内容和格式的规范，群发可方便向客户或指定的内部、外部对象组发送单一或批量的邮件。
  • 内部邮件可用于内部信息传递，以及系统工作通知的手段，适合企业用户上传、互传文件或信息。
  • （提示：由于强调协作共享，因此不能对邮件的私密内容提供保障）
<!-- r.t-->

业务流程重组

  • PMS 项目管理系统采用工作流组件，用户只需填写有关表单，系统会按照定义好的流程自动往下跑，下一级审批者将会收到相关资料，并可以根据需要修改、跟踪、管理、查询、统计、打印等，大大提高了效率，提升了公司的核心竞争力。
  • 工作流管理系统是一个真正的“人-机”系统，用户是系统中的基本角色，是直接的任务分派对象，他可以直接看到电脑针对自己列出的“任务清单”，跟踪每一项任务的状态，或继续一项任务，而不必从一个模块退出，进入另一个模块，搜索相应任务的线索。
  • 工作流管理是直接面向用户的。这样，用户的任务分派和任务的完成状态，可以被最大程度地受到优化。
  • 工作流的定义借助于图形化工具，依照业务过程实例的情况定义相应工作的安排。
<!-- r.t-->

全文检索

  • 全文检索是从数据库的海量无序的内容中，发现有意义的文章或知识。
  • 企业文档种类繁多，如果没有功能强大的全文检索引擎，这些文档没有利用的价值。
  • 通过数据挖掘技术，对文档和数据进行量化、整理，从而实现基于知识的决策。
  • 在信息时代，获取信息（或文档）是一件非常容易的事，获得有效的信息才是关键中的关键。全文检索技术的目标就是帮助用户实现获取有用的信息。
  • 全文检索技术，可实现与Google相同的搜索引擎功能，不仅仅具有搜索功能，更能根据输入的关键字，找到最佳匹配的文档。
  • 全文检索技术，通过数据向量化分析，可对文本信息进行度量，在信息度量基础上建立的搜索引擎，不是简单文字的搜索，而是经过优化的与主题相关度的搜索引擎。
  • 全文检索技术，能根据不同的知识特征进行分类，采用多种类型的数据库进行分布式存储，能对各种结构的知识进行统一集成。
  • 全文检索技术，能以各种手段为普通用户提供便捷的知识查询，返回有用的结果，同时能在查询中起到导航作用。
<!-- r.t-->

报表图表

  • PMS 项目管理系统分析和报告工具，为企业管理者进行各种商业知识分析决策支持。
  • 在一个充分集成的信息化环境中，信息管理相对比较容易理解，这样公司内的每个人都可以更快地制定或执行更合理的决策。
  • 系统的报表采用Microsoft Reporting Services高级报表技术，可以方便产生各种报表，报表可以在线浏览报表，或输出为Word、Excel等常见的文件格式。
  • 报表的内容可以系统中的任何记录都可以产生报表，也可以是各处室每月固定上报的月工作动态，报表的格式可以在具体实施时根据内容定制。
  • 报表可以以图表的形式对系统中的数据进行统计分析，图表模式的报表可以更直观在表现数据分析的结果。
<!-- r.t-->

系统后台

  • 系统管理员通过通过系统后台进行系统的设置和管理。
  • 系统管理员可查看系统日志、系统资源情况等信息。
  • 系统管理员可进行密码恢复或加密文档的解密操作。
<!-- r.t-->

机构成员

  • 建立单位的组织机构体系，为单位的成员指定所属的部门、职位。
  • 组织机构是PMS 项目管理系统的基础架构之一，系统的任务分配、审批流程等均需要依赖于组织机构的信息。
  • 首次安装系统后，通过机构成员中的功能，建立起组织机构的结构。
  • PMS 项目管理系统支持动态绘制组织机构图。
<!-- r.t-->

系统设置

  • 系统设置包括：机构、角色、权限、成员、字典、属性、分类、流程、表单、菜单、语言、界面、配色、模板等系统需要的基础属性数据。
  • 系统设置维护为管理员提供一个方便的工具进行基础数据的录入和维护。
  • 管理员可以使用批处理工具一次编辑大量的数据，提高工作效率。


小P 2009-05-18 10:16 发表评论
]]>用Acegi为你的Spring应用加把锁！http://www.blogjava.net/xpsir/articles/271245.html小P小PMon, 18 May 2009 02:09:00 GMThttp://www.blogjava.net/xpsir/articles/271245.htmlhttp://www.blogjava.net/xpsir/comments/271245.htmlhttp://www.blogjava.net/xpsir/articles/271245.html#Feedback0http://www.blogjava.net/xpsir/comments/commentRss/271245.htmlhttp://www.blogjava.net/xpsir/services/trackbacks/271245.html
 

简介

对于一个典型的Web应用，完善的认证和授权机制是必不可少的，在SpringFramework中，Juergen Hoeller提供的范例JPetStore给了一些这方面的介绍，但还远远不够，Acegi是一个专门为SpringFramework提供安全机制的项目，全称为Acegi Security System for Spring，当前版本为0.5.1，就其目前提供的功能，应该可以满足绝大多数应用的需求。

本文的主要目的是希望能够说明如何在基于Spring构架的Web应用中使用Acegi，而不是详细介绍其中的每个接口、每个类。注意，即使对已经存在的Spring应用，通过下面介绍的步骤，也可以马上享受到Acegi提供的认证和授权。

基础工作

在你的Web应用的lib中添加Acegi下载包中的acegi-security.jar

web.xml

实现认证和授权的最常用的方法是通过filter，Acegi亦是如此，通常Acegi需要在web.xml添加以下5个filter：

																						
<filter> 
  <filter-name>Acegi Channel Processing Filter</filter-name> 
  <filter-class>net.sf.acegisecurity.util.FilterToBeanProxy</filter-class> 
  <init-param> 
    <param-name>targetClass</param-name> 
    <param-value>net.sf.acegisecurity.securechannel.ChannelProcessingFilter</param-value> 
  </init-param> 
</filter> 
<filter> 
  <filter-name>Acegi Authentication Processing Filter</filter-name> 
  <filter-class>net.sf.acegisecurity.util.FilterToBeanProxy</filter-class> 
  <init-param> 
    <param-name>targetClass</param-name> 
    <param-value>net.sf.acegisecurity.ui.webapp.AuthenticationProcessingFilter</param-value> 
  </init-param> 
</filter> 
<filter> 
  <filter-name>Acegi HTTP BASIC Authorization Filter</filter-name> 
  <filter-class>net.sf.acegisecurity.util.FilterToBeanProxy</filter-class> 
  <init-param> 
    <param-name>targetClass</param-name> 
    <param-value>net.sf.acegisecurity.ui.basicauth.BasicProcessingFilter</param-value> 
  </init-param> 
</filter> 
<filter> 
  <filter-name>Acegi Security System for Spring Auto Integration Filter</filter-name> 
  <filter-class>net.sf.acegisecurity.ui.AutoIntegrationFilter</filter-class> 
</filter> 
<filter> 
  <filter-name>Acegi HTTP Request Security Filter</filter-name> 
  <filter-class>net.sf.acegisecurity.util.FilterToBeanProxy</filter-class> 
  <init-param> 
    <param-name>targetClass</param-name> 
    <param-value>net.sf.acegisecurity.intercept.web.SecurityEnforcementFilter</param-value> 
  </init-param> 
</filter>

最先引起迷惑的是net.sf.acegisecurity.util.FilterToBeanProxy，Acegi自己的文档上解释是：“What  FilterToBeanProxy does is delegate the Filter's methods through to a bean which is obtained from the Spring application context. This enables the bean to benefit from the Spring application context lifecycle support and configuration flexibility.”，如希望深究的话，去看看源代码应该不难理解。

再下来就是添加filter-mapping了：

																						
<filter-mapping> 
  <filter-name>Acegi Channel Processing Filter</filter-name> 
  <url-pattern>/*</url-pattern> 
</filter-mapping> 
<filter-mapping> 
  <filter-name>Acegi Authentication Processing Filter</filter-name> 
  <url-pattern>/*</url-pattern> 
</filter-mapping> 
<filter-mapping> 
  <filter-name>Acegi HTTP BASIC Authorization Filter</filter-name> 
  <url-pattern>/*</url-pattern> 
</filter-mapping> 
<filter-mapping> 
  <filter-name>Acegi Security System for Spring Auto Integration Filter</filter-name> 
  <url-pattern>/*</url-pattern> 
</filter-mapping> 
<filter-mapping> 
  <filter-name>Acegi HTTP Request Security Filter</filter-name> 
  <url-pattern>/*</url-pattern> 
</filter-mapping>
 
这里，需要注意以下三点： 
1) 这几个filter的顺序是不能更改的，顺序不对将无法正常工作； 
2) 如果你的应用不需要安全传输，如https，则将"Acegi Channel Processing Filter"相关内容注释掉即可； 
3) 如果你的应用不需要Spring提供的远程访问机制，如Hessian and Burlap，将"Acegi HTTP BASIC Authorization Filter"相关内容注释掉即可。

#p#

applicationContext.xml

接下来就是要添加applicationContext.xml中的内容了，从刚才FilterToBeanFactory的解释可以看出，真正的filter都在Spring的applicationContext中管理：

1)首先，你的数据库中必须具有保存用户名和密码的table，Acegi要求table的schema必须如下：

CREATE TABLE users ( 
    username VARCHAR(50) NOT NULL PRIMARY KEY, 
    password VARCHAR(50) NOT NULL, 
    enabled BIT NOT NULL 
); 
CREATE TABLE authorities ( 
    username VARCHAR(50) NOT NULL, 
    authority VARCHAR(50) NOT NULL 
); 
CREATE UNIQUE INDEX ix_auth_username ON authorities ( username, authority ); 
ALTER TABLE authorities ADD CONSTRAINT fk_authorities_users foreign key (username) 
REFERENCES users 
(username);

2)添加访问你的数据库的datasource和Acegi的jdbcDao，如下：

<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource"> 
  <property name="driverClassName"><value>${jdbc.driverClassName}</value></property> 
  <property name="url"><value>${jdbc.url}</value></property> 
  <property name="username"><value>${jdbc.username}</value></property> 
  <property name="password"><value>${jdbc.password}</value></property> 
</bean> 
<bean id="jdbcDaoImpl" class="net.sf.acegisecurity.providers.dao.jdbc.JdbcDaoImpl"> 
  <property name="dataSource"><ref bean="dataSource"/></property> 
</bean>

3)添加DaoAuthenticationProvider：

<bean id="daoAuthenticationProvider" 
class="net.sf.acegisecurity.providers.dao.DaoAuthenticationProvider"> 
  <property name="authenticationDao"><ref bean="authenticationDao"/></property> 
  <property name="userCache"><ref bean="userCache"/></property> 
</bean> 
<bean id="userCache" class="net.sf.acegisecurity.providers.dao.cache.EhCacheBasedUserCache"> 
  <property name="minutesToIdle"><value>5</value></property> 
</bean>

如果你需要对密码加密，则在daoAuthenticationProvider中加入：<property name="passwordEncoder"><ref bean="passwordEncoder"/></property>，Acegi提供了几种加密方法，详细情况可看包net.sf.acegisecurity.providers.encoding

4)添加authenticationManager：

<bean id="authenticationManager" class="net.sf.acegisecurity.providers.ProviderManager"> 
  <property name="providers"> 
    <list> 
      <ref bean="daoAuthenticationProvider"/> 
    </list> 
   </property> 
</bean>

5)添加accessDecisionManager：

 <bean id="accessDecisionManager" class="net.sf.acegisecurity.vote.AffirmativeBased"> 
  <property name="allowIfAllAbstainDecisions"> 
    <value>false</value> 
  </property> 
  <property name="decisionVoters"> 
    <list><ref bean="roleVoter"/></list> 
  </property> 
</bean> 
<bean id="roleVoter" class="net.sf.acegisecurity.vote.RoleVoter"/>

6)添加authenticationProcessingFilterEntryPoint：

<bean id="authenticationProcessingFilterEntryPoint" 
class="net.sf.acegisecurity.ui.webapp.AuthenticationProcessingFilterEntryPoint"> 
  <property name="loginFormUrl"><value>/acegilogin.jsp</value></property> 
  <property name="forceHttps"><value>false</value></property> 
</bean>

其中acegilogin.jsp是登陆页面，一个最简单的登录页面如下：

<%@ taglib prefix='c' uri='http://java.sun.com/jstl/core' %> 
<%@ page import="net.sf.acegisecurity.ui.AbstractProcessingFilter" %> 
<%@ page import="net.sf.acegisecurity.AuthenticationException" %> 
<html> 
  <head> 
    <title>Login</title> 
  </head> 
  <body> 
    <h1>Login</h1> 
    <form action="<c:url value='j_acegi_security_check'/>" method="POST"> 
      <table> 
        <tr><td>User:</td><td><input type='text' name='j_username'></td></tr> 
        <tr><td>Password:</td><td><input type='password' name='j_password'></td></tr> 
        <tr><td colspan='2'><input name="submit" type="submit"></td></tr> 
        <tr><td colspan='2'><input name="reset" type="reset"></td></tr> 
      </table> 
    </form> 
  </body> 
</html>

7)添加filterInvocationInterceptor：

<bean id="filterInvocationInterceptor" 
class="net.sf.acegisecurity.intercept.web.FilterSecurityInterceptor"> 
  <property name="authenticationManager"> 
    <ref bean="authenticationManager"/> 
  </property> 
  <property name="accessDecisionManager"> 
    <ref bean="accessDecisionManager"/> 
  </property> 
  <property name="objectDefinitionSource"> 
    <value> 
      CONVERT_URL_TO_LOWERCASE_BEFORE_COMPARISON 
      \A/sec/administrator.*\Z=ROLE_SUPERVISOR 
      \A/sec/user.*\Z=ROLE_TELLER 
    </value> 
  </property> 
</bean>

这里请注意，要objectDefinitionSource中定义哪些页面需要权限访问，需要根据自己的应用需求进行修改，我上面给出的定义的意思是这样的：

#p#

a. CONVERT_URL_TO_LOWERCASE_BEFORE_COMPARISON意思是在比较请求路径时全部转换为小写 
b. \A/sec/administrator.*\Z=ROLE_SUPERVISOR意思是只有权限为ROLE_SUPERVISOR才能访问/sec/administrator*的页面 
c. \A/sec/user.*\Z=ROLE_TELLER意思是只有权限为ROLE_TELLER的用户才能访问/sec/user*的页面

8)添加securityEnforcementFilter：

<bean id="securityEnforcementFilter" 
class="net.sf.acegisecurity.intercept.web.SecurityEnforcementFilter"> 
  <property name="filterSecurityInterceptor"> 
    <ref bean="filterInvocationInterceptor"/> 
  </property> 
  <property name="authenticationEntryPoint"> 
    <ref bean="authenticationProcessingFilterEntryPoint"/> 
  </property> 
</bean>

9)添加authenticationProcessingFilter：

<bean id="authenticationProcessingFilter" 
class="net.sf.acegisecurity.ui.webapp.AuthenticationProcessingFilter"> 
  <property name="authenticationManager"> 
    <ref bean="authenticationManager"/> 
  </property> 
  <property name="authenticationFailureUrl"> 
    <value>/loginerror.jsp</value> 
  </property> 
  <property name="defaultTargetUrl"> 
    <value>/</value> 
  </property> 
  <property name="filterProcessesUrl"> 
    <value>/j_acegi_security_check</value> 
  </property> 
</bean>

其中authenticationFailureUrl是认证失败的页面。

10)如果需要一些页面通过安全通道的话，添加下面的配置：

<bean id="channelProcessingFilter" 
class="net.sf.acegisecurity.securechannel.ChannelProcessingFilter"> 
  <property name="channelDecisionManager"> 
    <ref bean="channelDecisionManager"/> 
  </property> 
  <property name="filterInvocationDefinitionSource"> 
    <value> 
      CONVERT_URL_TO_LOWERCASE_BEFORE_COMPARISON 
      \A/sec/administrator.*\Z=REQUIRES_SECURE_CHANNEL 
      \A/acegilogin.jsp.*\Z=REQUIRES_SECURE_CHANNEL 
      \A/j_acegi_security_check.*\Z=REQUIRES_SECURE_CHANNEL 
      \A.*\Z=REQUIRES_INSECURE_CHANNEL 
    </value> 
  </property> 
</bean> 
<bean id="channelDecisionManager" 
class="net.sf.acegisecurity.securechannel.ChannelDecisionManagerImpl"> 
  <property name="channelProcessors"> 
    <list> 
      <ref bean="secureChannelProcessor"/> 
      <ref bean="insecureChannelProcessor"/> 
    </list> 
  </property> 
</bean> 
<bean id="secureChannelProcessor" 
class="net.sf.acegisecurity.securechannel.SecureChannelProcessor"/> 
<bean id="insecureChannelProcessor" 
class="net.sf.acegisecurity.securechannel.InsecureChannelProcessor"/>

缺少了什么？

Acegi目前提供了两种“secure object”，分别对页面和方法进行安全认证管理，我这里介绍的只是利用FilterSecurityInterceptor对访问页面的权限控制，除此之外，Acegi还提供了另外一个Interceptor——MethodSecurityInterceptor，它结合runAsManager可实现对对象中的方法的权限控制，使用方法可参看Acegi自带的文档和contact范例。

最后要说的

本来以为只是说明如何使用Acegi而已，应该非常简单，但真正写起来才发现想要条理清楚的理顺所有需要的bean还是很困难的，但愿我没有遗漏太多东西，如果我的文章有什么遗漏或错误的话，还请参看Acegi自带的quick-start范例，但请注意，这个范例是不能直接拿来用的。


小P 2009-05-18 10:09 发表评论
]]>prototype.js常用函数及其用法http://www.blogjava.net/xpsir/articles/132012.html小P小PTue, 24 Jul 2007 03:26:00 GMThttp://www.blogjava.net/xpsir/articles/132012.htmlhttp://www.blogjava.net/xpsir/comments/132012.htmlhttp://www.blogjava.net/xpsir/articles/132012.html#Feedback0http://www.blogjava.net/xpsir/comments/commentRss/132012.htmlhttp://www.blogjava.net/xpsir/services/trackbacks/132012.html
prototype.js常用函数及其用法
 
prototype.js常用函数:
函数名  解释  举例
 Element.toggle  交替隐藏或显示  Element.toggle(''div1'',''div2'')
 Element.hide  隐藏  Element.hide(''div1'',''div2'')
 Element.show 显示  Element.show(''div1'',''div2'')
 Element.remove  删除  Element.remove(''div1'',''div2'')
 Element.getHeight  取得高度  Element.getHeight(''div1'')
 Toggle.display  和Element.toggle相同  Toggle.display(''div1'',''div2'')
 Insertion.Before  在DIV前插入文字  Insertion.Before(''div1'',''my content'')
 Insertion.After  在DIV后插入文字  Insertion.After(''div1'',''my content'')
 Insertion.Top  在DIV里最前插入文字  Insertion.Top(''div1'',''this is a text'')
 Insertion.Bottom  在DIV里最后插入文字  Insertion.Bottom(''div1'',''this is a text'')
 PeriodicalExecuter  以给定频率调用一段JavaScript  PeridicalExecutor(test, 1)"这里test是Javascript的函数,1是频率(1秒).
 $  取得一个DIV, 相当于getElementById()  $(''div1'')
 Field.clear  清空一个输入框  Field.clear(''textfield1'')
 Field.focus 把 焦点集中在输入框上  Field.focus(''select1'')
 Field.present  判断内容是否为空  alert(Field.present(''textfield1''))"
 Field.select  选择输入框的内容  Field.select(''textfield1'')"
 Field.activate  把 焦点集中在输入框上并选择输入框的内容  Field.activate(''textfield1'')"
 Form.serialize  把表格内容转化成string  
 Form.getElements  取得表格内容为数组形式  
 Form.disable  disable表格所有内容  Form.disable(''form1'') (这个好象不work)
 Form.focusFirstElement  把焦点集中在表格第一个元素上  Form.focusFirstElement(''form1'')
 Form.reset  Reset表格 Form.reset(''form1'')
 Form.Element.getValue  取得表格输入框的值  Form.Element.getValue(''text1'')
 Form.Element.serialize   把表格中输入框内容转化成string  Form.Element.serialize(''text1'')
 $F  等同于Form.Element.getValue()  $F(''text1'')
 Effect.Highlight  高亮特效.  Effect.Highlight(''text1'')
 Effect.Fade  褪色特效  
 Effect.Scale  放大缩小(百分比）

Effect.Scale(''text1'', 200)
这里200 = 200%, 即两倍
 Effect.Squish  消失特效．文字缩小后消失  Effect.Squish(''text1'')
 Effect.Puff  消失特效．文字放大后消失  Effect.Puff(''text1'')
 Effect.Appear  出现特效  
 Effect.ContentZoom  ZOOM特效．  
 Ajax.Request  传送Ajax请求给服务器  Ajax.Request(''http://server/s.php'')
 Ajax.Updater  传送Ajax请求给服务器并用答复的结果更新指定的Container  Ajax.Updater(''text1'',''http://server/s.php'')

      基本用法:prototype.js给每个主要的类都分了一个Class,使用起来很方便.要产生特定的效果,只要用new Class.function(<argument>)就可以了.例如:

<DIV id="div1"><a href="#" onclick="new Element.toggle('div2')">Click Me</a></DIV>
<DIV id="div2">Hello!</DIV>

      当点击Click Me的时候,div2就会交替隐藏或显示.注意,你可以给toggle加上无限个parameter,比如Element.toggle(''div2'',''div3'',''div4'',...)
 


小P 2007-07-24 11:26 发表评论
]]>精通ejbhttp://www.blogjava.net/xpsir/articles/131600.html小P小PSat, 21 Jul 2007 03:20:00 GMThttp://www.blogjava.net/xpsir/articles/131600.htmlhttp://www.blogjava.net/xpsir/comments/131600.htmlhttp://www.blogjava.net/xpsir/articles/131600.html#Feedback0http://www.blogjava.net/xpsir/comments/commentRss/131600.htmlhttp://www.blogjava.net/xpsir/services/trackbacks/131600.html阅读全文

小P 2007-07-21 11:20 发表评论
]]>使用Java实现网络传输数据的压缩http://www.blogjava.net/xpsir/articles/28882.html小P小PSat, 21 Jan 2006 08:07:00 GMThttp://www.blogjava.net/xpsir/articles/28882.htmlhttp://www.blogjava.net/xpsir/comments/28882.htmlhttp://www.blogjava.net/xpsir/articles/28882.html#Feedback0http://www.blogjava.net/xpsir/comments/commentRss/28882.htmlhttp://www.blogjava.net/xpsir/services/trackbacks/28882.html 使用Java实现网络传输数据的压缩 ［ 作者：liudong    转贴自：Matrix    点击数：150    更新时间：2005-6-1    文章录入：sailing ］
本周,我回答了两个使用Java进行数据压缩的问题.

第一个问题是: 我怎样才能压缩那些不在文件中的数据.

第二个问题是: 我以极大的热情阅读了Todd Sundsted的"压缩你的数据,从而提高你的网络应用程序的性能",但是读完后我却有点失望.当我读到文章标题时我很高兴.我想我总算找到了解决问题的办法了.

在我们的公司,我们试图提高一个组织数据的RMI应用程序的性能.服务器端进行了绝大部分的处理和优化.我们花了一年半的时间去提高性能,但是现在看来瓶颈在于数据的传输上.在一天的任何时间内,我们都有可能在客户和服务器之间传送成千上万的数据.

一种可能的解决办法,我建议我们能够在把数据返回给客户端时先压缩这些数据,这在Todd的文章中已经说得很清楚了.但是,文章中的例子却是压缩文件,而不是我们所需要的----对数据进行压缩.

在RMI中的实现中,我们先从数据库取得数据,再把数据放入一个列表中,接着把这个列表返回给客户端,最后再把它们插入JTable中.我想在把数据返回给客户时,首先把列表中的数据压缩,然后在客户端解压缩,最后把数据插入到表格中.

这样的想法可行吗?

A:最近我收到了一些关于Todd的文章的疑问.很多读者看起来对文章中的举例很疑惑.因为文章中的例子是以文件压缩为核心的.

首先回答第一个问题,当你使用ZipInputStream 和 ZipOutputStream 并没有强制你必须使用文件.唯一要注意的是你必须把数据转换为字节数组的形式.

第二个问题比较棘手.在网络中,以RMI方式通信就需要作一些调整了.为了在传送数据之前就让RMI进行数据压缩,你必须创建一个能够压缩数据的新的套接字.然后,当你创建了一个套接字后,你得告诉RMI使用这一套接字.

以下是创建一个RMI形式的套接字的简要步骤:

1:选择或者创建一个新的套接字.(可以参看SUN'S的"创建一个典型的套接字").

2:创建一个服务器端的套接字.

3:创建一个RMIClientSocketFactory

4:创建一个RMIServerSocketFactory

5:创建一个继承了UnicastRemoteObjec的远程对象,从而使用新的factories.

根据这一大致的想法,我们来看每一步如何具体的实现.

步骤1: 创建ZipSocket 

由于要进行Zip压缩,我们重新创建这样的套接字

mport java.io.InputStream;

import java.io.OutputStream;

import java.util.zip.ZipInputStream;

import java.util.zip.ZipOutputStream;

import java.net.Socket;

public class ZipSocket extends Socket {



private InputStream in;

private OutputStream out;



public ZipSocket() { super(); }



public ZipSocket(String host, int port) 

throws IOException {

super(host, port);

}



public InputStream getInputStream() 

throws IOException {

if (in == null) {

in = new ZipInputStream(super.getInputStream());

}

return in;

}



public OutputStream getOutputStream() 

throws IOException {

if (out == null) {

out = new ZipOutputStream(super.getOutputStream());

}

return out;

}



public synchronized void close() throws IOException {

OutputStream o = getOutputStream();

o.flush();

super.close();

}

}





步骤2: 创建ZipServerSocket 



import java.net.ServerSocket;

import java.net.Socket;

import java.io.IOException;



public class ZipServerSocket extends ServerSocket

{

public ZipServerSocket(int port) throws IOException { 

super(port);

}



public Socket accept() throws IOException { 

Socket socket = new ZipSocket();

implAccept(socket);

return socket;

}

}





步骤3:创建ZipClientSocketFactory 

客户端的factory的创建必须遵循以下的形式: 



import java.io.IOException; 

import java.io.Serializable; 

import java.net.Socket; 

import java.rmi.server.RMIClientSocketFactory;



public class ZipClientSocketFactory 

implements RMIClientSocketFactory, Serializable { 

public Socket createSocket(String host, int port) 

throws IOException { 

ZipSocket socket = new ZipSocket(host, port); 

return socket; 

} 

}



步骤4:创建ZipServerSocketFactory 



import java.io.IOException; 

import java.io.Serializable; 

import java.net.ServerSocket; 

import java.rmi.server.RMIServerSocketFactory; 



public class ZipServerSocketFactory 

implements RMIServerSocketFactory, Serializable { 



public ServerSocket createServerSocket(int port) 

throws IOException { 

ZipServerSocket server = new ZipServerSocket(port); 

return server; 

} 

}



步骤5: 创建一个继承了UnicastRemoteObjec的远程对象,从而使用新的factories. 

public class YourRMIObject extends UnicastRemoteObject {



public YourRemoteObject( int port ) {

super( port, new ZipClientSocketFactory(), new ZipServerSocketFactory() );

}



// 剩下的是你自己的程序实现



}



现在你的通信数据得到了压缩.





关于作者:

Tony Sintes 是一个独立咨询人,同时也是First Class Consulting, Inc. 的创始人.这一咨询公司主要致力与对各个不同的企业系统进行量身定制和培训 . 业余时间,Tony 是一个积极的自由作家,同时也是Sams出版的<<21天学通面向对象编程>>的作者 (Sams, 2001; ISBN: 0672321092). 


小P 2006-01-21 16:07 发表评论
]]>qqhttp://www.blogjava.net/xpsir/articles/28022.html小P小PSat, 14 Jan 2006 06:22:00 GMThttp://www.blogjava.net/xpsir/articles/28022.htmlhttp://www.blogjava.net/xpsir/comments/28022.htmlhttp://www.blogjava.net/xpsir/articles/28022.html#Feedback0http://www.blogjava.net/xpsir/comments/commentRss/28022.htmlhttp://www.blogjava.net/xpsir/services/trackbacks/28022.html
与我聊天吧


小P 2006-01-14 14:22 发表评论
]]>oracle+jsp中blob类型存储大文本问题解决方法http://www.blogjava.net/xpsir/articles/23186.html小P小PFri, 09 Dec 2005 10:06:00 GMThttp://www.blogjava.net/xpsir/articles/23186.htmlhttp://www.blogjava.net/xpsir/comments/23186.htmlhttp://www.blogjava.net/xpsir/articles/23186.html#Feedback0http://www.blogjava.net/xpsir/comments/commentRss/23186.htmlhttp://www.blogjava.net/xpsir/services/trackbacks/23186.htmloracle 存储大文本一直是一个棘手的问题。
一、存数据库：
<%@page contentType="text/html; charset=gb2312" language="java" import="java.sql.*" errorPage="" %>
<%
//定义变量
java.sql.Connection conn; //数据库连接对象
String sql;
long id;
ResultSet rs;
Statement stmt,stmt1;

java.sql.DriverManager.registerDriver(new oracle.jdbc.driver.OracleDriver()); //装载JDBC驱动程序
conn = java.sql.DriverManager.getConnection("jdbc:oracle:thin:@192.168.1.2:1521:lqxm","lqxm","lqxm"); //连接数据库

request.setCharacterEncoding("GBK");
String title = request.getParameter("title");
String content = request.getParameter("content");
String sort = request.getParameter("sort");
String type = request.getParameter("type");
String rq = request.getParameter("rq");
String qy = request.getParameter("qy");
//插入数据,此时blob字段中插入的是空值
sql="insert into t_flfg (xlh,title,content,rq,sort,type,qy) ";
sql=sql+"Values(FLFG_SEQ.NEXTVAL,'" + title + "',empty_clob(),'" + rq + "','" + sort + "','" + type + "','" + qy + "')";
stmt=conn.createStatement();
stmt.executeUpdate(sql);
conn.commit();

conn.setAutoCommit(false);
stmt = conn.createStatement(ResultSet.TYPE_SCROLL_SENS99vIVE,ResultSet.CONCUR_UPDATABLE);
//取得刚才插入的ID
sql="select max(xlh) as xlh from t_flfg ";
rs=stmt.executeQuery(sql);
if(rs.next()) {
id=rs.getInt("xlh");
}
rs.close();

sql = "select content from t_flfg where xlh="+id+" for update";
rs = stmt.executeQuery(sql);
if (rs.next()) {
oracle.sql.CLOB clob = (oracle.sql.CLOB)rs.getClob(1);
clob.putString(1, content);
sql = "update t_flfg set content=? where xlh=" + id + ""; //将大文本更新进去，呵呵
PreparedStatement pstmt = conn.prepareStatement(sql);
pstmt.setClob(1, clob);
pstmt.executeUpdate();
}

conn.commit();
stmt.close();
conn.close();
%>

二、检索显示数据：
<%
ResultSet rs = flfgSave.searchOneInfo(request.getParameter("xlh")); //查询数据库获取记录集
rs.next();

int y;
String content = "";
oracle.sql.CLOB clob1;
char ac[] = new char[299];

String title = rs.getString("title");

clob1 = (oracle.sql.CLOB)rs.getObject("content");
Reader reader = clob1.getCharacterStream();
while((y = reader.read(ac, 0, 299)) != -1)
content += new String(ac, 0, y); //这就是取出来的大文本
%>



小P 2005-12-09 18:06 发表评论
]]>应用Java技术开发WAP应用程序http://www.blogjava.net/xpsir/articles/21931.html小P小PWed, 30 Nov 2005 03:42:00 GMThttp://www.blogjava.net/xpsir/articles/21931.htmlhttp://www.blogjava.net/xpsir/comments/21931.htmlhttp://www.blogjava.net/xpsir/articles/21931.html#Feedback0http://www.blogjava.net/xpsir/comments/commentRss/21931.htmlhttp://www.blogjava.net/xpsir/services/trackbacks/21931.html序言：
　　
　　由于前些时间，一些matrixer常问关于j2me中使用Pak文件的问题。本人虽学艺不深，但满怀热心的做了一番探索，现将制作Pak文件的看法和方法公布出来，大家多多提意见。
　　
　　一、什么是Pak文件：
　　
　　Pak文件就是将多个文件打包为一个单独文件，在这个文件中保存着多个文件的数据，当然还有一些描述文件结构的数据。所以将“Pak”作为文件的后缀是一种常规的用法，大家可以自定义其它的文件后缀。
　　
　　二、为什么使用Pak文件：
　　
　　由于MIDP对发布安装的j2me程序大小进行了限制，所以缩小发布程序就意味着能够提供更多的程序或者内容（如图片、音乐）给用户。而通过研究发现zip/jar算法对大文件的压缩率高于对等量的多个小文件的压缩率。
　　
　　当然还有其它方法，这里简单做一下讨论比如使用混淆器ProGuard的“-overloadaggressively”选项使jar文件缩小，但也会导致一些错误，因为这种方法生成jar中的class符合java byte code标准，但是与java语法相悖，严重的可能造成一些jre对Object的序列化错误。
　　
　　所以使用Pak方法将程序中要用到的资源（图片、音乐、文本）组合为单一文件是一个安全有效的方法。而且对于一些商用程序，完全可以在pak文件中对文件数据进行加密，很好的保护了作者和公司的权益。本人的sample中使用了简单的“加减法”加密，对于手机这类设备来讲是一个效率较高的选择。
　　
　　三、Pak文件的结构：
　　
　　大家可以自己设计Pak文件结构，本人这里只是抛砖引玉的作个sample。下面就是本人设计的Pak文件结构：
　　
　　PAK File Header：Pak文件的头部
　　
　　* 签名：6字节char数组 * 版本号：32位float * 文件table数量：32位整数 * 密码行为：8位字节 * 密码：8位字节 * 文件唯一ID：10字节char数组 * 保留位：32位整数(4字节)
　　
　　File Table：Pak文件中包含文件的列表，在一个Pak文件中一个被包含的文件对应一个File Table。
　　
　　* 文件名：30字节char数组 * 文件大小：32位整型 * 文件在pak文件中的位移：32位整数
　　
　　Concatenated File Data：按File Table的顺序连接在一起的文件数据。
　　* 文件数据
　　
　　四、程序框架：
　　
　　说明：由于Pak文件的制作和使用分别要使用两个java应用领域：j2se和j2me，所以本人将PakUtil类制作了2个版本（j2se和j2me）。
　　
　　程序框架如下：
　　1。PakHeader类，定义了Pak文件头。
　　2。PakFileTable类，定义Pak文件table。
　　3。PakUtil类（j2se版），具备两个功能：将多个png图片合成一个Pak文件，并使用简单的加减加密法对其进行加密；从Pak文件中取出png图片，构造byte数组（可以用来构造Image对象）或者写为文件。
　　PakUtil类（j2me版），具备的功能：从Pak文件中取出png图片，构造byte数组（可以用来构造Image对象）。
　　
　　五、PakHeader和PakFileTable类：
　　
　　PakHeader.java：
　　package cn.org.matrix.gmatrix.gameLab.util.pak;/** * Pak文件头： * 结构： *
　　签名：6字节char数组 *　 版本号：32位float *
　　文件table数量：32位整数 *
　　密码行为：8位字节 *　 密码：8位字节 *
　　文件唯一ID：10字节char数组 *
　　保留位：32位整数(4字节) * @author cleverpig * */class PakHeader {
　　//定义文件唯一ID长度
　　public static final int UNIQUEID_LENGTH=10;
　　//定义文件签名长度
　　public static final int SIGNATURE_LENGTH=6;
　　//定义加法运算
　　public static final int ADDITION_CIPHERACTION=0;
　　//定义减法运算
　　public static final int SUBTRACT_CIHOERACTION=1;
　　//文件签名
　　private char[] signature=new char[SIGNATURE_LENGTH];
　　//版本号
　　private float version=0f;
　　//文件table数量
　　private long numFileTableEntries=0;
　　//密码使用方法：在原数据上进行加法还是减法
　　private byte cipherAction=ADDITION_CIPHERACTION;
　　//密码值
　　private byte cipherValue=0x00;
　　//唯一ID
　　private char[] uniqueID=new char[UNIQUEID_LENGTH];
　　//保留的4字节
　　private long reserved=0;
　　public PakHeader(){
　　}
　　/**
　　* 构造方法
　　* @param signature 签名
　　* @param version 版本
　　* @param numFileTableEntries 文件table数量
　　* @param cipherAction 密码使用方法
　　* @param cipherValue 密码值
　　* @param uniqueID 唯一ID
　　* @param reserved 保留的2字节
　　*/
　　public PakHeader(char[] signature,float version,
　　long numFileTableEntries,byte cipherAction,
　　byte cipherValue,char[] uniqueID,long reserved){
　　for(int i=0;i<SIGNATURE_LENGTH;this.signature[i]=signature[i],i++)
　　;
　　this.version=version;
　　this.cipherAction=cipherAction;
　　this.numFileTableEntries=numFileTableEntries;
　　this.cipherValue=cipherValue;
　　for(int i=0;i<UNIQUEID_LENGTH;this.uniqueID[i]=uniqueID[i],i++);
　　this.reserved=reserved;
　　}　　　　　　　　
　　public byte getCipherValue() {
　　return cipherValue;　　　　
　　}
　　public void setCipherValue(byte cipherValue) {
　　this.cipherValue = cipherValue;
　　}
　　public long getNumFileTableEntries() {
　　return numFileTableEntries;
　　}
　　public void setNumFileTableEntries(long numFileTableEntries) {
　　this.numFileTableEntries = numFileTableEntries;
　　}
　　public long getReserved() {
　　return reserved;
　　}
　　public void setReserved(long reserved) {
　　this.reserved = reserved;
　　}
　　public char[] getUniqueID() {
　　return uniqueID;
　　}
　　public void setUniqueID(char[] uniqueID) {
　　for(int i=0;i<UNIQUEID_LENGTH;this.uniqueID[i]=uniqueID[i],i++)
　　;　　　　
　　}　　　　
　　public float getVersion() {
　　return version;
　　}　　　　
　　public void setVersion(float version) {
　　this.version = version;
　　}
　　public byte getCipherAction() {
　　return cipherAction;
　　}
　　public void setCipherAction(byte cipherAction) {
　　this.cipherAction = cipherAction;
　　}
　　public char[] getSignature() {
　　return signature;
　　}
　　public void setSignature(char[] signature) {
　　for(int i=0;i<SIGNATURE_LENGTH;this.signature[i] = signature[i],i++)
　　;　　　　
　　}
　　/**
　　* 返回PakHeader的大小
　　* @return 返回PakHeader的大小
　　*/　　　　
　　public static int size(){
　　return SIGNATURE_LENGTH+4+4+1+1+UNIQUEID_LENGTH+4;
　　}
　　public String toString(){
　　String result="";
　　result+="\t签名:"+new String(this.signature).trim()
　　+"\t版本号:"+this.version
　　+"\t文件table数量:"+this.numFileTableEntries
　　+"\t密码行为:" +this.cipherAction
　　+"\t密码:"+this.cipherValue　　　　　　　　　　　　
　　+"\t文件唯一ID:"+new String(this.uniqueID).trim()　　　　　　　　　　　　+"\t保留位:"+this.reserved;　　　　　　　　
　　return result;　　　　
　　}}
　　
　　PakFileTable.java
　　package cn.org.matrix.gmatrix.gameLab.util.pak;/** * Pak文件table类 * 文件table结构： *
　　文件名：30字节char数组 *
　　文件大小：32位整型 *
　　文件在pak文件中的位移：32位整数 * @author cleverpig * */class PakFileTable {
　　public static final int FILENAME_LENGTH=30;
　　//文件名
　　private char[] fileName=new char[FILENAME_LENGTH];
　　//文件大小
　　private long fileSize=0L;
　　//文件在pak文件中的位移
　　private long offSet=0L;
　　public PakFileTable(){
　　}
　　/**
　　* 构造方法
　　* @param fileName 文件名
　　* @param fileSize 文件大小
　　* @param offSet 文件在Pak文件中的位移
　　*/
　　public PakFileTable(char[] fileName,
　　long fileSize,long offSet){
　　for(int i=0;i<FILENAME_LENGTH;this.fileName[i]=fileName[i],i++)
　　;　　　　　　　　this.fileSize=fileSize;
　　this.offSet=offSet;
　　}
　　public char[] getFileName() {
　　return fileName;
　　}
　　public void setFileName(char[] fileName) {
　　for(int i=0;i<fileName.length;this.fileName[i]=fileName[i],i++)
　　;　　　　
　　}
　　public long getFileSize() {
　　return fileSize;
　　}
　　public void setFileSize(long fileSize) {
　　this.fileSize = fileSize;
　　}
　　public long getOffSet() {
　　return offSet;
　　}
　　public void setOffSet(long offSet) {
　　this.offSet = offSet;
　　}
　　/**
　　* 返回文件Table的大小
　　* @return 返回文件Table的大小
　　*/　　　　
　　public static int size(){
　　return FILENAME_LENGTH+4+4;
　　}
　　public String toString(){
　　return "\t文件名:"+new String(this.fileName).trim()
　　+"\t文件大小:"+this.fileSize
　　+"\t文件位移:"+this.offSet;
　　}}
　　
　　六、PakUtil类（j2se版）：
　　
　　PakUtil.java
　　package cn.org.matrix.gmatrix.gameLab.util.pak;import java.io.*;
　　import java.util.Vector;
　　/** * Pak工具类 * 功能：
　　*1.将多个png图片合成一个Pak文件，并使用简单的加减加密法对其进行加密；
　　* 2.从Pak文件中取出png图片，构造byte数组（可以用来构造Image对象）或者写为文件 * @author cleverpig * */public class PakUtil {
　　public PakUtil(){
　　}
　　/**
　　* 返回文件长度
　　* @param filePath 文件路径
　　* @return 文件长度
　　*/
　　private long getFileSize(String filePath){
　　File file=new File(filePath);
　　return file.length();
　　}
　　/**
　　* 返回文件名
　　* @param filePath 文件路径
　　* @return 文件名
　　*/
　　
　　private String getFileName(String filePath){
　　File file=new File(filePath);
　　return file.getName();
　　}
　　/**
　　* 计算文件位移的起始点
　　* @return 文件位移的起始点
　　*/
　　private long workOutOffsetStart(PakHeader header){
　　//计算出文件头+文件table的长度
　　return PakHeader.size()+header.getNumFileTableEntries()*PakFileTable.size();
　　}
　　/**
　　* 计算文件位移
　　* @param fileIndex 文件序号
　　* @param lastFileOffset 上一个文件位移
　　* @return　文件在pak文件中的位移
　　*/
　　private long workOutNextOffset(long sourceFileSize,long lastFileOffset){
　　return lastFileOffset+sourceFileSize;　　　　
　　}
　　/**
　　* 生成文件table
　　* @param sourceFileName 源文件名
　　* @param sourceFileSize 源文件长度
　　* @param currentFileOffset 当前文件位移
　　* @return 生成的PakFileTable对象
　　*/　　　　
　　private PakFileTable generateFileTable(String sourceFileName,
　　long sourceFileSize,long currentFileOffset){
　　PakFileTable ft=new PakFileTable();
　　ft.setFileName(sourceFileName.toCharArray());
　　ft.setFileSize(sourceFileSize);
　　ft.setOffSet(currentFileOffset);
　　return ft;
　　}
　　/**
　　* 将char字符数组写入到DataOutputStream中
　　* @param toWriteCharArray 被写入的char数组
　　* @param dos DataOutputStream
　　* @throws Exception
　　*/　　　　
　　private void writeCharArray(char[] toWriteCharArray,DataOutputStream dos) throws Exception{
　　for(int i=0;i<toWriteCharArray.length;dos.writeChar(toWriteCharArray[i]),i++);
　　}　　　　　　　　
　　/**
　　* 使用文件头中的密码对数据进行加密
　　* @param buff 被加密的数据
　　* @param buffLength 数据的长度
　　* @param header 文件头
　　*/
　　private void encryptBuff(byte[] buff,int buffLength,PakHeader header){
　　for(int i=0;i<buffLength;i++){
　　switch(header.getCipherAction()){
　　case PakHeader.ADDITION_CIPHERACTION:
　　buff[i]+=header.getCipherValue();
　　break;
　　case PakHeader.SUBTRACT_CIHOERACTION:
　　buff[i]-=header.getCipherValue();
　　break;
　　}
　　}
　　}
　　/**
　　* 使用文件头中的密码对数据进行解密
　　* @param buff 被解密的数据
　　* @param buffLength 数据的长度
　　* @param header 文件头
　　*/
　　private void decryptBuff(byte[] buff,int buffLength,PakHeader header){
　　for(int i=0;i<buffLength;i++){
　　switch(header.getCipherAction()){
　　case PakHeader.ADDITION_CIPHERACTION:
　　buff[i]-=header.getCipherValue();
　　break;
　　case PakHeader.SUBTRACT_CIHOERACTION:
　　buff[i]+=header.getCipherValue();
　　break;
　　}
　　}
　　}
　　/**
　　* 制作Pak文件
　　* @param sourceFilePath 源文件路径数组
　　* @param destinateFilePath 目的文件路径（Pak文件）
　　* @param cipherAction 密码行为
　　* @param cipherValue 密码
　　* @throws Exception
　　*/
　　public void makePakFile(String[] sourceFilePath,
　　String destinateFilePath,PakHeader header) throws Exception{
　　PakFileTable[] fileTable=new PakFileTable[sourceFilePath.length];
　　//计算文件位移起始点
　　long fileOffset=workOutOffsetStart(header);
　　//逐个建立文件table
　　for(int i=0;i<sourceFilePath.length;i++){
　　String sourceFileName=getFileName(sourceFilePath[i]);
　　long sourceFileSize=getFileSize(sourceFilePath[i]);
　　PakFileTable ft=generateFileTable(sourceFileName,sourceFileSize,fileOffset);
　　//计算下一个文件位移
　　fileOffset=workOutNextOffset(sourceFileSize,fileOffset);
　　fileTable[i]=ft;
　　}
　　//写入文件头
　　File wFile=new File(destinateFilePath);
　　FileOutputStream fos=new FileOutputStream(wFile);
　　DataOutputStream dos=new DataOutputStream(fos);
　　writeCharArray(header.getSignature(),dos);
　　dos.writeFloat(header.getVersion());
　　dos.writeLong(header.getNumFileTableEntries());
　　dos.writeByte(header.getCipherAction());
　　dos.writeByte(header.getCipherValue());
　　writeCharArray(header.getUniqueID(),dos);
　　dos.writeLong(header.getReserved());
　　//写入文件table
　　for(int i=0;i<fileTable.length;i++){
　　writeCharArray(fileTable[i].getFileName(),dos);
　　dos.writeLong(fileTable[i].getFileSize());
　　dos.writeLong(fileTable[i].getOffSet());
　　}
　　//写入文件数据
　　for(int i=0;i<fileTable.length;i++){
　　File ftFile=new File(sourceFilePath[i]);
　　FileInputStream ftFis=new FileInputStream(ftFile);
　　DataInputStream ftDis=new DataInputStream(ftFis);
　　byte[] buff=new byte[256];
　　int readLength=0;
　　while((readLength=ftDis.read(buff))!=-1){
　　encryptBuff(buff,readLength,header);
　　dos.write(buff,0,readLength);
　　}
　　ftDis.close();
　　ftFis.close();
　　}
　　dos.close();
　　}
　　/**
　　* 从DataInputStream读取char数组　　　　 * @param dis DataInputStream
　　* @param readLength 读取长度
　　* @return char数组
　　* @throws Exception
　　*/
　　private char[] readCharArray(DataInputStream dis,int readLength) throws Exception{
　　char[] readCharArray=new char[readLength];
　　for(int i=0;i<readLength;i++){
　　readCharArray[i]=dis.readChar();
　　}
　　return readCharArray;
　　}
　　/**
　　* 从PAK文件中读取文件头
　　* @param dis DataInputStream
　　* @return PakHeader
　　* @throws Exception
　　*/
　　private PakHeader readHeader(DataInputStream dis) throws Exception{
　　PakHeader header=new PakHeader();
　　char[] signature=readCharArray(dis,PakHeader.SIGNATURE_LENGTH);
　　header.setSignature(signature);
　　header.setVersion(dis.readFloat());
　　header.setNumFileTableEntries(dis.readLong());
　　header.setCipherAction(dis.readByte());
　　header.setCipherValue(dis.readByte());
　　char[] uniqueID=readCharArray(dis,PakHeader.UNIQUEID_LENGTH);
　　header.setUniqueID(uniqueID);
　　header.setReserved(dis.readLong());
　　return header;
　　}
　　/**
　　* 读取所有的文件table
　　* @param dis DataInputStream
　　* @param fileTableNumber 文件表总数
　　* @return 文件table数组
　　* @throws Exception
　　*/
　　private PakFileTable[] readFileTable(DataInputStream dis,int fileTableNumber) throws Exception{
　　PakFileTable[] fileTable=new PakFileTable[fileTableNumber];
　　for(int i=0;i<fileTableNumber;i++){
　　PakFileTable ft=new PakFileTable();
　　ft.setFileName(readCharArray(dis,PakFileTable.FILENAME_LENGTH));
　　ft.setFileSize(dis.readLong());
　　ft.setOffSet(dis.readLong());
　　fileTable[i]=ft;
　　}　　　　　　　　
　　return fileTable;
　　}
　　/**
　　* 从pak文件读取文件到byte数组
　　* @param dis DataInputStream
　　* @param fileTable PakFileTable
　　* @return byte数组
　　* @throws Exception
　　*/
　　private byte[] readFileFromPak(DataInputStream dis,PakHeader header,PakFileTable fileTable) throws Exception{
　　dis.skip(fileTable.getOffSet()-workOutOffsetStart(header));
　　//
　　int fileLength=(int)fileTable.getFileSize();
　　byte[] fileBuff=new byte[fileLength];
　　int readLength=dis.read(fileBuff,0,fileLength);
　　if (readLength<fileLength){
　　System.out.println("读取数据长度不正确");
　　return null;
　　}
　　else{
　　decryptBuff(fileBuff,readLength,header);
　　return fileBuff;
　　}
　　}
　　/**
　　* 将buffer中的内容写入到文件
　　* @param fileBuff 保存文件内容的buffer
　　* @param fileName 文件名
　　* @param extractDir 文件导出目录
　　* @throws Exception
　　*/
　　private void writeFileFromByteBuffer(byte[] fileBuff,String fileName,String extractDir) throws Exception{
　　String extractFilePath=extractDir+fileName;
　　File wFile=new File(extractFilePath);
　　FileOutputStream fos=new FileOutputStream(wFile);
　　DataOutputStream dos=new DataOutputStream(fos);
　　dos.write(fileBuff);
　　dos.close();
　　fos.close();
　　}
　　/**
　　* 从pak文件中取出指定的文件到byte数组，如果需要的话可以将byte数组写为文件
　　* @param pakFilePath　pak文件路径
　　* @param extractFileName pak文件中将要被取出的文件名
　　* @param writeFile 是否需要将byte数组写为文件
　　* @param extractDir 如果需要的话可以将byte数组写为文件，extractDir为取出数据被写的目录文件
　　* @return byte数组
　　* @throws Exception
　　*/
　　public byte[] extractFileFromPak(String pakFilePath,
　　String extractFileName,boolean writeFile,String extractDir) throws Exception{
　　File rFile=new File(pakFilePath);
　　FileInputStream fis=new FileInputStream(rFile);
　　DataInputStream dis=new DataInputStream(fis);
　　PakHeader header=readHeader(dis);
　　PakFileTable[] fileTable=readFileTable(dis,(int)header.getNumFileTableEntries());
　　boolean find=false;　　　　　　　　int fileIndex=0;
　　for(int i=0;i<fileTable.length;i++){
　　String fileName=new String(fileTable[i].getFileName()).trim();
　　if (fileName.equals(extractFileName)){
　　find=true;
　　fileIndex=i;
　　break;
　　}
　　}
　　if (find==false){
　　System.out.println("没有找到指定的文件");
　　return null;　　　　　　　　
　　}　　　　　　
　　else{
　　byte[] buff=readFileFromPak(dis,header,fileTable[fileIndex]);
　　if (writeFile){
　　writeFileFromByteBuffer(buff,extractFileName,extractDir);
　　}　　　　　　　　　　　　
　　else{
　　dis.close();
　　fis.close();
　　}
　　return buff;
　　}
　　}
　　/**
　　* 从pak文件中取出指定的Pak文件的信息
　　* @param pakFilePath　pak文件路径
　　* @return 装载文件头和文件table数组的Vector
　　* @throws Exception
　　*/
　　public Vector showPakFileInfo(String pakFilePath) throws Exception{
　　File rFile=new File(pakFilePath);
　　FileInputStream fis=new FileInputStream(rFile);
　　DataInputStream dis=new DataInputStream(fis);
　　PakHeader header=readHeader(dis);
　　PakFileTable[] fileTable=readFileTable(dis,(int)header.getNumFileTableEntries());　　　　　　　　Vector result=new Vector();
　　result.add(header);
　　result.add(fileTable);
　　return result;
　　}
　　public static void main(String[] argv) throws Exception{
　　PakUtil pu=new PakUtil();
　　//构造文件头
　　char[] signature=new char[PakHeader.SIGNATURE_LENGTH];
　　signature=new String("012345").toCharArray();
　　char[] uniqueID=new char[PakHeader.UNIQUEID_LENGTH];
　　uniqueID=new String("0123456789").toCharArray();
　　PakHeader header=new PakHeader();
　　header.setSignature(signature);
　　header.setNumFileTableEntries(3);
　　header.setCipherAction((byte)PakHeader.ADDITION_CIPHERACTION);
　　header.setCipherValue((byte)0x0f);
　　header.setUniqueID(uniqueID);
　　header.setVersion(1.0f);
　　header.setReserved(0L);
　　String[] filePathArray={"F:\\eclipse3.1RC3\\workspace\\gmatrixProject_j2se\\testFiles\\apple.png",
　　"F:\\eclipse3.1RC3\\workspace\\gmatrixProject_j2se\\testFiles\\cushaw.png",
　　"F:\\eclipse3.1RC3\\workspace\\gmatrixProject_j2se\\testFiles\\flash.png"};
　　String extractFilePath="F:\\eclipse3.1RC3\\workspace\\gmatrixProject_j2se\\testFiles\\test.pak";
　　//制作Pak文件
　　System.out.println("制作Pak文件...");
　　pu.makePakFile(filePathArray,extractFilePath,header);
　　System.out.println("制作Pak文件完成");
　　//从Pak文件中取出所有的图片文件
　　Vector pakInfo=pu.showPakFileInfo(extractFilePath);
　　header=(PakHeader)pakInfo.elementAt(0);
　　System.out.println("Pak文件信息:");
　　System.out.println("文件头:");
　　System.out.println(header);
　　PakFileTable[] fileTable=(PakFileTable[])pakInfo.elementAt(1);
　　for(int i=0;i<fileTable.length;i++){
　　System.out.println("文件table["+i+"]:");
　　System.out.println(fileTable[i]);
　　}
　　String restoreDir="F:\\eclipse3.1RC3\\workspace\\gmatrixProject_j2se\\testFiles\\extract\\";
　　String restoreFileName=null;
　　byte[] fileBuff=null;
　　for(int i=0;i<fileTable.length;i++){
　　restoreFileName=new String(fileTable[i].getFileName()).trim();
　　System.out.println("从Pak文件中取出"+restoreFileName+"文件...");
　　fileBuff=pu.extractFileFromPak(extractFilePath,restoreFileName,true,restoreDir);
　　System.out.println("从Pak文件中取出"+restoreFileName+"文件保存在"+restoreDir+"目录");
　　}
　　}}
　　
　　七、PakUtil类（j2me版）：
　　
　　PakUtil.java
　　package cn.org.matrix.gmatrix.gameLab.util.pak;
　　import java.io.*;
　　import java.util.Vector;
　　/** * Pak工具类 * 功能： * 从Pak文件中取出png图片，构造byte数组（可以用来构造Image对象） * @author cleverpig * */public class PakUtil {
　　public PakUtil(){
　　}
　　/**
　　* 计算文件位移的起始点
　　* @return 文件位移的起始点
　　*/
　　private long workOutOffsetStart(PakHeader header){
　　//计算出文件头+文件table的长度
　　return PakHeader.size()+header.getNumFileTableEntries()*PakFileTable.size();
　　}
　　/**
　　* 从DataInputStream读取char数组
　　* @param dis DataInputStream
　　* @param readLength 读取长度
　　* @return char数组
　　* @throws Exception
　　*/
　　private char[] readCharArray(DataInputStream dis,int readLength) throws Exception{
　　char[] readCharArray=new char[readLength];
　　for(int i=0;i<readLength;i++){
　　readCharArray[i]=dis.readChar();
　　}
　　return readCharArray;
　　}
　　/**
　　* 从PAK文件中读取文件头
　　* @param dis DataInputStream
　　* @return PakHeader
　　* @throws Exception
　　*/
　　private PakHeader readHeader(DataInputStream dis) throws Exception{
　　PakHeader header=new PakHeader();
　　char[] signature=readCharArray(dis,PakHeader.SIGNATURE_LENGTH);
　　header.setSignature(signature);
　　header.setVersion(dis.readFloat());
　　header.setNumFileTableEntries(dis.readLong());
　　header.setCipherAction(dis.readByte());
　　header.setCipherValue(dis.readByte());
　　char[] uniqueID=readCharArray(dis,PakHeader.UNIQUEID_LENGTH);
　　header.setUniqueID(uniqueID);
　　header.setReserved(dis.readLong());
　　return header;
　　}
　　/**
　　* 读取所有的文件table
　　* @param dis DataInputStream
　　* @param fileTableNumber 文件表总数
　　* @return 文件table数组
　　* @throws Exception
　　*/
　　private PakFileTable[] readFileTable(DataInputStream dis,int fileTableNumber) throws Exception{
　　PakFileTable[] fileTable=new PakFileTable[fileTableNumber];
　　for(int i=0;i<fileTableNumber;i++){
　　PakFileTable ft=new PakFileTable();
　　ft.setFileName(readCharArray(dis,PakFileTable.FILENAME_LENGTH));
　　ft.setFileSize(dis.readLong());
　　ft.setOffSet(dis.readLong());
　　fileTable[i]=ft;
　　}
　　return fileTable;
　　}
　　/**
　　* 从pak文件读取文件到byte数组
　　* @param dis DataInputStream
　　* @param fileTable PakFileTable
　　* @return byte数组
　　* @throws Exception
　　*/　　　　
　　private byte[] readFileFromPak(DataInputStream dis,PakHeader header,PakFileTable fileTable) throws Exception{
　　dis.skip(fileTable.getOffSet()-workOutOffsetStart(header));
　　//
　　int fileLength=(int)fileTable.getFileSize();
　　byte[] fileBuff=new byte[fileLength];
　　int readLength=dis.read(fileBuff,0,fileLength);
　　if (readLength<fileLength){
　　System.out.println("读取数据长度不正确");
　　return null;
　　}
　　else{
　　decryptBuff(fileBuff,readLength,header);
　　}　　　　　　　　
　　return fileBuff;
　　}
　　/**
　　* 使用文件头中的密码对数据进行解密
　　* @param buff 被解密的数据
　　* @param buffLength 数据的长度
　　* @param header 文件头
　　*/
　　private void decryptBuff(byte[] buff,int buffLength,PakHeader header){
　　for(int i=0;i<buffLength;i++){
　　switch(header.getCipherAction()){
　　case PakHeader.ADDITION_CIPHERACTION:
　　buff[i]-=header.getCipherValue();
　　break;
　　case PakHeader.SUBTRACT_CIHOERACTION:
　　buff[i]+=header.getCipherValue();
　　break;
　　}
　　}
　　}
　　/**
　　* 从pak文件中取出指定的文件到byte数组
　　* @param pakResourceURL　pak文件的资源路径
　　* @param extractResourceName pak文件中将要被取出的文件名
　　* @return byte数组　　　　
　　* @throws Exception
　　*/　　　　
　　public byte[] extractResourceFromPak(String pakResourceURL
　　,String extractResourceName) throws Exception{
　　InputStream is=this.getClass().getResourceAsStream(pakResourceURL);
　　DataInputStream dis=new DataInputStream(is);
　　PakHeader header=readHeader(dis);//
　　System.out.println("文件头:");//
　　System.out.println(header);
　　PakFileTable[] fileTable=readFileTable(dis,(int)header.getNumFileTableEntries());//
　　for(int i=0;i<fileTable.length;i++){//
　　System.out.println("文件table["+i+"]:");//
　　System.out.println(fileTable[i]);//
　　}
　　boolean find=false;
　　int fileIndex=0;
　　for(int i=0;i<fileTable.length;i++){
　　String fileName=new String(fileTable[i].getFileName()).trim();
　　if (fileName.equals(extractResourceName)){
　　find=true;
　　fileIndex=i;
　　break;
　　}
　　}
　　if (find==false){
　　System.out.println("没有找到指定的文件");
　　return null;
　　}
　　else{
　　byte[] buff=readFileFromPak(dis,header,fileTable[fileIndex]);
　　return buff;
　　}
　　}
　　/**
　　* 从pak文件中取出指定的Pak文件的信息
　　* @param pakResourcePath　pak文件资源路径
　　* @return 装载文件头和文件table数组的Vector
　　* @throws Exception
　　*/
　　public Vector showPakFileInfo(String pakResourcePath) throws Exception{
　　InputStream is=this.getClass().getResourceAsStream(pakResourcePath);
　　DataInputStream dis=new DataInputStream(is);
　　PakHeader header=readHeader(dis);
　　PakFileTable[] fileTable=readFileTable(dis,(int)header.getNumFileTableEntries());
　　Vector result=new Vector();
　　result.addElement(header);
　　result.addElement(fileTable);
　　return result;
　　}
　　public static void main(String[] argv) throws Exception{
　　PakUtil pu=new PakUtil();
　　String extractResourcePath="/test.pak";
　　//从Pak文件中取出所有的图片文件
　　Vector pakInfo=pu.showPakFileInfo(extractResourcePath);
　　PakHeader header=(PakHeader)pakInfo.elementAt(0);
　　System.out.println("Pak文件信息:");
　　System.out.println("文件头:");
　　System.out.println(header);
　　PakFileTable[] fileTable=(PakFileTable[])pakInfo.elementAt(1);
　　for(int i=0;i<fileTable.length;i++){
　　System.out.println("文件table["+i+"]:");
　　System.out.println(fileTable[i]);
　　}
　　String restoreFileName=null;　　　　　　　
　　byte[] fileBuff=null;
　　for(int i=0;i<fileTable.length;i++){
　　restoreFileName=new String(fileTable[i].getFileName()).trim();
　　System.out.println("从Pak文件中取出"+restoreFileName+"文件数据...");
　　fileBuff=pu.extractResourceFromPak(extractResourcePath,restoreFileName);
　　System.out.println("从Pak文件中取出"+restoreFileName+"文件数据完成");
　　}　　　
　　 }}
　　
　　八、源代码使用简介：
　　
　　Pak过程：j2se版的PakUtil将testFiles目录中的三个png文件Pak成为test.pak文件。
　　UnPak过程：j2se版的PakUtil将testFiles目录中test.pak文件释放到testFiles\extract目录下；j2me版的PakUtil从res目录中的test.pak文件读取出其中所包含的3个png文件数据并装入到byte数据，用来构造Image对象，大家请运行PakUtilTestMIDlet.java便可看到输出的信息。

小P 2005-11-30 11:42 发表评论
]]>3步把您的java程序转换为webservicehttp://www.blogjava.net/xpsir/articles/21929.html小P小PWed, 30 Nov 2005 03:37:00 GMThttp://www.blogjava.net/xpsir/articles/21929.htmlhttp://www.blogjava.net/xpsir/comments/21929.htmlhttp://www.blogjava.net/xpsir/articles/21929.html#Feedback0http://www.blogjava.net/xpsir/comments/commentRss/21929.htmlhttp://www.blogjava.net/xpsir/services/trackbacks/21929.html　　2、写wsdd
　　3、发布
　　
　　剩下的就只有调用了wsdl2java
　　
　　我原来的系统是CICS的，对后台封装了一层，现在用webservice再封装一层，前台页面，控制，数据传输，数据处理统统都可以分开了，爽
　　
　　//以下是从网上找的关于AXIS的入门教程
　　
　　一、Axis安装 1、环境 J2SE SDK 1.3 or 1.4: 我使用 1.4.2 Servlet Container: 我使用的Tomcat 5.0
　　
　　2、到 http://ws.apache.org/Axis/网站下载Axis安装包
　　
　　3、解压缩安装包，将Axis_UNZIP_PATH\Axis-version\webapps下的Axis包拷贝到TOMCAT_HOME\webapps\下，以下约定Axis_HOME为该TOMCAT_HOME\webapps\Axis目录
　　
　　4、启动tomcat,访问http://localhost:8080/Axis 检查安装是否成功
　　
　　5、以上步骤执行成功，可以开发webservice例子了
　　
　　Axis支持三种web service的部署和开发，分别为：
　　
　　1、Dynamic Invocation Interface ( DII)
　　
　　2、Stubs方式
　　
　　3、Dynamic Proxy方式
　　
　　二、编写DII(Dynamic Invocation Interface )方式web服务
　　
　　1.编写服务端程序HelloClient
　　
　　public class HelloClient
　　{
　　public String getName(String name)
　　{
　　return "hello "+name;
　　}
　　}
　　
　　2、将源码拷贝到Axis_HOME下，重命名为 HelloClient.jws
　　
　　3、访问连接http://localhost:8080/Axis/HelloClient.jws?wsdl，页面显示Axis自动生成的wsdl
　　
　　4、编写访问服务的客户端 TestHelloClient.java
　　
　　import org.apache.Axis.client.Call;
　　import org.apache.Axis.client.Service;
　　import javax.xml.namespace.QName;
　　import javax.xml.rpc.ServiceException;
　　import java.net.MalformedURLException;
　　import java.rmi.RemoteException;
　　
　　public class SayHelloClient2
　　{
　　public static void main(String[] args)
　　{
　　try
　　{
　　String endpoint =
　　"http://localhost:8080/Axis/HelloClient.jws";
　　
　　Service service = new Service();
　　Call call = null;
　　
　　call = (Call) service.createCall();
　　
　　call.setOperationName(new QName(
　　"http://localhost:8080/Axis/HelloClient.jws",
　　"getName"));
　　call.setTargetEndpointAddress
　　(new java.net.URL(endpoint));
　　
　　String ret = (String) call.invoke(new Object[]
　　{"zhangsan"});
　　System.out.println("return value is " + ret);
　　}
　　catch (Exception ex)
　　{
　　ex.printStackTrace();
　　}
　　}
　　}
　　
　　三、编写Dynamic Proxy方式访问服务
　　
　　1、编写部署服务端程序，同上边DII方式，本次仍使用上边部署的HelloClient
　　
　　2、编写代理接口
　　
　　public interface HelloClientInterface
　　extends java.rmi.Remote
　　{
　　public String getName(String name)
　　throws java.rmi.RemoteException;
　　}
　　
　　3、编写并执行客户端程序TestHelloClient.java
　　
　　import javax.xml.rpc.Service;
　　import javax.xml.rpc.ServiceFactory;
　　import java.net.URL;
　　import javax.xml.namespace.QName;
　　
　　public class TestHelloClient
　　{
　　public static void main(String[] args)
　　{
　　try
　　{
　　String wsdlUrl =
　　"http://localhost:8080/Axis/HelloClient.jws?wsdl";
　　String nameSpaceUri =
　　"http://localhost:8080/Axis/HelloClient.jws";
　　String serviceName = "HelloClientService";
　　String portName = "HelloClient";
　　
　　ServiceFactory serviceFactory =
　　ServiceFactory.newInstance();
　　Service afService =
　　serviceFactory.createService(new URL(wsdlUrl),
　　new QName(nameSpaceUri, serviceName));
　　HelloClientInterface proxy = (HelloClientInterface)
　　afService.getPort(new QName(
　　nameSpaceUri, portName),
　　HelloClientInterface.class);
　　System.out.println
　　("return value is "+proxy.getName("john") ) ;
　　}catch(Exception ex)
　　{
　　ex.printStackTrace() ;
　　}
　　}
　　}
　　
　　四、编写wsdd发布web服务，编写stub client访问web服务
　　
　　1、编写服务端程序server,SayHello.java，编译server.SayHello.java
　　package server;
　　public class SayHello
　　{
　　public String getName(String name)
　　{
　　return "hello "+name;
　　}
　　}
　　
　　2.编写LogHandler.java
　　import org.apache.Axis.AxisFault;
　　import org.apache.Axis.Handler;
　　import org.apache.Axis.MessageContext;
　　import org.apache.Axis.handlers.BasicHandler;
　　
　　import java.util.Date;
　　
　　public class LogHandler
　　extends BasicHandler
　　{
　　public void invoke
　　(MessageContext msgContext)
　　throws AxisFault
　　{
　　/** Log an access each time
　　we get invoked.
　　*/
　　try {
　　Handler serviceHandler
　　= msgContext.getService();
　　
　　Integer numAccesses =
　　(Integer)serviceHandler.getOption("accesses");
　　if (numAccesses == null)
　　numAccesses = new Integer(0);
　　numAccesses = new Integer
　　(numAccesses.intValue() + 1);
　　Date date = new Date();
　　String result =
　　date + ": service " +
　　msgContext.getTargetService() +
　　" accessed " + numAccesses + " time(s).";
　　serviceHandler.setOption
　　("accesses", numAccesses);
　　System.out.println(result);
　　} catch (Exception e)
　　{
　　throw AxisFault.makeFault(e);
　　}
　　}
　　}
　　
　　3、编写wsdd文件
　　
　　deploy.wsdd
　　<deployment xmlns=
　　"http://xml.apache.org/Axis/wsdd/"
　　xmlns:java=
　　"http://xml.apache.org/Axis/wsdd/providers/java">
　　<handler name="print" type="java:LogHandler"/>
　　<service name="sayhello"
　　provider="java:RPC">
　　<requestFlow>
　　<handler type="print"/>
　　</requestFlow>
　　<parameter name="className"
　　value="server.SayHello"/>
　　<parameter name="allowedMethods"
　　value="*"/>
　　</service>
　　</deployment>
　　
　　3、将编译后的文件拷贝到Axis_HOME/WEB-INF/classes下，如：D:\tomcat\webapps\Axis\WEB-INF\classes
　　
　　4、发布服务：
　　
　　java org.apache.Axis.client.AdminClient deploy.wsdd
　　
　　5、生成client stub文件
　　
　　a:方式1
　　
　　将SayHello.java拷贝到Axis_HOME/下，重命名为SayHello.jws，
　　
　　执行下面的命令生存client stub
　　
　　java org.apache.Axis.wsdl.WSDL2Java
　　-p client　http://localhost:8080
　　/Axis/services/SayHello.jws?wsdl
　　
　　b:方式2
　　
　　执行如下命令生成SayHello.wsdl
　　
　　java org.apache.Axis.wsdl.Java2WSDL
　　-oSayHello.wsdl -lhttp://localhost:8080
　　/Axis/services/SayHello -nsayhello server.SayHello
　　
　　执行如下命令生成client stub
　　
　　java org.apache.Axis.wsdl.WSDL2Java
　　SayHello.wsdl　-p client
　　
　　生成的stub client文件列表为：
　　
　　1.SayHello.java
　　
　　2.SayHelloService.java。
　　
　　3.SayHelloServiceLocator.java
　　
　　4.SayHelloSoapBindingStub.java
　　
　　6、编写客户端程序，编译并执行
　　
　　public class SayHelloClient
　　{
　　public static void main(String[] args)
　　{
　　try
　　{
　　SayHelloService service = new client.
　　SayHelloServiceLocator();
　　client.SayHello_PortType
　　client = service.getSayHello();
　　String retValue=client.getName("zhangsan");
　　System.out.println(retValue);
　　}
　　catch (Exception e)
　　{
　　System.err.println
　　("Execution failed. Exception: " + e);
　　}
　　}
　　}
　　
　　您也可以写server-config.wsdd
　　<?xml version="1.0" encoding="UTF-8"?>
　　<deployment xmlns="http://xml.apache.org/axis/wsdd/"
　　xmlns:java="http://xml.apache.org/axis/wsdd/providers/java">
　　<globalConfiguration>
　　
　　<parameter name="adminPassword" value="admin"/>
　　<parameter name="attachments.implementation"
　　value="org.apache.axis.attachments.AttachmentsImpl"/>
　　<parameter name="sendXsiTypes" value="true"/>
　　<parameter name="sendMultiRefs" value="true"/>
　　<parameter name="sendXMLDeclaration" value="true"/>
　　<parameter name="axis.sendMinimizedElements" value="true"/>
　　
　　<requestFlow>
　　<handler type="java:org.apache.axis.handlers.JWSHandler">
　　<parameter name="scope" value="session"/>
　　</handler>
　　
　　<handler type="java:org.apache.axis.handlers.JWSHandler">
　　<parameter name="scope" value="request"/>
　　<parameter name="extension" value=".jwr"/>
　　</handler>
　　
　　</requestFlow>
　　
　　</globalConfiguration>
　　<handler name="LocalResponder" type="java:org.apache.axis.transport.local.LocalResponder"/>
　　<handler name="URLMapper" type="java:org.apache.axis.handlers.http.URLMapper"/>
　　<handler name="Authenticate" type="java:org.apache.axis.handlers.SimpleAuthenticationHandler"/>
　　<handler name="print" type="java:stub.LogHandler"/>
　　
　　<service name="sayhello" provider="java:RPC">
　　<requestFlow>
　　<handler type="print"/>
　　</requestFlow>
　　<parameter name="className"　 value="stub.server.SayHello"/>
　　<parameter name="allowedMethods"　value="*"/>
　　</service>
　　
　　<transport name="http">
　　<requestFlow>
　　<handler type="URLMapper"/>
　　<handler type="java:org.apache.axis.handlers.http.HTTPAuthHandler"/>
　　</requestFlow>
　　</transport>
　　<transport name="local">
　　<responseFlow>
　　<handler type="LocalResponder"/>
　　</responseFlow>
　　</transport>
　　</deployment>

小P 2005-11-30 11:37 发表评论
]]>