<![CDATA[Greco's Knows-How]]> http://hi.baidu.com http://hi.baidu.com http://img.baidu.com/img/logo-hi.gif http://hi.baidu.com/gaozhiyan zh-cn www.baidu.com 5 <![CDATA[webxml文件]]> <?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd">
<web-app>
<display-name>Sample Application</display-name>
<description>This is a sample application</description>
<filter>
<!--过滤器名，可以随便取，当web应用中有多个过滤器时不允许重名.-->
<filter-name>SampleFilter</filter-name>
<!--具体的过滤器的类的完整的包名+类名。注意：不能写错了。否则容器不能正确的实例化过滤器-->
<filter-class>mypack.SampleFilter</filter-class>
<init-param>
<!-- 参数名 -->
<param-name>initParam1</param-name>
<!-- 参数值 -->
<param-value>2</param-value>
</init-param>
</filter>
<!-- Define the SampleFilter Mapping -->
<filter-mapping>
<!--过滤器名，注意要和上面的<filter-name>里的名字一样。-->
<filter-name>SampleFilter</filter-name>
<!-- 指定过滤器负责过滤的URL。这里指定了*.jsp表示在访问任何一个jsp页面时都会先使用mypack.SampleFilter过滤器进行过滤。如果写成login.jsp.则只有在访问login.jsp时才会调用该过滤器进行过滤。-->
<url-pattern>*.jsp</url-pattern>
</filter-mapping>
<servlet>
<!-- Servlet名字，可以随便取，有多个Servlet时不允许重名-->
<servlet-name>SampleServlet</servlet-name>
<!--指定实现这个Servlet的类。完整的包名+类名-->
<servlet-class>mypack.SampleServlet</servlet-class>
<!--定义Servlet的初始化参数(包括参数名和参数值)一个<servlet>元素里可以有多个<init-param>元素。在Servlet类中通过ServletConfig类的来访问这些参数。
-->
<init-param>
<!-- 参数名 -->
<param-name>initParam1</param-name>
<!-- 参数值 -->
<param-value>2</param-value>
</init-param>
<!--指定当前Web应用启动时装载Servlet的次序。当这个数>=0时，容器会按数值从小到大依次加载。如果数值<0或没有指定，容器将载Web客户首次访问这个Servlet时加载。-->
<load-on-startup>1</load-on-startup>
</servlet>
<!-- Define the SampleServlet Mapping -->
<servlet-mapping>
<!--必须和<servlet>里的<servlet-name>内容一样-->
<servlet-name>SampleServlet</servlet-name>
<!--指定访问这个Servlet的URL。这里给出的是对于整个Web应用的相对URL路径。-->
<url-pattern>/sample</url-pattern>
</servlet-mapping>
<session-config>
<!--设定HttpSession的生命周期。这里以分钟计算。下面的设定指明Session在最长不活动时间为10分钟。过了这个时间，Servlet容器将它作为无效处理。注意这里和程序里指定的计数单位不同，程序里是以秒为单位。<session-config>只有<session-timeout>这个元素-->
<session-timeout>10</session-timeout>
</session-config>
<!—配置会话侦听器，class表示一个HttpSessionListener或HttpSessionActivationListener 或 HttpSessionAttributeListener或HttpSessionBindingListener的实现类。该节点允许多个 -->
<listener>
<listener-class>com.cn.SessionListenerImpl</listener-class>
</listener>
<!-- 在用户访问Web应用时,如果仅给出Web应用的根访问URL，没有指定具体的文件名，容器会调用<weblcome-file-list> 元素里指定的文件清单。<welcome-file-list>里允许有多个<welcome-file>元素，每个元素代表一个文件。容器会先找第一文文件件是否存在，如果存在这把这个文件返回个客户，不再进行其他文件的查找。如果不存在则找第二个文件，依次类推。如果所有文件都不存在，则跑出404错误-->
<welcome-file-list>
<welcome-file>login.jsp</welcome-file>
<welcome-file>index.htm</welcome-file>
</welcome-file-list>
<!-- 设置Web应用引用的自定义标签库。下面的代码定义了一个/mytaglib标签库，它对应的TLD文件为/WEB-INF/mytaglib.tld -->
<taglib>
<taglib-uri>/mytaglib</taglib-uri>
<taglib-location>/WEB-INF/mytaglib.tld</taglib-location>
</taglib>
<!-- 如果Web应用访问了由Servlet容器管理的某个JNDI Resource必须在这里声明对JNDI Resource的引用 -->
<resource-ref>
<!-- 对应用资源的说明 -->
<description>DB Connection</description>
<!-- 指定所引用资源的JNDI名字 -->
<res-ref-name>jdbc/sampleDb</res-ref-name>
<!-- 指定所引用资源的类名字 -->
<res-type>javax.sql.DataSource</res-type>
<!-- 指定管理所引用资源的Manager， 它有两个可选值：Container和Application.Container表示由容器来创建和管理Resource，Application表示由Web应用来管理和创建Resource -->
<res-auth>Container</res-auth>
</resource-ref>
<security-constraint>
<web-resource-collection>
<!-- 这个名字是必须的，由工具使用，别的地方不使用 -->
<web-resource-name>my application</web-resource-name>
<!-- 指定要受约束的资源，至少有一个。可以有多个. -->
<uri-pattern>/*</uri-pattern>
<!-- 描述了度可与URL模式指定的资源哪些方法是受约束的，如果没有<http-method>元素，表示任何角色的人都无法访问任何http的方法   。这里放置了GET方法，表示只有GET方法是受约束的。其他任何角色的人可以访问POST和其他的方法。但不能访问GET方法。-->
<http-method>GET</http-method>
</web-resource-collection>
<!-- 如果没有<auth-constraint>表示所有角色都能访问GET方法，如果是<auth-constraint/>表示任何角色都不能访问GET方法 -->
<auth-constraint>
<!-- 可选的。表示哪些角色能够在指定的资源上调用受约束的方法。这里表示只有拥有Admin和Member角色的人能够访问GET方法
<security-role>>里的<role-name>值一样 -->
<role-name>Admin</role-name>
<role-name>Member</role-name>
</auth-constraint>
</security-constraint>
<!-- 将指定的角色映射到web.xml里 -->
<security-role>
<description>The role that is required to log into the my Application
</description>
<!-- 以下的角色和tomcat-users.xml里的<tomcat-users>里的<role rolename=""/>里的rolename属性值对应 -->
<role-name>Guest</role-name>
<role-name>Admin</role-name>
<role-name>Member</role-name>
</security-role>
<!-- 如果要想进行认证，必须有<login-config>-->
<login-config>
<!-- 认证方式。有4种：BASIC:基本。 DIGEST:摘要。CLIENT-CERT:客户证书(能提供最高强度的认证)。FORM:表单 -->
<auth-method>FORM</auth-method>
<realm-name>
Tomcat Servet Configuraton Form-Based Authentication Area
</realm-name>
<form-login-config>
<form-login-page>/login.jsp</form-login-page>
<form-error-page>/error.jsp</form-error-page>
</form-login-config>
</login-config>
</web-app> 阅读全文
类别：技术_java 查看评论]]> 2009年11月25日 星期三 下午 01:28 http://hi.baidu.com/gaozhiyan/blog/item/6f03ce36490db53b0b55a9a9.html <![CDATA[JS 验证]]> 1:js 字符串长度限制、判断字符长度、js限制输入、限制不能输入、textarea 长度限制
2.:js判断汉字、判断是否汉字 、只能输入汉字
3:js判断是否输入英文、只能输入英文
4:js只能输入数字,判断数字、验证数字、检测数字、判断是否为数字、只能输入数字
5:只能输入英文字符和数字
6: js email验证 、js 判断email 、信箱/邮箱格式验证
7:js字符过滤,屏蔽关键字
8:js密码验证、判断密码
2.1: js 不为空、为空或不是对象 、判断为空、判断不为空
2.2:比较两个表单项的值是否相同
2.3:表单只能为数字和"_",
2.4:表单项输入数值/长度限定
2.5:中文/英文/数字/邮件地址合法性判断
2.6:限定表单项不能输入的字符
2.7表单的自符控制
2.8:form文本域的通用校验函数

1. 长度限制
<script>
function test()
{
if(document.a.b.value.length>50)
{
alert("不能超过50个字符！");
document.a.b.focus();
return false;
}
}
</script>
<form name=a onsubmit="return test()">
<textarea name="b" cols="40" wrap="VIRTUAL" rows="6"></textarea>
<input type="submit" name="Submit" value="check">
</form>

2. 只能是汉字
<input onkeyup="value="/oblog/value.replace(/[^\u4E00-\u9FA5]/g,'')">

3." 只能是英文
<script language=javascript>
function onlyEng()
{
if(!(event.keyCode>=65&&event.keyCode<=90))
event.returnvalue=false;
}
</script>

<input onkeydown="onlyEng();">

4. 只能是数字
<script language=javascript>
function onlyNum()
{
if(!((event.keyCode>=48&&event.keyCode<=57)||(event.keyCode>=96&&event.keyCode<=105)))
//考虑小键盘上的数字键
event.returnvalue=false;
}
</script>

<input onkeydown="onlyNum();">

5. 只能是英文字符和数字
<input onkeyup="value="/oblog/value.replace(/[\W]/g,"'') "onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^\d]/g,''))">

6. 验证油箱格式
<SCRIPT LANGUAGE=javascript RUNAT=Server>
function isEmail(strEmail) {
if (strEmail.search(/^\w+((-\w+)|(\.\w+))*\@[A-Za-z0-9]+((\.|-)[A-Za-z0-9]+)*\.[A-Za-z0-9]+$/) != -1)
return true;
else
alert("oh");
}
</SCRIPT>
<input type=text onblur=isEmail(this.value)>

7. 屏蔽关键字(这里屏蔽***和****)
<script language="javascript1.2">
function test() {
if((a.b.value.indexOf ("***") == 0)||(a.b.value.indexOf ("****") == 0)){
alert(":)");
a.b.focus();
return false;}
}
</script>
<form name=a onsubmit="return test()">
<input type=text name=b>
<input type="submit" name="Submit" value="check">
</form>

8. 两次输入密码是否相同
<FORM METHOD=POST ACTION="">
<input type="password" id="input1">
<input type="password" id="input2">
<input type="button" value="test" onclick="check()">
</FORM>
<script>
function check()
{
with(document.all){
if(input1.value!=input2.value)
{
alert("false")
input1.value = "";
input2.value = "";
}
else document.forms[0].submit();
}
}
</script>
够了吧 :)
屏蔽右键 很酷
oncontextmenu="return false" ondragstart="return false" onselectstart="return false"
加在body中


二

2.1 表单项不能为空

<script language="javascript">
<!--
function CheckForm()
{
if (document.form.name.value.length == 0) {
alert("请输入您姓名!");
document.form.name.focus();
return false;
}
return true;
}
-->
</script>

2.2 比较两个表单项的值是否相同

<script language="javascript">
<!--
function CheckForm()
if (document.form.PWD.value != document.form.PWD_Again.value) {
alert("您两次输入的密码不一样！请重新输入.");
document.ADDUser.PWD.focus();
return false;
}
return true;
}
-->
</script>

2.3 表单项只能为数字和"_",用于电话/银行帐号验证上,可扩展到域名注册等

<script language="javascript">
<!--
function isNumber(String)
{
var Letters = "1234567890-"; //可以自己增加可输入值
var i;
var c;
if(String.charAt( 0 )=='-')
return false;
if( String.charAt( String.length - 1 ) == '-' )
return false;
for( i = 0; i < String.length; i ++ )
{
c = String.charAt( i );
if (Letters.indexOf( c ) < 0)
return false;
}
return true;
}
function CheckForm()
{
if(! isNumber(document.form.TEL.value)) {
alert("您的电话号码不合法！");
document.form.TEL.focus();
return false;
}
return true;
}
-->
</script>


2.4 表单项输入数值/长度限定

<script language="javascript">
<!--
function CheckForm()
{
if (document.form.count.value > 100 || document.form.count.value < 1)
{
alert("输入数值不能小于零大于100!");
document.form.count.focus();
return false;
}
if (document.form.MESSAGE.value.length<10)
{
alert("输入文字小于10!");
document.form.MESSAGE.focus();
return false;
}
return true;
}
//-->
</script>

2.5 中文/英文/数字/邮件地址合法性判断

<SCRIPT LANGUAGE="javascript">
<!--

function isEnglish(name) //英文值检测
{
if(name.length == 0)
return false;
for(i = 0; i < name.length; i++) {
if(name.charCodeAt(i) > 128)
return false;
}
return true;
}

function isChinese(name) //中文值检测
{
if(name.length == 0)
return false;
for(i = 0; i < name.length; i++) {
if(name.charCodeAt(i) > 128)
return true;
}
return false;
}

function isMail(name) // E-mail值检测
{
if(! isEnglish(name))
return false;
i = name.indexOf(" at ");
j = name dot lastIndexOf(" at ");
if(i == -1)
return false;
if(i != j)
return false;
if(i == name dot length)
return false;
return true;
}

function isNumber(name) //数值检测
{
if(name.length == 0)
return false;
for(i = 0; i < name.length; i++) {
if(name.charAt(i) < "0" || name.charAt(i) > "9")
return false;
}
return true;
}

function CheckForm()
{
if(! isMail(form.Email.value)) {
alert("您的电子邮件不合法！");
form.Email.focus();
return false;
}
if(! isEnglish(form.name.value)) {
alert("英文名不合法！");
form.name.focus();
return false;
}
if(! isChinese(form.cnname.value)) {
alert("中文名不合法！");
form.cnname.focus();
return false;
}
if(! isNumber(form.PublicZipCode.value)) {
alert("邮政编码不合法！");
form.PublicZipCode.focus();
return false;
}
return true;
}
//-->
</SCRIPT>

2.6 限定表单项不能输入的字符

<script language="javascript">
<!--

function contain(str,charset)// 字符串包含测试函数
{
var i;
for(i=0;i<charset.length;i++)
if(str.indexOf(charset.charAt(i))>=0)
return true;
return false;
}

function CheckForm()
{
if ((contain(document.form.NAME.value, "%\(\)><")) || (contain(document.form.MESSAGE.value, "%\(\)><")))
{
alert("输入了非法字符");
document.form.NAME.focus();
return false;
}
return true;
}
//-->
</script>

1. 检查一段字符串是否全由数字组成
---------------------------------------
<script language="Javascript"><!--
function checkNum(str){return str.match(/\D/)==null}
alert(checkNum("1232142141"))
alert(checkNum("123214214a1"))
// --></script>

2. 怎么判断是否是字符
---------------------------------------
if (/[^\x00-\xff]/g.test(s)) alert("含有汉字");
else alert("全是字符");

3. 怎么判断是否含有汉字
---------------------------------------
if (escape(str).indexOf("%u")!=-1) alert("含有汉字");
else alert("全是字符");

4. 邮箱格式验证
---------------------------------------
//函数名：chkemail
//功能介绍：检查是否为Email Address
//参数说明：要检查的字符串
//返回值：0：不是 1：是
function chkemail(a)
{ var i=a.length;
var temp = a.indexOf('@');
var tempd = a.indexOf('.');
if (temp > 1) {
if ((i-temp) > 3){
if ((i-tempd)>0){
return 1;
}

}
}
return 0;
}

5. 数字格式验证
---------------------------------------
//函数名：fucCheckNUM
//功能介绍：检查是否为数字
//参数说明：要检查的数字
//返回值：1为是数字，0为不是数字
function fucCheckNUM(NUM)
{
var i,j,strTemp;
strTemp="0123456789";
if ( NUM.length== 0)
return 0
for (i=0;i<NUM.length;i++)
{
j=strTemp.indexOf(NUM.charAt(i));
if (j==-1)
{
//说明有字符不是数字
return 0;
}
}
//说明是数字
return 1;
}

6. 电话号码格式验证
---------------------------------------
//函数名：fucCheckTEL
//功能介绍：检查是否为电话号码
//参数说明：要检查的字符串
//返回值：1为是合法，0为不合法
function fucCheckTEL(TEL)
{
var i,j,strTemp;
strTemp="0123456789-()# ";
for (i=0;i<TEL.length;i++)
{
j=strTemp.indexOf(TEL.charAt(i));
if (j==-1)
{
//说明有字符不合法
return 0;
}
}
//说明合法
return 1;
}

7. 判断输入是否为中文的函数
---------------------------------------
function ischinese(s){
var ret=true;
for(var i=0;i<s.length;i++)
ret=ret && (s.charCodeAt(i)>=10000);
return ret;
}

8. 综合的判断用户输入的合法性的函数
---------------------------------------
<script language="javascript">
//限制输入字符的位数开始
//m是用户输入，n是要限制的位数
function issmall(m,n)
{
if ((m<n) && (m>0))
{
return(false);
}
else
{return(true);}
}

9. 判断密码是否输入一致
---------------------------------------
function issame(str1,str2)
{
if (str1==str2)
{return(true);}
else
{return(false);}
}

10. 判断用户名是否为数字字母下滑线
---------------------------------------
function notchinese(str){
var reg=/[^A-Za-z0-9_]/g
if (reg.test(str)){
return (false);
}else{
return(true); }
}

2.8. form文本域的通用校验函数
---------------------------------------
作用：检测所有必须非空的input文本，比如姓名，账号，邮件地址等等。
该校验现在只针对文本域，如果要针对form里面的其他域对象，可以改变判断条件。

使用方法：在要检测的文本域中加入title文字。文字是在提示信息，你要提示给用户的该字段的中文名。比如要检测用户名
html如下<input name="txt_1" title="姓名">,当然，最好用可视化工具比如dreamweaver什么的来编辑域。
如果要检测数字类型数据的话，再把域的id统一为sz.
javascript判断日期类型比较麻烦，所以就没有做日期类型校验的程序了.高手可以补充。

程序比较草，只是提供一个思路。抛砖引玉！：）
哦，对了，函数调用方法：< form onsubmit="return dovalidate()">

function dovalidate()
{
fm=document.forms[0] //只检测一个form,如果是多个可以改变判断条件
for(i=0;i<fm.length;i++)
{
//检测判断条件，根据类型不同可以修改
if(fm[i].tagName.toUpperCase()=="INPUT" &&fm[i].type.toUpperCase()=="TEXT" && (fm[i].title!=""))

if(fm[i].value="/blog/="")//
{
str_warn1=fm[i].title+"不能为空!";
alert(str_warn1);
fm[i].focus();
return false;
}
if(fm[i].id.toUpperCase()=="SZ")//数字校验
{
if(isNaN(fm[i].value))
{ str_warn2=fm[i].title+"格式不对";
alert(str_warn2);
fm[i].focus();
return false;
}
}
}
return true;
}
 阅读全文
类别：技术_html/css/js 查看评论]]> 2009年11月20日 星期五 下午 05:11 http://hi.baidu.com/gaozhiyan/blog/item/dc1c4f093af212a52fddd4a6.html <![CDATA[专业网站设计师要求]]> 设计师的自信也非常重要的。我一直认为自信来源于专业，专业自信的设计师在与客户沟通中会给客户留下较好或较高的评价，而反之能力与自信缺乏的设计师在与客户沟通中会给客户留下许多误解让客户认为你不够专业，使顾客对设计师对公司同时失去信心。客户通过与设计师进行交谈时了解公司，不论这个设计师在公司地位是高还是低都是代表着公司的整体实力。设计师不够自信就会导致客户对公司的实力表示怀疑。通常造成这种怀疑的原因来自设计师自身。

自我推荐，大多数的设计师在谈判中会从公司的情况谈起，但有一点必须慎记：在介绍公司的同时适当的自我推销，在实际谈判中一般客户最关心的是价格，工程质量和后期服务。所以我们要让客户进一步的了解我们设计师自身的能力及公司的运作方针。

在受金融风暴影响的情况下，价格、质量、后期服务相同的情况下，各家公司都在研究从方方面面下功夫使客户如何选择自己的公司，选择你作为他们的设计师，这就要从我们个人及公司整体优势下手，就要学会如何自我推销，告诉客户告诉自己，你很专业很自信。

交谈中要让客户充分表达他的想法，专业的设计师善于聆听客户的谈话，有助于你了解客户的需要和更多的信息，真实想法，亦有助于建立与客户的相互信任；交谈中应以轻松自如的心态进行表达。过于紧张会减少所提的建设性意见的分量同时也会削弱你的说服力。 阅读全文
类别：网站架构 查看评论]]> 2009年11月17日 星期二 下午 12:01 http://hi.baidu.com/gaozhiyan/blog/item/affd42ecd10883db2e2e2189.html <![CDATA[网站建设规划]]> 一、建设网站的目的与功能（模式）定位
1、为什么要建，为了展示推广企业产品，还是什么原因，还是为了扩展业务等，总得有需求。
2、把握好你的内容，也就是对内容整合，然后确定你的网站功能或是模式（B2B,B2C或是，要定位好最能展示你所需求的模式）。
3、模式确定后，目的就很明确。
4、还要考虑网站发展到一定程度怎么扩展，或是加论坛，或是什么，都要规划好，并不盲目，如果发展情况有变，那是好事情，更有挑战意义，那你的计划还是没有白费，因为有这个计划做基础，你才能分析出更好的计划或是实施更好的计划。
5、强调一点，大多公司因为这个做的很差，没有认真实行明白老板的意思，而导致老板亏死，当然与老板用人有关系，呵呵，本人体会很深。

二、市场分析
1、相关行业市场怎样，有什么趋势特点等，合适在互联网发展不？考虑明白
2、分析竞争对手的市场战略，对手有网站，对手有多少，对手网站大多模式，对手的优势在哪里，缺陷在那里。对手投入的技术人力，要考虑分析，不然你只考虑你的野心，你去死吧。要明白什么事情友好从小做起，不要脱离实际，现在那么多企业倒闭，有的是原因，并不是没原因，经济危机就怎样，别人的公司能过难关，为什么你的不能，你吃什么去了。有点骂过火，但对大家有好处，包括我自己。
3、就是公司自身条件，小公司没有什么的，只要合理，你一样赚大钱。

三、网站技术解决（这个是我不会的，但我懂，不然怎么跟技术员沟通）
1、采用自建服务器，还是租呢，自己选择，总之不要在这里出错。
2、选择操作系统，这方面一定要考虑到投入成本、功能开发、稳定性和安全性，技术员一定要找好，不要告诉我为了省1000块你请个菜鸟，根据你的实际把。
3、采用什么方案，自己开发，还是网上找（电子商务方案）。
4、安全不用我说了吧。
5、相关程序开发：ASP\JSP|CGL、数据库程序等，要决定好。要我选，我选ASP，不为什么，我老公做这块的，方便，技术也好，干嘛不用，哈哈。

四、网站内容规划
1、根据网站的目的和功能规划网站内容，一般企业网站应包括：公司简介、产品介绍、服务内容、价格信息、联系方式、网上定单等基本内容。
2、电子商务类网站要提供会员注册、详细的商品服务信息、信息搜索查询、定单确认、付款、个人信息保密措施、相关帮助等。
3、如果网站栏目比较多，则考虑采用网站编程专人负责相关内容。 注意：网站内容是网站吸引浏览者最重要的因素，无内容或不实用的信息不会吸引匆匆浏览的访客。可事先对人们希望阅读的信息进行调查，并在网站发布后调查人们对网站内容的满意度，以及时调整网站内容。
4、还是那句老话，要什么具体分析好，做好。就算你穿一件很漂亮的衣服，但你思想那样，还是没人看你，女人也一样，就算你漂亮，你没内才，你还是得不到别人肯定。不要自己肯定自己吧，敢自己肯定自己的人一是有内才有能力，二是自大乱夸的人。哈哈

五、网页设计
　1、网页设计美术设计要求，网页美术设计一般要与企业整体形象一致，要符合CI规范。要注意网页色彩、图片的应用及版面规划，保持网页的整体一致性。
　2、在新技术的采用上要考虑主要目标访问群体的分布地域、年龄阶层、网络速度、阅读习惯等。
　3、制定网页改版计划，如半年到一年时间进行较大规模改版等。


六、网站维护
1、很重要一点，前面工作做的好，后面就很简单，但前面没做好，后面维护没有用，真的。不要取巧。
2、服务器及相关软硬件的维护，对可能出现的问题进行评估，制定响应时间。
3、数据库维护，有效地利用数据是网站维护的重要内容，因此数据库的维护要受到重视。
4、内容更新等等。

七、网站测试
不管是内容，还是技术方面，都要测试，经常有这样的事情发生，自己做的网站打不开，用不了。还有守服务器那个死小子在忽悠你，上班在睡觉，或是因为你不懂，他说一些连自己也不懂的问题找借口说是别的原因，马上开除他。哈哈
还有那老板为了节约，可笑的不重视服务器，那你走人，干吗？网站都老挂，还做个屁啊。
1、服务器稳定性、安全性。
　　2、程序及数据库测试。
　　3、网页兼容性测试，如浏览器、显示器。
　　4、根据需要的其他测试。
　　八、网站发布与推广
　　1、网站测试后进行发布的公关，广告活动。
　　2、搜索引掣登记等。

八、网站发布与推广
1、网站测试后进行发布的公关，广告活动。
2、搜索引掣登记等。
3、推广的办法很多，不要局限，不要老土，别人用什么，你就用什么，网络跟时间赛跑，你不要老落后一拍，我在推广方面有自己的见解，但并不是高手，有机会给大家总结下我的特殊方式，健康的。不健康的用上也没用，强调一个很重要的事情，不要以流量为主，内容很重要，内容好，推广自然好，但不要盲目的认为流量就是推广目标
4、推广与销售也要联系在一起，并不是要你把一个人当两个人用，根据你的实际情况来安排，不然谁给你做。别以为招人不难，那要看招什么人。

九、网站建设日程表

十、费用明细

十一、小女子在这里最后强调，从实际出发
初中小学的课没上好没关系，你记住一点，从实际出发，合理安排，只有有市场，把握你的优势，你的网站做的就是成功。就算你严格，也没人怪你，因为你的网站养活很多人。如果不实际，挂掉你的网站是正常，我鄙视做事情不实际的人，因为他有那么好的机会都不知道珍惜，失败是活该。嘴巴很毒的我自己刚开始就是不实际，所以毕业快两年了还没成功，还是个没事业的人，还是一个为别人打工却不知道努力的人，现在醒悟了，还好没晚。

十二、最后再强调，做事情要有狠心
（把女人的毒放在认真做事情上面，成功了没人说你是坏女人，把男人的毒放在事业上，没人说你不是男人）

转自一小女子

阅读全文
类别：网站架构 查看评论]]> 2009年11月17日 星期二 上午 11:57 http://hi.baidu.com/gaozhiyan/blog/item/9c278a1c9fec148186d6b68f.html <![CDATA[网站架构师成长之路]]>
       那么，到底什么是架构师呢？所谓的架构师，应该是一个技术企业的最高技术决策者。他主要负责公司软件产品或软件项目的技术路线与技术框架的制订。好的架构师都是善良的独裁者，具有很强的技术、良好的写作能力、良好的口头表达能力，能够在各个层次进行沟通。从开发人员到架构师的成长应该是阶梯式的，一般来讲开发人员在刚刚开始工作时只能开发简单的独立软件模块，慢慢的随着经验的增长，他开始接触一些相互之间有信息传递的模块，而后来，他会发现自己接到的开发任务已经不是一个独立的单体，这些任务由一些专门的软件部分组成，可能包含数据库，工作流引擎，消息服务等等各种功能模块，可能分布在不同的服务器上，所有的部分协同起来，完成软件功能。而这时候，体系结构的好坏将直接决定了系统的性能和可扩展性，而就在这时候，这名优秀的开发人员也开始思考架构师应该思考的问题了，或者说，他向成长为架构师的道路迈出了一大步。

       什么是架构师最具价值的技能呢？就是要了解不同的知识，做一个“杂家”或者说“博学家”。当然，如果你的数据库技术非常棒，或者你在工作流引擎方面具有不可超越的专家知识，那也是很不错的。好的架构师有好多都是从专家成长过来的。但是，这不是架构师应该做的事情，架构师应该做的是了解所有的东西，既了解技术的宏观面，又了解技术的细节。真正的架构师不仅仅要了解软件，也要了解硬件，在关键的部位使用合适的硬件来取代软件，可以成倍甚至成百倍的提高整个系统的效率。下面我将会以互联网行业对的架构师的要求为例，向大家讲解作为架构师应该具备的知识。

互联网行业是当前最激动人心的行业之一，很多的创新都来自于这个行业，而每一个大型的网站如Google，Yahoo，Myspace等都需要解决一个非常复杂的问题，就是网站的分布式向外扩展(Scale Out)的问题。解决这个问题，需要最优秀的架构师对业务进行剖析，利用软硬件将网站进行重构，甚至根据业务研发相应的分布式技术，解决网站复杂的分布式计算的问题。如果你想在这个行业中成为一名架构师的话，需要至少掌握网络知识，硬件，软件，网站优化等方方面面的知识：

1． 网络知识。
当前的软件已经绝对不是那种仅仅跑在一台单机上的孤立应用了。不仅仅是在互联网行业，任何一个行业的软件，都要求其具有网络功能。因此，网络知识是架构师必备的知识。我们所说的网络知识，不仅仅包括TCP/IP，http等互联网行业常用的软件协议，也包括网络规划，甚至更具体的说，根据网站应用所处的地理环境进行网络规划。比如人们常说：“这世界上最远的距离不是生与死的距离，而是电信到网通的距离”（笑）如果应用是建立在中国的，就要考虑电信用户和网通用户访问网站的速度应该都比较快才可以。这时候的解决方案可能有多种，比如采用CDN（Content Delivery Network内容分发网络）使得网站的内容发布到离用户最近的服务器，又可以采用把服务器放在一些所谓的双线机房中，甚至将几种方案结合起来使用。这些都统统归到网络知识中。做为公司的架构师，要对这些知识都有所了解，才有助于在遇到问题时找到最佳答案。

2． 硬件知识。
了解硬件的极限，是架构师的基本功。我见过一些人，他们的眼中软件硬件都是没有极限的，需要资源就申请，系统性能下降了就买更高级的设备。然而，硬件的性能有很大一部分取决于I/O设备。而这些I/O设备依靠的都是机械物理运动，这种运动是有极限的。因此当资源访问量增大到一定的程度时，这种物理运动将成为瓶颈。比如说，在开发网站的过程中，记录访客的状态是一件很重要的事情，一般来说可以使用HttpSession来记录。而HttpSession的存储问题将是一个很大的挑战，尤其是多机共享Session时，将HttpSession存成文件并通过多机共享或网络备份的方式来解决分布式的问题是常用的方案，然而，架构师必须考虑到这种方案是有I/O极限限制的，很难扩展到超过一定规模的大型网络。同时，架构师应该了解目前最近的硬件发展是否对软件系统会造成一定的影响，比如在多核的条件下是否对软件编程有新的要求，是否会对运行在虚拟机和非虚拟机上的程序有影响等等。

3． 软件知识。
软件知识所包含的范围就更加广泛了。对于互联网行业来讲，架构师要了解操作系统，数据库，应用服务器等各方面的知识。比如说，如果网站使用的操作系统是Linux，就要了解这个Linux版本的性能与局限性，比如说最多可以存放的单个文件为多大。有的数据库的数据是以单个文件来存放的，虽然我们很少见到数据库中的数据多到不能再放入一条记录的情况，但是作为架构师，请时刻注意，这种可能性是有的。而且如果你有幸在一家高速成长的互联网企业中，而你所负责的应用又没有经过优化的话，可能你会很快见到这种现象。这种现象的发生可能是由于操作系统不支持大文件的原因，也可能是数据库不支持大文件。不论如何，架构师应该在这种现象发生之前就把一切都准备好。对数据库中表的拆分是架构师应该遇到的另外一个困难。一般来说增加应用服务器比较简单而增加数据库服务器则是比较复杂的问题，如果一个站点由多个数据库支持，架构师需要考虑如何在保证数据一致的情况下，让多个数据库分担压力。有些解决方案是将数据库的读写分开，使得大多数的查询sql不经过核心数据库，而只是访问数据库的副本，但事实上，这种方式也只能维护规模不大的网站。对于大型的网站来说，把业务分散到不同的数据库中，只共享必要的数据，才是合理的提高网站扩展性的解决方案。

4． 其他知识。
作为系统架构师，可能还需要对分布式系统，负载均衡，网络安全，数据监控等等各方面都有所了解。不仅仅是了解理论知识，也要对相关的产品和业界进展有一定的认识。比如说做负载均衡最好的产品是那种。目前最常用的备份策略是什么，有什么缺点。如何使用缓存，如何做好日志分析等等。

     刚刚谈到的是架构师需要掌握的知识，然而，冰冻三尺非一日之寒。这个过程需要我们慢慢的积累。如果你已经进入到公司进行软件开发，请时刻关注你所开发软件的性能与可扩展性，而不仅仅局限在功能上，时刻想着任何一个简单的问题：我开发的模块如果放在多人并发的环境下会怎样，慢慢的就会有所心得。如果你还是一个在校学生，不要想着自己离架构师这个职位还很遥远。要知道，成为架构师的修炼之路是很长的，甚至可以说是终身的，因此早点进入学习状态，不断修炼自己。在学校期间学好离散数学，数据结构，操作系统，编译原理，体系结构，数据库原理等关键课程，并积极寻找机会到外面实习，增长自己的工作经验。如果有机会去到一些技术主导的公司中工作，就一定不要放弃这种机会，慢慢就会成长起来。最重要的，你会养成关注技术，勤于思考的好习惯。当有一天你发现自己对任何技术难题都可以一眼看到其本质，并能够将其分解为一个个可轻松解决的模块，你会由衷的感觉到知识给你带来的快乐，或许那一天，你已经是一个架构师了。 阅读全文
类别：网站架构 查看评论]]> 2009年11月17日 星期二 上午 11:45 http://hi.baidu.com/gaozhiyan/blog/item/161a0001a3da0d047aec2c87.html <![CDATA[vmweaver 增加第一硬盘磁盘空间]]> F:\VMware>vmware-vdiskmanager -x 20Gb E:\RE-VirtualMachine\Windows" "Server" "20
03" "Enterprise" "Edition.vmdk


Disk expansion completed successfully


类别：技术_其他 查看评论]]> 2009年11月16日 星期一 下午 08:33 http://hi.baidu.com/gaozhiyan/blog/item/4e718bb7a63db8fe30add1f9.html <![CDATA[网址备份]]> 网站优化_搜索引擎优化_seo
http://www.seochat.org/

SEO十万个为什么
http://www.seowhy.com/

SEO论坛
http://www.seobbs.net/


类别：网址 查看评论]]> 2009年11月16日 星期一 下午 06:55 http://hi.baidu.com/gaozhiyan/blog/item/37577f234ba824589922ed39.html <![CDATA[JSP调用JavaBean在网页上动态生成柱状图]]>
　　源程序如下：

//生成图片的 Java Bean
//作者:崔冠宇
//日期:2001-08-24
import java.io.*;
import java.util.*;
import com.sun.image.codec.jpeg.*;
import java.awt.image.*;
import java.awt.*;

public class ChartGraphics {
　BufferedImage image;
　public void createImage(String fileLocation) {
　　try {
　　　FileOutputStream fos = newFileOutputStream(fileLocation);
　　　BufferedOutputStream bos = newBufferedOutputStream(fos);
　　　JPEGImageEncoder encoder =JPEGCodec.createJPEGEncoder(bos);
　　　encoder.encode(image);
　　　bos.close();
　　} catch(Exception e) {
　　　System.out.println(e);
　　}
　}

　public void graphicsGeneration(int h1,int h2,int h3,int h4,inth5) {

　　final int X=10;
　　int imageWidth = 300;//图片的宽度
　　int imageHeight = 300;//图片的高度
　　int columnWidth=30;//柱的宽度
　　int columnHeight=200;//柱的最大高度

　　ChartGraphics chartGraphics = new ChartGraphics();
　　chartGraphics.image = new BufferedImage(imageWidth,imageHeight, BufferedImage.TYPE_INT_RGB);
　　Graphics graphics = chartGraphics.image.getGraphics();
　　graphics.setColor(Color.white);
　　graphics.fillRect(0,0,imageWidth,imageHeight);
　　graphics.setColor(Color.red);
　　graphics.drawRect(X+1*columnWidth, columnHeight-h1,columnWidth, h1);
　　graphics.drawRect(X+2*columnWidth, columnHeight-h2,columnWidth, h2);
　　graphics.drawRect(X+3*columnWidth, columnHeight-h3,columnWidth, h3);
　　graphics.drawRect(X+4*columnWidth, columnHeight-h4,columnWidth, h4);
　　graphics.drawRect(X+5*columnWidth, columnHeight-h5,columnWidth, h5);
　　chartGraphics.createImage('D:\\temp\\chart.jpg');
　}
}


　　解释：createImage(StringfileLocation)方法用于创建JPG图片,参数fileLocation为文件路径

　　graphicsGeneration(int h1,int h2,int h3,int h4,inth5)方法用于绘出图片的内容,参数h1……h5为每一个长方形的高度

　　第二步：创建另一个JavaBean从文本文件中读取数据(每一个长方形的高度)，在实际应用中数据存储在Oracle数据库中

　　源程序如下:

//读取Text文件中数据的 Java Bean
//作者:崔冠宇
//日期:2001-08-24
import java.io.*;
public class GetData {
　int heightArray[] = new int[5];
　public int[] getHightArray() {
　　try {
　　　RandomAccessFile randomAccessFile = new RandomAccessFile　　('d:\\temp\\ColumnHeightArray.txt','r');
　　　for (int i=0;i＜5;i++)
　　　{
　　　　heightArray[i] =Integer.parseInt(randomAccessFile.readLine());
　　　}
　　}
　　catch(Exception e) {
　　　System.out.println(e);
　　}
　　return heightArray;
　}
}

　　解释：getHightArray()用于从文本中读取数据,将文本中的String类型转换为int类型，并以数组类型返回。

　　第三步：创建JSP文件

　　源程序如下：


＜%@ page import='ChartGraphics' %＞
＜%@ page import='GetData' %＞
＜jsp:useBean id='cg'
＜jsp:useBean id='gd'
＜%!
int height[]=new int[5];
%＞
＜%
height=gd.getHightArray();
cg.graphicsGeneration(height[0],height[1],height[2],height[3],height[4]);
%＞
＜html＞
＜body＞
＜imgsrc="http://doc.readmen.com/7/d:\temp\chart.jpg"＞＜/img＞
＜/body＞
＜/html＞

　　JSP首先调用Bean(GetData..class)读取文件中的数据，再调用Bean(ChartGraphics.class)生成图片,最后显示图片。

　　由于文本(ColumnHeightArray.txt)中的数据可以随时变化，因此生成的图片中的5个长方形的高度是随之变化的，从而实现了图片的动态生成.该设计思想还可以用于制作网站的投票系统 阅读全文
类别：技术_java 查看评论]]> 2009年11月03日 星期二 下午 03:22 http://hi.baidu.com/gaozhiyan/blog/item/c7e53024a7a21a21d50742d3.html <![CDATA[java 汉字转拼音]]> /**
#############################################################################
# DESCRIBE 将汉字转化成拼音
# DATE 2006-7-12
# COMPANY FLX
# PORJECT JAVA
#############################################################################
*/
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Set;

public class CnToSpell {
private static LinkedHashMap spellMap = null;

static {
if (spellMap == null) {
   spellMap = newLinkedHashMap(400);
}
initialize();
System.out.println("Chinese transfer SpellDone.");
}

private CnToSpell() {
}

/**
* 获得单个汉字的Ascii.
* @param cn char
* 汉字字符
* @return int
* 错误返回 0,否则返回ascii
*/
public static int getCnAscii(char cn) {
byte[] bytes =(String.valueOf(cn)).getBytes();
if (bytes == null || bytes.length > 2 ||bytes.length <= 0) { //错误
   return 0;
}
if (bytes.length == 1) { //英文字符
   return bytes[0];
}
if (bytes.length == 2) { //中文字符
   int hightByte = 256 +bytes[0];
   int lowByte = 256 +bytes[1];
   int ascii = (256 * hightByte +lowByte) - 256 * 256;
   return ascii;
}
return 0; //错误
}

/**
*返回字符串的全拼,是汉字转化为全拼,其它字符不进行转换
* @param cnStr String
* 字符串
* @return String
* 转换成全拼后的字符串
*/
public static String getFullSpell(String cnStr){
if (null == cnStr || "".equals(cnStr.trim())){
   return cnStr;
}

char[] chars = cnStr.toCharArray();
StringBuffer retuBuf = new StringBuffer();
for (int i = 0, Len = chars.length; i < Len;i++) {
   int ascii =getCnAscii(chars[i]);
   if (ascii == 0) {//取ascii时出错
    retuBuf.append(chars[i]);
   } else {
    String spell= getSpellByAscii(ascii);
    if (spell ==null) {
     retuBuf.append(chars[i]);
    } else{
     retuBuf.append(spell);
    } // end ofif spell == null
   } // end of if ascii <=-20400
} // end of for

return retuBuf.toString();
}

/**
* 根据ASCII码到SpellMap中查找对应的拼音
* @param ascii int
* 字符对应的ASCII
* @return String
*拼音,首先判断ASCII是否>0&<160,如果是返回对应的字符,
*
否则到SpellMap中查找,如果没有找到拼音,则返回null,如果找到则返回拼音.
*/
public static String getSpellByAscii(int ascii){
if (ascii > 0 && ascii < 160) {//单字符
   return String.valueOf((char)ascii);
}

if (ascii < -20319 || ascii > -10247) {//不知道的字符
   return null;
}

Set keySet = spellMap.keySet();
Iterator it = keySet.iterator();

String spell0 = null;
;
String spell = null;

int asciiRang0 = -20319;
int asciiRang;
while (it.hasNext()) {

   spell = (String)it.next();
   Object valObj =spellMap.get(spell);
   if (valObj instanceof Integer){
    asciiRang =((Integer) valObj).intValue();

    if (ascii>= asciiRang0 && ascii < asciiRang) {//区间找到
     return (spell0 == null) ? spell : spell0;
    } else{
     spell0 = spell;
     asciiRang0 = asciiRang;
    }
   }
}

return null;

}

private static void initialize() {
spellPut("a", -20319);
spellPut("ai", -20317);
spellPut("an", -20304);
spellPut("ang", -20295);
spellPut("ao", -20292);
spellPut("ba", -20283);
spellPut("bai", -20265);
spellPut("ban", -20257);
spellPut("bang", -20242);
spellPut("bao", -20230);
spellPut("bei", -20051);
spellPut("ben", -20036);
spellPut("beng", -20032);
spellPut("bi", -20026);
spellPut("bian", -20002);
spellPut("biao", -19990);
spellPut("bie", -19986);
spellPut("bin", -19982);
spellPut("bing", -19976);
spellPut("bo", -19805);
spellPut("bu", -19784);
spellPut("ca", -19775);
spellPut("cai", -19774);
spellPut("can", -19763);
spellPut("cang", -19756);
spellPut("cao", -19751);
spellPut("ce", -19746);
spellPut("ceng", -19741);
spellPut("cha", -19739);
spellPut("chai", -19728);
spellPut("chan", -19725);
spellPut("chang", -19715);
spellPut("chao", -19540);
spellPut("che", -19531);
spellPut("chen", -19525);
spellPut("cheng", -19515);
spellPut("chi", -19500);
spellPut("chong", -19484);
spellPut("chou", -19479);
spellPut("chu", -19467);
spellPut("chuai", -19289);
spellPut("chuan", -19288);
spellPut("chuang", -19281);
spellPut("chui", -19275);
spellPut("chun", -19270);
spellPut("chuo", -19263);
spellPut("ci", -19261);
spellPut("cong", -19249);
spellPut("cou", -19243);
spellPut("cu", -19242);
spellPut("cuan", -19238);
spellPut("cui", -19235);
spellPut("cun", -19227);
spellPut("cuo", -19224);
spellPut("da", -19218);
spellPut("dai", -19212);
spellPut("dan", -19038);
spellPut("dang", -19023);
spellPut("dao", -19018);
spellPut("de", -19006);
spellPut("deng", -19003);
spellPut("di", -18996);
spellPut("dian", -18977);
spellPut("diao", -18961);
spellPut("die", -18952);
spellPut("ding", -18783);
spellPut("diu", -18774);
spellPut("dong", -18773);
spellPut("dou", -18763);
spellPut("du", -18756);
spellPut("duan", -18741);
spellPut("dui", -18735);
spellPut("dun", -18731);
spellPut("duo", -18722);
spellPut("e", -18710);
spellPut("en", -18697);
spellPut("er", -18696);
spellPut("fa", -18526);
spellPut("fan", -18518);
spellPut("fang", -18501);
spellPut("fei", -18490);
spellPut("fen", -18478);
spellPut("feng", -18463);
spellPut("fo", -18448);
spellPut("fou", -18447);
spellPut("fu", -18446);
spellPut("ga", -18239);
spellPut("gai", -18237);
spellPut("gan", -18231);
spellPut("gang", -18220);
spellPut("gao", -18211);
spellPut("ge", -18201);
spellPut("gei", -18184);
spellPut("gen", -18183);
spellPut("geng", -18181);
spellPut("gong", -18012);
spellPut("gou", -17997);
spellPut("gu", -17988);
spellPut("gua", -17970);
spellPut("guai", -17964);
spellPut("guan", -17961);
spellPut("guang", -17950);
spellPut("gui", -17947);
spellPut("gun", -17931);
spellPut("guo", -17928);
spellPut("ha", -17922);
spellPut("hai", -17759);
spellPut("han", -17752);
spellPut("hang", -17733);
spellPut("hao", -17730);
spellPut("he", -17721);
spellPut("hei", -17703);
spellPut("hen", -17701);
spellPut("heng", -17697);
spellPut("hong", -17692);
spellPut("hou", -17683);
spellPut("hu", -17676);
spellPut("hua", -17496);
spellPut("huai", -17487);
spellPut("huan", -17482);
spellPut("huang", -17468);
spellPut("hui", -17454);
spellPut("hun", -17433);
spellPut("huo", -17427);
spellPut("ji", -17417);
spellPut("jia", -17202);
spellPut("jian", -17185);
spellPut("jiang", -16983);
spellPut("jiao", -16970);
spellPut("jie", -16942);
spellPut("jin", -16915);
spellPut("jing", -16733);
spellPut("jiong", -16708);
spellPut("jiu", -16706);
spellPut("ju", -16689);
spellPut("juan", -16664);
spellPut("jue", -16657);
spellPut("jun", -16647);
spellPut("ka", -16474);
spellPut("kai", -16470);
spellPut("kan", -16465);
spellPut("kang", -16459);
spellPut("kao", -16452);
spellPut("ke", -16448);
spellPut("ken", -16433);
spellPut("keng", -16429);
spellPut("kong", -16427);
spellPut("kou", -16423);
spellPut("ku", -16419);
spellPut("kua", -16412);
spellPut("kuai", -16407);
spellPut("kuan", -16403);
spellPut("kuang", -16401);
spellPut("kui", -16393);
spellPut("kun", -16220);
spellPut("kuo", -16216);
spellPut("la", -16212);
spellPut("lai", -16205);
spellPut("lan", -16202);
spellPut("lang", -16187);
spellPut("lao", -16180);
spellPut("le", -16171);
spellPut("lei", -16169);
spellPut("leng", -16158);
spellPut("li", -16155);
spellPut("lia", -15959);
spellPut("lian", -15958);
spellPut("liang", -15944);
spellPut("liao", -15933);
spellPut("lie", -15920);
spellPut("lin", -15915);
spellPut("ling", -15903);
spellPut("liu", -15889);
spellPut("long", -15878);
spellPut("lou", -15707);
spellPut("lu", -15701);
spellPut("lv", -15681);
spellPut("luan", -15667);
spellPut("lue", -15661);
spellPut("lun", -15659);
spellPut("luo", -15652);
spellPut("ma", -15640);
spellPut("mai", -15631);
spellPut("man", -15625);
spellPut("mang", -15454);
spellPut("mao", -15448);
spellPut("me", -15436);
spellPut("mei", -15435);
spellPut("men", -15419);
spellPut("meng", -15416);
spellPut("mi", -15408);
spellPut("mian", -15394);
spellPut("miao", -15385);
spellPut("mie", -15377);
spellPut("min", -15375);
spellPut("ming", -15369);
spellPut("miu", -15363);
spellPut("mo", -15362);
spellPut("mou", -15183);
spellPut("mu", -15180);
spellPut("na", -15165);
spellPut("nai", -15158);
spellPut("nan", -15153);
spellPut("nang", -15150);
spellPut("nao", -15149);
spellPut("ne", -15144);
spellPut("nei", -15143);
spellPut("nen", -15141);
spellPut("neng", -15140);
spellPut("ni", -15139);
spellPut("nian", -15128);
spellPut("niang", -15121);
spellPut("niao", -15119);
spellPut("nie", -15117);
spellPut("nin", -15110);
spellPut("ning", -15109);
spellPut("niu", -14941);
spellPut("nong", -14937);
spellPut("nu", -14933);
spellPut("nv", -14930);
spellPut("nuan", -14929);
spellPut("nue", -14928);
spellPut("nuo", -14926);
spellPut("o", -14922);
spellPut("ou", -14921);
spellPut("pa", -14914);
spellPut("pai", -14908);
spellPut("pan", -14902);
spellPut("pang", -14894);
spellPut("pao", -14889);
spellPut("pei", -14882);
spellPut("pen", -14873);
spellPut("peng", -14871);
spellPut("pi", -14857);
spellPut("pian", -14678);
spellPut("piao", -14674);
spellPut("pie", -14670);
spellPut("pin", -14668);
spellPut("ping", -14663);
spellPut("po", -14654);
spellPut("pu", -14645);
spellPut("qi", -14630);
spellPut("qia", -14594);
spellPut("qian", -14429);
spellPut("qiang", -14407);
spellPut("qiao", -14399);
spellPut("qie", -14384);
spellPut("qin", -14379);
spellPut("qing", -14368);
spellPut("qiong", -14355);
spellPut("qiu", -14353);
spellPut("qu", -14345);
spellPut("quan", -14170);
spellPut("que", -14159);
spellPut("qun", -14151);
spellPut("ran", -14149);
spellPut("rang", -14145);
spellPut("rao", -14140);
spellPut("re", -14137);
spellPut("ren", -14135);
spellPut("reng", -14125);
spellPut("ri", -14123);
spellPut("rong", -14122);
spellPut("rou", -14112);
spellPut("ru", -14109);
spellPut("ruan", -14099);
spellPut("rui", -14097);
spellPut("run", -14094);
spellPut("ruo", -14092);
spellPut("sa", -14090);
spellPut("sai", -14087);
spellPut("san", -14083);
spellPut("sang", -13917);
spellPut("sao", -13914);
spellPut("se", -13910);
spellPut("sen", -13907);
spellPut("seng", -13906);
spellPut("sha", -13905);
spellPut("shai", -13896);
spellPut("shan", -13894);
spellPut("shang", -13878);
spellPut("shao", -13870);
spellPut("she", -13859);
spellPut("shen", -13847);
spellPut("sheng", -13831);
spellPut("shi", -13658);
spellPut("shou", -13611);
spellPut("shu", -13601);
spellPut("shua", -13406);
spellPut("shuai", -13404);
spellPut("shuan", -13400);
spellPut("shuang", -13398);
spellPut("shui", -13395);
spellPut("shun", -13391);
spellPut("shuo", -13387);
spellPut("si", -13383);
spellPut("song", -13367);
spellPut("sou", -13359);
spellPut("su", -13356);
spellPut("suan", -13343);
spellPut("sui", -13340);
spellPut("sun", -13329);
spellPut("suo", -13326);
spellPut("ta", -13318);
spellPut("tai", -13147);
spellPut("tan", -13138);
spellPut("tang", -13120);
spellPut("tao", -13107);
spellPut("te", -13096);
spellPut("teng", -13095);
spellPut("ti", -13091);
spellPut("tian", -13076);
spellPut("tiao", -13068);
spellPut("tie", -13063);
spellPut("ting", -13060);
spellPut("tong", -12888);
spellPut("tou", -12875);
spellPut("tu", -12871);
spellPut("tuan", -12860);
spellPut("tui", -12858);
spellPut("tun", -12852);
spellPut("tuo", -12849);
spellPut("wa", -12838);
spellPut("wai", -12831);
spellPut("wan", -12829);
spellPut("wang", -12812);
spellPut("wei", -12802);
spellPut("wen", -12607);
spellPut("weng", -12597);
spellPut("wo", -12594);
spellPut("wu", -12585);
spellPut("xi", -12556);
spellPut("xia", -12359);
spellPut("xian", -12346);
spellPut("xiang", -12320);
spellPut("xiao", -12300);
spellPut("xie", -12120);
spellPut("xin", -12099);
spellPut("xing", -12089);
spellPut("xiong", -12074);
spellPut("xiu", -12067);
spellPut("xu", -12058);
spellPut("xuan", -12039);
spellPut("xue", -11867);
spellPut("xun", -11861);
spellPut("ya", -11847);
spellPut("yan", -11831);
spellPut("yang", -11798);
spellPut("yao", -11781);
spellPut("ye", -11604);
spellPut("yi", -11589);
spellPut("yin", -11536);
spellPut("ying", -11358);
spellPut("yo", -11340);
spellPut("yong", -11339);
spellPut("you", -11324);
spellPut("yu", -11303);
spellPut("yuan", -11097);
spellPut("yue", -11077);
spellPut("yun", -11067);
spellPut("za", -11055);
spellPut("zai", -11052);
spellPut("zan", -11045);
spellPut("zang", -11041);
spellPut("zao", -11038);
spellPut("ze", -11024);
spellPut("zei", -11020);
spellPut("zen", -11019);
spellPut("zeng", -11018);
spellPut("zha", -11014);
spellPut("zhai", -10838);
spellPut("zhan", -10832);
spellPut("zhang", -10815);
spellPut("zhao", -10800);
spellPut("zhe", -10790);
spellPut("zhen", -10780);
spellPut("zheng", -10764);
spellPut("zhi", -10587);
spellPut("zhong", -10544);
spellPut("zhou", -10533);
spellPut("zhu", -10519);
spellPut("zhua", -10331);
spellPut("zhuai", -10329);
spellPut("zhuan", -10328);
spellPut("zhuang", -10322);
spellPut("zhui", -10315);
spellPut("zhun", -10309);
spellPut("zhuo", -10307);
spellPut("zi", -10296);
spellPut("zong", -10281);
spellPut("zou", -10274);
spellPut("zu", -10270);
spellPut("zuan", -10262);
spellPut("zui", -10260);
spellPut("zun", -10256);
spellPut("zuo", -10254);
}

public static void main(String[] args) {
String str = null;
str = "谢海101普降喜雨";
System.out.println("Spell=" +CnToSpell.getFullSpell(str));

str = "张牙舞爪》。，";
System.out.println("Spell=" +CnToSpell.getFullSpell(str));

str = "啦啦，可耻下场。";
System.out.println("Spell=" +CnToSpell.getFullSpell(str));

str = "猪油，猪八戒。";
System.out.println("Spell=" +CnToSpell.getFullSpell(str));
}

private static void spellPut(String spell, intascii) {
spellMap.put(spell, new Integer(ascii));
}
}

阅读全文
类别：技术_java 查看评论]]> 2009年11月03日 星期二 下午 03:21 http://hi.baidu.com/gaozhiyan/blog/item/9c278a1cc7b82c8186d6b6d3.html <![CDATA[java生成word html 并保存到数据库]]>         匆匆忙忙的就copy上来了，没有做一些删减，有一些多余的东西，有兴趣的朋友可以自行略去。我的注释相对比较清楚，可以按照自己的需求进行组合。
      在操作word的地方使用了jacob(jacob_1.9)，这个工具网上很容易找到，将jacob.dll放置系统Path中，直接放在system32下也可以，jacob.jar放置在classPath中。


代码如下：WordBridge.java

/**
* WordBridge.java
*/
package com.kela.util;

import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.PreparedStatement;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import com.jacob.activeX.ActiveXComponent;
import com.jacob.com.Dispatch;
import com.jacob.com.Variant;
import com.kela.db.PoolingDataSource;

/**
* 说明: 对word的操作<p>
*
* @author  kela.kf@gmail.com
*/
public class WordBridge {

   Log log =LogFactory.getLog("WordBridgt");

   private ActiveXComponentMsWordApp = null;
    privateDispatch document = null;
   
    /**
     * 打开word
     * @param makeVisible, true显示word, false不显示word
     */
    public voidopenWord(boolean makeVisible) {
       if (MsWordApp == null) {
         MsWordApp = new ActiveXComponent("Word.Application");
       }
  
       Dispatch.put(MsWordApp, "Visible", new Variant(makeVisible));
    }

    /**
     * 创建新的文档
     *
     */
   public voidcreateNewDocument() {
       Dispatch documents = Dispatch.get(MsWordApp,"Documents").toDispatch();
       document = Dispatch.call(documents, "Add").toDispatch();
    }

    /**
     * 关闭文档
     */
    public voidcloseDocument() {
      // 0 = wdDoNotSaveChanges
      // -1 = wdSaveChanges
      // -2 = wdPromptToSaveChanges
      Dispatch.call(document, "Close", new Variant(0));
      document = null;
    }

    /**
     * 关闭word
     *
     */
    public voidcloseWord() {
       Dispatch.call(MsWordApp, "Quit");
       MsWordApp = null;
       document = null;
    }

    /**
     * 插入文本
     * @param textToInsert 文本内容
     */
    public voidinsertText(String textToInsert) {
      Dispatch selection = Dispatch.get(MsWordApp,"Selection").toDispatch();
       Dispatch.put(selection, "Text", textToInsert);
    }

    /**
     * 保存文件
     * @param filename
     */
    public voidsaveFileAs(String filename) {
      Dispatch.call(document, "SaveAs", filename);
    }

    /**
     * 将word转换成html
     * @param htmlFilePath
     */
    public voidwordToHtml(String htmlFilePath) {
         Dispatch.invoke(document,"SaveAs",Dispatch.Method, new Object[]{htmlFilePath,new Variant(8)}, newint[1]);
     }

   /**
     * 保存word的同时，保存一个html
     * @param text 需要保存的内容
     * @param wordFilePath word的路径
     * @param htmlFilePath html的路径
     * @throws LTOAException
     */
    public voidwordAsDbOrToHtml(String text, String wordFilePath, StringhtmlFilePath) throws LTOAException {
  
      try {
         openWord(false);
          createNewDocument();
         insertText(text);
         saveFileAs(wordFilePath);
         wordToHtml(htmlFilePath);
     } catch (Exception ex) {
         log.error("错误 - 对word的操作发生错误");
          log.error("原因- " + ex.getMessage());
          thrownew LTOAException(LTOAException.ERR_UNKNOWN,"对word的操作发生错误("
                    + this.getClass().getName() + ".wordAsDbOrToHtml())", ex);
     } finally {
         closeDocument();
          closeWord();
     }
  
}

   /**
    *将word保存至数据库
    * @paramwordFilePath
    * @paramRecordID
    * @throwsLTOAException
    */
    public voidwordAsDatabase(String wordFilePath, String RecordID) throwsLTOAException {

       Connection conn = null;
        PreparedStatementpstmt = null;
        PoolingDataSourcepool = null;
       
       File file = null;
    
       String sql = "";
       try {
           sql = " UPDATE Document_File SET FileBody = ? WHERE RecordID = ?";
            
            pool= new PoolingDataSource();
           conn = pool.getConnection();
        
           file = new File(wordFilePath);
           InputStream is = new FileInputStream(file);
           byte[] blobByte = new byte[is.available()];
            is.read(blobByte);
           is.close();

          pstmt = conn.prepareStatement(sql);
          pstmt.setBinaryStream(1,(new ByteArrayInputStream(blobByte)),blobByte.length);
          pstmt.setString(2, RecordID);
           pstmt.executeUpdate();
     
        } catch (Exception ex) {
            log.error("错误 - 表 Document_File更新数据发生意外错误");
            log.error("原因 - " + ex.getMessage());
            throw new LTOAException(LTOAException.ERR_UNKNOWN,
                   "表Document_File插入数据发生意外错误("
                    + this.getClass().getName() + ".wordAsDatabase())", ex);
          }finally {
             pool.closePrepStmt(pstmt);
             pool.closeConnection(conn);
        }
    }

   /**
    *得到一个唯一的编号
    * @return编号
    */
   public String getRecordID(){
  
     String sRecordID = "";
  
     java.util.Date dt=new java.util.Date();
        long lg=dt.getTime();
        Long ld=new Long(lg);
        sRecordID =ld.toString();
       
        return sRecordID;
    }

   /**
     * 得到保存word和html需要的路径
     * @param systemType 模块类型 givInfo, sw, fw
     * @param fileType 文件类型 doc, html
     * @param recID 文件编号
     * @return 路径
     */
     public String getWordFilePath(String systemType,String fileType, String recID) {
  
       String filePath = "";
  
       File file = newFile(this.getClass().getResource("/").getPath());

       filePath = file.getPath().substring(0, file.getPath().length() -15);
       
       if(systemType.equalsIgnoreCase("govInfo")) {
   
           if(fileType.equalsIgnoreCase("doc"))
               filePath = filePath + "/uploadFiles/govInfo/document/" + recID +".doc";
            else if(fileType.equalsIgnoreCase("htm"))
               filePath = filePath + "/HTML/govInfo/" + recID + ".htm";
        } else if(systemType.equalsIgnoreCase("sw")){
            if(fileType.equalsIgnoreCase("doc"))
              filePath = filePath +"/uploadFiles/sw/document/" + recID + ".doc";
            else if(fileType.equalsIgnoreCase("htm"))
              filePath = filePath + "/HTML/sw/" + recID +".htm";
         } else if(systemType.equalsIgnoreCase("fw")) {
              if(fileType.equalsIgnoreCase("doc"))
                 filePath = filePath + "/uploadFiles/fw/document/" + recID +".doc";
              else if(fileType.equalsIgnoreCase("htm"))
                 filePath = filePath + "/HTML/fw/" + recID + ".htm";
         }
  
        return filePath;
    }
}

阅读全文
类别：技术_java 查看评论]]> 2009年11月03日 星期二 下午 03:20 http://hi.baidu.com/gaozhiyan/blog/item/a78df380f08081dd9023d9d2.html <![CDATA[String InputStream]]> //String转inputStream
1. String --> InputStream
InputStream String2InputStream(String str){
    ByteArrayInputStream stream = new ByteArrayInputStream(str.getBytes());
    return stream;
}

2. InputStream --> String
String inputStream2String(InputStream is){
    BufferedReader in = new BufferedReader(new InputStreamReader(is));
    StringBuffer buffer = new StringBuffer();
    String line = "";
    while ((line = in.readLine()) != null){
      buffer.append(line);
    }
    return buffer.toString();

InputStream inputStream =
postMethod.getResponseBodyAsStream();
BufferedReader in = new BufferedReader(new InputStreamReader(inputStream));
String xml = FileCopyUtils.copyToString(in);

====================================

   try {
    int len = request.getContentLength();
    byte buffer[];
    buffer = new byte[len];
    ServletInputStream in = request.getInputStream();
    int total = 0;
    for (int once = 0; total < len && once >= 0; total += once) {
     once = in.readLine(buffer, total, len);
    }
System.out.println(new String(buffer,"utf-8"));

======================

*
   try {
    InputStream is = request.getInputStream();
    byte buf[] = new byte[3000];
    is.read(buf);
System.out.println(new String(buf,"utf-8"));
   } catch (IOException e) {
   
   }

=============================

        int len = request.getContentLength();
        byte buffer[];
        buffer = new byte[len];
        ServletInputStream in = request.getInputStream();
        int total = 0;
        for (int once = 0; total < len && once >= 0; total += once) {
         once = in.readLine(buffer, total, len);
        }
       
        String temp=new String(buffer,"utf-8");

============================

/**********************************************************************/  
   ByteArrayOutputStream byteOutput= new ByteArrayOutputStream();
        try {       
        BufferedInputStream bufferInput = null;
        bufferInput = new BufferedInputStream(is);
            if(bufferInput==null){
            System.out.println("No data!");
            }
            int length;
            int size = 4096;           
            byte buf[] = new byte[size];
            byteOutput.reset();
            while ((length = bufferInput.read(buf, 0, size)) != -1) {
             byte[] temp = new byte[length];
             for (int i = 0; i < length; i++) {
                 temp[i] = buf[i];
             }
            byteOutput.write(temp);
            }
        } catch (Exception e) {
           e.printStackTrace();
        }      

        String data=byteOutput.toString();

阅读全文
类别：技术_java 查看评论]]> 2009年11月02日 星期一 下午 07:49 http://hi.baidu.com/gaozhiyan/blog/item/4b930da8926706bbca130cd2.html <![CDATA[修改SQL Server 2000数据库名称]]>
EXEC sp_renamedb 'oldDBname', 'newDBname'

EXEC sp_dboption 'newDBname', 'Single User', 'FALSE'

----------------------------------------------

sql server 2000 重命名 、更名、rename
类别：技术_database 查看评论]]> 2009年10月20日 星期二 上午 09:46 http://hi.baidu.com/gaozhiyan/blog/item/4629b8cb1634d3f753664f88.html <![CDATA[Struts,Spring,Hibernate三大框架的面试 笔试题]]> 1.Hibernate工作原理及为什么要用？

原理：
1.读取并解析配置文件
2.读取并解析映射信息，创建SessionFactory
3.打开Sesssion
4.创建事务Transation
5.持久化操作
6.提交事务
7.关闭Session
8.关闭SesstionFactory

为什么要用：
1. 对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码。
2. Hibernate是一个基于JDBC的主流持久化框架，是一个优秀的ORM实现。他很大程度的简化DAO层的编码工作
3. hibernate使用Java反射机制，而不是字节码增强程序来实现透明性。
4. hibernate的性能非常好，因为它是个轻量级框架。映射的灵活性很出色。它支持各种关系数据库，从一对一到多对多的各种复杂关系。

2．Hibernate是如何延迟加载?
1. Hibernate2延迟加载实现：
a)实体对象
b)集合（Collection）
2. Hibernate3 提供了属性的延迟加载功能 当Hibernate在查询数据的时候，数据并没有存在与内存中，当程序真正对数据的操作时，对象才存在与内存中，就实现了延迟加载，他节省了服务器的内存开销，从而提高了服务器的性能。  

3．Hibernate中怎样实现类之间的关系?
(如：一对多、多对多的关系) 类与类之间的关系主要体现在表与表之间的关系进行操作，它们都市对对象进行操作，我们程序中把所有的表与类都映射在一起，它们通过配置文件中的many-to-one、one-to-many、many-to-many

4.Struts1流程：
1、客户端浏览器发出HTTP请求。
2、根据web.xml配置，该请求被ActionServlet接收。
3、根据struts-config.xml配置， ActionServlet先将请求中的参数填充到ActionForm中，然后ActionServlet再将请求发送到Action 进行处理。
4、是否验证，需要验证则调用ActionForm的validate方法，验证失败则跳转到input，成功则继续。
5、Action从ActionForm获得数据，调用javabean 中的业务方法处理数据。
6、Action返回ActionForward对象，跳转到相应JSP页面或Action。
7、返回HTTP响应到客户端浏览器。MVC设计模式：modal：“模型” 也称业务逻辑，是正真完成任务的代码,相当与JavaBeanview：视图，其实就是显示界面，相当于JSPcontroller：控制器，他控制模型和视图的交互过程，相当于servletstruts1是基于MVC设计模式hibernate是基于ORM对象关系映射

5.struts是什么？
struts1是基于JSP和servlet的一个开源的Web应用框架，使用的是MVC的设计模式struts2是基于webwork技术的框架，是sun和webwork公司联手开发的一个功能非常齐全的框架，struts2和struts1没有任何关系，是一个全新的框架

6.spring是什么？
spring是一个集成了许多第三方框架的大杂烩，其核心技术是IOC（控制反转，也称依赖注入）和AOP（面向切面编程）

7.hibernate是什么？
hibernate是基于ORM对象关系映射（完成对象数据到关系数据映射的机制）实现的,做数据持久化的工具

8.JSF是什么？
JavaServer Face是基于组件的web开发框架，跟sturts差不多的框架

9.数据库里面的索引和约束是什么?
索引是为了提高数据的检索速度，索引是建立在数据表上，根据一个或多个字段建立的约束是为了保持数据的完整性，约束有非空约束，主键约束，外键约束等等。

10.spring是什么这个问题，往往可以通过我们为什么要使用spring这个问题来切入：
AOP 让开发人员可以创建非行为性的关注点，称为横切关注点，并将它们插入到应用程序代码中。使用 AOP 后，公共服务 （比 如日志、持久性、事务等）就可以分解成方面并应用到域对象上，同时不会增加域对象的对象模型的复杂性。 IOC 允许创建一个可以构造对象的应用环境，然后向这些对象传递它们的协作对象。正如单词 倒置 所表明的，IOC 就像反 过来的 JNDI。没有使用一堆抽象工厂、服务定位器、单元素（singleton）和直接构造（straight construction），每一个对象都是用其协作对象构造的。因此是由容器管理协作对象（collaborator）。 Spring即使一个AOP框架，也是一IOC容器。 Spring 最好的地方是它有助于您替换对象。有了 Spring，只要用 JavaBean 属性和配置文件加入依赖性（协作对象）。然后可以很容易地在需要时替换具有类似接口的协作对象。

11.用自己的话简要阐述struts2的执行流程。
Struts 2框架本身大致可以分为3个部分：
核心控制器FilterDispatcher、业务控制器Action和用户实现的企业业务逻辑组件。
核心控制器FilterDispatcher是Struts 2框架的基础，包含了框架内部的控制流程和处理机制。
业务控制器Action和业务逻辑组件是需要用户来自己实现的。用户在开发Action和业务逻辑组件的同时，还需要编写相关的配置文件，供核心控制器FilterDispatcher来使用。
Struts 2的工作流程相对于Struts 1要简单，与WebWork框架基本相同，所以说Struts 2是WebWork的升级版本。基本简要流程如下：
1、客户端浏览器发出HTTP请求。
2、根据web.xml配置，该请求被FilterDispatcher接收。
3、根据struts.xml配置，找到需要调用的Action类和方法， 并通过IoC方式，将值注入给Aciton。
4、Action调用业务逻辑组件处理业务逻辑，这一步包含表单验证。
5、Action执行完毕，根据struts.xml中的配置找到对应的返回结果result，并跳转到相应页面。
6、返回HTTP响应到客户端浏览器。

阅读全文
类别：招聘相关 查看评论]]> 2009年10月13日 星期二 上午 11:55 http://hi.baidu.com/gaozhiyan/blog/item/89a236b340d210add8335a97.html <![CDATA[基于 IBM FileNet P8 4.5 平台上 Component Integrator 的原理和应用]]> IBM FileNet P8 platform 为企业内容管理和工作流管理的应用级程序的开发提供了方便快捷的平台和工具，Component Integrator 作为 IBM FileNet Business Process Management 产品的一部分，在一定程度上实现了对整个 FileNet P8 平台功能的扩展。本文详细介绍了 Component Integrator 的架构、原理和用途，并且通过实例演示怎样创建，配置和使用 Component Integrator。

Component Integrator 介绍

Component Integrator 概述

CI(Component Integrator) 是 FileNet Business Process Management 组件提供的用来连接 Process Engine 和外部系统的服务。客户可以通过它将自定义的 Java 类库或者 Java 消息服务 (JMS, Java Message Services) 组件导入到一个工作流的定义中，同时，它还提供基本的 EIS (Enterprise Information System) 集成。

FileNet BPM component integration 包括以下四个要素：

  • Application Engine 的组件管理器（Component Manager）。
  • Application Engine 的组件适配器（Component adaptors）。
  • Process Engine 的组件队列（Component queues）。
  • CE_Operations ：一个 BPM 自身提供的组件用于集成 Conent Engine 和 Process Engine 。

启动 Component Integration 主要可以帮助实现以下功能：

  • 轻松简单的扩展了商业功能，减轻了开发的工作量。
  • 系统自动处理业务流程。
  • 将外部的功能引入一个工作流。
  • 使用已经存在的 Java 对象和组件。
  • 与 JMS(Java Message Service) 的集成。

Component Integrator 架构


图 1. Component Integrator 的架构
图 1. Component Integrator 的架构

在后面我们的 Java 组件和 JMS 组件应用举例中，请对照上面的架构图以便更加清晰的了解每个部分的功能以及它们之间是如何协同作用的。

Component Integrator 配置工具

接下来介绍一下在上面的架构图中看到的 Component Integrator 的配置工具：

  • 流程配置工作台 (Process Configuration Console)
    • 创建组件队列；
    • 向队列中导入操作；
  • 流程设计器（Process Designer）
    • 向一个工作流定义中加入 Component 步骤元素。一个组件步骤工作流活动代表工作流中的一个活动，这个活动被分配给了一个组件队列中的一个或者多个操作。
  • 组件管理器 (Component Manager)
    • 轮询组件队列中的任务和响应事件触发。
    • 将工作派发到 Java 或者 JMS 组件服务适配器。
  • 流程任务管理器（Process Task Manager）
    • 启动，停止和管理组件管理器。
  • 以上全部工具都是作为典型的 Application Engine 安装的一部分随之一起自动安装的。

组件工作原理

下面介绍组件是如何工作的：

  • 一个组件相当于一个“任务执行者”，它不包含用户交互界面，通过 Component Integrator 自动地对工作流中的数据进行处理，并且执行任务单元 (work items) 上的自动化操作 (operations).
  • 如果一个工作项（work item）正在组件队列中等待处理，它会先向组件发送请求，组件收到请求后，会回应或者执行其他的外部操作。


图 2. Components 工作原理
图 2. Components 工作原理

组件类型

组件分为两类：Java 组件和 JMS 组件

Java 组件的功能由 JAR 文件提供，它是双向通信的，即数据可以由区域（isolated region）传送到组件中，区域也可以从组件中接受数据。要想使用 Java 组件，必须先配置 Java 组件适配器。

JMS 组件的功能是向特定的队列中发送消息，与 Java 组件不同的是，它是单向通信的，即数据只能从区域传送到 JMS 队列，而不能从 JMS 队列中接受数据。要想使用 JMS 组件，必须先配置 JMS 组件适配器。

Content Engine (CE) Operations

除了以上介绍的两种组件之外，IBM FileNet 还通过 Component Integrator 基础架构为用户提供了 CE operations 组件。它用于帮助对存储在对象库（object store）中的文件或者其他对象进行处理，比如将一个文件存入对象库中文件夹中，或者删除一个已经存在的文件，用模板发布一个文件，获取或更改一个文件或者文件夹的属性值。

回页首

将 Component Integrator 应用于工作流实例

这部分通过三个实例，分别介绍了如何将 CE_Operations，Java 组件，JMS 组件应用到工组流中，以及应用前的配置工作。

CE_Opetions 应用举例

在这个部分，将会用到“ CE_Operations Test Workflow ”工作流，这个工作流通过使用 CE_Operations 内置众多可用的操作 (operations) 中的一个操作实现了将 Content Engine 的对象库中的文档类型对象的属性 (Properties) 映射 (map to) 到工作流中数据域 (Data fields) 的功能。

1. 在 PE 服务器上的进程任务控制器 (Process Task Manager) 中 , 检查并确保 Process Engine 的服务器连接配置正确 , 启动进程服务 (Process Service); 在 AE 服务器上的进程任务控制器中启动组件管理器 (Component Manager)，然后通过登录 Workplace 进入流程设计器中。


图 3. 在 PE 上的进程控制器中确认 Process Engi 那个 ne 配置
图 3. 在 PE 上的进程控制器中确认 Process Engi 那个 ne 配置

图 4. 在 AE 上的进程控制器中启动组件管理器
图 4. 在 AE 上的进程控制器中启动组件管理器

2. 进入流程设计器，以’ Check-out ’方式打开存储在 CE 对象库中的工作流定义“ CEOperations Test Workflow ”


图 5. CEOperations Test Workflow 工作流设计图
图 5. CEOperations Test Workflow 工作流设计图

3. 按照表 1 为组件步骤“获取订单详细信息”的添加操作“ getStringProperty ”。


表 1. 设置组件步骤属性
操作名称 参数名称 类型 表达式
getStringProperty sourceDocument 附件 cruise_document
symbolicPropName 字符串 “ DocumentTitle ”
( 注意 : 没有空格 )
return_value 字符串 document_title

4. 验证，传输并启动工作流，并且为其指定一个订单文件作为附件。


图 6. 分配附件并启动工作流
图 6. 分配附件并启动工作流

5. 最后进入我的收件箱中检查结果 , 找到刚刚创建的工作项 , 查看它的 order_price 和 document_title 的值已经自动地被系统从文件属性中添加到工作流中。


图 7. 检验结果
图 7. 检验结果

Java 组件应用举例

在这个部分中 , 将会用到一个“ Verification Workflow ”。这个工作流定义了用户在付款之前，验证信用卡是否有效的阶段。它包含了一个叫做“ CC_Validate ”的组件步骤，这个步骤是通过使用 Java 组件实现的，最终会得到一个布尔类型的返回值来说明认证成功或者失败。

  1. 在处理配置工作台中新建一个叫做“ CC_Validate ”的组件队列，选择 Java 组件作为它的适配器。然后配置这个适配器，选择要导入的 JAR 文件“ CC_Validate.jar ”，并且选择文件中的 CC_Validate.class 类。最后在 JAAS 证书部分中输入用户名，密码以及配置环境（CELogin）。


图 8. 添加组件队列并配置组件适配器
图 8. 添加组件队列并配置组件适配器

  1. 为 CC_Validate 组件队列添加操作“ validaCC ”，并且建议将参数名称改为一个具有实际意义的名字。最后保存更改。


图 9. 为组件添加操作
图 9. 为组件添加操作

  1. 打开 Application Engine 的流程任务管理器，在组件管理器中选择相应的区域，将“ CC_Validte.jar ”文件添加到要求的库中，之后启动服务。


图 10. 添加要求的库
图 10. 添加要求的库

  1. 进入流程设计器，打开 Verification Workflow, 为组件步骤选择操作。


图 11. Verification Workflow
图 11. Verification Workflow

图 12. 添加操作
图 12. 添加操作

  1. 最后验证，传输并启动这个工作流。在启动之前，为了能在组件队列中看到当前的任务状态，可以先停止组件管理器中的 CC_Validate 组件。启动工作流后首先进入第一个步骤，填写信用卡类型和卡号等信息，如果填写无误，工作项将进入组建步骤，并自动执行，通过流程跟踪器（Process Tracker），可以看到 CC_Validate 组件队列这个步骤已经更新为完成状态，并且验证成功，工作项进入了下一个步骤。


图 13. 验证成功
图 13. 验证成功

JMS 应用举例

在这个部分中，将会用到一个“ Reservation Workflow ”。这个工作流实现了客户订单的预定阶段，它包含一个叫做“ Print Letter ”的组件步骤，这个步骤通过使用 JMS 组件实现了打印客户预订信息的功能。

  1. 首先进入 WebLogic 控制台，分别新建 JMS 连接工厂和 JMS 队列，并记录下它们的名字：


表 2. JMS 连接工厂和队列
JMS Connection Factory JNDI MagellanConnectionFactory
JMS queue JNDI PrintQueue

  1. 通过发送并接受 JMS 消息来验证 JMS 队列是否连接成功。例如通过 QueueSend 发送“ Hello World! ”，然后通过“ QueueReceive ”接收到了“ Hello World! ”，说明配置成功。


图 14. 发送接受 JMS 消息
图 14. 发送接受 JMS 消息

  1. 在处理配置工作台中新建一个叫做“ Print_Operations ”的组件队列，选择 JMS 组件作为它的适配器。然后配置这个适配器，输入在第一步中记录下来的两个 JNDI 名字。最后在 JAAS 证书部分中输入用户名，密码以及配置环境（CELogin）。


图 15. 新建并配置 JMS 组件
图 15. 新建并配置 JMS 组件

  1. 为建好的 JMS 组件添加操作，


图 16. 为 JMS 组件添加操作
图 16. 为 JMS 组件添加操作

  1. 打开 Application Engine 的流程任务管理器，在组件管理器中选择相应的区域，在高级选项中输入 JNDI 初始环境工厂：weblogic.jndi.WLInitialContextFactory，然后将“ weblogic.jar ”文件添加到要求的库中，最后启动服务。


图 17. 配置组件管理器
图 17. 配置组件管理器

  1. 完成全部配置工作后，进入流程设计器，打开 Reservation Workflow 并使用 JMS 组件队列，


图 18. Reservation Workflow
图 18. Reservation Workflow

图 19. 添加操作
图 19. 添加操作

  1. 验证，传输并启动这个工作流。当工作项到 check availability step 时，到我的收件箱中输入要求的信息完成这个步骤，之后工作项进入到 Print_Operations 组件队列，并有系统自动执行，可以通过流程跟踪器来查看工作流的历史纪录，发现任务已经在下一个步骤。最后，通过第二步中的 QueueRecieve 小程序来验证当前工作流已经发出了消息。


图 20. 打印成功
图 20. 打印成功

图 21. 接收消息
图 21. 接收消息

参考资料

学习


获得产品和技术


讨论

non-original

阅读全文
类别：Ibm Filenet P8 查看评论]]> 2009年10月10日 星期六 下午 02:56 http://hi.baidu.com/gaozhiyan/blog/item/9ba7adeef48c71232cf534f4.html <![CDATA[filenet:IBM FileNet Enterprise Manager 如何实现类似数据库的触发和对触发的处理]]> 个以内容和流程管理为核心产品主要应用在金融行业为企业提供流程管理和内容管理相关服务

　　Content Engine(CE)则是 IBM FileNet P8 4.0 Platform 产品最核心组件的它负责内容管理核心解决方案并为结构化数据、半结构化数据和非结构化数据进行统集中式管理其具体功能有:内容搜索和存储、版本管理、文档生命周期管理、事件订阅等

　　Content Engine 提供了个框架可以使 Event 或者 Custom Event 在 Content Engine 中 object 或 上被触发时执行用户指定行为(Event Action)我们称的为 subscription也就是说 subscription 是将 event action、个或者多个 event 和个监听触发 event target Content Engine object 或 绑定在起般而言event action 是被开发者编码实现而 subscription 则是在 Enterprise Manager 被管理员所添加

　　在 Content Engine 中可以使用 subscription 等相关技术来实现类似数据库触发器功能从而可以实现对复杂流程控制、维护数据完整性、审计等多种功能

　　举例

　　假设我们已经通过编码实现了个 event action(参见下面相关概念中有关 event action 介绍和如何实现 event action 部分)让它在某个指定类型 document 被删掉后发送封 email 我们需要执行以下步骤来实现并验证这个 subscription:

　　在该 document 上创建个 subscription并将这个 event action 指派给它；

　　选择 Deletion Event 作为这个 subscription trigger events 的；

　　创建上述 document 个对象然后将其删除；

　　您可以去您指定邮箱中查找有关删除该 document 对象 email

　　在 CE 中当任何个 object 或 发生了某个 eventsubscription 处理器都会检验在其上是否指定了这个事件作为触发事件如果指定了处理器就会读取相应 event action 内容并相应思路方法作为该 event 响应

　　相关概念

　　当定义个 subscription您需要设置 event action, target object, and trigger event下面就分别介绍它们定义:

　　Event Action

　　Event action 是指个实现了 Content Engine API's EventActionHandler 接口 Java™ 类即描述了当某个 trigger event 触发 target object 定义 subscription 时Content Engine 需要执行操作

　　Event action 有着广泛用途如:

　　通知 / 通讯:你可以实现个 event action 用来自动根据特定事件和源对象给合适人发送相关 email 等信息

　　记录日志 / 计数:通过跟踪 CE 中各种区别对象和事件使用频率来自动生成有关事件详细记录或者自动增加相关计数器并将这些信息写入数据库或者文件中

　　过滤:对于像文档生命周期(document le cycle)或者工作流流程(workflow process)等复杂流程您可能需要个高级过滤器用来在系统接收某个 document 的前对于这个 document 内容或者 document 本身进行过滤您也可以编写个 event handler 来拒绝某些特定 document 进入并且中止或者回滚事务(transaction)

　　Target Object

　　Target object 是指被 subscription 作用对象它可以是以下几种类型:

　　Class definition:在这种情况下subscription 可以影响到它所有 instance

　　Single instance:在这种情况下subscription 只会影响到该对象某个 version

　　Version series:在这种情况下subscription 可以影响到个 versionable object 所有 version而每个 version 都是个独立 instance

　　上面例子就属于 Class definition 情况

　　虽然您可以将 subscription 指派给独立 instance但是如果将 subscription 指派给 会让它变得更加有效将 subscription 指派给 会保证它对象会得到致管理而且在 上建立 subscription 会减少同时运行 subscription 总量从而提升系统性能

　　Trigger Event

　　Trigger event 是指希望被用来触发某个 subscription 事件而 target object 类型决定了哪些 trigger event 类型对于其上 subscription 是可用

　　上面例子里trigger event 类型是“ Deletion Event ”

　　下面表格描述了在 Content Engine 中区别 target object 上可供使用 trigger event 类型:

　　表 1. Event 信息表

Event 类型 描述 Target object 类型
Cancel Checkout Event 无论何时在个 document 上 reservation 被取消时就触发个指定 event action Document
Change Class Event 无论何时在个 object 所属 被变更时就触发个指定 event action Document, folder, custom object
Change State Event 无论何时在个 document 声明周期状态( lecycle state )被变更时就触发个指定 event action Document
Checkin Event 无论何时在个 document 被 check in 时就触发个指定 event action Document
Checkout Event 无论何时在个 document 被 check out 时就触发个指定 event action Document
Classy Complete Event 无论何时在个 document 已经被 ier 处理过后触发个指定 event action Document
Creation Event 无论何时在某个 例子被创建并保存时触发个指定 event action Document, folder, or custom object
Custom Event 无论何时在个用户定义 custom event 出现时触发个指定 event action 很多种类 object
Deletion Event 无论何时在个对象被从 object store 删除时触发个指定 event action Document, folder, or custom object
Demote Version Event 无论何时在个 document 降级到个 minor version 时触发个指定 event action 只在允许 versioning document 上有效 Document
File Event 无论何时在个对象被归档到个文件夹时触发个指定 event action (包括子文件夹创建) Folder
Freeze Event 无论何时在个 document Freeze 思路方法被时触发个指定 event action Document
Lock Event 无论何时在个对象 Lock 思路方法被时触发个指定 event action Document, folder, or custom object
Promote Version Event 无论何时在个 document 升级到个 major version 时触发个指定 event action 只在允许 versioning document 上有效 Document
Unfile Event 无论何时在个对象被从个文件夹中删除时触发个指定 event action (包括子文件夹删除) Folder
Unlock Event 无论何时在个对象 Unlock 思路方法被时触发个指定 event action Document, folder, or custom object
Update Event 无论何时在个对象 properties 被改变时触发个指定 event action Document, folder, or custom object
Update Security Event 无论何时在个对象 Security 设置被改变时触发个指定 event action Document, folder, or custom object



　　Custom Event

　　尽管 Content Engine 已经提供了很多种类 event但其强大可扩展性使您仍然可以根据需要创建自己 custom event

　　在默认情况下Event 下面存在这个 CustomEvent 类它是所有用户定义 custom event 基类也就是说使用 Enterprise Manager 创建自己 custom event 就是创建了个 CustomEvent 子类

　　旦创建了个 custom event 并且刷新了 object store那您就可以在给 或者 object 创建 subscription 时从可用 event 列表中选取该 custom event

　　小结

　　在 Content Engine 中subscription 包含了 event action, target object 和 trigger event它们代表含义分别为:

　　表 2. 概念小结表

Event action Subscription 被触发后执行操作
Target object 设置 subscription 目标即在哪监听 trigger event 发生并触发 event action
Trigger event 描述了哪种(或哪些)事件可以触发该 subscription



　　如何实现 Event Action

　　上面提到过 Event action 是指个实现了 Content Engine API's EventActionHandler 接口 Java™ 类而 EventActionHandler 接口里只定义了个思路方法:

void　onEvent　(　ObjectChangeEvent　event,　Id　subscriptionId)　
　　

　　其中 event 表示 Trigger event而用户或者开发者可以通过 subscriptionId 来获取和这个 event acion 关联对象即 target object 实现了 EventActionHandler 接口中 _disibledevent=>

　　2. 输入 Subscription 名字:

　　图 2. 输入 Subscription 名字



　　3. 选择是对该 所有 instance 都生效还是对单独某个生效:

　　图 3. 选择 Subscription 影响对象



　　4. 从可用 event 列表中选择触发 Subscription trigger event(前面提到您可以建立自己 custom event 看来扩展 Content Engine 提供给您 trigger event)

　　图 4. 选择 trigger event



　　5. 选取 Event Action即当上面选中 event 出现时做出什么相应您可以在这里创建新 Event Action, 只需要指定实现 EventActionHandler 接口 或者 JAR 文件路径然后给该 Event Action 命名即可

　　图 5. 选择 Event Action



　　6. 指定些附加属性:

　　图 6. 指定附加属性



　　7. 最后点击 Finish

　　图 7. 点击 Finish



　　这样我们就完成了在 ContentEngineTest 类上建立名称为 SubscriptionTest、trigger event 为 Deletion Event、Event Action 为 Workflow Event Action 个 Subscription

　　这个 Subscription 会在 ContentEngineTest 例子(Target object)被删除(Deletion Event)时自动触发 Workflow Event Action

　　整理总结

　　本文介绍了 Content Engine 中 subscription 相关 event action, target object 和 trigger event 概念并讲解了如何在 Content Engine 中添加用户自定义 event(custom event)和 event action最后又在 FileNet Enterprise Manager 模拟了建立 subscription 全过程借助本文读者可以更好掌握 Content Engine 中 subscription 相关概念和技术更好利用 Content Engine 完成工作并提高效率希望本文对您工作有所帮助 阅读全文
类别：Ibm Filenet P8 查看评论]]> 2009年09月28日 星期一 下午 02:28 http://hi.baidu.com/gaozhiyan/blog/item/77aa1c2d0b8a053e359bf7fa.html