我来解决手机电池问题 ：
工具----设置------网络设置-------运营商选择------
手动
-------选择你使用的运营商------ok 。这样大概要待机多1/3时间
posted @
2007-01-10 11:06 rkind 阅读(226) |
评论 (0) |
编辑 收藏posted @
2006-12-08 16:19 rkind 阅读(234) |
评论 (0) |
编辑 收藏
今天在试验了一下在Struts-config中配置数据源，虽然说这种方法并不推荐，
操作步骤：
首先导入几个需要的包：首先自己连接数据库用的包，因为我用的是Mysql所以用的是“mm.mysql-2.0.4-bin.jar”，还有“commons-dbcp-1.2.1.jar”这个是数据源中要用到的包，还有“commons-pool-1.2.jar”这个不太清楚
其次在Struts-config.xml中加入如下代码
<data-sources>
<data-source key="rki" type="org.apache.commons.dbcp.BasicDataSource"> //type代表类，rki表示当有多个数据源时相
//当于一个索引，id值
<set-property property="driverClassName" value="org.gjt.mm.mysql.Driver" />//连接mysql所需的类库
<set-property property="url" value="jdbc:mysql://172.20.0.40:3306/test?useUnicode=true&characterEncoding=GBK" />
<set-property property="username" value="root" />
<set-property property="password" value="你的密码" />
<set-property property="maxActive" value="10" />
<set-property property="maxWait" value="500" />
<set-property property="defaultAutoCommit" value="false" />
<set-property property="defaultReadOnly" value="false" />
</data-source>
</data-sources>然后现在就可以在你的Action试验数据库的连接，简单引用的代码片断
datasource = getDataSource(request, "rki");
conn = datasource.getConnection();
Statement state = conn.createStatement();
System.out.println("hello");
String sql = "select * from notice where title='test'";
ResultSet rs = state.executeQuery(sql);
while (rs.next()) 
{
request.getSession().setAttribute("cont",
rs.getString("content"));
System.out.println("database connect true");
}
rs.close(); 在试验的过程中，老是不能连接，出“Initializing application data source”我仔细检查过以上的配置并没有问题，重启了几次服务器也不行，查了N多资料，最后居然自己好了，郁闷的要死
一点总结，
可见在Struts中配置数据源要比别的连接方法要复杂，而且效率上来说也不一定要好，还不如自己通过自己编写简单的访问数据库的类，或者是直接采用Tomcat的数据源要方便 一些。
posted @
2006-10-31 15:49 rkind 阅读(360) |
评论 (0) |
编辑 收藏
在Struts中可以通过<html:errors/>来显示错误信息，今天简单看了一点，总结一下：
1）如果是采用了formbean的validate的话，首先，struts-config.xml中Action需要加入validate="true"
其实，在Actionform中的validate必须返回一个自己定义的Actionerrors，如例：
public ActionErrors validate(ActionMapping mapping,
HttpServletRequest request) {
ActionErrors errors = new ActionErrors();
if (this.content.equals("")) {
errors.add("content", new ActionError("error.user"));
}
return errors;
} 2）如果没有采用，而是用Action验证的话，也需要先定义一个Actionerrors，然后再通过
saveErrors(request,errors);把Actionerrrors保存到request中
3）需要注意的
a,每个ActionErrors都有一个String,和一个ActionError构成，ActionError里面的String是和项目资源文件里的一一对应的，String是和html:errors中property相对应的。
posted @
2006-10-30 17:23 rkind 阅读(544) |
评论 (0) |
编辑 收藏这就是在前面的简单应用中，在view中，通过<bean:write name="myform" property="name">调用Actionform时出的问题，这个问题的直接原因很简单就是：找不到"myform"这个Bean，用网上的话说就是“在Action里一般会request.setAttribute()一些对象，然后在转向的jsp文件里（用tag或request.getAttribute()方法）得到这些对象并显示出来。这个异常是说jsp要得到一个对象，但前面的Action里并没有将对象设置到request（也可以是session、servletContext）里。可能是名字错了，请检查jsp里的tag的一般是name属性，或getAttribute()方法的参数值；或者是Action逻辑有问题没有执行setAttribute()方法就先转向了。
还有另外一个可能，纯粹是jsp文件的问题，例如<logic:iterate>会指定一个id值，然后在循环里<bean:write>使用这个值作为name的值，如果这两个值不同，也会出现此异常。（都是一个道理，request里没有对应的对象。）”。
我对Actionform的机制不理解，心中的疑问：
1）如果ActionForm是Struts自动封装到Request中，那么我可以直接在view.jsp中，能过<bean:write>调用这个ActionForm，如果假设这种情况成立时，那么Beanwrite中的bean名应该是ActionForm的类名，还是在Struts-config.xml里给ActionForm定义的类名？
2）如果没有封装的话，那么是不是需要在Action中把Actionform通过request.setAttribute("","")放到request中
还是要放到Session中，
我测试时候出的问题
有一次就是在1）的情况下测试成功的，但是以后再怎么试都不行，那次是引用的Struts-config.xml里给ActionForm定义的类名。非常奇怪，
还有就是2）的情况，测试中如果Action和Frombean在一个包下面，那么通过request.setAttribute("","")，就可以获取到Bean，如果不是的话，有时候行，有时候不行，
如果通过request.getSession.setAttribute()设置ActionForm的话，每次都可以，他们的Scope肯定在一个Request中，那么为什么Session就可以，而Request不行。(结论：因为是在Actionfoward中设置了“redirect='true'，这样的话一跳转时，Request中的内容都会被重置，所以不行，把这一句去掉就可以了”)
posted @
2006-10-30 14:07 rkind 阅读(8488) |
评论 (1) |
编辑 收藏
1、简介
简单的页面输入并显示的功能，有两个页面，
upnews.jsp 提供输入内容的界面，show.jsp显示已经输入的内容
2、源码
struts-config，流程图
源代码
Strust-config.xml
<form-bean name="upNewsForm" type="com.rkind.struts.form.UpNewsForm" /> <action attribute="upNewsForm" input="/upNews.jsp" name="upNewsForm" path="/upNews" scope="request" type="com.rkind.struts.action.UpNewsAction">
<forward name="suc" path="/show.jsp" redirect="true" />
</action>
upnews.jsp
都是eclispe自动生成的
<html:form action="/upNews">
content : <html:text property="content"/><html:errors property="content"/><br/>
<html:submit/><html:cancel/>
</html:form>
show.jsp这个简单就一句话，
<bean:write name="upNewsForm" property="content"/>
模型的部分 formbean,自动生成，未做改动
Controller部分，核心啊
UpNewsForm upNewsForm = (UpNewsForm) form;
// TODO Auto-generated method stub
String te=upNewsForm.getContent();
try{
if(te.equals("")){
return new ActionForward(mapping.getInput());
}
return (mapping.findForward("suc"));
}catch(Exception e){
throw new RuntimeException(e.getMessage()); 好了，但是在测试的时候一直出问题，输入以后不能正常，原因有2
1、在链接时候，没有加“/”导致不能正常连接
2、
forward name="suc" path="/show.jsp" redirect="true" 起初没有加redirect，不能跳转。
posted @
2006-10-27 12:39 rkind 阅读(470) |
评论 (0) |
编辑 收藏
1、插入和包含
1） js,一般都放在head之间、注释的作用是当客户端浏览器版本过低时，不能识别而发生错误
<script language="JavaScript">
<!--
document.write( "Hello World!");
//-->
</script>
2）另外你也可以编辑.js文件，然后在页面里面直接引用就可以了
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312">
<title>javascript</title><script language="javascript"src="Untitled-2.js"></script></head>
2、write
在js中要显示字符，需要用document.write()的形式，writeln区别就是再write的基础上加入了换行
3、如例
document.write("Hello World!");
document.write("test"+document.lastModified);
document.bgColor = " black "
其中，document是对象，write是method,输出字符可以用加的形式，,可以在js里面设定页面的背景
4、提示框
1）window.alert("testtesttest")
弹出窗口
2）window.confirm("test")
3)有输入框的提示框
window.prompt("test")
一不小心双击了标签了，写的全都没了！！！后面的不写了，写js时一定要注意“” ’号的运用！
js的功能是超级强大的，运用还是要靠脑筋的，
posted @
2006-10-26 12:09 rkind 阅读(450) |
评论 (0) |
编辑 收藏
一、术语session
在我的经验里，session这个词被滥用的程度大概仅次于transaction，更加有趣的是transaction与session在某些语境下的含义是相同的。
session，中文经常翻译为会话，其本来的含义是指有始有终的一系列动作/消息，比如打电话时从拿起电话拨号到挂断电话这中间的一系列过程可以称之为一个session。有时候我们可以看到这样的话“在一个浏览器会话期间，...”，这里的会话一词用的就是其本义，是指从一个浏览器窗口打开到关闭这个期间①。最混乱的是“用户（客户端）在一次会话期间”这样一句话，它可能指用户的一系列动作（一般情况下是同某个具体目的相关的一系列动作，比如从登录到选购商品到结账登出这样一个网上购物的过程，有时候也被称为一个transaction），然而有时候也可能仅仅是指一次连接，也有可能是指含义①，其中的差别只能靠上下文来推断②。
然而当session一词与网络协议相关联时，它又往往隐含了“面向连接”和/或“保持状态”这样两个含义，“面向连接”指的是在通信双方在通信之前要先建立一个通信的渠道，比如打电话，直到对方接了电话通信才能开始，与此相对的是写信，在你把信发出去的时候你并不能确认对方的地址是否正确，通信渠道不一定能建立，但对发信人来说，通信已经开始了。“保持状态”则是指通信的一方能够把一系列的消息关联起来，使得消息之间可以互相依赖，比如一个服务员能够认出再次光临的老顾客并且记得上次这个顾客还欠店里一块钱。这一类的例子有“一个TCP session”或者“一个POP3 session”③。
而到了web服务器蓬勃发展的时代，session在web开发语境下的语义又有了新的扩展，它的含义是指一类用来在客户端与服务器之间保持状态的解决方案④。有时候session也用来指这种解决方案的存储结构，如“把xxx保存在session里”⑤。由于各种用于web开发的语言在一定程度上都提供了对这种解决方案的支持，所以在某种特定语言的语境下，session也被用来指代该语言的解决方案，比如经常把Java里提供的javax.servlet.http.HttpSession简称为session⑥。
鉴于这种混乱已不可改变，本文中session一词的运用也会根据上下文有不同的含义，请大家注意分辨。
在本文中，使用中文“浏览器会话期间”来表达含义①，使用“session机制”来表达含义④，使用“session”表达含义⑤，使用具体的“HttpSession”来表达含义⑥
二、HTTP协议与状态保持
HTTP协议本身是无状态的，这与HTTP协议本来的目的是相符的，客户端只需要简单的向服务器请求下载某些文件，无论是客户端还是服务器都没有必要纪录彼此过去的行为，每一次请求之间都是独立的，好比一个顾客和一个自动售货机或者一个普通的（非会员制）大卖场之间的关系一样。
然而聪明（或者贪心？）的人们很快发现如果能够提供一些按需生成的动态信息会使web变得更加有用，就像给有线电视加上点播功能一样。这种需求一方面迫使HTML逐步添加了表单、脚本、DOM等客户端行为，另一方面在服务器端则出现了CGI规范以响应客户端的动态请求，作为传输载体的HTTP协议也添加了文件上载、cookie这些特性。其中cookie的作用就是为了解决HTTP协议无状态的缺陷所作出的努力。至于后来出现的session机制则是又一种在客户端与服务器之间保持状态的解决方案。
让我们用几个例子来描述一下cookie和session机制之间的区别与联系。笔者曾经常去的一家咖啡店有喝5杯咖啡免费赠一杯咖啡的优惠，然而一次性消费5杯咖啡的机会微乎其微，这时就需要某种方式来纪录某位顾客的消费数量。想象一下其实也无外乎下面的几种方案：
1、该店的店员很厉害，能记住每位顾客的消费数量，只要顾客一走进咖啡店，店员就知道该怎么对待了。这种做法就是协议本身支持状态。
2、发给顾客一张卡片，上面记录着消费的数量，一般还有个有效期限。每次消费时，如果顾客出示这张卡片，则此次消费就会与以前或以后的消费相联系起来。这种做法就是在客户端保持状态。
3、发给顾客一张会员卡，除了卡号之外什么信息也不纪录，每次消费时，如果顾客出示该卡片，则店员在店里的纪录本上找到这个卡号对应的纪录添加一些消费信息。这种做法就是在服务器端保持状态。
由于HTTP协议是无状态的，而出于种种考虑也不希望使之成为有状态的，因此，后面两种方案就成为现实的选择。具体来说cookie机制采用的是在客户端保持状态的方案，而session机制采用的是在服务器端保持状态的方案。同时我们也看到，由于采用服务器端保持状态的方案在客户端也需要保存一个标识，所以session机制可能需要借助于cookie机制来达到保存标识的目的，但实际上它还有其他选择。
三、理解cookie机制
cookie机制的基本原理就如上面的例子一样简单，但是还有几个问题需要解决：“会员卡”如何分发；“会员卡”的内容；以及客户如何使用“会员卡”。
正统的cookie分发是通过扩展HTTP协议来实现的，服务器通过在HTTP的响应头中加上一行特殊的指示以提示浏览器按照指示生成相应的cookie。然而纯粹的客户端脚本如JavaScript或者VBScript也可以生成cookie。
而cookie的使用是由浏览器按照一定的原则在后台自动发送给服务器的。浏览器检查所有存储的cookie，如果某个cookie所声明的作用范围大于等于将要请求的资源所在的位置，则把该cookie附在请求资源的HTTP请求头上发送给服务器。意思是麦当劳的会员卡只能在麦当劳的店里出示，如果某家分店还发行了自己的会员卡，那么进这家店的时候除了要出示麦当劳的会员卡，还要出示这家店的会员卡。
cookie的内容主要包括：名字，值，过期时间，路径和域。
其中域可以指定某一个域比如.google.com，相当于总店招牌，比如宝洁公司，也可以指定一个域下的具体某台机器比如www.google.com或者froogle.google.com，可以用飘柔来做比。
路径就是跟在域名后面的URL路径，比如/或者/foo等等，可以用某飘柔专柜做比。
路径与域合在一起就构成了cookie的作用范围。
如果不设置过期时间，则表示这个cookie的生命期为浏览器会话期间，只要关闭浏览器窗口，cookie就消失了。这种生命期为浏览器会话期的cookie被称为会话cookie。会话cookie一般不存储在硬盘上而是保存在内存里，当然这种行为并不是规范规定的。如果设置了过期时间，浏览器就会把cookie保存到硬盘上，关闭后再次打开浏览器，这些cookie仍然有效直到超过设定的过期时间。
存储在硬盘上的cookie可以在不同的浏览器进程间共享，比如两个IE窗口。而对于保存在内存里的cookie，不同的浏览器有不同的处理方式。对于IE，在一个打开的窗口上按Ctrl-N（或者从文件菜单）打开的窗口可以与原窗口共享，而使用其他方式新开的IE进程则不能共享已经打开的窗口的内存cookie；对于Mozilla Firefox0.8，所有的进程和标签页都可以共享同样的cookie。一般来说是用javascript的window.open打开的窗口会与原窗口共享内存cookie。浏览器对于会话cookie的这种只认cookie不认人的处理方式经常给采用session机制的web应用程序开发者造成很大的困扰。
下面就是一个goolge设置cookie的响应头的例子
HTTP/1.1 302 Found
Location: http://www.google.com/intl/zh-CN/
Set-Cookie: PREF=ID=0565f77e132de138:NW=1:TM=1098082649:LM=1098082649:S=KaeaCFPo49RiA_d8; expires=Sun, 17-Jan-2038 19:14:07 GMT; path=/; domain=.google.com
Content-Type: text/html
这是使用HTTPLook这个HTTP Sniffer软件来俘获的HTTP通讯纪录的一部分
浏览器在再次访问goolge的资源时自动向外发送cookie
使用Firefox可以很容易的观察现有的cookie的值
使用HTTPLook配合Firefox可以很容易的理解cookie的工作原理。
IE也可以设置在接受cookie前询问
这是一个询问接受cookie的对话框。
四、理解session机制
session机制是一种服务器端的机制，服务器使用一种类似于散列表的结构（也可能就是使用散列表）来保存信息。
当程序需要为某个客户端的请求创建一个session的时候，服务器首先检查这个客户端的请求里是否已包含了一个session标识 - 称为session id，如果已包含一个session id则说明以前已经为此客户端创建过session，服务器就按照session id把这个session检索出来使用（如果检索不到，可能会新建一个），如果客户端请求不包含session id，则为此客户端创建一个session并且生成一个与此session相关联的session id，session id的值应该是一个既不会重复，又不容易被找到规律以仿造的字符串，这个session id将被在本次响应中返回给客户端保存。
保存这个session id的方式可以采用cookie，这样在交互过程中浏览器可以自动的按照规则把这个标识发挥给服务器。一般这个cookie的名字都是类似于SEEESIONID，而。比如weblogic对于web应用程序生成的cookie，JSESSIONID=ByOK3vjFD75aPnrF7C2HmdnV6QZcEbzWoWiBYEnLerjQ99zWpBng!-145788764，它的名字就是JSESSIONID。
由于cookie可以被人为的禁止，必须有其他机制以便在cookie被禁止时仍然能够把session id传递回服务器。经常被使用的一种技术叫做URL重写，就是把session id直接附加在URL路径的后面，附加方式也有两种，一种是作为URL路径的附加信息，表现形式为http://...../xxx;jsessionid=ByOK3vjFD75aPnrF7C2HmdnV6QZcEbzWoWiBYEnLerjQ99zWpBng!-145788764另一种是作为查询字符串附加在URL后面，表现形式为http://...../xxx?jsessionid=ByOK3vjFD75aPnrF7C2HmdnV6QZcEbzWoWiBYEnLerjQ99zWpBng!-145788764
这两种方式对于用户来说是没有区别的，只是服务器在解析的时候处理的方式不同，采用第一种方式也有利于把session id的信息和正常程序参数区分开来。
为了在整个交互过程中始终保持状态，就必须在每个客户端可能请求的路径后面都包含这个session id。
另一种技术叫做表单隐藏字段。就是服务器会自动修改表单，添加一个隐藏字段，以便在表单提交时能够把session id传递回服务器。比如下面的表单
在被传递给客户端之前将被改写成
这种技术现在已较少应用，笔者接触过的很古老的iPlanet6(SunONE应用服务器的前身)就使用了这种技术。实际上这种技术可以简单的用对action应用URL重写来代替。
在谈论session机制的时候，常常听到这样一种误解“只要关闭浏览器，session就消失了”。其实可以想象一下会员卡的例子，除非顾客主动对店家提出销卡，否则店家绝对不会轻易删除顾客的资料。对session来说也是一样的，除非程序通知服务器删除一个session，否则服务器会一直保留，程序一般都是在用户做log off的时候发个指令去删除session。然而浏览器从来不会主动在关闭之前通知服务器它将要关闭，因此服务器根本不会有机会知道浏览器已经关闭，之所以会有这种错觉，是大部分session机制都使用会话cookie来保存session id，而关闭浏览器后这个session id就消失了，再次连接服务器时也就无法找到原来的session。如果服务器设置的cookie被保存到硬盘上，或者使用某种手段改写浏览器发出的HTTP请求头，把原来的session id发送给服务器，则再次打开浏览器仍然能够找到原来的session。
恰恰是由于关闭浏览器不会导致session被删除，迫使服务器为seesion设置了一个失效时间，当距离客户端上一次使用session的时间超过这个失效时间时，服务器就可以认为客户端已经停止了活动，才会把session删除以节省存储空间。
五、理解javax.servlet.http.HttpSession
HttpSession是Java平台对session机制的实现规范，因为它仅仅是个接口，具体到每个web应用服务器的提供商，除了对规范支持之外，仍然会有一些规范里没有规定的细微差异。这里我们以BEA的Weblogic Server8.1作为例子来演示。
首先，Weblogic Server提供了一系列的参数来控制它的HttpSession的实现，包括使用cookie的开关选项，使用URL重写的开关选项，session持久化的设置，session失效时间的设置，以及针对cookie的各种设置，比如设置cookie的名字、路径、域，cookie的生存时间等。
一般情况下，session都是存储在内存里，当服务器进程被停止或者重启的时候，内存里的session也会被清空，如果设置了session的持久化特性，服务器就会把session保存到硬盘上，当服务器进程重新启动或这些信息将能够被再次使用，Weblogic Server支持的持久性方式包括文件、数据库、客户端cookie保存和复制。
复制严格说来不算持久化保存，因为session实际上还是保存在内存里，不过同样的信息被复制到各个cluster内的服务器进程中，这样即使某个服务器进程停止工作也仍然可以从其他进程中取得session。
cookie生存时间的设置则会影响浏览器生成的cookie是否是一个会话cookie。默认是使用会话cookie。有兴趣的可以用它来试验我们在第四节里提到的那个误解。
cookie的路径对于web应用程序来说是一个非常重要的选项，Weblogic Server对这个选项的默认处理方式使得它与其他服务器有明显的区别。后面我们会专题讨论。
关于session的设置参考[5] http://e-docs.bea.com/wls/docs70/webapp/weblogic_xml.html#1036869
六、HttpSession常见问题
（在本小节中session的含义为⑤和⑥的混合）
1、session在何时被创建
一个常见的误解是以为session在有客户端访问时就被创建，然而事实是直到某server端程序调用HttpServletRequest.getSession(true)这样的语句时才被创建，注意如果JSP没有显示的使用 <%@page session="false"%>关闭session，则JSP文件在编译成Servlet时将会自动加上这样一条语句HttpSession session = HttpServletRequest.getSession(true);这也是JSP中隐含的session对象的来历。
由于session会消耗内存资源，因此，如果不打算使用session，应该在所有的JSP中关闭它。
2、session何时被删除
综合前面的讨论，session在下列情况下被删除a.程序调用HttpSession.invalidate();或b.距离上一次收到客户端发送的session id时间间隔超过了session的超时设置;或c.服务器进程被停止（非持久session）
3、如何做到在浏览器关闭时删除session
严格的讲，做不到这一点。可以做一点努力的办法是在所有的客户端页面里使用javascript代码window.oncolose来监视浏览器的关闭动作，然后向服务器发送一个请求来删除session。但是对于浏览器崩溃或者强行杀死进程这些非常规手段仍然无能为力。
4、有个HttpSessionListener是怎么回事
你可以创建这样的listener去监控session的创建和销毁事件，使得在发生这样的事件时你可以做一些相应的工作。注意是session的创建和销毁动作触发listener，而不是相反。类似的与HttpSession有关的listener还有HttpSessionBindingListener，HttpSessionActivationListener和HttpSessionAttributeListener。
5、存放在session中的对象必须是可序列化的吗
不是必需的。要求对象可序列化只是为了session能够在集群中被复制或者能够持久保存或者在必要时server能够暂时把session交换出内存。在Weblogic Server的session中放置一个不可序列化的对象在控制台上会收到一个警告。我所用过的某个iPlanet版本如果session中有不可序列化的对象，在session销毁时会有一个Exception，很奇怪。
6、如何才能正确的应付客户端禁止cookie的可能性
对所有的URL使用URL重写，包括超链接，form的action，和重定向的URL，具体做法参见[6]
http://e-docs.bea.com/wls/docs70/webapp/sessions.html#100770
7、开两个浏览器窗口访问应用程序会使用同一个session还是不同的session
参见第三小节对cookie的讨论，对session来说是只认id不认人，因此不同的浏览器，不同的窗口打开方式以及不同的cookie存储方式都会对这个问题的答案有影响。
8、如何防止用户打开两个浏览器窗口操作导致的session混乱
这个问题与防止表单多次提交是类似的，可以通过设置客户端的令牌来解决。就是在服务器每次生成一个不同的id返回给客户端，同时保存在session里，客户端提交表单时必须把这个id也返回服务器，程序首先比较返回的id与保存在session里的值是否一致，如果不一致则说明本次操作已经被提交过了。可以参看《J2EE核心模式》关于表示层模式的部分。需要注意的是对于使用javascript window.open打开的窗口，一般不设置这个id，或者使用单独的id，以防主窗口无法操作，建议不要再window.open打开的窗口里做修改操作，这样就可以不用设置。
9、为什么在Weblogic Server中改变session的值后要重新调用一次session.setValue
做这个动作主要是为了在集群环境中提示Weblogic Server session中的值发生了改变，需要向其他服务器进程复制新的session值。
10、为什么session不见了
排除session正常失效的因素之外，服务器本身的可能性应该是微乎其微的，虽然笔者在iPlanet6SP1加若干补丁的Solaris版本上倒也遇到过；浏览器插件的可能性次之，笔者也遇到过3721插件造成的问题；理论上防火墙或者代理服务器在cookie处理上也有可能会出现问题。
出现这一问题的大部分原因都是程序的错误，最常见的就是在一个应用程序中去访问另外一个应用程序。我们在下一节讨论这个问题。
七、跨应用程序的session共享
常常有这样的情况，一个大项目被分割成若干小项目开发，为了能够互不干扰，要求每个小项目作为一个单独的web应用程序开发，可是到了最后突然发现某几个小项目之间需要共享一些信息，或者想使用session来实现SSO(single sign on)，在session中保存login的用户信息，最自然的要求是应用程序间能够访问彼此的session。
然而按照Servlet规范，session的作用范围应该仅仅限于当前应用程序下，不同的应用程序之间是不能够互相访问对方的session的。各个应用服务器从实际效果上都遵守了这一规范，但是实现的细节却可能各有不同，因此解决跨应用程序session共享的方法也各不相同。
首先来看一下Tomcat是如何实现web应用程序之间session的隔离的，从Tomcat设置的cookie路径来看，它对不同的应用程序设置的cookie路径是不同的，这样不同的应用程序所用的session id是不同的，因此即使在同一个浏览器窗口里访问不同的应用程序，发送给服务器的session id也可以是不同的。
根据这个特性，我们可以推测Tomcat中session的内存结构大致如下。
笔者以前用过的iPlanet也采用的是同样的方式，估计SunONE与iPlanet之间不会有太大的差别。对于这种方式的服务器，解决的思路很简单，实际实行起来也不难。要么让所有的应用程序共享一个session id，要么让应用程序能够获得其他应用程序的session id。
iPlanet中有一种很简单的方法来实现共享一个session id，那就是把各个应用程序的cookie路径都设为/（实际上应该是/NASApp，对于应用程序来讲它的作用相当于根）。
/NASApp
需要注意的是，操作共享的session应该遵循一些编程约定，比如在session attribute名字的前面加上应用程序的前缀，使得setAttribute("name", "neo")变成setAttribute("app1.name", "neo")，以防止命名空间冲突，导致互相覆盖。
在Tomcat中则没有这么方便的选择。在Tomcat版本3上，我们还可以有一些手段来共享session。对于版本4以上的Tomcat，目前笔者尚未发现简单的办法。只能借助于第三方的力量，比如使用文件、数据库、JMS或者客户端cookie，URL参数或者隐藏字段等手段。
我们再看一下Weblogic Server是如何处理session的。
从截屏画面上可以看到Weblogic Server对所有的应用程序设置的cookie的路径都是/，这是不是意味着在Weblogic Server中默认的就可以共享session了呢？然而一个小实验即可证明即使不同的应用程序使用的是同一个session，各个应用程序仍然只能访问自己所设置的那些属性。这说明Weblogic Server中的session的内存结构可能如下
对于这样一种结构，在session机制本身上来解决session共享的问题应该是不可能的了。除了借助于第三方的力量，比如使用文件、数据库、JMS或者客户端cookie，URL参数或者隐藏字段等手段，还有一种较为方便的做法，就是把一个应用程序的session放到ServletContext中，这样另外一个应用程序就可以从ServletContext中取得前一个应用程序的引用。示例代码如下，
应用程序A
context.setAttribute("appA", session);
应用程序B
contextA = context.getContext("/appA");
HttpSession sessionA = (HttpSession)contextA.getAttribute("appA");
值得注意的是这种用法不可移植，因为根据ServletContext的JavaDoc，应用服务器可以处于安全的原因对于context.getContext("/appA");返回空值，以上做法在Weblogic Server 8.1中通过。
那么Weblogic Server为什么要把所有的应用程序的cookie路径都设为/呢？原来是为了SSO，凡是共享这个session的应用程序都可以共享认证的信息。一个简单的实验就可以证明这一点，修改首先登录的那个应用程序的描述符weblogic.xml，把cookie路径修改为/appA访问另外一个应用程序会重新要求登录，即使是反过来，先访问cookie路径为/的应用程序，再访问修改过路径的这个，虽然不再提示登录，但是登录的用户信息也会丢失。注意做这个实验时认证方式应该使用FORM，因为浏览器和web服务器对basic认证方式有其他的处理方式，第二次请求的认证不是通过session来实现的。具体请参看[7] secion 14.8 Authorization，你可以修改所附的示例程序来做这些试验。
八、总结
session机制本身并不复杂，然而其实现和配置上的灵活性却使得具体情况复杂多变。这也要求我们不能把仅仅某一次的经验或者某一个浏览器，服务器的经验当作普遍适用的经验，而是始终需要具体情况具体分析。
posted @
2006-04-27 14:38 rkind 阅读(226) |
评论 (0) |
编辑 收藏
输入 :*#92702689# 手机会出现
第一行， Serial no: 手机串号
手机串号是手机的身份证，此串号的第七第八位代码表示手机的产地，
nokia的代码如下：
10：芬兰；20：德国；30：韩国；40：北京；60：东莞
新的nokia手机已经不使用这个编号来区分产地了。
第二行， Made ： 072003 生产日期
这个生产日期如果离当前日期太远，就有可能是翻新机
第三行， purchasing date ： mmyyyy 购买日期
可以修改，修改以后没法更改了，即使你把手机软件刷新。
如果这里已有日期，肯定是翻新机或有毛病后人家退货的
提醒大家注意，赶快更改这里，不要给JS留下骗人的可乘之机。
第四行， Repaired ： mmyyyy 上次维修日期
如果有说明此手机维修过（JS一般会注意这个冬冬，会把它刷掉的）
第五行， Life timer 00002:20
看看Life timer时间 通话时间 新的应该是没有通话时间的
**如果你忘了钱包的密码，输入*#7370925538#就可以还原。
第三行这里特别有用，
可以修改，修改以后没法更改了，即使你把手机软件刷新。
如果这里已有日期，肯定是翻新机或有毛病后人家退货的
提醒大家注意，赶快更改这里，不要给JS留下骗人的可乘之机。
posted @
2006-04-05 15:14 rkind 阅读(782) |
评论 (0) |
编辑 收藏
老久没有郁闷的心情，然而终于却是来了，
我总是想能想出很多东西来，然后反应却很慢，又做了一件很傻的事
这是一个教训！不管怎么样，现在都不可能补救了。
也许跟心情有关吧，以后好好努力吧
posted @
2006-03-09 16:49 rkind 阅读(234) |
评论 (0) |
编辑 收藏
可以自由的从MP3机上下载音乐文件，而且大大提升了传输的速度，
首先从：
http://bbs.imp3.net/attachment.php?aid=99466下载一个iriver的插件
运行TC－－－＞菜单点配置－－－＞插件－－－－＞文件系统插件点设置－－－＞点添加新插件，这时候就添加下边附件中的插件就行了。
然后软件运行时的界面就和我们的IMM差不多，不过功能更强大，安装只占4.5MB。
不过要想访问MP3（有驱无驱都好使）请点主菜单栏下面的盘符栏的网上邻居
就会找到，然后一切OK
posted @
2006-02-24 17:52 rkind 阅读(508) |
评论 (0) |
编辑 收藏
一直以来，认为实现这种上传要比下载简单的多，可是等到真正去实现的时候，才发现原来挺麻烦的
遇到的问题有：
1中文文件名的问题。
2文件没有下载提示直接就打开，包括rar的。
就这么两个小问题却让我花了三天的时间，不得不汗一下我的效率。
首先来说中文链接的问题，tomcat默认是不支持中文URL的，但是可以在Sever.xml中把 Connector 的属性加上一条： URIEncoding="GBK"；然后在传递之前，链接的中文还要先encode一下
例如：java.net.URLEncoder.encode（“测试.txt”）; 这样中文就会变成％D％F之类的，总之就可以正常传递了。
而关于点击文件直接就打开了是比较郁闷，查找了些资料，也试了网上的一些方法，一直不行
，最后采用的文件流的方式，才顺利解决。代码大致如下：
while(rs.next()){
try{
OutputStream o=response.getOutputStream();
byte b[]=new byte[500];
filename=rs.getString("filename");//rs.为从数据库查找到的结果集
filename=java.net.URLEncoder.encode(filename).trim();
File file=new File("d:/upload/20060221/",rs.getString("filename"));
//
response.setHeader("Content-Disposition","attachment; filename="+filename);
response.setContentType("APPLICATION/OCTET-STREAM");
long fileLength=file.length();
String length=String.valueOf(fileLength);
response.setHeader("Content_Length",length);
java.io.FileInputStream in = new java.io.FileInputStream(file);
int n=0;
while ((n=in.read(b)) != -1) {
o.write(b,0,n);
}
in.close();
o.close();
}catch(Exception e){
System.out.print(e);
}
}
rs.close();
这样的话，中英文文件都能正常下载并使用，但是中文文件用Ie直接下载下来后文件名还是乱码，用下载工具则一切正常。
posted @
2006-02-21 15:58 rkind 阅读(248) |
评论 (0) |
编辑 收藏以前装过sql server，后来删掉。现在重装，却出现“以前的某个程序安装已在安装计算机上创建挂起的文件操作。运行安装程序之前必须重新启动计算机”错误。无法进行下去。
参考网上资料，总算搞定。步骤是：
1）添加/删除程序中彻底删除sql server。
2）将没有删除的sql server目录也删除掉。
3）打开注册表编辑器，在HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager中找到PendingFileRenameOperations项目，并删除它。这样就可以清除安装暂挂项目。
4）删除注册表中跟sql server相关的键。
其实估计只要做第3步就可以搞定，这样就可以清除安装暂挂项目。自己是先走了1，2，4，最后做了3才搞定。所以估计3才是最关键的。
ME too
posted @
2006-02-21 09:47 rkind 阅读(157) |
评论 (0) |
编辑 收藏前两天要把我们信息平台上的tomcat４加为服务，
刚一开始就想先迁移到tomcat5上可是迁移以后数据库总是联不上，郁闷了好久。
后来又从网上找直接把tomcat4加为服务的脚本，尝试了几次，总是找不到tomcat的目录，原来批处理文件里面不识别空格，把文件名改了下，服务算是加上了，可启动时却总是出错误，又重新装了一次tomcat4.1.3,发现装完以后在 /bin的文件夹里，根本就没有tomcat.exe,着实有些郁闷，看来原来那个tomcat.exe肯定是从tomcat5里面拷过来的。不经意间又装了一遍tomcat4.1.3，发现有一个选项（NT service xp/2000;only）郁闷啊，这不是直接就可以加为服务吗，晕死了过去。。。。
这说明我还是太粗心了，装过那么多回tomcat，也想过这个ntservice，怎么就记过这就是加成服务的呢
，我说网上相关的东西怎么这么少，原来是apahce已经带了这个功能。
posted @
2006-02-14 11:17 rkind 阅读(268) |
评论 (0) |
编辑 收藏把以下代码粘贴到首页中，就可以从counter.txt中读取访问量。
一定要注意路径的问题，刚开始直接用counter.txt，结果总是找不到文件，而且用绝对路径也不行，
但是用/counter.txt就没有问题
<%!
int number=0;
synchronized void countPeople(){
if(number==0){
try{
FileInputStream in=new FileInputStream("/counter.txt");
DataInputStream dataIn=new DataInputStream(in);
number=dataIn.readInt();
number++;
in.close();
dataIn.close();
}catch(FileNotFoundException e){
number++;
try{
FileOutputStream out=new FileOutputStream("/counter.txt");
DataOutputStream dataOut=new DataOutputStream(out);
dataOut.writeInt(number);
out.close();
dataOut.close();
}catch(IOException ffe){
System.out.print(ffe);
}
}catch(IOException ee){
System.out.println(ee);
}
}else{
number++;
try{
FileOutputStream out=new FileOutputStream("/counter.txt");
DataOutputStream dataOut=new DataOutputStream(out);
dataOut.writeInt(number);
out.close();
dataOut.close();
}catch(FileNotFoundException e){
System.out.println(e);
}
catch(IOException e){
System.out.println(e);
}
}
}
%>
<% countPeople();%>
posted @
2006-01-19 11:26 rkind 阅读(314) |
评论 (0) |
编辑 收藏
1、首先进入C:\WINDOWS\system32\drivers找到ETC这个文件夹
2、将ETC文件夹里面的hosts用记事本打开
3、在最后一栏上加上127.0.0.1 auto.search.msn.com
4、保存退出即可。
你试试，就清静多了
posted @
2006-01-18 15:37 rkind 阅读(499) |
评论 (0) |
编辑 收藏
|
您的人格类型是： ISFJ（内向，感觉，情感，判断） |
您的工作中的优势：
◆ 能够很好地集中精力，关注焦点
◆ 很强的工作伦理，工作努力而且很负责任
◆ 良好的协作技巧，能和别人建立和谐友好的关系
◆ 讲求实效的工作态度，办事方法切实可行
◆ 十分关注细节，能够准确把握事实
◆ 乐于助人，给同事和下属职员的工作提供支持和帮助
◆ 了解公司（或者组织）的经历，能够很好地维护公司的传统
◆ 杰出的组织才能
◆ 愿意在传统的机构中工作，而且兢兢业业，不遗余力
◆ 能够连续工作，对于相同的工作不会感到厌倦
◆ 非常强的责任意识，别人可以信赖
◆ 喜欢运用固定的办事程序，尊重别人的地位和能力
◆ 通情达理，视角现实
您工作中可能存在的不足：
◆ 可能会低估自己的能力，难于坚持维护自己的需要和利益
◆ 不愿意尝试新的和未经考验的观点和想法
◆ 对反对意见过于敏感，在紧张的环境中容易感到压抑
◆ 可能只关注眼前的细节，而对整体和未来不太重视
◆ 倾向于同时投入到过多的工作任务中去
◆ 难以适应新的情况，或者在不同工作任务中间来回切换时有困难
◆ 易于被需要同时解决太多的任务或者项目时会弄得无所适从
◆ 如果自己得不到充分的重视和赞赏，可能会感到灰心丧气
◆ 一旦做出决定，就不愿意从头考虑同一个问题
| |
posted @
2006-01-10 17:10 rkind 阅读(150) |
评论 (0) |
编辑 收藏<form action="submit_1.html" method=post>
<input type=image src="exa.gif" name="sub1">
</form>
就是这简单
posted @
2006-01-04 13:58 rkind 阅读(495) |
评论 (0) |
编辑 收藏
你可以通过下列途径学习spring：
(1) spring下载包中doc目录下的MVC-step-by-step和sample目录下的例子都是比较好的spring开发的例子。
(2) AppFuse集成了目前最流行的几个开源轻量级框架或者工具 Ant,XDoclet,Spring,Hibernate(iBATIS),JUnit,Cactus,StrutsTestCase,Canoo's WebTest,Struts Menu,Display Tag Library,OSCache,JSTL,Struts 。
你可以通过AppFuse源代码来学习spring。
AppFuse网站：http://raibledesigns.com/wiki/Wiki.jsp?page=AppFuse
(3)Spring 开发指南(夏昕)（http://www.xiaxin.net/Spring_Dev_Guide.rar）
一本spring的入门书籍,里面介绍了反转控制和依赖注射的概念，以及spring的bean管理，spring的MVC，spring和hibernte，iBatis的结合。
(4) spring学习的中文论坛
SpringFramework中文论坛(http://spring.jactiongroup.net)
Java视线论坛(http://forum.javaeye.com)的spring栏目
2、利用Spring框架编程，console打印出log4j:WARN Please initialize the log4j system properly？
说明你的log4j.properties没有配置。请把log4j.properties放到工程的classpath中，eclipse的classpath为bin目录，由于编译后src目录下的文件会拷贝到bin目录下，所以你可以把log4j.properties放到src目录下。
这里给出一个log4j.properties的例子：
log4j.rootLogger=DEBUG,stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d %5p (%F:%L) - %m%n |
3、出现 java.lang.NoClassDefFoundError?
一般情况下是由于你没有把必要的jar包放到lib中。
比如你要采用spring和hibernate（带事务支持的话），你除了spring.jar外还需要hibernat.jar、aopalliance.jar、cglig.jar、jakarta-commons下的几个jar包。
http://www.springframework.org/download.html下载spring开发包，提供两种zip包
spring-framework-1.1.3-with-dependencies.zip和spring-framework-1.1.3.zip，我建议你下载spring-framework-1.1.3-with-dependencies.zip。这个zip解压缩后比后者多一个lib目录，其中有hibernate、j2ee、dom4j、aopalliance、jakarta-commons等常用包。
4、java.io.FileNotFoundException: Could not open class path resource [....hbm.xml],提示找不到xml文件？
原因一般有两个：
(1)该xml文件没有在classpath中。
(2)applicationContext-hibernate.xml中的xml名字没有带包名。比如：
＜bean id="sessionFactory" class="org.springframework.orm.hibernate.LocalSessionFactoryBean"＞
＜property name="dataSource"＞＜ref bean="dataSource"/＞＜/property＞
＜property name="mappingResources"＞
＜list＞
＜value＞User.hbm.xml＜/value＞
错，改为：
＜value＞com/yz/spring/domain/User.hbm.xml＜/value＞
＜/list＞
＜/property＞
＜property name="hibernateProperties"＞
＜props＞
＜prop key="hibernate.dialect"＞ net.sf.hibernate.dialect.MySQLDialect ＜/prop＞
＜prop key="hibernate.show_sql"＞true＜/prop＞
＜/props＞
＜/property＞
＜/bean＞ |
5、org.springframework.beans.NotWritablePropertyException: Invalid property 'postDao' of bean class？
出现异常的原因是在application-xxx.xml中property name的错误。
＜property name="...."＞ 中name的名字是与bean的set方法相关的，而且要注意大小写。
比如
public class PostManageImpl extends BaseManage implements PostManage {
private PostDAO dao = null;
public void setPostDAO(PostDAO postDAO){
this.dao = postDAO;
}
} |
那么xml的定义应该是：
＜bean id="postManage" parent="txProxyTemplate"＞
＜property name="target"＞
＜bean class="com.yz.spring.service.implement.PostManageImpl"＞
＜property name="postDAO"＞＜ref bean="postDAO"/＞＜/property＞ 对
＜property name="dao"＞＜ref bean="postDAO"/＞＜/property＞ 错
＜/bean＞
＜/property＞
＜/bean＞ |
6、Spring中如何实现事务管理？
首先，如果使用mysql，确定mysql为InnoDB类型。
事务管理的控制应该放到商业逻辑层。你可以写个处理商业逻辑的JavaBean，在该JavaBean中调用DAO，然后把该Bean的方法纳入spring的事务管理。
比如：xml文件定义如下：
＜bean id="txProxyTemplate" abstract="true"
class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"＞
＜property name="transactionManager"＞＜ref bean="transactionManager"/＞＜/property＞
＜property name="transactionAttributes"＞
＜props＞
＜prop key="save*"＞PROPAGATION_REQUIRED＜/prop＞
＜prop key="remove*"＞PROPAGATION_REQUIRED＜/prop＞
＜prop key="*"＞PROPAGATION_REQUIRED＜/prop＞
＜/props＞
＜/property＞
＜/bean＞
＜bean id="userManage" parent="txProxyTemplate"＞
＜property name="target"＞
＜bean class="com.yz.spring.service.implement.UserManageImpl"＞
＜property name="userDAO"＞＜ref bean="userDAO"/＞＜/property＞
＜/bean＞
＜/property＞
＜/bean＞ |
com.yz.spring.service.implement.UserManageImpl就是我们的实现商业逻辑的JavaBean。我们通过parent元素声明其事务支持。
7、如何管理Spring框架下更多的JavaBean？
JavaBean越多，spring配置文件就越大，这样不易维护。为了使配置清晰，我们可以将JavaBean分类管理，放在不同的配置文件中。 应用启动时将所有的xml同时加载。
比如：
DAO层的JavaBean放到applicationContext-hibernate.xml中，商业逻辑层的JavaBean放到applicationContext-service.xml中。然后启动类中调用以下代码载入所有的ApplicationContext。
String[] paths = {"com/yz/spring/dao/hibernate/applicationContext-hibernate.xml",
"com/yz/spring/service/applicationContext-service.xml"};
ctx = new ClassPathXmlApplicationContext(paths); |
8、web应用中如何加载ApplicationContext？
可以通过定义web.xml，由web容器自动加载。
＜servlet＞
＜servlet-name＞context＜/servlet-name＞
＜servlet-class＞org.springframework.web.context.ContextLoaderServlet＜/servlet-class＞
＜load-on-startup＞1＜/load-on-startup＞
＜/servlet＞
＜context-param＞
＜param-name＞contextConfigLocation＜/param-name＞
＜param-value＞/WEB-INF/applicationContext-hibernate.xml＜/param-value＞
＜param-value＞/WEB-INF/applicationContext-service.xml＜/param-value＞
＜/context-param＞ |
9、在spring中如何配置的log4j?
在web.xml中加入以下代码即可。
＜context-param＞
＜param-name＞log4jConfigLocation＜/param-name＞
＜param-value＞/WEB-INF/log4j.properties＜/param-value＞
＜/context-param＞ |
10、Spring框架入门的编程问题解决了，我该如何更深地领会Spring框架呢？
这两本书你该去看看。这两本书是由Spring的作者Rod Johnson编写的。
Expert One on one J2EE Design and Development
Expert One on one J2EE Development Without EJB |
你也该看看martinfowler的Inversion of Control Containers and the Dependency Injection pattern。
| http://www.martinfowler.com/articles/injection.html |
再好好研读一下spring的文档。
| http://www.jactiongroup.net/reference/html/index.html（中文版，未全部翻译） |
还有就是多实践吧。
posted @
2005-12-06 17:54 rkind 阅读(191) |
评论 (0) |
编辑 收藏abstract class和interface是Java语言中对于抽象类定义进行支持的两种机制，正是由于这两种机制的存在，才赋予了Java强大的面向对象能力。abstract class和interface之间在对于抽象类定义的支持方面具有很大的相似性，甚至可以相互替换，因此很多开发者在进行抽象类定义时对于abstract class和interface的选择显得比较随意。
其实，两者之间还是有很大的区别的，对于它们的选择甚至反映出对于问题领域本质的理解、对于设计意图的理解是否正确、合理。本文将对它们之间的区别进行一番剖析，试图给开发者提供一个在二者之间进行选择的依据。
一、理解抽象类
abstract class和interface在Java语言中都是用来进行抽象类（本文中的抽象类并非从abstract class翻译而来，它表示的是一个抽象体，而abstract class为Java语言中用于定义抽象类的一种方法，请读者注意区分）定义的，那么什么是抽象类，使用抽象类能为我们带来什么好处呢？
在面向对象的概念中，我们知道所有的对象都是通过类来描绘的，但是反过来却不是这样。并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。抽象类往往用来表征我们在对问题领域进行分析、设计中得出的抽象概念，是对一系列看上去不同，但是本质上相同的具体概念的抽象。
比如：如果我们进行一个图形编辑软件的开发，就会发现问题领域存在着圆、三角形这样一些具体概念，它们是不同的，但是它们又都属于形状这样一个概念，形状这个概念在问题领域是不存在的，它就是一个抽象概念。正是因为抽象的概念在问题领域没有对应的具体概念，所以用以表征抽象概念的抽象类是不能够实例化的。
在面向对象领域，抽象类主要用来进行类型隐藏。我们可以构造出一个固定的一组行为的抽象描述，但是这组行为却能够有任意个可能的具体实现方式。这个抽象描述就是抽象类，而这一组任意个可能的具体实现则表现为所有可能的派生类。模块可以操作一个抽象体。由于模块依赖于一个固定的抽象体，因此它可以是不允许修改的；同时，通过从这个抽象体派生，也可扩展此模块的行为功能。熟悉OCP的读者一定知道，为了能够实现面向对象设计的一个最核心的原则OCP(Open-Closed Principle)，抽象类是其中的关键所在。
二、从语法定义层面看abstract class和interface
在语法层面，Java语言对于abstract class和interface给出了不同的定义方式，下面以定义一个名为Demo的抽象类为例来说明这种不同。使用abstract class的方式定义Demo抽象类的方式如下：
abstract class Demo ｛
abstract void method1();
abstract void method2();
…
｝ |
使用interface的方式定义Demo抽象类的方式如下：
interface Demo {
void method1();
void method2();
…
} |
在abstract class方式中，Demo可以有自己的数据成员，也可以有非abstarct的成员方法，而在interface方式的实现中，Demo只能够有静态的不能被修改的数据成员（也就是必须是static final的，不过在interface中一般不定义数据成员），所有的成员方法都是abstract的。从某种意义上说，interface是一种特殊形式的abstract class。
从编程的角度来看，abstract class和interface都可以用来实现"design by contract"的思想。但是在具体的使用上面还是有一些区别的。
首先，abstract class在Java语言中表示的是一种继承关系，一个类只能使用一次继承关系。但是，一个类却可以实现多个interface。也许，这是Java语言的设计者在考虑Java对于多重继承的支持方面的一种折中考虑吧。
其次，在abstract class的定义中，我们可以赋予方法的默认行为。但是在interface的定义中，方法却不能拥有默认行为，为了绕过这个限制，必须使用委托，但是这会 增加一些复杂性，有时会造成很大的麻烦。
在抽象类中不能定义默认行为还存在另一个比较严重的问题，那就是可能会造成维护上的麻烦。因为如果后来想修改类的界面（一般通过abstract class或者interface来表示）以适应新的情况（比如，添加新的方法或者给已用的方法中添加新的参数）时，就会非常的麻烦，可能要花费很多的时间（对于派生类很多的情况，尤为如此）。但是如果界面是通过abstract class来实现的，那么可能就只需要修改定义在abstract class中的默认行为就可以了。
同样，如果不能在抽象类中定义默认行为，就会导致同样的方法实现出现在该抽象类的每一个派生类中，违反了"one rule，one place"原则，造成代码重复，同样不利于以后的维护。因此，在abstract class和interface间进行选择时要非常的小心。
三、从设计理念层面看abstract class和interface
上面主要从语法定义和编程的角度论述了abstract class和interface的区别，这些层面的区别是比较低层次的、非本质的。本文将从另一个层面：abstract class和interface所反映出的设计理念，来分析一下二者的区别。作者认为，从这个层面进行分析才能理解二者概念的本质所在。
前面已经提到过，abstarct class在Java语言中体现了一种继承关系，要想使得继承关系合理，父类和派生类之间必须存在"is a"关系，即父类和派生类在概念本质上应该是相同的。对于interface 来说则不然，并不要求interface的实现者和interface定义在概念本质上是一致的，仅仅是实现了interface定义的契约而已。为了使论述便于理解，下面将通过一个简单的实例进行说明。
考虑这样一个例子，假设在我们的问题领域中有一个关于Door的抽象概念，该Door具有执行两个动作open和close，此时我们可以通过abstract class或者interface来定义一个表示该抽象概念的类型，定义方式分别如下所示：
使用abstract class方式定义Door：
abstract class Door {
abstract void open();
abstract void close()；
}
使用interface方式定义Door：
interface Door {
void open();
void close();
} |
其他具体的Door类型可以extends使用abstract class方式定义的Door或者implements使用interface方式定义的Door。看起来好像使用abstract class和interface没有大的区别。
如果现在要求Door还要具有报警的功能。我们该如何设计针对该例子的类结构呢（在本例中，主要是为了展示abstract class和interface反映在设计理念上的区别，其他方面无关的问题都做了简化或者忽略）下面将罗列出可能的解决方案，并从设计理念层面对这些不同的方案进行分析。
解决方案一：
简单的在Door的定义中增加一个alarm方法，如下：
abstract class Door {
abstract void open();
abstract void close()；
abstract void alarm();
}
或者
interface Door {
void open();
void close();
void alarm();
} |
那么具有报警功能的AlarmDoor的定义方式如下：
class AlarmDoor extends Door {
void open() { … }
void close() { … }
void alarm() { … }
}
或者
class AlarmDoor implements Door ｛
void open() { … }
void close() { … }
void alarm() { … }
｝ |
这种方法违反了面向对象设计中的一个核心原则ISP（Interface Segregation Priciple），在Door的定义中把Door概念本身固有的行为方法和另外一个概念"报警器"的行为方法混在了一起。这样引起的一个问题是那些仅仅依赖于Door这个概念的模块会因为"报警器"这个概念的改变（比如：修改alarm方法的参数）而改变，反之依然。
解决方案二：
既然open、close和alarm属于两个不同的概念，根据ISP原则应该把它们分别定义在代表这两个概念的抽象类中。定义方式有：这两个概念都使用abstract class方式定义；两个概念都使用interface方式定义；一个概念使用abstract class方式定义，另一个概念使用interface方式定义。
显然，由于Java语言不支持多重继承，所以两个概念都使用abstract class方式定义是不可行的。后面两种方式都是可行的，但是对于它们的选择却反映出对于问题领域中的概念本质的理解、对于设计意图的反映是否正确、合理。我们一一来分析、说明。
如果两个概念都使用interface方式来定义，那么就反映出两个问题：
1、我们可能没有理解清楚问题领域，AlarmDoor在概念本质上到底是Door还是报警器？
2、如果我们对于问题领域的理解没有问题，比如：我们通过对于问题领域的分析发现AlarmDoor在概念本质上和Door是一致的，那么我们在实现时就没有能够正确的揭示我们的设计意图，因为在这两个概念的定义上（均使用interface方式定义）反映不出上述含义。
如果我们对于问题领域的理解是：AlarmDoor在概念本质上是Door，同时它有具有报警的功能。我们该如何来设计、实现来明确的反映出我们的意思呢？前面已经说过，abstract class在Java语言中表示一种继承关系，而继承关系在本质上是"is a"关系。所以对于Door这个概念，我们应该使用abstarct class方式来定义。另外，AlarmDoor又具有报警功能，说明它又能够完成报警概念中定义的行为，所以报警概念可以通过interface方式定义。如下所示：
abstract class Door {
abstract void open();
abstract void close()；
}
interface Alarm {
void alarm();
}
class AlarmDoor extends Door implements Alarm {
void open() { … }
void close() { … }
void alarm() { … }
} |
这种实现方式基本上能够明确的反映出我们对于问题领域的理解，正确的揭示我们的设计意图。其实abstract class表示的是"is a"关系，interface表示的是"like a"关系，大家在选择时可以作为一个依据，当然这是建立在对问题领域的理解上的，比如：如果我们认为AlarmDoor在概念本质上是报警器，同时又具有Door的功能，那么上述的定义方式就要反过来了。
abstract class和interface是Java语言中的两种定义抽象类的方式，它们之间有很大的相似性。但是对于它们的选择却又往往反映出对于问题领域中的概念本质的理解、对于设计意图的反映是否正确、合理，因为它们表现了概念间的不同的关系（虽然都能够实现需求的功能）。这其实也是语言的一种的惯用法，希望读者朋友能够细细体会
posted @
2005-12-06 11:03 rkind 阅读(212) |
评论 (0) |
编辑 收藏
|
JBUILDER的光标定位不准确的最佳解决方案是：进入%JBUILDER_HOME%/bin目录下，用写字板编辑jbuilder.config，把下面的配置加进去：
vmparam -Dprimetime.editor.useVariableWidthFont=true |
posted @
2005-12-06 11:02 rkind 阅读(221) |
评论 (0) |
编辑 收藏Ant的简介：类似make工具，但可以支持多平台
Ant的安装：配置ant的准备工作：ant_home 指Ant的安装目录，在path中加入%ant_home%/bin,用于命令行下
运 行ant
Ant的结构：主要是通过对build.xml的配置，
Ant内置任务： 描述
property 设置name/value的属性
mkdir 创建目录
copy 拷贝
delete 删除
javac 编绎
war 打包
下面是一个简单build.xml的示例：
<project name="bookstore" default="about" basedir=".">
<target name="init">
<tstamp/>
<property name="build" value="build" />
<property name="src" value="src" />
<property environment="myenv" />
<property name="servletpath" value="${myenv.CATALINA_HOME}/common/lib/servlet-api.jar" />
<property name="mysqlpath" value="WEB-INF/lib/mysqldriver.jar" />
<mkdir dir="${build}" />
<mkdir dir="${build}\WEB-INF" />
<mkdir dir="${build}\WEB-INF\classes" />
<copy todir="${build}" >
<fileset dir="${basedir}" >
<include name="*.jsp" />
<include name="*.bmp" />
<include name="WEB-INF/**" />
<exclude name="build.xml" />
</fileset>
</copy>
</target>
<target name="compile" depends="init">
<javac srcdir="${src}"
destdir="${build}/WEB-INF/classes"
classpath="${servletpath}:${mysqlpath}">
</javac>
</target>
<target name="bookstorewar" depends="compile">
<war warfile="${build}/bookstore.war" webxml="${build}/WEB-INF/web.xml">
<lib dir="${build}/WEB-INF/lib"/>
<classes dir="${build}/WEB-INF/classes"/>
<fileset dir="${build}"/>
</war>
</target>
<target name="about" >
<echo>
This build.xml file contains targets
for building bookstore web application
</echo>
</target>
</project>
从示例我们看出来，整个xml是一个project，project下有几个为init,compile,的target
运行时首先在这个目录下打开dos窗口，以这个xml为准，如果你只运行ant那么只会输出echo中的内容
因为project的default是about; 如果运行ant complie 它会执行两个target: init 和complie，因为complie是依靠init
的。
用了以后发现ant 原来很简单，当然现在只是学了个皮毛而已。
posted @
2005-11-25 14:53 rkind 阅读(244) |
评论 (0) |
编辑 收藏 RMI，远程方法调用（Remote Method Invocation）是Enterprise JavaBeans的支柱，是建立分布式Java应用程序的方便途径。RMI是非常容易使用的，但是它非常的强大。
RMI的基础是接口，RMI构架基于一个重要的原理：定义接口和定义接口的具体实现是分开的。下面我们通过具体的例子，建立一个简单的远程计算服务和使用它的客户程序
一个正常工作的RMI系统由下面几个部分组成：
● 远程服务的接口定义
● 远程服务接口的具体实现
● 桩（Stub）和框架（Skeleton）文件
● 一个运行远程服务的服务器
● 一个RMI命名服务，它允许客户端去发现这个远程服务
● 类文件的提供者（一个HTTP或者FTP服务器）
● 一个需要这个远程服务的客户端程序
下面我们一步一步建立一个简单的RMI系统。首先在你的机器里建立一个新的文件夹，以便放置我们创建的文件，为了简单起见，我们只使用一个文件夹存放客户端和服务端代码，并且在同一个目录下运行服务端和客户端。
如果所有的RMI文件都已经设计好了，那么你需要下面的几个步骤去生成你的系统：
1、 编写并且编译接口的Java代码
2、 编写并且编译接口实现的Java代码
3、 从接口实现类中生成桩（Stub）和框架（Skeleton）类文件
4、 编写远程服务的主运行程序
5、 编写RMI的客户端程序
6、 安装并且运行RMI系统
1、 接口
第一步就是建立和编译服务接口的Java代码。这个接口定义了所有的提供远程服务的功能，下面是源程序：
//Calculator.java
//define the interface
import java.rmi.Remote;
public interface Calculator extends Remote
{
public long add(long a, long b)
throws java.rmi.RemoteException;
public long sub(long a, long b)
throws java.rmi.RemoteException;
public long mul(long a, long b)
throws java.rmi.RemoteException;
public long div(long a, long b)
throws java.rmi.RemoteException;
}
注意，这个接口继承自Remote，每一个定义的方法都必须抛出一个RemoteException异常对象。
建立这个文件，把它存放在刚才的目录下，并且编译。
>javac Calculator.java
2、 接口的具体实现
下一步，我们就要写远程服务的具体实现，这是一个CalculatorImpl类文件：
//CalculatorImpl.java
//Implementation
import java.rmi.server.UnicastRemoteObject
public class CalculatorImpl extends UnicastRemoteObject implements Calculator
{
// 这个实现必须有一个显式的构造函数，并且要抛出一个RemoteException异常
public CalculatorImpl()
throws java.rmi.RemoteException {
super();
}
public long add(long a, long b)
throws java.rmi.RemoteException {
return a + b;
}
public long sub(long a, long b)
throws java.rmi.RemoteException {
return a - b;
}
public long mul(long a, long b)
throws java.rmi.RemoteException {
return a * b;
}
public long div(long a, long b)
throws java.rmi.RemoteException {
return a / b;
}
}
同样的，把这个文件保存在你的目录里然后编译他。
这个实现类使用了UnicastRemoteObject去联接RMI系统。在我们的例子中，我们是直接的从UnicastRemoteObject这个类上继承的，事实上并不一定要这样做，如果一个类不是从UnicastRmeoteObject上继承，那必须使用它的exportObject()方法去联接到RMI。
如果一个类继承自UnicastRemoteObject，那么它必须提供一个构造函数并且声明抛出一个RemoteException对象。当这个构造函数调用了super()，它久激活UnicastRemoteObject中的代码完成RMI的连接和远程对象的初始化。
3、 桩（Stubs）和框架（Skeletons）
下一步就是要使用RMI编译器rmic来生成桩和框架文件，这个编译运行在远程服务实现类文件上。
>rmic CalculatorImpl
在你的目录下运行上面的命令，成功执行完上面的命令你可以发现一个Calculator_stub.class文件，如果你是使用的Java2SDK，那么你还可以发现Calculator_Skel.class文件。
4、 主机服务器
远程RMI服务必须是在一个服务器中运行的。CalculatorServer类是一个非常简单的服务器。
//CalculatorServer.java
import java.rmi.Naming;
public class CalculatorServer {
public CalculatorServer() {
try {
Calculator c = new CalculatorImpl();
Naming.rebind("rmi://localhost:1099/CalculatorService", c);
} catch (Exception e) {
System.out.println("Trouble: " + e);
}
}
public static void main(String args[]) {
new CalculatorServer();
}
}
建立这个服务器程序，然后保存到你的目录下，并且编译它。
5、 客户端
客户端源代码如下：
//CalculatorClient.java
import java.rmi.Naming;
import java.rmi.RemoteException;
import java.net.MalformedURLException;
import java.rmi.NotBoundException;
public class CalculatorClient {
public static void main(String[] args) {
try {
Calculator c = (Calculator)
Naming.lookup(
"rmi://localhost
/CalculatorService");
System.out.println( c.sub(4, 3) );
System.out.println( c.add(4, 5) );
System.out.println( c.mul(3, 6) );
System.out.println( c.div(9, 3) );
}
catch (MalformedURLException murle) {
System.out.println();
System.out.println(
"MalformedURLException");
System.out.println(murle);
}
catch (RemoteException re) {
System.out.println();
System.out.println(
"RemoteException");
System.out.println(re);
}
catch (NotBoundException nbe) {
System.out.println();
System.out.println(
"NotBoundException");
System.out.println(nbe);
}
catch (
java.lang.ArithmeticException
ae) {
System.out.println();
System.out.println(
"java.lang.ArithmeticException");
System.out.println(ae);
}
}
}
保存这个客户端程序到你的目录下（注意这个目录是一开始建立那个，所有的我们的文件都在那个目录下），并且编译他。
6、 运行RMI系统
现在我们建立了所有运行这个简单RMI系统所需的文件，现在我们终于可以运行这个RMI系统啦！来享受吧。
我们是在命令控制台下运行这个系统的，你必须开启三个控制台窗口，一个运行服务器，一个运行客户端，还有一个运行RMIRegistry。
首先运行注册程序RMIRegistry，你必须在包含你刚写的类的那么目录下运行这个注册程序。
>rmiregistry
好，这个命令成功的话，注册程序已经开始运行了，不要管他，现在切换到另外一个控制台，在第二个控制台里，我们运行服务器CalculatorService，因为RMI的安全机制将在服务端发生作用,所以你必须增加一条安全策略。以下是对应安全策略的例子
grant {
permission java.security.AllPermission "", "";
};
注意:这是一条最简单的安全策略,它允许任何人做任何事,对于你的更加关键性的应用,你必须指定更加详细安全策略。
现在为了运行服务端，你需要除客户类(CalculatorClient.class)之外的所有的类文件。确认安全策略在policy.txt文件之后,使用如下命令来运行服务器。
> java -Djava.security.policy=policy.txt CalculatorServer
这个服务器就开始工作了，把接口的实现加载到内存等待客户端的联接。好现在切换到第三个控制台，启动我们的客户端。
为了在其他的机器运行客户端程序你需要一个远程接口(Calculator.class) 和一个stub(CalculatorImpl_Stub.class)。 使用如下命令运行客户端
prompt> java -Djava.security.policy=policy.txt CalculatorClient
如果所有的这些都成功运行，你应该看到下面的输出：
1
9
18
3
如果你看到了上面的输出，恭喜你，你成功了，你已经成功的创建了一个RMI系统，并且使他正确工作了。即使你运行在同一个计算机上，RMI还是使用了你的网络堆栈和TCP/IP去进行通讯，并且是运行在三个不同的Java虚拟机上。这已经是一个完整的RMI系统。
posted @
2005-11-15 18:46 rkind 阅读(219) |
评论 (0) |
编辑 收藏 在一个有密码保护的Web应用中，正确处理用户退出过程并不仅仅只需调用HttpSession的invalidate()方法。现在大部分浏览器上都有后退和前进按钮，允许用户后退或前进到一个页面。如果在用户在退出一个Web应用后按了后退按钮浏览器把缓存中的页面呈现给用户，这会使用户产生疑惑，他们会开始担心他们的个人数据是否安全。许多Web应用强迫用户退出时关闭整个浏览器，这样，用户就无法点击后退按钮了。还有一些使用javascript，但在某些客户端浏览器这却不一定起作用。这些解决方案都很笨拙且不能保证在任一情况下100%有效，同时，它也要求用户有一定的操作经验。
这篇文章以示例阐述了正确解决用户退出问题的方案。作者Kevin Le首先描述了一个密码保护Web应用，然后以示例程序解释问题如何产生并讨论解决问题的方案。文章虽然是针对JSP页面进行阐述，但作者所阐述的概念很容易理解切能够为其他Web技术所采用。最后作者展示了如何用Jakarta Struts优雅地解决这一问题。
大部分Web应用不会包含象银行账户或信用卡资料那样机密的信息，但一旦涉及到敏感数据，我们就需要提供一类密码保护机制。举例来说，一个工厂中工人通过Web访问他们的时间安排、进入他们的训练课程以及查看他们的薪金等等。此时应用SSL(Secure Socket Layer)有点杀鸡用牛刀的感觉，但不可否认，我们又必须为这些应用提供密码保护，否则，工人（也就是Web应用的使用者）可以窥探到工厂中其他雇员的私人机密信息。
与上述情形相似的还有位处图书馆、医院等公共场所的计算机。在这些地方，许多用户共同使用几台计算机，此时保护用户的个人数据就显得至关重要。设计良好编写优秀的应用对用户专业知识的要求少之又少。
我们来看一下现实世界中一个完美的Web应用是如何表现的：一个用户通过浏览器访问一个页面。Web应用展现一个登陆页面要求用户输入有效的验证信息。用户输入了用户名和密码。此时我们假设用户提供的身份验证信息是正确的，经过了验证过程，Web应用允许用户浏览他有权访问的区域。用户想退出时，点击退出按钮，Web应用要求用户确认他是否则真的需要退出，如果用户确定退出，Session结束，Web应用重新定位到登陆页面。用户可以放心的离开而不用担心他的信息会泄露。另一个用户坐到了同一台电脑前，他点击后退按钮，Web应用不应该出现上一个用户访问过的任何一个页面。事实上，Web应用在第二个用户提供正确的验证信息之前应当一直停留在登陆页面上。
通过示例程序，文章向您阐述了如何在一个Web应用中实现这一功能。
JSP示例
为了更为有效地阐述实现方案，本文将从展示一个示例应用logoutSampleJSP1中碰到的问题开始。这个示例代表了许多没有正确解决退出过程的Web应用。logoutSampleJSP1包含了下述jsp页面：login.jsp, home.jsp, secure1.jsp, secure2.jsp, logout.jsp, loginAction.jsp, and logoutAction.jsp。其中页面home.jsp, secure1.jsp, secure2.jsp, 和logout.jsp是不允许未经认证的用户访问的，也就是说，这些页面包含了重要信息，在用户登陆之前或者退出之后都不应该出现在浏览器中。login.jsp包含了用于用户输入用户名和密码的form。logout.jsp页包含了要求用户确认是否退出的form。loginAction.jsp和logoutAction.jsp作为控制器分别包含了登陆和退出代码。
第二个示例应用logoutSampleJSP2展示了如何解决示例logoutSampleJSP1中的问题。然而，第二个应用自身也是有疑问的。在特定的情况下，退出问题还是会出现。
第三个示例应用logoutSampleJSP3在第二个示例上进行了改进，比较完善地解决了退出问题。
最后一个示例logoutSampleStruts展示了Struts如何优美地解决登陆问题。
注意：本文所附示例在最新版本的Microsoft Internet Explorer (IE), Netscape Navigator, Mozilla, FireFox和Avant浏览器上测试通过。
Login action
Brian Pontarelli的经典文章《J2EE Security: Container Versus Custom》讨论了不同的J2EE认证途径。文章同时指出，HTTP协议和基于form的认证并未提供处理用户退出的机制。因此，解决途径便是引入自定义的安全实现机制。
自定义的安全认证机制普遍采用的方法是从form中获得用户输入的认证信息，然后到诸如LDAP (lightweight directory access protocol)或关系数据库的安全域中进行认证。如果用户提供的认证信息是有效的，登陆动作往HttpSession对象中注入某个对象。HttpSession存在着注入的对象则表示用户已经登陆。为了方便读者理解，本文所附的示例只往HttpSession中写入一个用户名以表明用户已经登陆。清单1是从loginAction.jsp页面中节选的一段代码以此阐述登陆动作：
Listing 1
//...
//initialize RequestDispatcher object; set forward to home page by default
RequestDispatcher rd = request.getRequestDispatcher("home.jsp");
//Prepare connection and statement
rs = stmt.executeQuery("select password from USER where userName = '" + userName + "'");
if (rs.next()) {
//Query only returns 1 record in the result set; only 1
password per userName which is also the primary key
if (rs.getString("password").equals(password)) { //If valid password
session.setAttribute("User", userName); //Saves username string in the session object
}
else { //Password does not match, i.e., invalid user password
request.setAttribute("Error", "Invalid password.");
rd = request.getRequestDispatcher("login.jsp");
}
} //No record in the result set, i.e., invalid username
else {
request.setAttribute("Error", "Invalid user name.");
rd = request.getRequestDispatcher("login.jsp");
}
}
//As a controller, loginAction.jsp finally either forwards to "login.jsp" or "home.jsp"
rd.forward(request, response);
//... |
本文所附示例均以关系型数据库作为安全域，但本文所阐述的观点对任何类型的安全域都是适用的。
Logout action
退出动作就包含了简单的删除用户名以及对用户的HttpSession对象调用invalidate()方法。清单2是从loginoutAction.jsp页面中节选的一段代码以此阐述退出动作：
Listing 2
//...
session.removeAttribute("User");
session.invalidate();
//... |
阻止未经认证访问受保护的JSP页面
从form中获取用户提交的认证信息并经过验证后，登陆动作简单地往 HttpSession对象中写入一个用户名，退出动作则做相反的工作，它从用户的HttpSession对象中删除用户名并调用invalidate()方法销毁HttpSession。为了使登陆和退出动作真正发挥作用，所有受保护的JSP页面都应该首先验证HttpSession中是否包含了用户名以确认当前用户是否已经登陆。如果HttpSession中包含了用户名，也就是说用户已经登陆，Web应用则将剩余的JSP页发送给浏览器，否则，JSP页将跳转到登陆页login.jsp。页面home.jsp, secure1.jsp, secure2.jsp和logout.jsp均包含清单3中的代码段：
Listing 3
//...
String userName = (String) session.getAttribute("User");
if (null == userName) {
request.setAttribute("Error", "Session has ended. Please login.");
RequestDispatcher rd = request.getRequestDispatcher("login.jsp");
rd.forward(request, response);
}
//...
//Allow the rest of the dynamic content in this JSP to be served to the browser
//... |
在这个代码段中，程序从HttpSession中减缩username字符串。如果字符串为空，Web应用则自动中止执行当前页面并跳转到登陆页，同时给出Session has ended. Please log in.的提示；如果不为空，Web应用则继续执行，也就是把剩余的页面提供给用户。
运行logoutSampleJSP1
运行logoutSampleJSP1将会出现如下几种情形：
1) 如果用户没有登陆，Web应用将会正确中止受保护页面home.jsp, secure1.jsp, secure2.jsp和logout.jsp的执行，也就是说，假如用户在浏览器地址栏中直接敲入受保护JSP页的地址试图访问，Web应用将自动跳转到登陆页并提示Session has ended.Please log in.
2) 同样的，当一个用户已经退出，Web应用也会正确中止受保护页面home.jsp, secure1.jsp, secure2.jsp和logout.jsp的执行
3) 用户退出后，如果点击浏览器上的后退按钮，Web应用将不能正确保护受保护的页面——在Session销毁后（用户退出）受保护的JSP页重新在浏览器中显示出来。然而，如果用户点击返回页面上的任何链接，Web应用将会跳转到登陆页面并提示Session has ended.Please log in.
阻止浏览器缓存 上述问题的根源在于大部分浏览器都有一个后退按钮。当点击后退按钮时，默认情况下浏览器不是从Web服务器上重新获取页面，而是从浏览器缓存中载入页面。基于Java的Web应用并未限制这一功能，在基于PHP、ASP和.NET的Web应用中也同样存在这一问题。
在用户点击后退按钮后，浏览器到服务器再从服务器到浏览器这样通常意思上的HTTP回路并没有建立，仅仅只是用户，浏览器和缓存进行了交互。所以，即使包含了清单3上的代码来保护JSP页面，当点击后退按钮时，这些代码是不会执行的。
缓存的好坏，真是仁者见仁智者见智。缓存的确提供了一些便利，但通常只在使用静态的HTML页面或基于图形或影响的页面你才能感受到。而另一方面，Web应用通常是基于数据的，数据通常是频繁更改的。与从缓存中读取并显示过期的数据相比，提供最新的数据才是更重要的！
幸运的是，HTTP头信息“Expires”和“Cache-Control”为应用程序服务器提供了一个控制浏览器和代理服务器上缓存的机制。HTTP头信息Expires告诉代理服务器它的缓存页面何时将过期。HTTP1.1规范中新定义的头信息Cache-Control可以通知浏览器不缓存任何页面。当点击后退按钮时，浏览器重新访问服务器已获取页面。如下是使用Cache-Control的基本方法：
1) no-cache:强制缓存从服务器上获取新的页面
2) no-store: 在任何环境下缓存不保存任何页面
HTTP1.0规范中的Pragma:no-cache等同于HTTP1.1规范中的Cache-Control:no-cache，同样可以包含在头信息中。
通过使用HTTP头信息的cache控制，第二个示例应用logoutSampleJSP2解决了logoutSampleJSP1的问题。logoutSampleJSP2与logoutSampleJSP1不同表现在如下代码段中，这一代码段加入进所有受保护的页面中:
//...
response.setHeader("Cache-Control","no-cache"); //Forces caches to obtain a new copy of the page from the origin server
response.setHeader("Cache-Control","no-store"); //Directs caches not to store the page under any circumstance
response.setDateHeader("Expires", 0); //Causes the proxy cache to see the page as "stale"
response.setHeader("Pragma","no-cache"); //HTTP 1.0 backward compatibility
String userName = (String) session.getAttribute("User");
if (null == userName) {
request.setAttribute("Error", "Session has ended. Please login.");
RequestDispatcher rd = request.getRequestDispatcher("login.jsp");
rd.forward(request, response);
}
//... |
通过设置头信息和检查HttpSession中的用户名确保了浏览器不缓存页面，同时，如果用户未登陆，受保护的JSP页面将不会发送到浏览器，取而代之的将是登陆页面login.jsp。
运行logoutSampleJSP2 运行logoutSampleJSP2后将回看到如下结果：
1) 当用户退出后试图点击后退按钮，浏览器并不会显示受保护的页面，它只会现实登陆页login.jsp同时给出提示信息Session has ended. Please log in.
2) 然而，当按了后退按钮返回的页是处理用户提交数据的页面时，IE和Avant浏览器将弹出如下信息提示：
警告：页面已过期……（你肯定见过）
选择刷新后前一个JSP页面将重新显示在浏览器中。很显然，这不是我们所想看到的因为它违背了logout动作的目的。发生这一现象时，很可能是一个恶意用户在尝试获取其他用户的数据。然而，这个问题仅仅出现在后退按钮对应的是一个处理POST请求的页面。
记录最后登陆时间 上述问题之所以出现是因为浏览器将其缓存中的数据重新提交了。这本文的例子中，数据包含了用户名和密码。无论是否给出安全警告信息，浏览器此时起到了负面作用。
为了解决logoutSampleJSP2中出现的问题，logoutSampleJSP3的login.jsp在包含username和password的基础上还包含了一个称作lastLogon的隐藏表单域，此表单域动态的用一个long型值初始化。这个long型值是调用System.currentTimeMillis()获取到的自1970年1月1日以来的毫秒数。当login.jsp中的form提交时，loginAction.jsp首先将隐藏域中的值与用户数据库中的值进行比较。只有当lastLogon表单域中的值大于数据库中的值时Web应用才认为这是个有效的登陆。
为了验证登陆，数据库中lastLogon字段必须以表单中的lastLogon值进行更新。上例中，当浏览器重复提交数据时，表单中的lastLogon值不比数据库中的lastLogon值大，因此，loginAction转到login.jsp页面，并提示Session has ended.Please log in.清单5是loginAction中节选的代码段：
清单5
//...
RequestDispatcher rd = request.getRequestDispatcher("home.jsp"); //Forward to homepage by default
//...
if (rs.getString("password").equals(password)) {
//If valid password
long lastLogonDB = rs.getLong("lastLogon");
if (lastLogonForm ＞ lastLogonDB) {
session.setAttribute("User", userName); //Saves username string in the session object
stmt.executeUpdate("update USER set lastLogon= " + lastLogonForm + " where userName = '" + userName + "'");
}
else {
request.setAttribute("Error", "Session has ended. Please login.");
rd = request.getRequestDispatcher("login.jsp"); }
}
else { //Password does not match, i.e., invalid user password
request.setAttribute("Error", "Invalid password.");
rd = request.getRequestDispatcher("login.jsp");
}
//...
rd.forward(request, response);
//... |
为了实现上述方法，你必须记录每个用户的最后登陆时间。对于采用关系型数据库安全域来说，这点可以可以通过在某个表中加上lastLogin字段轻松实现。LDAP以及其他的安全域需要稍微动下脑筋，但很显然是可以实现的。
表示最后登陆时间的方法有很多。示例logoutSampleJSP3利用了自1970年1月1日以来的毫秒数。这个方法在许多人在不同浏览器中用一个用户账号登陆时也是可行的。
运行logoutSampleJSP3 运行示例logoutSampleJSP3将展示如何正确处理退出问题。一旦用户退出，点击浏览器上的后退按钮在任何情况下都不会是受保护的页面在浏览器上显示出来。这个示例展示了如何正确处理退出问题而不需要额外的培训。
为了使代码更简练有效，一些冗余的代码可以剔除掉。一种途径就是把清单4中的代码写到一个单独的JSP页中，通过标签＜jsp:include＞其他页面也可以引用。
Struts框架下的退出实现 与直接使用JSP或JSP/servlets相比，另一个可选的方案是使用Struts。为一个基于Struts的Web应用添加一个处理退出问题的框架可以优雅地不费气力的实现。这部分归功于Struts是采用MVC设计模式的因此将模型和视图清晰的分开。另外，Java是一个面向对象的语言，其支持继承，可以比JSP中的脚本更为容易地实现代码重用。在Struts中，清单4中的代码可以从JSP页面中移植到Action类的execute()方法中。
此外，我们还可以定义一个继承Struts Action类的基本类，其execute()方法中包含了清单4中的代码。通过使用类继承机制，其他类可以继承基本类中的通用逻辑来设置HTTP头信息以及检索HttpSession对象中的username字符串。这个基本类是一个抽象类并定义了一个抽象方法executeAction()。所有继承自基类的子类都应实现exectuteAction()方法而不是覆盖它。清单6是基类的部分代码：
清单6
public abstract class BaseAction extends Action {
public ActionForward execute(ActionMapping mapping, ActionForm form,HttpServletRequest request, HttpServletResponse response)
throws IOException, ServletException {
response.setHeader("Cache-Control","no-cache");
//Forces caches to obtain a new copy of the page from the origin server
response.setHeader("Cache-Control","no-store");
//Directs caches not to store the page under any circumstance
response.setDateHeader("Expires", 0); //Causes the proxy cache to see the page as "stale"
response.setHeader("Pragma","no-cache"); //HTTP 1.0 backward compatibility
if (!this.userIsLoggedIn(request)) {
ActionErrors errors = new ActionErrors();
errors.add("error", new ActionError("logon.sessionEnded"));
this.saveErrors(request, errors);
return mapping.findForward("sessionEnded");
}
return executeAction(mapping, form, request, response);
}
protected abstract ActionForward executeAction(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response)
throws IOException, ServletException;
private boolean userIsLoggedIn(HttpServletRequest request) {
if (request.getSession().getAttribute("User") == null) {
return false;
}
return true;
}
} |
清单6中的代码与清单4中的很相像，仅仅只是用ActionMapping findForward替代了RequestDispatcher forward。清单6中，如果在HttpSession中未找到username字符串，ActionMapping对象将找到名为sessionEnded的forward元素并跳转到对应的path。如果找到了，子类将执行其实现了executeAction()方法的业务逻辑。因此，在配置文件struts-web.xml中为所有子类声明个一名为sessionEnded的forward元素是必须的。清单7以secure1 action阐明了这样一个声明：
清单7
＜action path="/secure1"
type="com.kevinhle.logoutSampleStruts.Secure1Action"
scope="request"＞
＜forward name="success" path="/WEB-INF/jsps/secure1.jsp"/＞
＜forward name="sessionEnded" path="/login.jsp"/＞
＜/action＞ |
继承自BaseAction类的子类Secure1Action实现了executeAction()方法而不是覆盖它。Secure1Action类不执行任何退出代码，如清单8：
public class Secure1Action extends BaseAction {
public ActionForward executeAction(ActionMapping mapping, ActionForm form,
HttpServletRequest request, HttpServletResponse response)
throws IOException, ServletException {
HttpSession session = request.getSession();
return (mapping.findForward("success"));
}
} |
只需要定义一个基类而不需要额外的代码工作，上述解决方案是优雅而有效的。不管怎样，将通用的行为方法写成一个继承StrutsAction的基类是许多Struts项目的共同经验，值得推荐。
结论 本文阐述了解决退出问题的方案，尽管方案简单的令人惊讶，但却在所有情况下都能有效地工作。无论是对JSP还是Struts，所要做的不过是写一段不超过50行的代码以及一个记录用户最后登陆时间的方法。在Web应用中混合使用这些方案能够使拥护的私人数据不致泄露，同时，也能增加用户的经验。
posted @
2005-11-14 16:48 rkind 阅读(209) |
评论 (0) |
编辑 收藏Beanutils用了魔术般的反射技术，实现了很多夸张有用的功能，都是C/C++时代不敢想的。无论谁的项目，始终一天都会用得上它。我算是后知后觉了，第一回看到它的时候居然错过。
1.属性的动态getter,setter
在这框架满天飞的年代，不能事事都保证执行getter,setter函数了，有时候属性是要需要根据名字动态的取得的，就像这样：
BeanUtils.getProperty(myBean,"code");
而BeanUtils更强的功能是直接访问内嵌对象的属性，只要使用逗号分割。
BeanUtils.getProperty(orderBean, "address.city");
其他类库的BeanUtils通常都很简单，不能访问内嵌的对象，所以经常要用Jakata的BeanUtils替换它们。
BeanUtils还支持List和Map类型的属性。如下面的语法即可取得顾客列表中第一个顾客的名字
BeanUtils.getProperty(orderBean, "customers[1].name");
其中BeanUtils会使用ConvertUtils类把字符串转为Bean属性的真正类型，方便从HttpServletRequest等对象中提取bean，或者把bean输出到页面。
而PropertyUtils就会原色的保留Bean原来的类型。
2.beanCompartor 动态排序
还是通过反射，动态设定Bean按照哪个属性来排序，而不再需要在bean的Compare接口进行复杂的条件判断。 List peoples = ...; // Person对象的列表 Collections.sort(peoples, new BeanComparator("age")); }}} 如果要支持多个属性的复合排序，如"Order By lastName,firstName" ArrayList sortFields = new ArrayList();
sortFields.add(new BeanComparator("lastName"));
sortFields.add(new BeanComparator("firstName"));
ComparatorChain multiSort = new ComparatorChain(sortFields);
Collections.sort(rows,multiSort);
其中ComparatorChain属于jakata commons-collections包。
如果age属性不是普通类型，构造函数需要再传入一个comparator对象为age变量排序。
3.Converter 把Request中的字符串转为实际类型对象
经常要从request,resultSet等对象取出值来赋入bean中，下面的代码谁都写腻了，如果不用MVC框架的绑定功能的话。
String a = request.getParameter("a");
bean.setA(a);
String b = ....
不妨改为
MyBean bean = ...;
HashMap map = new HashMap();
Enumeration names = request.getParameterNames();
while (names.hasMoreElements())
{
String name = (String) names.nextElement();
map.put(name, request.getParameterValues(name));
}
BeanUtils.populate(bean, map);
其中BeanUtils的populate方法或者getProperty,setProperty方法其实都会调用convert进行转换。
但Converter只支持一些基本的类型，甚至连java.util.Date类型也不支持。而且它比较笨的一个地方是当遇到不认识的类型时，居然会抛出异常来。
对于Date类型，我参考它的sqldate类型实现了一个Converter,而且添加了一个设置日期格式的函数。要把这个Converter注册，需要如下语句：
ConvertUtilsBean convertUtils = new ConvertUtilsBean();
DateConverter dateConverter = new DateConverter();
convertUtils.register(dateConverter,Date.class);
//因为要注册converter,所以不能再使用BeanUtils的静态方法了，必须创建BeanUtilsBean实例
BeanUtilsBean beanUtils = new BeanUtilsBean(convertUtils,new PropertyUtilsBean());
beanUtils.setProperty(bean, name, value);
!4 其他功能
4.1 PropertyUtils，当属性为Collection,Map时的动态读取：
Collection: 提供index
{{{ BeanUtils.getIndexedProperty(orderBean,"items",1);或者
BeanUtils.getIndexedProperty(orderBean,"items[1]");
Map: 提供Key Value
BeanUtils.getMappedProperty(orderBean, "items","111");//key-value goods_no=111
或者
BeanUtils.getMappedProperty(orderBean, "items(111)");
4.2 PropertyUtils，获取属性的Class类型
public static Class getPropertyType(Object bean, String name)
4.3 ConstructorUtils，动态创建对象
public static Object invokeConstructor(Class klass, Object arg)
4.4 DynaClass动态类
其中ComparatorChain属于jakata commons-collections包。 经常要从request,resultSet等对象取出值来赋入bean中，下面的代码谁都写腻了，如果不用MVC框架的绑定功能的话。 不妨改为 其中BeanUtils的populate方法或者getProperty,setProperty方法其实都会调用convert进行转换。 或者 4.2 PropertyUtils，获取属性的Class类型
posted @
2005-11-14 15:12 rkind 阅读(141) |
评论 (0) |
编辑 收藏Struts的Token（令牌）机制能够很好的解决表单重复提交的问题，基本原理是：服务器端在处理到达的请求之前，会将请求中包含的令牌值与保存在当前用户会话中的令牌值进行比较，看是否匹配。在处理完该请求后，且在答复发送给客户端之前，将会产生一个新的令牌，该令牌除传给客户端以外，也会将用户会话中保存的旧的令牌进行替换。这样如果用户回退到刚才的提交页面并再次提交的话，客户端传过来的令牌就和服务器端的令牌不一致，从而有效地防止了重复提交的发生。
这时其实也就是两点，第一：你需要在请求中有这个令牌值，请求中的令牌值如何保存，其实就和我们平时在页面中保存一些信息是一样的，通过隐藏字段来保存，保存的形式如： 〈input type="hidden" name="org.apache.struts.taglib.html.TOKEN" value="6aa35341f25184fd996c4c918255c3ae"〉，这个value是TokenProcessor类中的generateToken()获得的，是根据当前用户的session id和当前时间的long值来计算的。第二：在客户端提交后，我们要根据判断在请求中包含的值是否和服务器的令牌一致，因为服务器每次提交都会生成新的Token，所以，如果是重复提交，客户端的Token值和服务器端的Token值就会不一致。下面就以在数据库中插入一条数据来说明如何防止重复提交。
在Action中的add方法中，我们需要将Token值明确的要求保存在页面中，只需增加一条语句：saveToken(request);，如下所示：
public ActionForward add(ActionMapping mapping, ActionForm form,
HttpServletRequest request, HttpServletResponse response)
//前面的处理省略
saveToken(request);
return mapping.findForward("add");
}在Action的insert方法中，我们根据表单中的Token值与服务器端的Token值比较，如下所示：
public ActionForward insert(ActionMapping mapping, ActionForm form,
HttpServletRequest request, HttpServletResponse response)
if (isTokenValid(request, true)) {
// 表单不是重复提交
//这里是保存数据的代码
} else {
//表单重复提交
saveToken(request);
//其它的处理代码
}
}
其实使用起来很简单，举个最简单、最需要使用这个的例子：
一般控制重复提交主要是用在对数据库操作的控制上，比如插入、更新、删除等，由于更新、删除一般都是通过id来操作（例如：updateXXXById, removeXXXById），所以这类操作控制的意义不是很大（不排除个别现象），重复提交的控制也就主要是在插入时的控制了。
先说一下，我们目前所做项目的情况：
目前的项目是用Struts＋Spring＋Ibatis，页面用jstl，Struts复杂View层，Spring在Service层提供事务控制，Ibatis是用来代替JDBC，所有页面的访问都不是直接访问jsp，而是访问Structs的Action，再由Action来Forward到一个Jsp，所有针对数据库的操作，比如取数据或修改数据，都是在Action里面完成，所有的Action一般都继承BaseDispatchAction，这个是自己建立的类，目的是为所有的Action做一些统一的控制，在Struts层，对于一个功能，我们一般分为两个Action，一个Action里的功能是不需要调用Struts的验证功能的（常见的方法名称有add,edit,remove,view,list），另一个是需要调用Struts的验证功能的（常见的方法名称有insert,update）。
就拿论坛发贴来说吧，论坛发贴首先需要跳转到一个页面，你可以填写帖子的主题和内容，填写完后，单击“提交”，贴子就发表了，所以这里经过两个步骤：
1、转到一个新增的页面，在Action里我们一般称为add，例如：
public ActionForward add(ActionMapping mapping, ActionForm form,
HttpServletRequest request, HttpServletResponse response)
throws Exception {
//这一句是输出调试信息，表示代码执行到这一段了
log.debug(":: action - subject add");
//your code here
//这里保存Token值
saveToken(request);
//跳转到add页面，在Structs-config.xml里面定义，例如，跳转到subjectAdd.jsp
return mapping.findForward("add");
}
2、在填写标题和内容后，选择 提交 ，会提交到insert方法，在insert方法里判断，是否重复提交了。
public ActionForward insert(ActionMapping mapping, ActionForm form,
HttpServletRequest request, HttpServletResponse response){
if (isTokenValid(request, true)) {
// 表单不是重复提交
//这里是保存数据的代码
} else {
//表单重复提交
saveToken(request);
//其它的处理代码
}
}
下面更详细一点（注意，下面所有的代码使用全角括号）：
1、你想发贴时，点击“我要发贴”链接的代码可以里这样的：
〈html:link action="subject.do?method=add"〉我要发贴〈/html:link〉
subject.do 和 method 这些在struct-config.xml如何定义我就不说了，点击链接后，会执行subject.do的add方法，代码如上面说的，跳转到subjectAdd.jsp页面。页面的代码大概如下：
〈html:form action="subjectForm.do?method=insert"〉
〈html:text property="title" /〉
〈html:textarea property="content" /〉
〈html:submit property="发表" /〉
〈html:reset property="重填" /〉
〈html:form〉
如果你在add方法里加了“saveToken(request);”这一句，那在subjectAdd.jsp生成的页面上，会多一个隐藏字段，类似于这样〈input type="hidden" name="org.apache.struts.taglib.html.TOKEN" value="6aa35341f25184fd996c4c918255c3ae"〉，
2、点击发表后，表单提交到subjectForm.do里的insert方法后，你在insert方法里要将表单的数据插入到数据库中，如果没有进行重复提交的控制，那么每点击一次浏览器的刷新按钮，都会在数据库中插入一条相同的记录，增加下面的代码，你就可以控制用户的重复提交了。
if (isTokenValid(request, true)) {
// 表单不是重复提交
//这里是保存数据的代码
} else {
//表单重复提交
saveToken(request);
//其它的处理代码
}
注意，你必须在add方法里使用了saveToken(request)，你才能在insert里判断，否则，你每次保存操作都是重复提交。
记住一点，Struts在你每次访问Action的时候，都会产生一个令牌，保存在你的Session里面，如果你在Action里的函数里面，使用了saveToken(request);，那么这个令牌也会保存在这个Action所Forward到的jsp所生成的静态页面里。
如果你在你Action的方法里使用了isTokenValid，那么Struts会将你从你的request里面去获取这个令牌值，然后和Session里的令牌值做比较，如果两者相等，就不是重复提交，如果不相等，就是重复提交了。
由于我们项目的所有Action都是继承自BaseDispatchAction这个类，所以我们基本上都是在这个类里面做了表单重复提交的控制，默认是控制add方法和insert方法，如果需要控制其它的方法，就自己手动写上面这些代码，否则是不需要手写的，控制的代码如下：
public abstract class BaseDispatchAction extends BaseAction {
protected ActionForward perform(ActionMapping mapping, ActionForm form,
HttpServletRequest request, HttpServletResponse response)
throws Exception {
String parameter = mapping.getParameter();
String name = request.getParameter(parameter);
if (null == name) { //如果没有指定 method ，则默认为 list
name = "list";
}
if ("add".equals(name)) {
if ("add".equals(name)) {
saveToken(request);
}
} else if ("insert".equals(name)) {
if (!isTokenValid(request, true)) {
resetToken(request);
saveError(request, new ActionMessage("error.repeatSubmit"));
log.error("重复提交！");
return mapping.findForward("error");
}
}
return dispatchMethod2(mapping, form, request, response, name);
}
}
posted @
2005-11-14 14:32 rkind 阅读(305) |
评论 (0) |
编辑 收藏SELECT COUNT(*) AS Expr1 FROM History
DELETE FROM History WHERE (Id > 0)
truncate table youtable;
为什么要用TRUNCATE TABLE 语句代替DELETE语句？当你使用TRUNCATE TABLE语句时，记录的删除是不作记录的。也就是说，这意味着TRUNCATE TABLE 要比DELETE快得多。
posted @
2005-11-11 11:25 rkind 阅读(284) |
评论 (0) |
编辑 收藏
我今年39岁了，25岁研究生毕业，工作14年，回头看看，应该说走了不少的弯路，有一些经验和教训。现在开一个小公司，赚的钱刚够养家糊口的。看看这些刚毕业的学生，对前景也很迷茫，想抛砖引玉，谈谈自己的看法，局限于理工科的学生，我对文科的不懂，身边的朋友也没有这一类型的。
91年研究生毕业，那时出路就是1种：留在北京的国营单位，搞一个北京户口，这是最好的选择。到后来的2～3年内，户口落定了，又分成4条出路：
1、 上国内的大企业，如：华为
2、 自己做公司，做产品开发；
3、 上外企，比如：爱立信、诺基亚
4、 自己做公司，做买卖；
5、 移民加拿大
我想，首先要看自己适合做什么？做技术还是做买卖。
做技术，需要你对技术感兴趣。我掰着数了一遍，我们研究生班的30来号人，实际上，适合做技术的，大概只有3、4个人，这几个人，1个现在还在华为，3个移民加拿大了，现在这4个人混的还可以，在华为的同学也移民加拿大了，他在华为呆了6年，在华为奖金工资加起来大概30万吧，还有华为的股票，再过几年，华为的股票一上市，也能值个100～200万。要是一毕业就去华为，那现在就绝对不是这个数字了。
要是做技术，最好的就是上大公司，国内的大型企业，象华为中兴肯定是首选，能学到很多东西。华为虽然累，但是，年轻人不能怕累，要是到老了，还需要去打拼，那才是真的累啊。
在外企，我想他们主要就是技术支持和销售，但是技术是学不到的，当然不能一概而论，我指的是象爱立信和诺基亚，真正的研发不会在中国做的，学到的也不如在华为多，其它的中兴我不是很了解，我想应该也不错啊。
一个人都有一技之长，有傍身之技，那是最好的，走到哪里，都能有一口饭吃，还吃的不错，这是传统的观点。
任何技术都是要在某个行业去应用，这个行业市场越大当然越好；要在一个领域之内，做深做精，成为绝对的专家，这是走技术道路的人的选择。不要跳来跳去，在中国，再小的行业你要做精深了，都可以产生很大的利润。
研究生刚毕业的时候，做产品开发的有不少人，都是自己拍拍脑子，觉得这个产品有市场，就自己出来做。现在看来，我的这些同学，做产品开发的成功的没有一例，为什么？资源不足。
1． 资金，刚毕业的学生啊，就是没钱；没钱，也意味着你开发的东西都是小产品；而且只能哥几个自己上，研发、生产、销售都是一个人或者几个人自己来，没有积累，什么都是重新来过。
2． 人脉，任何一个行业，要想进去，需要有很深的人脉，否则，谁会用你的东西啊？谁敢用你的东西啊？
我看到的，我这个班上开发产品的，自己还在坚持的，只剩下一个人了，说实在的，到现在，没有自己的汽车，也没有自己的房子，混的挺惨的。现在出国的不说了，在外企、在华为，至少都是几十万的年薪了，还有各种福利，就是产品开发成功了，又能如何？也就是这样了，但是以前那些年，都没有金钱的积累，等于白干。
我身边的一个自动化系的研究生班的同学，能靠自己开发产品活得还可以的，也只有2个人。说明这条路不是那么好走的啊。
其次就是上外企。我的2个同学，一个上了爱立信，一个先到爱立信后到诺基亚，都混的不错。到诺基亚的后来利用在诺基亚结识的人脉（就是哪些电信的头头脑脑），自己开了公司，也赚了不少的钱。
外企最大的好处就是除了能学到比较规范的管理外，还能给你的职业生涯镀金。到了一个外企外，再到同行业的外企我想就很容易了。而且外企的收入高啊。
自己做公司，做买卖，一开始有3～4个人走这条路，但是真正发财的只有一个人，其他人后来上外企了。做买卖，还是要有一定的天赋，还有机遇。要有对金钱的赤裸裸的欲望，要有商业上的头脑。后来我们同学在一起谈，说，我们即使给自己这个机遇，也未必能做的好。何况当时那个同学看好的产品（做一个台湾产品的代理），我们大家都没有看好，说明，真理还是掌握在少数人手里。
到后来，同学们纷纷移民移民加拿大。
移民加拿大对搞技术的人来说，还是一个不错的选择，但是要尽早，练了几年的技术，就赶紧出去，大概是在1996年走了不到10个，现在都还可以，买了房子和车了。要是晚了，语言再学也难了，而且在国内都混的还可以了，也就没有必要出去了。
我自己呢，先是在国营的研究所混了4年，后来到一家公司干了6年，2002年出来自己做公司，现在也就是混了一个温饱吧，算是有房有车，有点积蓄，但是不多，还有一个可爱的女儿。回首这10来年，有一些经验和教训。
1． 要有一个职业生涯的规划。首先需要定位自己做什么合适，是做买卖还是做技术，一条路走到黑；当然，做了技术，后来改行也行；
2． 做技术，就是要做精做深，成为这个行业的这个技术的专家；最好就是去国内的大公司，才能全面学到东西，能够给你培训的机会；如果大公司进不去，先到小公司练技术，找机会再到大公司去镀金，学高深的技术。千万不要自己做产品，要做也是对这个行业熟悉了，再去做。
3． 积极争取机会。积极争取学习和进步的机会。比如，做技术，就需要多锻炼，多学习，来提高自己的水平。一门技术，只要有机会去学习，都能学的会；要是没有机会，天才也没有办法学到这个技术。柳传志就说，杨元庆就是“哭着喊着要进步”，实际上，就是争取自己的机会；当然，这种强烈的进步欲望，也是领导看重的地方。每一步都走在前面，积累10年，你就有了比其他人更多的机会了。
4． 积累个人的信誉。从你的职业生涯的第一天，就要按照诚信的原则办事。要做到，当人们提起你的名字的时候，说，这哥们还不错，做事还行。
5． 注意利用资源。如果你有有钱的亲戚、成功的长辈或者朋友，可以充分利用这些机会，得到更加顺利的发展前景。
6． 注意财富的不断积累。人生要想得到自由，财富是很关键的。否则，永远仰人鼻息，永远看人脸色。人都是势利眼。今后的家庭、职业生涯，金钱的积累很重要，没有钱，永远不能开张自己的事业，得到更多的机会；财富要做到逐年积累，你才能家庭生活幸福。没有钱是不可能有幸福的家庭的。
7． 注意人脉的积累。最终，事业要靠在社会上的人脉的资源。要注意认识在你这个行业的人，结交他们，最终他们会成为你事业上的助力。
8． 寻求贵人相助。要找大老板来帮助你，得到大老板的赏识。想想看，大蛋糕，切一点就够了，小蛋糕，都给你也吃不饱啊。
9． 多听听成功的前辈和成功的朋友的意见。注意少听家里长辈的意见，尤其是都已经退休的长辈，他们对社会的认识还停留在很久以前，而这个社会已经发生很大的变化呢。最重要的是，长辈有时候会强求你做一些事情，但是，最终的结果他们是不负责的。只有你才能对自己负责。
posted @
2005-11-10 15:02 rkind 阅读(234) |
评论 (0) |
编辑 收藏滚动公告栏的实现
用到如下html标签：
《MARQUEE id=mar onmouseout=this.start(); direction=up height=150 name="mar"
onmouseover="this.stop();" scrollAmount="1" scrollDelay="0"
style="LINE-HEIGHT: 100%; PADDING-LEFT: 0px; PADDING-RIGHT:0px"width="100%">
1净化社会环境
2也是净化社会平步青云
3净化社会环境
4也是净化社会平步青云
5净化社会环境
6也是净化社会平步青云
7净化社会环境
8也是净化社会平步青云
其中marquee中height中的属性可以更改每次显示的行数，……
posted @
2005-11-02 08:43 rkind 阅读(406) |
评论 (0) |
编辑 收藏