2007年4月7日
#
---转自网络
运行cmd regedit msconfig提示找不到文件
作者: 笑嘻嘻
今天我同学的电脑，开始运行“cmd regedit msconfig” 这三个命令都不行 ，提示"找不到文件"。可是文件明明在阿。
直接运行system32目录下的cmd也不行，照样提示"找不到文件"。把cmd改名为cmd1就能够运行
我的处理过程：
开始我怀疑是中病毒了，是病毒程序在监听哪个程序标题为“cmd”，发现就结束。
首先用卡巴扫了一下启动项，没发现病毒。又用冰刃查了一下启动项，进程，都没问题。
想了想会不会中了rootkit 级的马儿，可用冰刃仔细看了看内核，没有显示红色的阿，刚才杀毒软件也没报，是的可能性就不怎么大了。
那会不会是这个文件遭病毒感染了，我最讨厌感染型的蠕虫病毒了。我从我自己的电脑上把才cmd.exe拷贝过来了，用软件比较了下（光看大小不行的），一样的。
Hash.zip (28.61 KB , 下载:6次)
----------------------------------------------------------------------------
文件: C:WINDOWSsystem32cmd.exe
大小: 470528 字节
文件版本: 5.1.2600.2180 (xpsp_sp2_rtm.040803-2158)
修改时间: 2005年12月15日, 8:00:00
MD5: 722A247ACB86960A708528120759266D
SHA1: A859B7173FB0B1786BE07B01F779725EDF9043E7
CRC32: 15544920
-----------------------------------------------------------------------------
后来经过询问前几天中过病毒，会不会是上次病毒修改了注册表什么地方，虽然病毒是被杀了，但是修改的地方仍然没有改过来的呢。结果证明，这个判断是正确的。
具体处理方法：
用冰刃的修改注册表，或者将windeows目录下的regedit.exe修改一下名字，比如叫regedit1.exe，修改注册表。
将HKEY_LOCAL_MACHINESOFTWAREMicrosoftWindows NTCurrentVersionImage File Execution Options 里面的
cmd.exe
msconfig.exe
regedit.exe
regedit32.exe
删除就可以了。
典型的 映像劫持。
这只是处理病毒后遗症，具体的处理病毒的方法没有写，因为有很多病毒都会造成这种状况，具体病毒具体对待。
--转自
做共享软件是有利可图的，这是真的，1999年3月以前我还不信，可是经过一年多的
研究和实践下来，我已经每月能赚4万多美金了，比某些大公司总裁还多。但是，
我敢说，80%以上的共享软件作者并不成功，实际上，他们远远没有赚到他们本来可以
赚到的收入。
软件共享发行销售（先试后买）是一种市场营销手段，和其他所有市场营销手段一样，
是有学问的，要想通过软件共享发行获得成功，就必须掌握这些学问。
今天，我来贴上第一篇技术文章，收钱的办法
在几年以前，Internet还没有流行的时候，共享软件的作者只能靠从邮件中收到用户的支票和现金的方法来赚钱,而用户寄出支票后,还要等上一周或更多的时间得到来自作者的注册码。注意,当以下几种情况发生时，软件作者的生意就做不成了:
1）用户的支票本刚好用完，等他买回新支票本时，消费冲动已经没有了
2）用户的邮票刚好用完，他还不得不去一趟邮局买邮票，转念一想，这软件我也不是
非买不可，算了
3）用户无法忍受要等好多天才能拿到注册码
一句话，太不方便了
现在好了，有了Internet，有了电子商务，用户可以在最想买你的软件的一刹那间，迅速的用他的信用卡在网上买下你的软件，连后悔的时间都没有，共享软件发财的日子到来乐。
那么，如何在网上收取信用卡呢？
如果你拥有一个公司，在美国银行有信用卡商号帐户,又购买了银行的GATEWAY软件,在自己的网站上开发了信用卡收费系统当然很好,但对于广大共享软件作者来说,这很不现实.有简单的办法，就是找一家信用卡收款代理公司，让他们替你收款，你只要每个月等他们给你寄一张总额的支票(他们会提取一定比例的佣金)就行了.
这样的代理公司网站有：
WWW.QWERKS.COM 提成 15-20% （服务极好，是我的服务商）
WWW.Shareit.COM
WWW.REGNOW.COM
WWW.REGSOFT.COM
WWW.Kagi.com
对于咱们国内的共享软件作者，还要做的一件事就是去中国银行开个户头（北京中行的活期一本通就很好用),如果你打算让信用卡公司把钱电汇给你,你还要知道银行的英文名字,地址,帐户名,
帐号,转帐的SWIFT Code(可以从银行职员那里问到)
到信用卡代理公司的网站上开户非常简单，通常确认它们的一个在线协议，填入一些个人信息和产品信息，几分钟就OK了
这里面有一个值得注意的地方，就是，当用户付了款后，注册码怎么给的问题，你可以选择由你来给（每收到一份订单，他们会给你发一封email,包含用户资料和email），由你生成注册码email给用户，也可以把注册码生成代码给信用卡公司，让他们编到他们的系统里去，用户来了订单后自动发出注册码，也可以由你一次性生成几百个注册码给他们，他们每收到一份订单时用掉一个注册码。
我个人的意见是，这几个信用卡服务商信誉都非常好，一次给他们几百个注册码是最简单的办法，对服务商来说操作简单，对用户来说快，交完钱马上就得到注册码了
当你完成作者和产品在信用卡服务商那里的登记后，就会得到一个URL连接，你把这个连接加到你的主页上面,标上一个“Buy Now”，用户点这里就可以用信用卡付款了，当然，你也可以把这个连接做到你的软件界面里去，这样用户在试用你的软件时，随时想买都可以点击这个连接上网购买
具体实例可以参考我的网站和软件
http://www.zy2000.com
MP3 CD Maker
对于一些Internet软件，如断点续传的下载软件，还有另外一种赚钱方法，就是对用户免费，而在软件界面上登一个banner广告赚取广告费。最有名的广告代理商是
www.radiate.com
他的广告付费是每CPM 2-5美元，也就是说，如果一天里有10万个用户使用了你的软件一次的话，你就得到200-500美元。这家公司声称，著名的下载工具软件Gozilla!落户Radiate后，每月从Radiate那里赚到22万美元,我们著名的NetAnt是不是该赶快行动了？
我们也不反对用户用支票和现金购买软件，事实上，信用卡服务商都提供支票和现金收款业务，我们可以在网页中提供信用卡服务商的地址和服务热线电话，具体例子可以参考我的网页中 FAQ 一页的内容
1 .from
1.1单表查询
from eg.cat as cat.其中，cat只是一个别名，为了用其他子语句的时候书写简单
1.2多表查询
from eg.Cat,eg.Dog
from eg.Cat as cat,eg.Dog as dog
2 join相关
(inner) join
left (outer) join
right (outer) join
full join
HQL同样对SQL中的这些特性支持
下面插播一个小话题，关于上边的那些特性，我一直都没怎么用，今天既然说到这里，就想
把上边的几个特性的用法说一下，也算对自己的一个补充：
假设有两个表：部门、员工，下面列举一些数据：
员工(Employee)：
ID Name DepNo
001 Jplateau 01
002 Jony 01
003 Camel 02
部门(Department)：
ID Name
01 研发部
02 营销部
在Hibernate中我们操纵的都是对象，所以我们操纵的是部门类和员工类
1).(inner) join
select employee.ID as id1,employee.Name as name1,department.ID as id2,department.Name
as name2 from Employee as employee join Department as department on employee.DepNo=
department.ID (注意到条件语句我用on 没有用where)
那么执行结果是什么呢？
id1 name1 id2 name2
++++++++++++++++++++++++++++++++++++++
001 Jplateau 01 研发部
002 Jony 01 研发部
2).left (outer) join
select employee.ID as id1,employee.Name as name1,department.ID as id2,department.Name
as name2 from Employee as employee left join Department as department on employee.DepNo=
department.ID
那么执行结果又该是什么呢？
id1 name1 id2 name2
++++++++++++++++++++++++++++++++++++++
001 Jplateau 01 研发部
002 Jony 01 研发部
003 Camel null null
{就是说此时我要已第一个表的记录多少为准，第二个表中没有相应纪录的时候填充null}
3). right (outer) join
select employee.ID as id1,employee.Name as name1,department.ID as id2,department.Name
as name2 from Employee as employee right join Department as department on employee.DepNo=
department.ID
那么执行结果又该是什么呢？
id1 name1 id2 name2
++++++++++++++++++++++++++++++++++++++
001 Jplateau 01 研发部
002 Jony 01 研发部
null null 02 营销部
{就是说此时我要已第二个表的记录多少为准，第一个表中没有相应纪录的时候填充null}
3 大小写敏感
4。select语句
就是要确定你要从查询中返回哪些对象或者哪些对象的属性。写几个例子吧：
select employee form Employee as employee
select employee form Employee as employee where employee.Name like 'J%'
select employee.Name form Employee as employee where employee.Name like 'J%'
select employee.ID as id1,employee.Name as name1,department.ID as id2,department.Name
as name2 from Employee as employee right join Department as department on employee.DepNo=
department.ID
select elements(employee.Name) from Employee as employee
（不明白elements到底是做什么用的？望给于说明）
等等
5。数学函数
JDO目前好像还不支持此类特性。
avg(...), sum(...), min(...), max(...)
count(*)
count(...), count(distinct ...), count(all...)
其用法和SQL基本相同
select distinct employee.name from Employee as employee
select count(distinct employee.name),count(employee) from Employee as employee
6。polymorphism (暂时不知道如何解释？)
from com.test.Animal as animal
不光得到所有Animal得实例，而且可以得到所有Animal的子类（如果我们定义了一个子类Cat）
一个比较极端的例子
from java.lang.Object as o
可以得到所有持久类的实例
7。where语句
定义查询语句的条件，举几个例子吧：
from Employee as employee where employee.Name='Jplateau'
from Employee as employee where employee.Name like 'J%'
from Employee as employee where employee.Name like '%u'
在where语句中“=”不光可以比较对象的属性，也可以比较对象，如：
select animal from com.test.Animal as animal where animal.name=dog
8。表达式
在SQL语句中大部分的表达式在HQL中都可以使用：
mathematical operators +, -, *, /
binary comparison operators =, >=, <=, <>, !=, like
logical operations and, or, not
string concatenation ||
SQL scalar functions like upper() and lower()
Parentheses ( ) indicate grouping
in, between, is null
JDBC IN parameters ?
named parameters :name, :start_date, :x1 （这种应该是另一种"?"的变通解决方法）
SQL literals 'foo', 69, '1970-01-01 10:00:01.0'
Java public static final constants eg.Color.TABBY
其他不必解释了，在这里我只想对查询中的参数问题说明一下：
大家知道在SQL中进行传递参数进行查询的时候，我们通常用PreparedStatement，在语句中写一大堆的“？”，
在hql中也可以用这种方法，如：
List mates = sess.find(
"select employee.name from Employee as employee " +
"where employee.Name=? ",
name,
Hibernate.STRING
);
(说明：上面利用Session里的find方法，在hibernate的api Session中重载了很多find方法，它可以满足你多种形式的查询)
上边是一个参数的情形，这种情况下紧接着引入参数和定义参数的类型，当为多个参数，调用另一个find方法，它的后两个
参数都是数组的形式。
还有另外一种方法来解决上边的问题，JDO也有这样的方法，不过和hibernate的表现形式上有差别，但他们两个骨子里却是
一样的，如：
Query q = sess.createQuery("select employee.name from Employee as employee where employee.Name=:name");
q.setString("name", "Jplateau");
//当有多个参数的时候在此逐一定义
Iterator employees = q.iterate();
9。order 语句
和sql语句没什么差别，如：
select employee.name from Employee as employee where employee.Name like 'J%' order by employee.ID desc (或者asc)
10。group by 语句
同样和sql语句没什么差别，如：
select employee.name,employee.DepNo from Employee as employee group by employee.DepNo
select foo.id, avg( elements(foo.names) ), max( indices(foo.names) ) from eg.Foo foo group by foo.id
{Note: You may use the elements and indices constructs inside a select clause, even on databases with no subselects.}
谁帮我解释一下上边两句，谢过！
11。子查询
hibernate同样支持子查询，写几个例子：
from eg.Cat as fatcat where fatcat.weight > ( select avg(cat.weight) from eg.DomesticCat cat )
－转载
下面是作者对设计模式的理解并自以为所对应的实例
一 ： 单例模式(Singleton)
账本类：1 单一实例 2 给多个对象共享 3 自己创建。网页计数器
二：策略模式(Strategy)
使用QQ泡MM时使用外挂 客户端 ：ME 抽象类： 外挂 具体：策略（图片，笑话，名人名言）
图书销售算法（不同书本折扣的算法）
三：原型模式(Prototype)
复印技术： 1 不是同一个对象 2 属同类
短消息（转发） 1-n个MM
四：门面模式(Façade)
Facade典型应用就是数据库JDBC的应用和Session的应用
ME---àMM---à(father,mum,sister,brother)
五：备忘录模式(Memento)
备份系统时使用
GHOST
六 ： 命令模式（Command）
MM（客户端）--àME（请求者）--à命令角色--à（具体命令）-à代理处（接收者）--àMM
上网 IE 输入 http地址 发送命令
七： 解释器(Interpreter)
编译原理之编译器
文言文注释：一段文言文，将它翻译成白话文
八：调停者模式(Mediator)
法院和原告，被告的关系
九：责任链模式(CHAIN OF RESPONSIBLEITY)
喝酒时通过成语接龙决定谁喝酒(马到成功－功不可没－没完没了)
十：工厂模式（Factory）
水果园—〉（葡萄园，苹果园）--〉（葡萄，苹果）（各自生产）
十一：抽象工厂模式（Abstract Factory）
女娲造人---〉（阴，阳）--〉（人，兽）----〉（男人，女人，公兽，母兽）(人和兽属于不同的产品类)
十二：建造模式（Builder）
汽车制造
十三：合成模式（Composite）
windows的目录树（文件系统）
十四：装饰模式（DECORATOR）
在visio中文件可以使用背景进行装饰
变废为宝
十五：设计模式之Adapter(适配器)
充电器（手机和220V电压）
jdbc-odbc桥
十六：桥梁模式（Bridge）
jdbc驱动程序
十七：代理模式（Proxy）
用代理服务器连接出网
销售代理（厂商）律师代理（客户）
foxmail
枪手
十八：享元模式（Flyweight）
字体的26个字母和各自的斜体等
十九：状态模式（State）
人心情不同时表现不同有不同的行为
编钟
登录login logout
二十：观察者模式（Observer）
公司邮件系统everyone@sina.com的应用。当公司员工向这个邮箱发邮件时会发给公司的每一个员工。如果设置了Outlook则会及时收到通知。
接收到短消息
二十一：模板方法模式（Template）
使用网页设计时使用的模板架构网页（骨架） 算法的各个逻辑系统
二十二：访问者模式（Visitor）
电脑销售系统： 访问者（自己）---〉电脑配置系统（主板，CPU，内存。。。。。。）
二十三：迭代子模式（Iterator）
查询数据库，返回结果集（map， list， set）
下面的参考文献是读书笔记的全部参考文献。这里不一定用到的。
参考文献：
http://blog.csdn.net/airhand/
http://blog.csdn.net/bloom121/
http://blog.csdn.net/laurecn/
http://blog.csdn.net/legendinfo/
http://www-128.ibm.com/developerworks/cn/java/l-struts1-1/
《Design Patterns》
《Java与模式》
《设计模式：可复用面向对象软件的基础》
Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1227902
摘要: 事件源对象 event.srcElement.tagName event.srcElement.type
捕获释放 event.srcElement.setCapture(); event.srcElement.releaseCapture();
事件按键 event.keyCode event.shiftKey event.altKey event....
阅读全文
转自 IBM 刘武东，谢谢作者的辛勤劳动！
前言
Jive是一个开放的Java源代码项目。其目标是建设一个开放结构的，强壮的，易于扩展的基于JSP的论坛。在其设计目标的指导下，其结构设计得非常得好，融合了很多新的观念，比如Design Pattern，可更换的Skin，可插入Plug等等。详细解读其源代码对于理解这些新的设计上的概念是很有裨益的。如果你对Design Pattern和Java语言有一定的了解，但是还是会时常迷惑于其中的话，不妨研究研究Jive源代码，一定会对其中的很多概念有更深入的理解。这篇文章源于我的Jive源代码研究笔记，希望能够提纲挈领，带领大家进入到这个美好的世界。当然，如果没有时间仔细地看源代码的话，看看这篇文章，我想也是会有一些帮助的。
再开始之前，需要指出的是，Jive中对Design Pattern的应用，并没有拘礼与GOF书中所给出的实现方法，而是有许多变通的地方。一方面，我想是由于具体的实际需要，另一方面，我想这也是设计观念进化的结果吧。因而，这些变通的地方，将是我讲解的重点。
整体结构概叙
基于一个OO的设计原则：面向接口编程，而不是针对实现编程。Jive在设计的时候，把其大部分的基本对象都设计为接口或者抽象类。在Jive中，基本的接口有Forum，ForumMessage，ForumThread，Group，User，Authorization和Query。我们可以很容易的从这些接口的名字来知道他们的功用，下面的类图给出了这些类之间的一些静态关系：
图1：Jive整体关系
你可能会有疑问，为什么会都是接口呢？这是基于扩展性考虑的。在Jive给出的实现中，所有的这些接口，Forum，ForumMessage，User等等，都使用数据库来实现的，一条消息，或者一个用户对应于数据库中的一条消息Jive使用了DbForum，DbForumMessage，DbUser等类来实现这些接口，通过JDBC来操作数据库，使之作为论坛的底层支撑。
然而，有时候，或许我们并不想使用数据库，比如我们想只是使用文件系统来作为论坛的底层支撑，这时候，我们需要做的只是编码实现了Forum等等接口的诸如FileFroum，FileForumMessage等对象，然后嵌入Jive中即可，原有的任何代码都可以不用改变！！！这就是面向接口编程的威力了！
下面来看看具体的设计和编码。
AbstractFactory模式和可扩展性
如果要实现较好的可扩展性，AbstractFactory模式确实是一件利器。如上面所说，如果要创建的Forum接口的不同实现，而又不想更改代码的话，就需要用到抽象工厂了。再Jive中，AuthorizationFactory类是一个抽象类，用来创建Authorization对象。这是一个抽象工厂，可以通过不同的子类来创建不同的Authorization对象。这个工厂的实现方法是：
在AuthorizationFactory中使用一个private static变量factory，用来引用具体的抽象工厂的实例：
private static AuthorizationFactory factory = null;
用一个private static的String，来指明具体的抽象工厂的子类类名：
private static String className ="com.coolservlets.forum.database.DbAuthorizationFactory";
然后是用一个private static的loadAuthorizationFactory方法来给这个factory变量赋值，生成具体的抽象工厂类：
private static void loadAuthorizationFactory() {
if (factory == null) {
synchronized(className) {
if (factory == null) {
String classNameProp = PropertyManager.getProperty(
"AuthorizationFactory.className"
);
if (classNameProp != null) {
className = classNameProp;
}
try {
Class c = Class.forName(className);
factory = (AuthorizationFactory)c.newInstance();
}
catch (Exception e) {
System.err.println("Exception loading class: " + e);
e.printStackTrace();
}
}
}
}
}
|
在static的getAuthorization方法返回一个Authorization的过程中，先初始化工厂类factory变量，然后用factory的createAuthorization方法来创建：
public static Authorization getAuthorization(String username,
String password) throws UnauthorizedException
{
loadAuthorizationFactory();
return factory.createAuthorization(username, password);
}
|
不同的子类有不同的createAuthorization方法的实现。比如在DbAuthorizationFactory这个AuthorizationFactory的数据库实现子类中，createAuthorization方法是这样实现的：
public Authorization createAuthorization(String username, String password)
throws UnauthorizedException
{
if (username == null || password == null) {
throw new UnauthorizedException();
}
password = StringUtils.hash(password);
int userID = 0;
Connection con = null;
PreparedStatement pstmt = null;
try {
con = DbConnectionManager.getConnection();
pstmt = con.prepareStatement(AUTHORIZE);
pstmt.setString(1, username);
pstmt.setString(2, password);
ResultSet rs = pstmt.executeQuery();
if (!rs.next()) {
throw new UnauthorizedException();
}
userID = rs.getInt(1);
}
catch( SQLException sqle ) {
System.err.println("Exception in DbAuthorizationFactory:" + sqle);
sqle.printStackTrace();
throw new UnauthorizedException();
}
finally {
try { pstmt.close(); }
catch (Exception e) { e.printStackTrace(); }
try { con.close(); }
catch (Exception e) { e.printStackTrace(); }
}
return new DbAuthorization(userID);
}
|
在这个类中，可以看到抽象类和具体的子类之间的关系，它们是如何协作的，又是如何划分抽象方法和非抽象方法的，这都是值得注意的地方。一般的，抽象方法需要子类来实现，而抽象类中的非抽象方法应该所有子类所能够共享的，或者可是说，是定义在抽象方法之上的较高层的方法。这确实是一个抽象工厂的好例子！虽然实现的方法已经和GOF中给出的实现相差较远了，但思想没变，这儿的实现，也确实是要巧妙的些。
还有就是静态方法的使用，使得这个类看起来有些Singleton的意味。这使得对于AbstractFactory的创建变得简单。
下面的类图给出了这个AbstractFactory的实现的总体情况：
图2：AbstractFactory模式的实现类图
在AuthorizationFactory中定义的其它方法，涉及到具体的如何创建Authorization，都是作为abstract方法出现，具体实现留给子类来完成。
这样，在需要生成一个Authorization的时候，只需要调用AuthorizationFactory的静态方法getAuthorization就可以了，由子类实现了具体的细节。
其它的，如同上面讲到的，在创建Forum的时候用的ForumFactory，具有同上面一样的实现，这就是模式之所以称为模式的所在了。
Proxy模式和权限控制
Proxy模式的功能有很多，比如远程代理，用来给远程对象提供一个本地代表；虚代理，用来为创建开大开销的对象提供缓冲，等等。在Jive中使用的是保护代理，为被保护的对象提供权限控制。
我们都知道在一个论坛中，权限的控制是必须的，否则论坛就很可能会被搞得一团糟。Jive中引入Proxy对象，Authorization接口以及权限描叙属类来提供对论坛的保护。
以ForumFactory为例，一个额外的ForumFactoryProxy来处理权限认证的工作，它为某一个ForumFactory提供了一个代理，保证只有授权的用户才能够存取ForumFactory的某些操作。实际上ForumFactory在这儿不仅仅只是一个生成Forum的类的，它更像是一个Forum的管理类。提供了添加，删除，枚举等等一系列的功能，而有些功能不是什么样的人都可以使用的，因而引入了另外的一个代理类来处理权限的问题。
当然，代理类需要继承ForumFactory，以使方法签名一致： ForumFactoryProxy extends ForumFactory
在它的构造方法中，就提供了一个ForumFactory对象，这是需要被代理的对象；一个Authorization对象，提供用户信息；还有一个ForumPermissions，提供认证信息：
public ForumFactoryProxy(ForumFactory factory, Authorization authorization,
ForumPermissions permissions)
{
this.factory = factory;
this.authorization = authorization;
this.permissions = permissions;
}
|
一般的代理过程都是这样的，在访问某个方法之前，必须接受权限的检查，以createForum为例：
public Forum createForum(String name, String description)
throws UnauthorizedException, ForumAlreadyExistsException
{
if (permissions.get(ForumPermissions.SYSTEM_ADMIN)) {
Forum newForum = factory.createForum(name, description);
return new ForumProxy(newForum, authorization, permissions);
}
else {
throw new UnauthorizedException();
}
}
|
下面给出这个模式的类图：
图3：Proxy模式的类图
这个模式的实现基本上和GOF中所给出的实现一致。在Jive中，几乎所有的接口，Forum，ForumMessage，ForumThread等等，都会有一个相应的Proxy对象来进行权限控制。而在创建具体的对象的时候，都是用相应的Proxy对象来代替原有的对象返回的。例如在ForumFactory的getInstance()方法中需要返回一个Forum的时候，Jive是这样做的：
public static ForumFactory getInstance(Authorization authorization) {
......
ForumFactoryProxy proxy = new ForumFactoryProxy(factory,authorization, factory.getPermissions(authorization));
return proxy;
}
|
因而，所有被创建的对象实际上都是Proxy对象，抽象工厂保证了没有权限验证的对象根本不会客户所得到，它们只会在Proxy的内部扮演角色，而永远不会被外部对象所存取，这样，就从根本上保证了论坛的安全。
Decorator模式和过滤器
一般的在OO设计中，而外功能的添加是通过继承来实现的，但是继承有的时候不够灵活，而且当功能的组合很多的时候，继承的子类就会成几何级数增长，使得类多的难以控制。正是基于这样的考虑，Decorator模式得以诞生。
Decorator模式相当于封装了某个特定的操作，当某个对象需要这个操作的时候，加上这个Decorator即可。并且，多个Decorator还可以组合，以提供更多的功能。
在Jive中，Decorator模式应用在一些过滤器（Filter）中。Filter提供对ForumMessage对象内容的重新构造。比如，当一个ForumMessage对象流过一个名为FilterCodeHighlight的过滤器后，存在于消息中的所有Java源代码文本，会被重新构造为具有语法高亮显示的消息。在比如，当经过了语法高亮修饰的消息再流过一个名为FilterHtml的过滤器后，消息中的HTML片断会被注释可以在HTML内部显示文本，这样就防止了用户输入了HTML控制标签后，使得页面显示不正常的问题。
Jive中，所有的过滤器继承于一个抽象类ForumMessageFilter，而ForumMessageFilter又实现了ForumMessage接口。也就是说，每一个过滤器实际上也是一个ForumMessage对象。
ForumMessageFilter中还封装一个ForumMessage对象。进行过滤的方法很简单，使用的是getBody()，比如在FilterCodeHighlight这个类中：
public String getBody() {
return highlightCode(message.getBody());
}
|
highlightCode是一个private方法，实施具体的过滤的细节。getBody()方法实际上是定义在ForumMessage接口中的，当调用过滤器的getBody()方法时，就能够得到结构重整后的ForumMessage对象了。这个对象可以被其他客户引用，也可以在传递给另外的过滤器，实施进一步的操作。
在实现一个具体的消息的过滤的时候，在Forum中有addForumMessageFilter()，applyFilters()方法，用来实现对过滤器的应用。
对一个Forum，使用addForumMessageFilter()方法添加一个Filter的时候，并没有指定一个具体的Message，而只是一个规则（Filter中封装了过滤规则），然后applyFilter()方法中，实施这些规则：
public ForumMessage applyFilters(ForumMessage message) {
//Loop through filters and apply them
for (int i=0; i < filters.length; i++) {
message = filters[i].clone(message);
}
return message;
}
|
过滤器的clone()方法，为过滤器复制消息体。这个方法的使用，分离了在过滤器中对于消息体和过滤规则的初始化过程，这也是一个值得借鉴的技巧！
下面给出Decorator模式的类图:
图4：Decorator模式的类图
我们可以看到Decorator模式实际上和Proxy模式是很相近的，但是它们代表两个不同的功能含义。Proxy模式提供一个对象的控制，而Decorator模式则是为对象提供额外的功能。
Iterator模式和论坛的浏览erator模式用来分离数据结构和遍历算法，降低两者之间的耦合度，以使得同一个数据结构用不同的算法遍历时，仍能够具有相同的接口，另一方面，Iterator模式使得当改换遍历算法后，不需要更改程序的代码。
在Java的JDK中本身就定义有一个Iterator接口，在Iterator接口中仅仅定义了三个方法，hasNext()判断是否遍历完最后一个元素，next()方法返回要遍历的数据结构中一个对象，remove()则删除当前对象。Jive中使用IteratorProxy抽象类继承了这一接口。这儿Proxy的含义和上面一样，也就是说，这个IteratorProxy出了会实现Iterator的遍历功能外，还会有代理权限控制的功能。
对于论坛中的基本对象Forum，ForumThread，ForumMessage，Group，User都有相应的遍历器。比如对应于Forum接口有ForumIteratorProxy对象。这个ForumIteratorProxy遍历器就相当于一个封装了一系列Forum对象的集合类，通过定义好的接口hasNext()和next()可以方便的遍历这个集合，而并不需要知道是如何遍历这个集合的。遍历的算法可能很简单，也可能很复杂，但是对于外部的客户而言，这并没有任何的区别。
而对于论坛中具体的遍历方法，这取决于具体的实现，在Jive中给出的是数据库的实现。
我们就以MessageIteratorProxy为例，来讲解Iterator模式的用法。
DbThreadIterator对象实现了Iterator接口，是对于一个Thread中所有Message的遍历器，我们来看看它是如何实现的。
hasNext()判断在这个Thread中是不是还有下一条Message：
public boolean hasNext() {
if (currentIndex+1 >= messages.length) {
return false;
}
return true;
}
|
next()方法从数据库中取出与在这个Thread中的下一条Message：
public Object next() throws java.util.NoSuchElementException {
ForumMessage message = null;
if (nextMessage != null) {
message = nextMessage;
nextMessage = null;
}
else {
message = getNextMessage();
if (message == null) {
throw new java.util.NoSuchElementException();
}
}
return message;
}
|
这样，通过对数据库的操作，DbThreadIterator实现了对一个Thread中所有Message遍历的方法。
再ForumThread接口中有messages()方法，返回在这个Thread中的所有Message的一个遍历器（Iterator），实际上也就是返回了一个Message的集合：
public Iterator messages();
在DbForumThread中实现了这个方法：
public Iterator messages() {return new DbThreadIterator(this);}
从DbForumThread的messages()方法中所返回的就是这个Thread中所有Message的一个遍历器，通过这个遍历器，我们就可以访问Thread中的所有的Message了。当然，事情还没有完，由于权限的问题，我们还需要构造这个遍历器的Proxy对象，然后通过这个Proxy对象来访问遍历器。
下面的类图给出了在Jive中Iterator模式的实现方法：
图5：Jive中Iterator模式的实现
在Jive中，因为在一个Thread之下，Message是按树形结构组织的，因而，当需要层级表示一个Thread中的Message之间的关系的时候，仅仅用上面讲到的线性的Iterator是不够的。这时候，对Iterator的概念进行推广，就引入了TreeWalker接口。
顾名思义，TreeWalker提供了遍历一个树和存取树上节点的方法：
public interface TreeWalker {
public ForumMessage getRoot();
public ForumMessage getChild(ForumMessage parent, int index);
public int getChildCount(ForumMessage parent);
public int getRecursiveChildCount(ForumMessage parent);
public int getIndexOfChild(ForumMessage parent, ForumMessage child);
public boolean isLeaf(ForumMessage node);
|
TreeWalker只是Iterator的简单推广，并没有Iterator应用的那么广泛，而且，也可以很容易的在TreeWalker上面在套一层Iterator的借口，让它在某些情况下行使Iterator的职责。这儿就不再多讨论了。
再此，Jive设计中所有涉及到的设计模式的地方，基本上都讲完了，看完了之后，是不是对设计模式有了更进一步的了解了呢？
下一部分的内容，将会涉及到具体的编码，深入到JSP的内部，我们将会看到Jive中是如何实现可更换的Skin的，还会涉及Tag Library的一些内容。好了，这次就到这儿了。下次再见。
转载自http://hi.baidu.com/ahunspun/blog/item/0069084e9882a0cbd0c86a66.html
一． Input和Output
1. stream代表的是任何有能力产出数据的数据源，或是任何有能力接收数据的接收源。在Java的IO中，所有的stream（包括Input和Out
stream）都包括两种类型：
1.1 以字节为导向的stream
以字节为导向的stream，表示以字节为单位从stream中读取或往stream中写入信息。以字节为导向的stream包括下面几种类型：
1) inputstream：
1) ByteArrayInputStream：把内存中的一个缓冲区作为InputStream使用
2) StringBufferInputStream：把一个String对象作为InputStream
3) FileInputStream：把一个文件作为InputStream，实现对文件的读取操作
4) PipedInputStream：实现了pipe的概念，主要在线程中使用
5) SequenceInputStream：把多个InputStream合并为一个InputStream
2) Outputstream
1) ByteArrayOutputStream：把信息存入内存中的一个缓冲区中
2) FileOutputStream：把信息存入文件中
3) PipedOutputStream：实现了pipe的概念，主要在线程中使用
4) SequenceOutputStream：把多个OutStream合并为一个OutStream
1.2 以Unicode字符为导向的stream
以Unicode字符为导向的stream，表示以Unicode字符为单位从stream中读取或往stream中写入信息。以Unicode字符为导向的stream包括下面几
种类型：
1) Input Stream
1) CharArrayReader：与ByteArrayInputStream对应
2) StringReader：与StringBufferInputStream对应
3) FileReader：与FileInputStream对应
4) PipedReader：与PipedInputStream对应
2) Out Stream
1) CharArrayWrite：与ByteArrayOutputStream对应
2) StringWrite：无与之对应的以字节为导向的stream
3) FileWrite：与FileOutputStream对应
4) PipedWrite：与PipedOutputStream对应
以字符为导向的stream基本上对有与之相对应的以字节为导向的stream。两个对应类实现的功能相同，字是在操作时的导向不同。如
CharArrayReader：和ByteArrayInputStream的作用都是把内存中的一个缓冲区作为InputStream使用，所不同的是前者每次从内存中读取一个
字节的信息，而后者每次从内存中读取一个字符。
1.3 两种不现导向的stream之间的转换
InputStreamReader和OutputStreamReader：把一个以字节为导向的stream转换成一个以字符为导向的stream。
2. stream添加属性
2.1 “为stream添加属性”的作用
运用上面介绍的Java中操作IO的API，我们就可完成我们想完成的任何操作了。但通过FilterInputStream和FilterOutStream的子类，我们可以
为stream添加属性。下面以一个例子来说明这种功能的作用。
如果我们要往一个文件中写入数据，我们可以这样操作：
FileOutStream fs = new FileOutStream(“test.txt”);
然后就可以通过产生的fs对象调用write()函数来往test.txt文件中写入数据了。但是，如果我们想实现“先把要写入文件的数据先缓存到内存
中，再把缓存中的数据写入文件中”的功能时，上面的API就没有一个能满足我们的需求了。但是通过FilterInputStream和FilterOutStream的
子类，为FileOutStream添加我们所需要的功能。
2.2 FilterInputStream的各种类型
2.2.1 用于封装以字节为导向的InputStream
1) DataInputStream：从stream中读取基本类型（int、char等）数据。
2) BufferedInputStream：使用缓冲区
3) LineNumberInputStream：会记录input stream内的行数，然后可以调用getLineNumber()和setLineNumber(int)
4) PushbackInputStream：很少用到，一般用于编译器开发
2.2.2 用于封装以字符为导向的InputStream
1) 没有与DataInputStream对应的类。除非在要使用readLine()时改用BufferedReader，否则使用DataInputStream
2) BufferedReader：与BufferedInputStream对应
3) LineNumberReader：与LineNumberInputStream对应
4) PushBackReader：与PushbackInputStream对应
2.3 FilterOutStream的各种类型
2.2.3 用于封装以字节为导向的OutputStream
1) DataIOutStream：往stream中输出基本类型（int、char等）数据。
2) BufferedOutStream：使用缓冲区
3) PrintStream：产生格式化输出
2.2.4 用于封装以字符为导向的OutputStream
1) BufferedWrite：与对应
2) PrintWrite：与对应
3. RandomAccessFile
1) 可通过RandomAccessFile对象完成对文件的读写操作
2) 在产生一个对象时，可指明要打开的文件的性质：r，只读；w，只写；rw可读写
3) 可以直接跳到文件中指定的位置
4. I/O应用的一个例子
import java.io.*;
public class TestIO{
public static void main(String[] args)
throws IOException{
//1.以行为单位从一个文件读取数据
BufferedReader in =
new BufferedReader(
new FileReader("F:\\nepalon\\TestIO.java"));
String s, s2 = new String();
while((s = in.readLine()) != null)
s2 += s + "\n";
in.close();
//1b. 接收键盘的输入
BufferedReader stdin =
new BufferedReader(
new InputStreamReader(System.in));
System.out.println("Enter a line:");
System.out.println(stdin.readLine());
//2. 从一个String对象中读取数据
StringReader in2 = new StringReader(s2);
int c;
while((c = in2.read()) != -1)
System.out.println((char)c);
in2.close();
//3. 从内存取出格式化输入
try{
DataInputStream in3 =
new DataInputStream(
new ByteArrayInputStream(s2.getBytes()));
while(true)
System.out.println((char)in3.readByte());
}
catch(EOFException e){
System.out.println("End of stream");
}
//4. 输出到文件
try{
BufferedReader in4 =
new BufferedReader(
new StringReader(s2));
PrintWriter out1 =
new PrintWriter(
new BufferedWriter(
new FileWriter("F:\\nepalon\\ TestIO.out")));
int lineCount = 1;
while((s = in4.readLine()) != null)
out1.println(lineCount++ + "：" + s);
out1.close();
in4.close();
}
catch(EOFException ex){
System.out.println("End of stream");
}
//5. 数据的存储和恢复
try{
DataOutputStream out2 =
new DataOutputStream(
new BufferedOutputStream(
new FileOutputStream("F:\\nepalon\\ Data.txt")));
out2.writeDouble(3.1415926);
out2.writeChars("\nThas was pi:writeChars\n");
out2.writeBytes("Thas was pi:writeByte\n");
out2.close();
DataInputStream in5 =
new DataInputStream(
new BufferedInputStream(
new FileInputStream("F:\\nepalon\\ Data.txt")));
BufferedReader in5br =
new BufferedReader(
new InputStreamReader(in5));
System.out.println(in5.readDouble());
System.out.println(in5br.readLine());
System.out.println(in5br.readLine());
}
catch(EOFException e){
System.out.println("End of stream");
}
//6. 通过RandomAccessFile操作文件
RandomAccessFile rf =
new RandomAccessFile("F:\\nepalon\\ rtest.dat", "rw");
for(int i=0; i<10; i++)
rf.writeDouble(i*1.414);
rf.close();
rf = new RandomAccessFile("F:\\nepalon\\ rtest.dat", "r");
for(int i=0; i<10; i++)
System.out.println("Value " + i + "：" + rf.readDouble());
rf.close();
rf = new RandomAccessFile("F:\\nepalon\\ rtest.dat", "rw");
rf.seek(5*8);
rf.writeDouble(47.0001);
rf.close();
rf = new RandomAccessFile("F:\\nepalon\\ rtest.dat", "r");
for(int i=0; i<10; i++)
System.out.println("Value " + i + "：" + rf.readDouble());
rf.close();
}
}
关于代码的解释（以区为单位）：
1区中，当读取文件时，先把文件内容读到缓存中，当调用in.readLine()时，再从缓存中以字符的方式读取数据（以下简称“缓存字节读取方
式”）。
1b区中，由于想以缓存字节读取方式从标准IO（键盘）中读取数据，所以要先把标准IO（System.in）转换成字符导向的stream，再进行
BufferedReader封装。
2区中，要以字符的形式从一个String对象中读取数据，所以要产生一个StringReader类型的stream。
4区中，对String对象s2读取数据时，先把对象中的数据存入缓存中，再从缓冲中进行读取；对TestIO.out文件进行操作时，先把格式化后的信
息输出到缓存中，再把缓存中的信息输出到文件中。
5区中，对Data.txt文件进行输出时，是先把基本类型的数据输出屋缓存中，再把缓存中的数据输出到文件中；对文件进行读取操作时，先把文
件中的数据读取到缓存中，再从缓存中以基本类型的形式进行读取。注意in5.readDouble()这一行。因为写入第一个writeDouble()，所以为了
正确显示。也要以基本类型的形式进行读取。
6区是通过RandomAccessFile类对文件进行操作。
摘要: 感谢ryang的劳动！
Java实现通用线程池
线程池通俗的描述就是预先创建若干空闲线程，等到需要用多线程去处理事务的时候去唤醒某些空闲线程执行处理任务，这样就省去了频繁创建线程的时间，因为频繁创建线程是要耗费大量的CPU资源的。如果一个应用程序需要频繁地处理大量并发事务，不断的创建销毁线程往往会大大地降低系统的效率，这时候线程池就派上用场了。 &...
阅读全文
虚拟机加载类的途径：
1、Dog dog ＝ new Dog（）；
这个动作会导致常量池的解析，Dog类被隐式装载。
如果当前ClassLoader无法找到Dog，则抛出NoClassDefFoundError。
2、Class clazz ＝ Class.forName（“Dog”）；
Object dog ＝clazz.newInstance（）；
通过反射加载类型，并创建对象实例
如果无法找到Dog，则抛出ClassNotFoundException。
3、Class clazz ＝ classLoader.loadClass（“Dog”）；
Object dog ＝clazz.newInstance（）；
通过反射加载类型，并创建对象实例
如果无法找到Dog，则抛出ClassNotFoundException。
那么，1和2和3究竟有什么区别呢？分别用于什么情况呢？
1和2使用的类加载器是相同的，都是当前类加载器。（即：this.getClass.getClassLoader）。
3由用户指定类加载器。
如果需要在当前类路径以外寻找类，则只能采用第3种方式。第3种方式加载的类与当前类分属不同的命名空间。
当前类加载器命名空间对其不可见。当然，如果被加载类的超类对于当前类命名空间可见的话，则可以进行强制转型。
第1和第2种情况区别不大。如果，Dog类在编译时无法得到，则使用第2种方式。
另外，第1种和第2种都会导致类被初始化，即：执行类的静态初始化语句，而第3种情况不会。
另外注意，第1种抛出Error，第2、3种抛出Exception，它们分属于不同的异常/错误分支。
JAVA 方面
1 面向对象的特征有哪些方面
2 String 是最基本的数据类型吗?
3 int 和 Integer 有什么区别
4 String 和StringBuffer 的区别
5 运行时异常与一般异常有何异同？
异常表示程序运行过程中可能出现的非正常状态，运行时异常表示虚拟机的通常
操作中可能遇到的异常，是一种常见运行错误。java 编译器要求方法必须声明抛
出可能发生的非运行时异常，但是并不要求必须声明抛出未被捕获的运行时异
常。
6 说出一些常用的类，包,接口，请各举5 个
7 说出ArrayList,Vector, LinkedList 的存储性能和特性
ArrayList 和Vector 都是使用数组方式存储数据，此数组元素数大于实际存储的
数据以便增加和插入元素，它们都允许直接按序号索引元素，但是插入元素要涉
及数组元素移动等内存操作，所以索引数据快而插入数据慢，Vector 由于使用了
synchronized 方法（线程安全），通常性能上较ArrayList 差，而LinkedList 使用
双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时
只需要记录本项的前后项即可，所以插入速度较快。
8 设计4 个线程，其中两个线程每次对j 增加1，另外两个线程对j 每次减少1。
写出程序。
以下程序使用内部类实现线程，对j 增减的时候没有考虑顺序问题。
public class ThreadTest1{
private int j;
public static void main(String args[]){
ThreadTest1 tt=new ThreadTest1();
Inc inc=tt.new Inc();
Dec dec=tt.new Dec();
for(int i=0;i<2;i++){
Thread t=new Thread(inc);
t.start();
t=new Thread(dec);
t.start();
}
}
private synchronized void inc(){
j++;
System.out.println(Thread.currentThread().getName()+"-inc:"+j);
}
private synchronized void dec(){
j--;
System.out.println(Thread.currentThread().getName()+"-dec:"+j);
}
class Inc implements Runnable{
public void run(){
for(int i=0;i<100;i++){
inc();
}
}
}
class Dec implements Runnable{
public void run(){
for(int i=0;i<100;i++){
dec();
}
}
}
}
9．JSP 的内置对象及方法。
request request 表示HttpServletRequest 对象。它包含了有关浏览器请求的信息，并且提
供了几个用于获取cookie, header, 和session 数据的有用的方法。
response response 表示HttpServletResponse 对象，并提供了几个用于设置送回 浏览器的
响应的方法（如cookies,头信息等）
out out 对象是javax.jsp.JspWriter 的一个实例，并提供了几个方法使你能用于向浏览器回
送输出结果。
pageContext pageContext 表示一个javax.servlet.jsp.PageContext 对象。它是用于方便存
取各种范围的名字空间、servlet 相关的对象的API，并且包装了通用的servlet 相关功能的
方法。
session session 表示一个请求的javax.servlet.http.HttpSession 对象。Session 可以存贮用
户的状态信息
application applicaton 表示一个javax.servle.ServletContext 对象。这有助于查找有关
servlet 引擎和servlet 环境的信息
config config 表示一个javax.servlet.ServletConfig 对象。该对象用于存取servlet 实例的初
始化参数。
page page 表示从该页面产生的一个servlet 实例
10.用socket 通讯写出客户端和服务器端的通讯，要求客户发送数据后能够回显
相同的数据。
参见课程中socket 通讯例子。
11 说出Servlet 的生命周期，并说出Servlet 和CGI 的区别。
Servlet 被服务器实例化后，容器运行其init 方法，请求到达时运行其service 方
法，service 方法自动派遣运行与请求对应的doXXX 方法（doGet，doPost）等，
当服务器决定将实例销毁的时候调用其destroy 方法。
与cgi 的区别在于servlet 处于服务器进程中，它通过多线程方式运行其service
方法，一个实例可以服务于多个请求，并且其实例一般不会销毁，而CGI 对每
个请求都产生新的进程，服务完成后就销毁，所以效率上低于servlet。
12.EJB 是基于哪些技术实现的?并说出SessionBean 和EntityBean 的区别，
StatefulBean 和StatelessBean 的区别。
13．EJB 包括（SessionBean,EntityBean）说出他们的生命周期，及如何管理事务
的？
14．说出数据连接池的工作机制是什么?
15 同步和异步有和异同，在什么情况下分别使用他们？举例说明。
16 应用服务器有那些？
17 你所知道的集合类都有哪些？主要方法？
18 给你一个:驱动程序A,数据源名称为B,用户名称为C,密码为D,数据库表为T，
请用JDBC 检索出表T 的所有数据。
19．说出在JSP 页面里是怎么分页的?
页面需要保存以下参数：
总行数：根据sql 语句得到总行数
每页显示行数：设定值
当前页数：请求参数
页面根据当前页数和每页行数计算出当前页第一行行数，定位结果集到此行，对
结果集取出每页显示行数的行即可。
数据库方面：
1. 存储过程和函数的区别
存储过程是用户定义的一系列sql 语句的集合，涉及特定表或其它对象
的任务，用户可以调用存储过程，而函数通常是数据库已定义的方法，
它接收参数并返回某种类型的值并且不涉及特定用户表。
2. 事务是什么？
事务是作为一个逻辑单元执行的一系列操作，一个逻辑工作单元必须有四个
属性，称为 ACID（原子性、一致性、隔离性和持久性）属性，只有这样才能成
为一个事务：
原子性
事务必须是原子工作单元；对于其数据修改，要么全都执行，要么全都不执行。
一致性
事务在完成时，必须使所有的数据都保持一致状态。在相关数据库中，所有规则
都必须应用于事务的修改，以保持所有数据的完整性。事务结束时，所有的内部
数据结构（如 B 树索引或双向链表）都必须是正确的。
隔离性
由并发事务所作的修改必须与任何其它并发事务所作的修改隔离。事务查看数据
时数据所处的状态，要么是另一并发事务修改它之前的状态，要么是另一事务修
改它之后的状态，事务不会查看中间状态的数据。这称为可串行性，因为它能够
重新装载起始数据，并且重播一系列事务，以使数据结束时的状态与原始事务执
行的状态相同。
持久性
事务完成之后，它对于系统的影响是永久性的。该修改即使出现系统故障也将一
直保持。
3. 游标的作用？如何知道游标已经到了最后？
游标用于定位结果集的行，通过判断全局变量@@FETCH_STATUS 可以判
断是否到了最后，通常此变量不等于0 表示出错或到了最后。
4. 触发器分为事前触发和事后触发，这两种触发有和区别。语句级触发和
行级触发有何区别。
事前触发器运行于触发事件发生之前，而事后触发器运行于触发事件发
生之后。通常事前触发器可以获取事件之前和新的字段值。
语句级触发器可以在语句执行前或后执行，而行级触发在触发器所影响
的每一行触发一次。
http://www.zhuicha.com/zhuicha/onlineHB/linuxcmd/ 此网站列举了常用命令
文件传输
备份压缩
文件管理
磁盘管理
磁盘维护
系统设置
系统管理
文档编辑
网络通讯
电子邮件与新闻组
X WINDOWS SYSTEM
对于这个系列里的问题，每个学Java的人都应该搞懂。当然，如果只是学Java玩玩就无所谓了。如果你认为自己已经超越初学者了，却不很懂这些问题，请将你自己重归初学者行列。内容均来自于CSDN的经典老贴。
问题一：我声明了什么！
String s = "Hello world!";
许多人都做过这样的事情，但是，我们到底声明了什么？回答通常是：一个String，内容是“Hello world!”。这样模糊的回答通常是概念不清的根源。如果要准确的回答，一半的人大概会回答错误。
这个语句声明的是一个指向对象的引用，名为“s”，可以指向类型为String的任何对象，目前指向"Hello world!"这个String类型的对象。这就是真正发生的事情。我们并没有声明一个String对象，我们只是声明了一个只能指向String对象的引用变量。所以，如果在刚才那句语句后面，如果再运行一句：
String string = s;
我们是声明了另外一个只能指向String对象的引用，名为string，并没有第二个对象产生，string还是指向原来那个对象，也就是，和s指向同一个对象。
问题二："=="和equals方法究竟有什么区别？
==操作符专门用来比较变量的值是否相等。比较好理解的一点是：
int a=10;
int b=10;
则a==b将是true。
但不好理解的地方是：
String a=new String("foo");
String b=new String("foo");
则a==b将返回false。
根据前一帖说过，对象变量其实是一个引用，它们的值是指向对象所在的内存地址，而不是对象本身。a和b都使用了new操作符，意味着将在内存中产生两个内容为"foo"的字符串，既然是“两个”，它们自然位于不同的内存地址。a和b的值其实是两个不同的内存地址的值，所以使用"=="操作符，结果会是false。诚然，a和b所指的对象，它们的内容都是"foo"，应该是“相等”，但是==操作符并不涉及到对象内容的比较。
对象内容的比较，正是equals方法做的事。
看一下Object对象的equals方法是如何实现的：
boolean equals(Object o){
return this==o;
}
Object对象默认使用了==操作符。所以如果你自创的类没有覆盖equals方法，那你的类使用equals和使用==会得到同样的结果。同样也可以看出，Object的equals方法没有达到equals方法应该达到的目标：比较两个对象内容是否相等。因为答案应该由类的创建者决定，所以Object把这个任务留给了类的创建者。
看一下一个极端的类：
Class Monster{
private String content;
...
boolean equals(Object another){ return true;}
}
我覆盖了equals方法。这个实现会导致无论Monster实例内容如何，它们之间的比较永远返回true。
所以当你是用equals方法判断对象的内容是否相等，请不要想当然。因为可能你认为相等，而这个类的作者不这样认为，而类的equals方法的实现是由他掌握的。如果你需要使用equals方法，或者使用任何基于散列码的集合（HashSet,HashMap,HashTable），请察看一下java doc以确认这个类的equals逻辑是如何实现的。
继续深入讨论一下“＝＝”和equals，看如下例子
public class TestStringIntern {
public static void main(String[] args) {
testIt();
}
private static void testIt() {
String s1 = "sean_gao";
String s2 = "sean"+"_"+"gao";
String s3 = new String("sean_gao");
String s4 = new String("sean_gao").intern();
System.out.println("s1==s2? "+(s1==s2));
System.out.println("s1==s3? "+(s1==s3));
System.out.println("s1==s4? "+(s1==s4));
System.out.println("s1.equals(s2)? "+(s1.equals(s2)));
System.out.println("s1.equals(s3)? "+(s1.equals(s3)));
System.out.println("s1.equals(s4)? "+(s1.equals(s4)));
}
}
以下是结果：
s1==s2? true // 引用的是同一个对象，因为内容一致
s1==s3? false // 引用的是不同的对象，因为用了new关键字
s1==s4? true // 引用的是同一个对象，因为用了intern方法
s1.equals(s2)? true // 内容一致
s1.equals(s3)? true // 内容一致
s1.equals(s4)? true // 内容一致
再次解释：对于String对象，如果是按照String s = "some string";这样的形式声明的，如果同一个JVM中恰好有相同内容的String对象，那么这个s指向的就是那个已有的对象。但如果使用String s = new String("some string");这样的语法，那么不管JVM中有没有可以重用的String对象，都将新建一个对象。
==操作符判断的是对象引用是否指向同一个对象，而equals方法在String类中的实现是判断String对象的内容是否一致。
问题三：String到底变了没有？
没有。因为String被设计成不可变(immutable)类，所以它的所有对象都是不可变对象。请看下列代码：
String s = "Hello";
s = s + " world!";
s所指向的对象是否改变了呢？从本系列第一篇的结论很容易导出这个结论。我们来看看发生了什么事情。在这段代码中，s原先指向一个String对象，内容是"Hello"，然后我们对s进行了+操作，那么s所指向的那个对象是否发生了改变呢？答案是没有。这时，s不指向原来那个对象了，而指向了另一个String对象，内容为"Hello world!"，原来那个对象还存在于内存之中，只是s这个引用变量不再指向它了。
通过上面的说明，我们很容易导出另一个结论，如果经常对字符串进行各种各样的修改，或者说，不可预见的修改，那么使用String来代表字符串的话会引起很大的内存开销。因为String对象建立之后不能再改变，所以对于每一个不同的字符串，都需要一个String对象来表示。这时，应该考虑使用StringBuffer类，它允许修改，而不是每个不同的字符串都要生成一个新的对象。并且，这两种类的对象转换十分容易。
同时，我们还可以知道，如果要使用内容相同的字符串，不必每次都new一个String。例如我们要在构造器中对一个名叫s的String引用变量进行初始化，把它设置为初始值，应当这样做：
public class Demo {
private String s;
...
public Demo {
s = "Initial Value";
}
...
}
而非
s = new String("Initial Value");
后者每次都会调用构造器，生成新对象，性能低下且内存开销大，并且没有意义，因为String对象不可改变，所以对于内容相同的字符串，只要一个String对象来表示就可以了。也就说，多次调用上面的构造器创建多个对象，他们的String类型属性s都指向同一个对象。
上面的结论还基于这样一个事实：对于字符串常量，如果内容相同，Java认为它们代表同一个String对象。而用关键字new调用构造器，总是会创建一个新的对象，无论内容是否相同。
至于为什么要把String类设计成不可变类，是它的用途决定的。其实不只String，很多Java标准类库中的类都是不可变的。在开发一个系统的时候，我们有时候也需要设计不可变类，来传递一组相关的值，这也是面向对象思想的体现。不可变类有一些优点，比如因为它的对象是只读的，所以多线程并发访问也不会有任何问题。当然也有一些缺点，比如每个不同的状态都要一个对象来代表，可能会造成性能上的问题。所以Java标准类库还提供了一个可变版本，即StringBuffer。
问题四：final关键字到底修饰了什么？
final使得被修饰的变量"不变"，但是由于对象型变量的本质是“引用”，使得“不变”也有了两种含义：引用本身的不变，和引用指向的对象不变。
引用本身的不变：
final StringBuffer a=new StringBuffer("immutable");
final StringBuffer b=new StringBuffer("not immutable");
a=b;//编译期错误
引用指向的对象不变：
final StringBuffer a=new StringBuffer("immutable");
a.append(" broken!"); //编译通过
可见，final只对引用的“值”(也即它所指向的那个对象的内存地址)有效，它迫使引用只能指向初始指向的那个对象，改变它的指向会导致编译期错误。至于它所指向的对象的变化，final是不负责的。这很类似==操作符：==操作符只负责引用的“值”相等，至于这个地址所指向的对象内容是否相等，==操作符是不管的。
理解final问题有很重要的含义。许多程序漏洞都基于此----final只能保证引用永远指向固定对象，不能保证那个对象的状态不变。在多线程的操作中,一个对象会被多个线程共享或修改，一个线程对对象无意识的修改可能会导致另一个使用此对象的线程崩溃。一个错误的解决方法就是在此对象新建的时候把它声明为final，意图使得它“永远不变”。其实那是徒劳的。
问题五：到底要怎么样初始化！
本问题讨论变量的初始化，所以先来看一下Java中有哪些种类的变量。
1. 类的属性，或者叫值域
2. 方法里的局部变量
3. 方法的参数
对于第一种变量，Java虚拟机会自动进行初始化。如果给出了初始值，则初始化为该初始值。如果没有给出，则把它初始化为该类型变量的默认初始值。
int类型变量默认初始值为0
float类型变量默认初始值为0.0f
double类型变量默认初始值为0.0
boolean类型变量默认初始值为false
char类型变量默认初始值为0(ASCII码)
long类型变量默认初始值为0
所有对象引用类型变量默认初始值为null，即不指向任何对象。注意数组本身也是对象，所以没有初始化的数组引用在自动初始化后其值也是null。
对于两种不同的类属性，static属性与instance属性，初始化的时机是不同的。instance属性在创建实例的时候初始化，static属性在类加载，也就是第一次用到这个类的时候初始化，对于后来的实例的创建，不再次进行初始化。这个问题会在以后的系列中进行详细讨论。
对于第二种变量，必须明确地进行初始化。如果再没有初始化之前就试图使用它，编译器会抗议。如果初始化的语句在try块中或if块中，也必须要让它在第一次使用前一定能够得到赋值。也就是说，把初始化语句放在只有if块的条件判断语句中编译器也会抗议，因为执行的时候可能不符合if后面的判断条件，如此一来初始化语句就不会被执行了，这就违反了局部变量使用前必须初始化的规定。但如果在else块中也有初始化语句，就可以通过编译，因为无论如何，总有至少一条初始化语句会被执行，不会发生使用前未被初始化的事情。对于try-catch也是一样，如果只有在try块里才有初始化语句，编译部通过。如果在catch或finally里也有，则可以通过编译。总之，要保证局部变量在使用之前一定被初始化了。所以，一个好的做法是在声明他们的时候就初始化他们，如果不知道要出事化成什么值好，就用上面的默认值吧！
其实第三种变量和第二种本质上是一样的，都是方法中的局部变量。只不过作为参数，肯定是被初始化过的，传入的值就是初始值，所以不需要初始化。
问题六：instanceof是什么东东？
instanceof是Java的一个二元操作符，和==，>，<是同一类东东。由于它是由字母组成的，所以也是Java的保留关键字。它的作用是测试它左边的对象是否是它右边的类的实例，返回boolean类型的数据。举个例子：
String s = "I AM an Object!";
boolean isObject = s instanceof Object;
我们声明了一个String对象引用，指向一个String对象，然后用instancof来测试它所指向的对象是否是Object类的一个实例，显然，这是真的，所以返回true，也就是isObject的值为True。
instanceof有一些用处。比如我们写了一个处理账单的系统，其中有这样三个类：
public class Bill {//省略细节}
public class PhoneBill extends Bill {//省略细节}
public class GasBill extends Bill {//省略细节}
在处理程序里有一个方法，接受一个Bill类型的对象，计算金额。假设两种账单计算方法不同，而传入的Bill对象可能是两种中的任何一种，所以要用instanceof来判断：
public double calculate(Bill bill) {
if (bill instanceof PhoneBill) {
//计算电话账单
}
if (bill instanceof GasBill) {
//计算燃气账单
}
...
}
这样就可以用一个方法处理两种子类。
然而，这种做法通常被认为是没有好好利用面向对象中的多态性。其实上面的功能要求用方法重载完全可以实现，这是面向对象变成应有的做法，避免回到结构化编程模式。只要提供两个名字和返回值都相同，接受参数类型不同的方法就可以了：
public double calculate(PhoneBill bill) {
//计算电话账单
}
public double calculate(GasBill bill) {
//计算燃气账单
}
所以，使用instanceof在绝大多数情况下并不是推荐的做法，应当好好利用多态。
主要就我所了解的J2EE开发的框架或开源项目做个介绍,可以根据需求选用适当的开源组件进行开发.主要还是以Spring为核心,也总结了一些以前web开发常用的开源工具和开源类库
1持久层:
1)Hibernate
这个不用介绍了,用的很频繁,用的比较多的是映射,包括继承映射和父子表映射
对于DAO在这里介绍个在它基础上开发的包bba96,目前最新版本是bba96 2.0它对Hibernate进行了封装, 查询功能包括执行hsql或者sql查询/更新的方法，如果你要多层次逻辑的条件查询可以自己组装QueryObject.可以参考它做HibernateDAO.也可以直接利用它
2) iBATIS
另一个ORM工具,Apache的,没有Hibernate那么集成,自由度比较大
2:SpringMVC
原理说明和快速入门:
配置文件为:
Spring的配置文件默认为WEB-INF/xxxx-servelet.xm其中xxx为web.xml中org.springframework.web.servlet.DispatcherServlet的servlet-name。
Action分发:
Spring将按照配置文件定义的URL，Mapping到具体Controller类，再根据URL里的action= xxx或其他参数，利用反射调用Controller里对应的Action方法。
输入数据绑定:
Spring提供Binder 通过名字的一一对应反射绑定Pojo，也可以直接从request.getParameter()取数据。
输入数据验证
Sping 提供了Validator接口当然还可以使用开源的Commons-Validaor支持最好
Interceptor(拦截器)
Spring的拦截器提供接口需要自己编写,在这点不如WebWork做的好.全面
(这里提一下WebWork和Struts的区别最主要的区别在于WebWork在建立一个Action时是新New一个对象而Struts是SingleMoule所有的都继承它的一个Action,所以根据项目需要合适的选择.)
3:View层
1) 标签库:JSP2.0/JSTL
由于Webwork或Spring的标签确实很有限,一般view层用JSTL标签,而且据说JSTL设计很好速度是所有标签中最快的使用起来也很简单
2) 富客户端:DOJO Widgets, YUI(YahooUI),FCKEditor, Coolest日历控件
Dojo主要提供Tree, Tab等富客户端控件,可以用其进行辅助客户端开发
YahooUI和DOJO一样它有自己的一套javascript调试控制台,主要支持ajax开发也有很多Tree,Table,Menu等富客户端控件
FCKEditor 最流行的文本编辑器
Coolest日历控件 目前很多日历控件可用,集成在项目中也比较简单,这个只是其中的一个,界面不错的说..
3) JavaScript:Prototype.js
Prototype.js作为javascript的成功的开源框架，封装了很多好用的功能,通过它很容易编写AJAX应用,现在AJAX技术逐渐成熟,框架资源比较丰富,比如YUI,DWR等等,也是因为JavaScript没有合适的调试工具,所以没有必要从零开始编写AJAX应用,个人认为多用一些成熟的Ajax框架实现无刷新更新页面是不错的选择.
4)表格控件:Display Tag ,Extreme Table
这两个的功能差不多,都是View层表格的生成,界面也比较相向,可以导出Excel,Pdf,对Spring支持很容易.
相比较而言比较推荐ExtremeTable,它的设计很好功能上比DisplayTag多一些,支持Ajax,封装了一些拦截器,而且最方面的是在主页wiki中有详细的中文使用文档.
5):OSCache
OSCache是OpenSymphony组织提供的一个J2EE架构中Web应用层的缓存技术实现组件,Cache是一种用于提高系统响应速度、改善系统运行性能的技术。尤其是在Web应用中，通过缓存页面的输出结果，可以很显著的改善系统的稳定性和运行性能。
它主要用在处理短时间或一定时间内一些数据或页面不会发生变化,或将一些不变的统计报表,缓冲在内存,可以充分的减轻服务器的压力,防治负载平衡,快速重启服务器(通过硬盘缓存).
6)SiteMesh
sitemesh应用Decorator模式主要用于提高页面的可维护性和复用性，其原理是用Filter截取request和response,把页面组件head,content,banner结合为一个完整的视图。通常我们都是用include标签在每个jsp页面中来不断的包含各种header, stylesheet, scripts and footer，现在，在sitemesh的帮助下，我们删掉他们轻松达到复合视图模式.
Sitemesh也是 OpenSymphony的一个项目现在最近的版本是2.2,目前OpenSymphony自从04年就没有更新的版本了..感觉它还是比较有创新的一种页面组装方式, OpenSymphony开源组织的代码一般写的比较漂亮,可以改其源代码对自己的项目进行适配.
测试发现Sitemesh还存在一些问题,比如中文问题,它的默认编码是iso-8859-1在使用时候需要做一些改动.
7)CSS,XHTML
这个不用说了,遵循W3C标准的web页面开发.
8)分页标签: pager-taglib组件
Pager-taglib 是一套分页标签库，可以灵活地实现多种不同风格的分页导航页面，并且可以很好的与服务器分页逻辑分离.使用起来也比较简单.
9)Form: Jodd Form taglib
Jodd Form taglib使用比较简单,只要把<form>的头尾以<jodd:form bean= "mybean">包住
就会自动绑定mybean, 自动绑定mybean的所有同名属性到普通html标记input, selectbox, checkbox,radiobox.....在这些input框里不用再写任何代码…
10)Ajax:DWR
J2EE应用最常用的ajax框架
11)报表 图表
Eclipse BIRT功能比较强大,也很庞大..好几十M,一般没有特别需求或别的图表设计软件可以解决的不用它
JasperReports+ iReport是一个基于Java的开源报表工具，它可以在Java环境下像其它IDE报表工具一样来制作报表。JasperReports支持PDF、HTML、XLS、CSV和XML文件输出格式。JasperReports是当前Java开发者最常用的报表工具。
JFreeChart主要是用来制作各种各样的图表，这些图表包括：饼图、柱状图(普通柱状图以及堆栈柱状图)、线图、区域图、分布图、混合图、甘特图以及一些仪表盘等等。
琴棋报表,国产的..重点推荐,适合中国的情况,开放源代码，使用完全免费。纯JAVA开发，适用多种系统平台。特别适合B/S结构的系统。官方网站有其优点介绍,看来用它还是不错的选择,最重要的是支持国产呵呵
4:权限控制: Acegi
Acegi是Spring Framework 下最成熟的安全系统，它提供了强大灵活的企业级安全服务，如完善的认证和授权机制，Http资源访问控制，Method 调用访问控制等等,支持CAS
(耶鲁大学的单点登陆技术,这个单点登陆方案比较出名.我也进行过配置使用,可以根据项目需要,如果用户分布在不同的地方不同的系统通用一套登陆口令可以用它进行解决,一般注册机登陆机就是这样解决的)
Acegi只是于Spring结合最好的安全框架,功能比较强大,当然还有一些其他的安全框架,这里列举一些比较流行的是我从网上找到的,使用方法看其官方文档把…
JAAS, Seraph, jSai - Servlet Security, Gabriel, JOSSO, Kasai, jPAM, OpenSAML都是些安全控制的框架..真够多的呵呵
5:全文检索
1) Lucene
Lucene是一套全文索引接口,可以通过它将数据进行倒排文件处理加入索引文件,它的索引速度和查询速度是相当快的,查询百万级数据毫秒级出结果,现在最火的Apache开源项目,版本更新速度很快现在已经到了2.0,每个版本更新的都比较大,目前用的最多的版本应该是1.4.3,但它有个不太方面的地方单个索引文件有2G文件限制,现在2.0版本没有这个限制,我研究的比较多,它的扩展性比较好,可以很方面的扩充其分词接口和查询接口.
基于它的开发的系统很多,比如最常用的Eclipse的搜索功能,还有一些开源的软件比如Compass,Nutch,Lius,还有我最近做的InSearch(企业级FTP文件网页搜索)
6:公共Util类
主要是Jakarta-Commons类库,其中最常用得是以下几个类库
1) Jakarta-Commons-Language
最常用得类是StringUtils类,提供了使用的字符串处理的常用方法效率比较高
2) Jakarta-Commons-Beantuils
主要用Beantuils能够获得反射函数封装及对嵌套属性，map,array型属性的读取。
3) Jakarta-Commons-Collections
里面有很多Utils方法
7 日志管理
Log4J
任务是日志记录,分为Info,Warn,error几个层次可以更好的调试程序
8 开源的J2EE框架
1) Appfuse
Appfuse是Matt Raible 开发的一个指导性的入门级J2EE框架, 它对如何集成流行的Spring、Hibernate、iBatis、Struts、Xdcolet、JUnit等基础框架给出了示范. 在持久层，AppFuse采用了Hibernate O/R映射工具；在容器方面，它采用了Spring,用户可以自由选择Struts、Spring/MVC，Webwork，JSF这几个Web框架。
2) SpringSide
.SpringSide较完整的演示了企业应用的各个方面,是一个电子商务网站的应用 SpringSide也大量参考了Appfuse中的优秀经验。最重要的是它是国内的一个开源项目,可以了解到国内现在的一些实际技术动态和方向很有指导意义…
9:模版 Template
主要有Veloctiy和Freemarker
模板用Servlet提供的数据动态地生成 HTML。编译器速度快，输出接近静态HTML 页面的速度。
10:工作流
我所知道比较出名的主要有JBpm Shark Osworkflow,由于对它没有过多的研究所以还不是很清楚之间有什么区别.
项目管理软件
dotProject:是一个基于LAMP的开源项目管理软件。最出名的项目管理软件
JIRA: 项目计划，任务安排，错误管理
Bugzilla:提交和管理bug,和eclipse集成,可以通过安装MyEclipse配置一下即可使用
BugFree借鉴微软公司软件研发理念、免费开放源代码、基于Web的精简版Bug管理
CVS:这个就不介绍了都在用.
SVN: SubVersion已逐渐超越CVS，更适应于JavaEE的项目。Apache用了它很久后，Sourceforge刚刚推出SVN的支持。
测试用例:主要JUnit单元测试,编写TestCase,Spring也对Junit做了很好的支持
后记:
以Spring为主的应用开发可选用的组件中间件真是眼花缭乱,所以针对不同的项目需求可以利用不同的开源产品解决,比如用Spring+Hibernate/ iBATIS或Spring+WebWork+Hibernate/ iBATIS或Spring+Struts+Hibernate/ iBATIS,合理的框架设计和代码复用设计对项目开发效率和程序性能有很大的提高,也有利于后期的维护.
现在主流的Java集成开发工具(IDE)Eclipse越来越流行,自从3.0版本以后Eclipse也逐渐稳定,现在Eclipse开发社区的人员越来越多版本更新速度也越来越快,目前最近的版本是3.2,Eclipse相比较一些其他的IDE如NetBeans/SunOne Studio,Jbuilder,IntelliJ IDEA主要的优点在于它是免费的、开放源代码的、质量很好，而且非常容易定制。Eclipse的最大的优势在于它的插件机制,除了很小的运行时内核外,Eclipse的所有的东西都是插件.现在插件超多眼花缭乱…正确有效的使用一些插件对开发速度很有提高.Eclipse的插件开发机制也比较简单运用Eclipse的基础库SWT,JFace,和插件开发环境PDE可以定制开发一些符合自己框架标准的代码生成框架,避免重复性代码的编写,把更多的精力放在如何构造合理的架构提高项目开发的速度方面.
首先介绍插件的配置方法一般来讲对于非安装文件,将插件的文件夹features, plugins放在Eclipse目录下的features,plugins下即可.如果不能使用可能是因为插件版本和当前Eclipse版本不匹配所致,下载合适的插件版本即可.目前3.1版本比较稳定在此平台应用的插件也比较多
下面主要介绍开发J2EE常用的插件的功能和简单快速的使用方法:
1:MyEclipse
很强大的Eclipse增强插件集合,集成了很多的J2EE的功能,比如Spring,Hibernate,Struts,EJB,JSTL等插件,也支持Tomcat,Jboss,Weblogic,WebSphere等主流容器的配置,还有DatabaseExplorer数据库管理插件,也集成了主流的bug管理系统bugzilla的错误提交,也提供了UML图的绘制插件,是一个比较全面的插件集合,官方更新速度很快,现在最新的版本是MyEclipse 5.0 GA支持Eclipse3.2不过是收费的,可以在网上找到破解码:-)
对于Tomcat开发为主流的常用的功能它的Reload机制,在window->Preferences->MyEclipse下Application Servers里Tomcat设置TomcatHome,然后通过快捷工具栏中的Run/Stop/Restart MyEclipse Application Servers启动服务,这样你的项目修改Java类不需要在重启Tomcat就可以实现改过的功能.
如果初时工程设为Web Projects可以通过Myeclipse为其添加Spring,Struts,Jsf,Jstl,Hibernate的库,设置方法为右键你的工程然后在菜单中选择Myeclipse在弹出菜单中Add相应的Capabilities.也可以选择为工程添加J2EE容器,如果上一步配置了Myeclipse Application Servers可以Add Tomcat Server,然后它会自动部署到Tomcat的webapps下.
DatabaseExplorer配置比较简单也比较好用,配置方法为:New一个Driver选择相应SqlServer2000,或Oracle的驱动jar,按照提示配置好数据库连接字符串就可以操作数据库了,也可以执行sql查询.
Myeclipse为开发便利为Eclipse开发了它的几个视图,可以通过菜单window->Open Perspective选择适当的视图,如MyEclipse Database Explorer,MyEclipse J2EE Development,MyEclipseHibernate和MyEclipse Web2.0
MyEclipse的缺点就在于对系统要求太高,开文件过多会死掉有时,所以一般1G内存跑起来比较爽,可以通过-Xmx属性对Eclipse使用的内存进行扩充.
对于UML方面说一下一般MyEclipse这个功能是个花瓶中看不中用,小的功能比较简单的UML图还可以够用,对于UML的正向或者逆向工程不支持,所以一般不用它.建议使用”Eclipse UML”插件
2. Lomboz
Lomboz也是一个功能强大的基于J2EE的集成插件其功能主要是JSP高亮显示,语法检查和编码助手,支持部署J2EE Web应用程序,利用Wizard创建Web应用和常用的代码生成,支持JSP的调试.
Lomboz的配置很简单将其放在Eclipse相应的文件夹即可.
Lomboz的优势在于可以调试Jsp, Lomboz的调试原理在于对要调试的jsp页面所产生的java代码进行调试,和java工程的调试过程一样,调试方法是打开Lomboz J2EE View 选择服务器,单击右键debug server,打开jsp所生成的java文件设置断点,在IE打开jsp就可以激活调试进行jsp调试,其实我感觉最好的调试方法是System.out.println,比较快捷.
3.SWT-Designer
看名字就知道是开发Java图形用户界面的插件,可以用于开发PDE插件或基于SWT的应用程序,非常强大的开发工具收费的不过比VE稳定很多,可以画界面,使用方法比较简单
在官方下载找个注册码激活就可以.
4.JSEclipse
这个对于WEB开发很有用可以对javascript进行高亮显示,语法检查和编码助手,特别是在Myeclipse或Lomboz下js开发时有时候没有编码助手,错误也没有提示,很不方面,JSEclipse可以进行编码提示和错误提示很实用!对于以后的ajax编码和富客户端开发调试效率会有很大的提高!
5.Properties Editor
编辑java的属性文件，并可以自动存盘为Unicode格式
6.XMLBuddy
XMLBuddy 主要用于编辑XML文件
7.Log4E
Log4E Log4j插件，提供各种和Log4j相关的任务，如为方法、类添加一个logger等,主要优点在于代码生成免去了每个类都要logger一下的麻烦
.使用方法比较简单..选中某个.java文件右键选择Log4J.
8.FreeMarker Eclipse Plugin / FreeMarker IDE
FreeMarker没有语法高亮看起来确实很不爽…调试起来比较痛苦这个插件用来在Eclipse中支持FreeMarker模板语言.它包括语法高亮显示，语法错误提示、视图等.
9.Veloedit
Velocity模版开发插件与FreeMarker类似
以上几个都是最常用的J2EE的插件,我都测试过很方便,在网上都有新版本下载,如果你的内存比较大可以用MyEclipse作为主要开发工具,辅助其他几个实用的插件,如果你机子配置不是很高.采用Lomboz加上其他几个插件也可.当然还有很多实用的插件这里没有介绍比如Profiler(性能跟踪、测量工具，能跟踪、测量ＢＳ程序) VSS Plugin for Eclipse (Microsoft Visual SourceSafe (VSS)),大家可以发掘介绍…
常用Eclipse快捷键介绍
主要总结了最最常用的Eclipse快捷键的功能
F3: 打开申明（Open declaration）。
Control-Shift-G: 在workspace中搜索引用（reference）。这个热键的作用和F3恰好相反.
Control-Shift-F: 根据代码风格设定重新格式化代码.
Control-Shift-O: 快速引入要import的类说明.
Control-O: 快速概要。通过这个快捷键，你可以迅速的跳到一个方法或者属性.
Control-/: 对一行注释或取消注释。对于多行也同样适用。
Spirng的InitializingBean为bean提供了定义初始化方法的方式。InitializingBean是一个接口，它仅仅包含一个方法：afterPropertiesSet()。
Bean实现这个接口，在afterPropertiesSet()中编写初始化代码：
package research.spring.beanfactory.ch4;
import org.springframework.beans.factory.InitializingBean;
public class LifeCycleBean implements InitializingBean{
public void afterPropertiesSet() throws Exception {
System.out.println("LifeCycleBean initializing...");
}
}
在xml配置文件中并不需要对bean进行特殊的配置：
xml version="1.0" encoding="UTF-8"?>
DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean name="lifeBean" class="research.spring.beanfactory.ch4.LifeCycleBean">
bean>
beans>
编写测试程序进行测试：
package research.spring.beanfactory.ch4;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
public class LifeCycleTest {
public static void main(String[] args) {
XmlBeanFactory factory=new XmlBeanFactory(new ClassPathResource(
"research/spring/beanfactory/ch4/context.xml"));
factory.getBean("lifeBean");
}
}
运行上面的程序我们会看到：“LifeCycleBean initializing...”，这说明bean的afterPropertiesSet已经被Spring调用了。
Spring在设置完一个bean所有的合作者后，会检查bean是否实现了InitializingBean接口，如果实现就调用bean的afterPropertiesSet方法。
SHAPE \* MERGEFORMAT
查看bean是否实现InitializingBean接口
|
Spring虽然可以通过InitializingBean完成一个bean初始化后对这个bean的回调，但是这种方式要求bean实现 InitializingBean接口。一但bean实现了InitializingBean接口，那么这个bean的代码就和Spring耦合到一起了。通常情况下我不鼓励bean直接实现InitializingBean，可以使用Spring提供的init-method的功能来执行一个bean 子定义的初始化方法。
写一个java class，这个类不实现任何Spring的接口。定义一个没有参数的方法init()。
package research.spring.beanfactory.ch4;
public class LifeCycleBean{
public void init(){
System.out.println("LifeCycleBean.init...");
}
}
在Spring中配置这个bean：
xml version="1.0" encoding="UTF-8"?>
DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean name="lifeBean" class="research.spring.beanfactory.ch4.LifeCycleBean"
init-method="init">
bean>
beans>
当Spring实例化lifeBean时，你会在控制台上看到” LifeCycleBean.init...”。
Spring要求init-method是一个无参数的方法，如果init-method指定的方法中有参数，那么Spring将会抛出java.lang.NoSuchMethodException
init-method指定的方法可以是public、protected以及private的，并且方法也可以是final的。
init-method指定的方法可以是声明为抛出异常的，就像这样：
final protected void init() throws Exception{
System.out.println("init method...");
if(true) throw new Exception("init exception");
}
如果在init-method方法中抛出了异常，那么Spring将中止这个Bean的后续处理，并且抛出一个org.springframework.beans.factory.BeanCreationException异常。
InitializingBean和init-method可以一起使用，Spring会先处理InitializingBean再处理init-method。
org.springframework.beans.factory.support. AbstractAutowireCapableBeanFactory完成一个Bean初始化方法的调用工作。 AbstractAutowireCapableBeanFactory是XmlBeanFactory的超类，再 AbstractAutowireCapableBeanFactory的invokeInitMethods方法中实现调用一个Bean初始化方法：
org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.java:
//……
//在一个bean的合作者设备完成后，执行一个bean的初始化方法。
protected void invokeInitMethods(String beanName, Object bean, RootBeanDefinition mergedBeanDefinition)
throws Throwable {
//判断bean是否实现了InitializingBean接口
if (bean instanceof InitializingBean) {
if (logger.isDebugEnabled()) {
logger.debug("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
}
//调用afterPropertiesSet方法
((InitializingBean) bean).afterPropertiesSet();
}
//判断bean是否定义了init-method
if(mergedBeanDefinition!=null&&mergedBeanDefinition.getInitMethodName() != null) {
//调用invokeCustomInitMethod方法来执行init-method定义的方法
invokeCustomInitMethod(beanName, bean, mergedBeanDefinition.getInitMethodName());
}
}
//执行一个bean定义的init-method方法
protected void invokeCustomInitMethod(String beanName, Object bean, String initMethodName)
throws Throwable {
if (logger.isDebugEnabled()) {
logger.debug("Invoking custom init method '" + initMethodName +
"' on bean with name '" + beanName + "'");
}
//使用方法名，反射Method对象
Method initMethod = BeanUtils.findMethod(bean.getClass(), initMethodName, null);
if (initMethod == null) {
throw new NoSuchMethodException(
"Couldn't find an init method named '" + initMethodName + "' on bean with name '" + beanName + "'");
}
//判断方法是否是public
if (!Modifier.isPublic(initMethod.getModifiers())) {
//设置accessible为true，可以访问private方法。
initMethod.setAccessible(true);
}
try {
//反射执行这个方法
initMethod.invoke(bean, (Object[]) null);
}
catch (InvocationTargetException ex) {
throw ex.getTargetException();
}
}
//………..
通过分析上面的源代码我们可以看到，init-method是通过反射执行的，而afterPropertiesSet是直接执行的。所以 afterPropertiesSet的执行效率比init-method要高，不过init-method消除了bean对Spring依赖。在实际使用时我推荐使用init-method。
需要注意的是Spring总是先处理bean定义的InitializingBean，然后才处理init-method。如果在Spirng处理InitializingBean时出错，那么Spring将直接抛出异常，不会再继续处理init-method。
如果一个bean被定义为非单例的，那么afterPropertiesSet和init-method在bean的每一个实例被创建时都会执行。单例 bean的afterPropertiesSet和init-method只在bean第一次被实例时调用一次。大多数情况下 afterPropertiesSet和init-method都应用在单例的bean上。
Spring BeanFactory提供了类似pico container中自动装配组件依赖的对象的功能。自动装配能应用在每个组件上，可以为一些组件定义自动装配，而另一些组件则不使用。
使用”autowire”属性可以设置自动装配，autowire有五种模式：
默认属性，不进行自动装配。
通过bean的属性名称自动装配合作者。
SHAPE \* MERGEFORMAT
Spring用bean 中set方法名和BeanFactory中定义的合作者的名称做匹配，一但2者匹配，Sping就会把合作者进行注入。
可以使用id属性也可以使用name属性定义合作者的名称，这2个属性在Spring进行自动装配时没有区别。
当有多个名称相同的合作者在Spring中定义时，Srping在自动装配时选择最后一个定义的合作者注入。
SHAPE \* MERGEFORMAT
在多个合作者名称相同进行自动装配时，合作者的id属性并不会比name属性优先处理。无论怎样定义Spring总会把最后一个定义的合作者注入。
通过bean set方法中参数的类型和BeanFactory中定义合作者的类型做匹配，Spring会找到匹配的合作者进行注入。
SHAPE \* MERGEFORMAT
在byType自动装配模式中，Spring不关心合作者的名称，只关心合作者的类型是否满足条件。
类似上面介绍的byName的方式，在byType方式中，当具有相同名称并且有相同类型的多个合作者被找到时，Spring会注入最后一个定义的合作者。
SHAPE \* MERGEFORMAT
在byType装配时，如果有2个不同名称但是类型相同的合作者被找到，那么Spring会抛出一个依赖异常。
SHAPE \* MERGEFORMAT
抛出依赖异常，通知用户在byType方式中同样类型的Bean只能定义一个。
org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name 'dao' defined in class path resource [research/spring/beanfactory/ch3/context.xml]: Unsatisfied dependency expressed through bean property 'database': There are 2 beans of type [class research.spring.beanfactory.ch3.Database] for autowire by type. There should have been 1 to be able to autowire property 'database' of bean 'dao'...
constructor
constructor其实时按byType的方式进行构造函数的注入。
SHAPE \* MERGEFORMAT
constructor装配方式不关心构造参数的顺序，无论构造函数参数的顺序如何Spring都会按类型匹配到正确的合作者进行注入。
在byType方式中，当没有找到类型相同的合作者时Spring什么都不会去做。但是在constructor方式中，当没有找到和Bean构造函数中参数类型相匹配的合作者时，Spring会抛出异常。
Spring在进行constructor方式的自动装配时，强制要求所有的构造函数中所有的合作者都必须存在。
在autodetect的方式中，Spring检查一个Bean内部是否有默认的构造函数。如果有默认的参数Spring就使用byType的方式进行自动装配。如果没有默认的构造函数Spring则使用constructor的方式进行自动装配。
如果一个Bean同时定义了默认构造函数和带参数的构造函数，Spring仍会使用byType的方式进行装配。
不管使用上述哪种装配方式，都可以在Bean中显示的定义合作者。显示定义的依赖关系优先级比自动装配高。
自动装配的功能可以和自动依赖检查一起使用。Spring会首先进行自动装配，然后在进行依赖检查。
自动装配提供了简化配置的可能性，但是我并不建议在项目中大量的使用自动装配，特别时byType方式。因为自动装配，尤其时byType方式，破坏了Bean和合作者之间显示的依赖关系，所有的依赖关系都时不明显的。在使用自动装配后我们的依赖关系需要到源代码中才能看到，这使得维护或文档化Bean的依赖关系变得很困难。
适当的使用自动装配比如byName方式的装配，是有一些好处的。比如我们在一些特定的范围里可以借助byName自动装配的功能来实现“
以惯例来代替配置”的框架。
自动依赖检查可以保证所有java bean中的属性（set方法）都在Spring中正确的配置。如果在一个java bean中定义了一个name属性，并且也setName方法。那么在开启自动依赖检查功能后，就必须在Spring中定义这个属性，否则Spring将抛出异常。
请看下面的例子：
Dao.java
包含一个setName方法。
package research.spring.beanfactory.ch3;
public class Dao {
private String name;
public void setName(String name) {
this.name = name;
}
}
context.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean name="dao" class="research.spring.beanfactory.ch3.Dao"> </bean>
<bean id="database" class="research.spring.beanfactory.ch3.Database">
</bean>
</beans>
我们在context.xml没有定义Dao的name属性。上面的配置，Spring可以正常的实例化Dao对象。
下面我们修改context.xml:
我们通过dependency-check=all，在Dao上增加了自动依赖检查的功能。
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean name="dao" class="research.spring.beanfactory.ch3.Dao" dependency-check="all" > </bean>
<bean id="database" class="research.spring.beanfactory.ch3.Database">
</bean>
</beans>
当配置依赖检查时，Spring实例化Dao时会抛出一个异常：
Spring定义了4种依赖检查的策略：
不进行依赖检查。
只对简单属性和集合中的简单属性进行检查。不对依赖的对象检查。
只对为对象类型的属性进行检查。
对所有类型进行检查。
如果把上面例子里的context.xml改成这样：
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean name="dao" class="research.spring.beanfactory.ch3.Dao" dependency-check="objects" > </bean>
<bean id="database" class="research.spring.beanfactory.ch3.Database">
</bean>
</beans>
Spring将不会抛出异常，因为objects只对依赖的对象进行检查。
dependency-check在Spring中又以下的限制：
- 不能对构造函数中的参数进行检查。
- 即使属性中有默认值，只要包含了set方法，那么dependency-check仍然需要检查Spring中是否配置了这个属性。
package research.spring.beanfactory.ch3;
public class Dao {
private Database database;
private String name="chenjie";
//dependency-check仍然会检查这个属性是否配置注入
public void setName(String name) {
this.name = name;
}
public void setDatabase(Database database) {
this.database = database;
}
}
即使Dao设置里name得默认值，但是只要有setName方法，dependency-check仍然会判断是否在配置文件中设置了setName对应的注入。
depend-on用来表示一个Bean的实例化依靠另一个Bean先实例化。如果在一个bean A上定义了depend-on B那么就表示：A 实例化前先实例化 B。
这种情况下，A可能根本不需要持有一个B对象。
比如说，你的DAO Bean实例化之前你必须要先实例化Database Bean，DAO Bean并不需要持有一个Database Bean的实例。因为DAO的使用是依赖Database启动的，如果Database Bean不启动，那么DAO即使实例化也是不可用的。这种情况DAO对Database的依赖是不直接的。
除了在DAO上使用构造函数注入Database Bean以外，Spring没有任何依赖注入的关系能够满足上面的情况。但是DAO也许根本不需要Database的实例被注入，因为DAO是通过JDBC访问数据库的，它不需要调用Database 上的任何方法和属性。
在这种情况下你可以使用depends-on来定义在DAO被实例化之前先去实例化Database。你可这样定义：
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean name="dao" class="research.spring.beanfactory.ch3.Dao" depends-on="database">
</bean>
<bean id="database" class="research.spring.beanfactory.ch3.Database">
</bean>
</beans>
通过定义depends-on=”database”可以控制Sping实例化dao的顺序。在任何时候Spring总会保证实例化DAO之前先实例Database。
通常depends-on常常应用在上面的场景中。如果DAO depend-on Database的同时需要得到Database的实例，那么使用构造函数注入是一个比较好的解决办法。因为构造函数注入的方式是要先实例化目标对象依赖的对象然后在实例化目标对象。关于构造函数的输入请参考另一篇文章
《Spring内核研究-set方法注入和构造函数注入》 DAO depend-on Database时，也可以在DAO上定义setDatabase方法来接收一个Database的实例。这样Sping会保证DAO创建前先创建Database实例，然后在把实例化DAO后调用DAO的setDatabase方法把刚才创建的Database的实例注入给DAO。前提条件时Database必须定义成单例的。否则Spring在DAO depend-on Database时会创建一个Database的实例，在DAO.setDatabase时又会创建Database另外的一个实例。这种情况可能不是你想要的，而且很可能会造成比较隐蔽的错误。
使用set方法注入depend-on的对象：
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean name="dao" class="research.spring.beanfactory.ch3.Dao" depends-on="database ">
<property name="database">
<ref bean="database"></ref>
</property>
</bean>
<bean id="database" class="research.spring.beanfactory.ch3.Database">
</bean>
</beans>
一般在depends-on一个对象并且又需要这个对象实例的情况下，我都建议你使用构造函数的注入方式替换depend-on。只有不能构造函数中添加依赖对象参数的情况下才使用上面例子里的方式。
可以同时使用depends-on和构造函数注入，如A depends-on B 并且 new A(B b)。
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean name="dao" class="research.spring.beanfactory.ch3.Dao" depends-on="database">
<constructor-arg>
<ref bean="database"></ref>
</constructor-arg>
</bean>
<bean id="database" class="research.spring.beanfactory.ch3.Database">
</bean>
</beans>
然而这种做法是不合适的，因为在构在函数中注入依赖对象的方式可以包含depends-on的情况。也就时说new A(B b)包含了A depends-on B的所有情况。既然已经定义了new A(B b)就没有必要在定义A depends-on B。所以，new A(B b)可以替代A depends-on B。在A创建前必须创建B，而且A不需要使用B实例的情况下只能使用A depends-on B。
Spring允许Bean和Bean依赖的Bean（合作者）上同时定义depends-on。比如A depends-on B && B depends-on C && C depends-on D。下面这样定义是合法的。Sping实例化他们的顺序是D->C->B->A。
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean name="a" class="research.spring.beanfactory.ch3.A" depends-on="b" />
<bean name="b" class="research.spring.beanfactory.ch3.B" depends-on="c" />
<bean name="c" class="research.spring.beanfactory.ch3.C" depends-on="D" />
<bean name="d" class="research.spring.beanfactory.ch3.D" />
</beans>
但是Spring不允许A depends-on B && B depends-on A的情况。看下面的例子，由于D又依赖回A，这种在依赖关系中形成了一个闭环，Spring将无法处理这种依赖关系。所以下面的这种定义是不合法的。
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean name="a" class="research.spring.beanfactory.ch3.A" depends-on="b" />
<bean name="b" class="research.spring.beanfactory.ch3.B" depends-on="c" />
<bean name="c" class="research.spring.beanfactory.ch3.C" depends-on="D" />
<bean name="d" class="research.spring.beanfactory.ch3.D" depends-on="A"/>
</beans>
一个Bean可以同时depends-on多个对象如，A depends-on D,C,B。可以使用“，”或“；”定义多个depends-on的对象。
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean name="a" class="research.spring.beanfactory.ch3.A" depends-on="d,c,b" />
<bean name="b" class="research.spring.beanfactory.ch3.B" />
<bean name="c" class="research.spring.beanfactory.ch3.C" />
<bean name="d" class="research.spring.beanfactory.ch3.D" />
</beans>
上面的例子中A的实例化需要先实例化D，C，B。Spring会按照depend-on中定义的顺序来处理Bean。在这个例子里Spring实例化对象的顺利是D->C->B->A。虽然实例化对象的顺序和前面“A depends-on B && B depends-on C && C depends-on D”的情况一下，但是这里的意义是完全不同的。不能用“A depends-on D,C,B”代替“A depends-on B && B depends-on C && C depends-on D”。
depends-on是一个非常又用的功能，借助depends-on我们可以管理那些依赖关系不明显或者没有直接依赖关系的对象。
Spring专门设计了对工厂模式支持，你可以使用静态工厂方法来创建一个Bean，也可以使用实例工厂的方法来创建Bean。下面分别介绍这2种方法。
定义一个Bean使用自己类上的静态工厂方法来创建自己。
context.xml
factory-menthod定义了userDao Bean使用UserDao类的getInstance方法来创建自己的实例。userManager仍然通过lookup方法获得userDao。Lookup方法并不关心一个Bean的实例时怎样创建的，所以可以混合使用lookup方法和factory-menthod方法。
xml version="1.0" encoding="UTF-8"?>
DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean name="userManager"
class="research.spring.beanfactory.ch2.UserManager">
<lookup-method name="getUserDao" bean="userDao" />
bean>
<bean name="userDao" class="research.spring.beanfactory.ch2.UserDao"
factory-method="getInstance" / >
beans>
UserDao.java
增加一个getInstance方法来创建自己的实例。
package research.spring.beanfactory.ch2;
public class UserDao {
public static UserDao getInstance() {
return new UserDao("static factory method");
}
private String name = "";
public UserDao(String name) {
this.name = name;
}
public void create() {
System.out.println("create user from - " + name);
}
}
Test.java
package research.spring.beanfactory.ch2;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
public class Test {
public static void main(String[] args) {
XmlBeanFactory factory=new XmlBeanFactory(new ClassPathResource(
"research/spring/beanfactory/ch2/context.xml"));
UserManager manager=(UserManager) factory.getBean("userManager");
manager.createUser();
}
}
运行Test.java，你会看到：
create user from - static factory method
这说明userDao使用它自己得静态工厂创建得。
静态工厂方法存在一些限制：
- 静态工厂方法上不能有参数，也不能在Spring种定义静态工厂方法的参数。
- 静态工厂方法只能是public的，不能是private或protected的。
- 静态工厂方法不能和构造函数注入一起使用。下面的定义时不能正常工作的：
package research.spring.beanfactory.ch2;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
public class Test {
public static void main(String[] args) {
XmlBeanFactory factory=new XmlBeanFactory(new ClassPathResource(
"research/spring/beanfactory/ch2/context.xml"));
UserManager manager=(UserManager) factory.getBean("userManager");
manager.createUser();
}
}
定义一个Bean使用这个Bean的工厂对象上的工厂方法来创建自己。
我们定义一个UserDao的Factory来创建UserDao。
UserDaoFactory.java
package research.spring.beanfactory.ch2;
public class UserDaoFactory{
public UserDao getUserDao(){
return new UserDao("UserDaoFactory");
}
}
修改context.xml:
xml version="1.0" encoding="UTF-8"?>
DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean name="userManager"
class="research.spring.beanfactory.ch2.UserManager">
<lookup-method name="getUserDao" bean="userDao" />
bean>
<bean name="userDao" class="research.spring.beanfactory.ch2.UserDao"
factory-bean="userDaoFactory" factory-method="getUserDao" >
bean>
<bean name="userDaoFactory" class="research.spring.beanfactory.ch2.UserDaoFactory">
bean>
beans>
再次运行Test.java你会看到：
create user from – UserDaoFactory
通过上面的配置Spring已经使用userDaoFactory实例的工厂方法来创建userDao了。
- factory-bean定义了工厂Bean
- factory-method定义了工厂方法
实例工厂和静态工厂一样都存在相同的限制：
- 静态工厂方法上不能有参数，也不能在Spring种定义静态工厂方法的参数。
- 静态工厂方法只能是public的，不能是private或protected的。
- 静态工厂方法不能和构造函数注入一起使用。
和静态工厂不同的是：
- 实例工厂方法不能是静态的，而静态工厂方法必须是静态的。
通过上面的例子我们看到Spring对工厂模式对了完整的支持。但是这里还是需要说明，如果使用IoC模式设计的系统一般情况下不需要为任何Bean做工厂类。在我的观点里，工厂模式仅仅是遗留系统，使用依赖注入模式可以取代工厂模式。Spring对工厂的支持仅仅是为了可以很好的集成遗留系统。
“Lookup方法”可以使Spring替换一个bean原有的，获取其它对象具体的方法，并自动返回在容器中的查找结果。
我们来看这个例子：
UserDao.java
在UserDao的构造函数中接受一个name参数，创建UserDao的对象会把自己的名字传递给userDao，这样userDao的create方法中就会把userDao的创建者打印出来。
package research.spring.beanfactory.ch2;
public class UserDao {
private String name="";
public UserDao(String name){
this.name=name;
}
public void create(){
System.out.println("create user from - "+name);
}
}
UserManager.java
在这段代码中UserManager依靠getUserDao方法来获取UserDao对象。由于在getUserDao方法里显示的声明了如何去实例一个UserDao，所以上面的代码不符合IoC模式的风格。虽然使用GetUserDao封装了UserDao的创建过程，但是UserManager和UserDao的关系仍然非常紧密。
package research.spring.beanfactory.ch2;
public class UserManager {
public UserDao getUserDao() {
return new UserDao("UserManager.getUserDao()");
}
public void createUser() {
UserDao dao = getUserDao(); //通过getUserDao获得userDao
dao.create();
}
}
LookupMethodTest.java
通过BeanFactory获得UserManager，并调用createUser方法。
package research.spring.beanfactory.ch2;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
public class LookupMethodTest {
public static void main(String[] args) {
XmlBeanFactory factory=new
XmlBeanFactory(new ClassPathResource("research/spring/beanfactory/ch2/context.xml"));
UserManager manager=(UserManager) factory.getBean("userManager");
manager.createUser(); //create a User
}
}
context.xml
xml version="1.0" encoding="UTF-8"?>
DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean name="userManager"
class="research.spring.beanfactory.ch2.UserManager">
bean>
<bean name="userDao class="research.spring.beanfactory.ch2.UserDao" >
bean>
beans>
运行LookupMethodTest你会看到屏幕输入” create user from - UserManager.getUserDao()”。
由于是遗留系统，所以我们不能修改UserManager。现在我希望让这个UserManager依赖的Dao对象由spring管理，而不修改原有的代码。
在这个场景中我们就可以利用Spring提供的“Lookup方法”来替换原有的getUserDao方法，实现自动获取userDao的功能。修改context.xml：
xml version="1.0" encoding="UTF-8"?>
DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean name="userManager"
class="research.spring.beanfactory.ch2.UserManager">
<lookup-method name="getUserDao" bean="userDao" />
bean>
<bean name="userDao" class="research.spring.beanfactory.ch2.UserDao" >
<constructor-arg>
<value>lookup methodvalue>
constructor-arg>
bean>
<bean name="userDaoFactory" class="research.spring.beanfactory.ch2.UserDaoFactory">
bean>
beans>
再次运行LookupMethodTest你会看到不同的输出结果“create user from - lookup method”。字符串“lookup method”是通过构造函数注入给userDao的。原来的userManager.java并没有作任何修改，仍然是通过UserDao dao = getUserDao();来获得userDao的。这说明Spring已经替换了原有的getUserDao方法的实现，当执行getUserDao时Spring会在容器中寻找指定的Bean，并返回这个Bean。
通过这种机制我们可以在不修改原系统代码的情况下，可以轻易的把UserDao换成别的类型相容的对象而不会影响原系统。Spring是使用CGLIB在字节码级别动态实现出userManager的子类，并重写getUserDao方法的方式来实现这个神奇的功能的。
修改LookupMethodTest.java：
package research.spring.beanfactory.ch2;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
public class LookupMethodTest {
public static void main(String[] args) {
XmlBeanFactory factory=new XmlBeanFactory(new ClassPathResource(
"research/spring/beanfactory/ch2/context.xml"));
UserManager manager=(UserManager) factory.getBean("userManager");
System.out.println(manager.toString()); //打印userManager的信息
manager.createUser(); //create a User
}
}
我们在获取UserManager的实例后打印出这个实例的信息，再次运行LookupMethodTest你会看到：
注意manager.toString()打印出了：
这个是CGLIG动态生成的类，而不是原来的UserManager的实例。所以请记住在任何时候只要定义了一个Bean的Lookup方法，那么这个Bean的实例将是一个CGLIB动态生成的实例而不是原来类的实例。
Spring允许在一个Bean中定义多个Lookup方法。
<bean name="userManager"
class="research.spring.beanfactory.ch2.UserManager">
<lookup-method name="getUserDao" bean="userDao" />
<lookup-method name="getOtherDao" bean="otherDao" />
bean>
上面的做法是合法的，并且可以正常工作。
虽然Spring会用CGLIB动态生成一个带有Lookup方法bean的子类，但是这并不影响Spring完成其它的功能。Sping还是允许Lookup方法和setXXX、构造函数注入以及后面我们将介绍的自动依赖检查和自动装配的功能同时使用。
Spring还允许Lookup方法中定义的方法带有参数，但是Sping不会处理这些参数。
修改UserManager：
package research.spring.beanfactory.ch2;
public class UserManager {
private UserDao dao;
public void setDao(UserDao dao) {
this.dao = dao;
}
public UserDao getUserDao(String daoName) {
return new UserDao("UserManager.getUserDao()");
}
public void createUser() {
UserDao dao = getUserDao(“userDao”); //通过getUserDao获得userDao
dao.create();
}
}
虽然方法上由参数，但是上面的代码可以正常工作。Spring不会处理这些参数。
Spring对Lookup方法也存在一些限制：
- 方法不能是private的，但可以是protected的。
- 方法不能是静态的。
有一个比较有趣的用法，就是在抽象类上定义Lookup方法。你一定记得经典的工厂模式吧。定义一个抽象工厂，然后为每一类具体产品实现一个具体产品的工厂。
一个抽象工厂：
package research.spring.beanfactory.ch2;
public abstract class Factory {
public abstract UserDao getProduct();
}
具体一类产品的工厂：
package research.spring.beanfactory.ch2;
public class UserDaoFactory extends Factory{
public UserDao getProduct(){
return new UserDao("UserDaoFactory");
}
}
用户可以通过：
new UserDaoFactory().getProduce();
来获取具体的UserDao产品。
但是如果有很多产品就需要做出实现出很多工厂如，DocumentDaoFactory、GroupDaoFactory等等，这样系统中会出现大量的工厂。工厂的泛滥并不能说明系统的设计是合理的。
既然Spring可以在抽象类上使用Lookup方法，那么我们就可以不同实现真的去实现那么多的子类了。我们可以在抽象类上直接定义Lookup方法和目标对象。用户直接通过抽象类来获得需要的产品对象。看下面这个例子：
Factory.ava
package research.spring.beanfactory.ch2;
public abstract class Factory {
public abstract Object getProduct();
}
context.xml
如果指定userDaoFactory的类为一个抽象类，并且再这个bean里定义了Lookup方法，那么Spring会自动生成这个抽象类的子类实现。
xml version="1.0" encoding="UTF-8"?>
DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean name="userManager"
class="research.spring.beanfactory.ch2.UserManager">
<lookup-method name="getUserDao" bean="userDao" />
bean>
<bean name="userDao" class="research.spring.beanfactory.ch2.UserDao" >
<constructor-arg>
<value>lookup methodvalue>
constructor-arg>
bean>
<bean name="userDaoFactory" class="research.spring.beanfactory.ch2.Factory" singleton="false">
<lookup-method name="getProduct" bean="userDao" />
bean>
beans>
Test.java
package research.spring.beanfactory.ch2;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
public class LookupMethodTest {
public static void main(String[] args) {
XmlBeanFactory factory=new XmlBeanFactory(new ClassPathResource(
"research/spring/beanfactory/ch2/context.xml"));
//获得抽象工厂
Factory abstractFactory=(Factory) factory.getBean("userDaoFactory");
UserDao userDao=(UserDao) abstractFactory.getProduct();
System.out.println(userDao.toString());
userDao.create();
}
}
运行Test你会看到：
research.spring.beanfactory.ch2.UserManager$$EnhancerByCGLIB$$cc2f8f1c@12c7568
create user from - lookup method
对，这个结果和上面的例子是完全一样的。UserDao并没有改变，我们通过抽象的Factory获得了具体的UserDao的实例。这样即使系统中很多的具体产品我们也不需要实现每类产品的工厂类了。只需要在系统中配置多个抽象工厂，并且配置每个工厂的singlton为false，在用户使用时使用不同抽象工厂的实例就可以了。
<bean name="userDaoFactory" class="research.spring.beanfactory.ch2.Factory" singleton="false">
<lookup-method name="getProduct" bean="userDao" />
bean>
<bean name="documentDaoFactory" class="research.spring.beanfactory.ch2.Factory" singleton="false">
<lookup-method name="getProduct" bean="documentDao" />
bean>
Spring不关心抽象类中的定义的lookup方法是否时抽象的，Spring都会重写这个方法。
既然Sping可以动态实现抽象类的子类那么，它能不能动态创建出实现一个接口的类呢。答案时肯定的。上面的例子可以直接把Factory变成一个接口，仍然可以正常工作。
这里需要注意的是，只要在一个Bean上明确的定义了Lookup方法，Spring才会使用CGLIB来做原对象的字节码代理。如果一个没有定义Lookup方法的抽象类或接口是不能直接被Spring实例的。
本文介绍了Lookup方法的使用和工作原理，希望读者能够对Lookup方法有了比较深入的了解。虽然我的例子可以简化工厂模式，但是我并不鼓励大家在实际系统中这样做。因为我始终认为“工厂模式”只要在遗留系统中才会碰到。使用IoC模式基本上可以替代所有的对象创建模式。本章的例子只是为了说明Lookup方法如何使用，和Lookup方法的一些特殊情况。Lookup方法一般只在处理遗留代码时使用。
Spring种提供了2种常用的注入方式，set方法注入和构造函数注入。由于这2种注入方式很相似，都可以满足我们的需求，所以在大多数情况下我们忽视了这2种注入方式的区别。下面让我们看看这2种注入方式的特点。
我们先看看Spring在使用set方法注入时，是怎样实例化一个Bean和Bean的合作者的：
在A中有一个setB方法用来接收B对象的实例。那么Spring实例化A对象的过程如下：
在不考虑Bean的初始化方法和一些Spring回调的情况下，Spring首先去调用A对象的构造函数实例化A，然后查找A依赖的对象本例子中是B（合作者）。一但找到合作者，Spring就会调用合作者(B)的构造函数实例化B。如果B还有依赖的对象Spring会把B上依赖的所有对象都按照相同的机制实例化然后调用A对象的setB(B b)把b对象注入给A。
因为Spring调用一个对象的set方法注入前,这个对象必须先被实例化。所以在"使用set方法注入"的情况下Spring会首先调用对象的构造函数。
我们在来看通过构造函数注入的过程：
如果发现配置了对象的构造注入，那么Spring会在调用构造函数前把构造函数需要的依赖对象都实例化好，然后再把这些实例化后的对象作为参数去调用构造函数。
在使用构造函数和set方法依赖注入时，Spring处理对象和对象依赖的对象的顺序时不一样的。一般把一个Bean设计为构造函数接收依赖对象时，其实是表达了这样一种关系：他们（依赖对象）不存在时我也不存在，即“没有他们就没有我”。
通过构造函数的注入方式其实表达了2个对象间的一种强的聚合关系：组合关系。就比如一辆车如果没有轮子、引擎等部件那么车也就不存在了。而且车是由若干重要部件组成的，在这些部件没有的情况下车也不可能存在。这里车和他的重要部件就时组合的关系。如果你的应用中有这样类似的场景那么你应该使用“构造函数注入”的方式管理他们的关系。“构造函数注入”可以保证合作者先创建，在后在创建自己。
通过set方法注入的方式表达了2个对象间较弱的依赖关系：聚合关系。就像一辆车，如果没有车内音像车也时可以工作的。当你不要求合作者于自己被创建时，“set方法注入”注入比较合适。
虽然在理论上“构造函数注入”和“set方法注入”代表2种不同的依赖强度，但是在spring中，spring并不会把无效的合作者传递给一个bean。如果合作者无效或不存在spring会抛出异常，这样spring保证一个对象的合作者都是可用的。所以在spring中，“构造函数注入”和“set方法注入”唯一的区别在于2种方式创建合作者的顺序不同。
使用构造函数依赖注入时，Spring保证所有一个对象所有依赖的对象先实例化后，才实例化这个对象。（没有他们就没有我原则）
使用set方法依赖注入时，Spring首先实例化对象，然后才实例化所有依赖的对象。
网络上搜到的SCEA 的考试经验，希望对大家有所帮助！
正文：
今天，2005年4月9号中午，我通过了Sun的系统架构师考试(SCEA)的310-051部分。总成绩72%（很勉强，及格线68%）。面向对象概念、EJB、设计模式、消息、国际化等部分都对了80-100%；通用架构、遗留系统连接、EJB容器、协议、J2EE应用、安全等部分只有50-66%左右的正确率。
但好歹整体是pass，否则又浪费银子了——1250RMB实在太贵。就在昨晚，老公明白我今天就要考试，马上表达了他的不满：
第一、 他认为我准备不够，肯定pass不了，简直是浪费银子。
第二、 他认为我那么早考过，就不会接着深入学习，很快会忘掉这些知识滴。
但我今天早上还是在他极不看好的抱怨声中去考试。第一道题就是又臭又长的遗留系统连接题，这些电脑屏幕上的英文马上让我的脑袋轰地晕了。所以接下来我一直是在极度紧张晕乎乎的情况下考试的。
臭长的情景题目奇多，我以为时间不一定够，心情紧张地完全影响了我做题效果。但我依然30分钟左右把48个题目全部做了一遍。然后再用25分钟左右仔细检查了一遍，特别仔细研究那些臭长的题目，所有题目全部用排错法选一次答案，但被重新选择答案的题目不超过5个。剩下20分钟左右时，又开始重新过一遍，但做到第34时，整个考试就over了，打印机就刷刷刷打印成绩。我没看到屏幕上的成绩提示，很着急，马上直接去看打印机吐出来的纸，直到看到成绩是pass，才知道这1250块是没有浪费掉。
从考场出来，恰好老公打电话来汇报他酒店的房间可看海景。我告诉他我过了，并埋怨自己备考方向不十分正确导致成绩不算良好。他很意外我通过了没有浪费钱；然后打断我详细的成绩汇报，叫我不要太得意。
其实，我觉得如果备考得当，是很可能拿到80%的。但现在根本没有什么书能完全覆盖了Sun的考试范围，也没有很update的guideline。通过这次实战，我觉得我知道了Sun的真实考试范围，因此觉得有必要整理出来，让后来者少走弯路。
我认为有三个资料是大家主要应该关注的。
1.《J2EE学习指南-Sun certified enterprise architect for J2EE (Exam 310-051)（英文版）》，一定要读英文版，因为考试是英文。Paul R.Allen，Joseph J.Bambara 人民邮电出版社。
这本书粗看是覆盖了SCEA全部大纲，但其实很多真正考试内容没涉及，比如遗留系统连接、安全、集群、负载平衡。而遗留系统连接部分，最新的JCA并没有考，考的还是Screen Scraper及Corba等综合技术连接各种复杂的遗留系统。其他内容，该书也写的很罗索，不精炼。
2. 《Sun Certified Enterprise Architect for J2EE Technology Study Guide》Prentice Hall 著，作者是Sun的，该书接近于Sun的官方资料了。
这本书很好，简洁、扼要，非常适合最后冲刺阶段使用。但缺点是完全没有消息、遗留系统连接等内容。但是设计模式、协议、安全等部分相当好，至少比《J2EE学习指南》好。集群、负载平衡等部分，这本书一样没涉及。
我自己翻译了这本书的中文简版，如果想对J2EE入个门，可以参考。但最好读原文。连英文技术资料都看不懂的人，我想绝对通不过这个考试的，考试中的情景题都是很长的英文。《中文Sun的系统架构师认证教材》http://community.csdn.net/Expert/topic/3892/3892784.xml?temp=.1181452
3.yahoo讨论组上的资源，有最接近Sun考试范围的资料和题目，是考80%的最好保证。
scea_j2ee http://groups.yahoo.com/group/scea_j2ee
scea_prep http://groups.yahoo.com/group/scea_prep
特别推荐的是《Java Architect Notes - Balaji.doc》和《SCEA Practice Questions1.zip》及其他类似电子文档。
Balaji等人的笔记，更符合Sun实际考试的内容，比以上两本书更贴近考试范围。比如其中提到的集群、负载平衡、遗留系统连接等技术，今天我都被考到，而且我都没考好。因为之前我一直以为出版的书更可能贴近考试，而我对上面两本书的知识点都掌握到90%。但我接触yahoo的资料很迟，对这些资料跟那两本书的不同很怀疑，怀疑yahoo的资料不正确。但实际考试告诉我，yahoo的资料更正确。
《SCEA Practice Questions1.zip》这些题目，多数跟Sun考试接近，特别是安全、遗留系统连接、集群、负载平衡等情景分析题，J2EE应用分析题等。但那些很detail的，接近编程的题目，可能不会考。而且这些题目的结果分析部分特别详尽，非常有利于让你处理J2EE选型等情景题目。
尤其是其中部分题就基本重现在我今天的考试中，那些关于集群、负载平衡、J2EE应用分析的情景题。如果再考一次，我发誓我会把yahoo group中的题目用心重做一遍。那样我绝对可以拿到80%了。
我觉得SCEA考试是一个覆盖面很广的东东。备考的过程中，绝对可以优化、充实自己的技术知识。比如通过这段时间的学习，我觉得我更了解J2EE及实际系统选型，也学会了设计模式。之前我基本是设计模式盲，现在我却可以历历数出各模式的特点，甚至有更深入研究的兴趣。我觉得备考SCEA是学习更多知识的方式，而考试结果只是附加的回报。
备考时间和步骤建议：
先介绍本人的背景和准备时间。
本人具有多年J2EE工作经验，很早学习OOA、J2EE，很早就深入学习、模拟过pet store的framework。工作中的项目有很多practices及EJB pattern，但这个很好的framework我没参与设计。
大概是去年（04年）11月初左右有了考SCEA的想法。然后买了上面提到的《J2EE学习指南》。在年前看完了这本书，同时就着《设计模式（中文版）》、《设计模式和Java》等书，对设计模式入了门。原来想年前考，但工作突然趋紧，加上要过年、写网络小说、看小说，就把考试计划推迟到年后。
过了年，又因为分心去“研究”宏微观的经济、管理及把手头长编网络小说over掉，也就不敢贸然考试。但工作轻松，所以还是花了很多时间学习SCEA。
进入三月下旬（20号之后），我的SCEA冲刺阶段开始了。反反复复看前面提到的两本书和设计模式，终于把设计模式给吃下了。一直到三月底，才接触到Balaji的《Java Architect Notes》，做yahoo上共享的题目。做题结果很惨，正确率只有50%左右。所以很快发现自己在情景题、安全等方面的不足，并力补之，同时花了2天半，把《Sun Certified Enterprise Architect for J2EE Technology Study Guide》翻译了一下。
到了4月2号，我决定报名9号考试。然后又把那2本书看一编，把《SCEA Practice Questions1.zip》等数百套题过一遍。6号交钱报名。7号下午通过作题，就发现自己不是很行。8号打印Sun的考试大纲，发现有些地方要加强。但最后认为安全、遗留系统连接、集群、负载平衡等比率不多，幻想Sun不会考那些DNS集群机制等题目，所以还是决定去考试（已经报名了，也不可能推迟）。可是9号考试的时候，心理很明白准备不充分，因此考试特别紧张。但谢天谢地，我面向对象概念、EJB、设计模式、消息、国际化等扎实的底子和yahoo资料给我的遗留系统连接、集群、负载平衡的粗浅印象，到底还是让我pass了。
要说明的是，我全部是工作时学习，根据工作强度，每天有0-7个小时学习。周末和晚上是不学习的。周末用来办事、逛街、去公园；晚上用来上网。
我觉得准备SCEA的时间因人而异。对于普通水平，如我，若集中学习，2-3个月够了；对于更高水平，1个月甚至更短也行；对于水平更差，我想4-6个月都可能。
最后要强调的是英语。这个考试有接近50%是臭长的情景题，还是多项选择，如果基本英语要求都达不到的人，可能连正确理解题目都困难。而另外那些简短的题目，偶尔也有一两个不认识的关键的单词，这绝对影响作题，因为那会让你不知道整个句子的概念。我考试就遇到1-2个这样的题目其中各有1个不认识的关键的单词。我很怀疑通用架构、J2EE应用部分我得分过底就是因为这个原因。
搞定英语，我觉得只能是基本只看英文资料和做英文题目。我的英语底子一般，也就四级水平，工作是纯英文，近两年除了小说、新闻看中文的，其他只看英文。但我的英语还是稍微影响了我的考试，至少我是这样认为的。
以上是我考后的感想。我觉得yahoo上的资料最符合sun考试范围的；但那两本书应该是主要的学习基础。如果EJB不熟的人，其他一些EJB书籍都很必要。
如果大家希望有个学习计划的参考，我建议是：
1．先学《J2EE学习指南》和其他的有名的EJB书籍（一本网上最著名、最流行的就行了）。这个时间应该1个月左右。
2．再学习《Sun Certified Enterprise Architect for J2EE Technology Study Guide》。
3．然后学习Balaji的笔记。
4．打印Sun的考试大纲，逐条检验知识点。
考试大纲 http://www.sun.com/training/catalog/courses/CX-310-051.xml
5．做yahoo上的《SCEA Practice Questions1.zip》等题目。
6．考试前2天，根据做题经验，结合考试大纲，再逐一根据各知识点复习。
7．考试时，也许第一个题目就是很长的英文题。不用被吓着，稳定心态做下去。你会发现后面那些简短的题目几秒钟就可以搞定一个。你肯定有时间回头检查的。
310-051只是系统架构师的第一步，后面还有Assignment (CX-310-300A) 、Essay Exam (CX-310-061)两步。我不知道我什么时候会考，考试费太贵了（全程5000），最好能找个地方报销。我更看中学习过程及实际掌握的知识，考试的结果，尤其是证书，天晓得有没有用。但第一步应该是最难的一步，选择题考过了，剩下两步应该更容易。也许我会去考，如果考过了，如果有经验，我一样会来分享的。考虑到第一个1250花出去，我老公可能会催我考下去，他会觉得既然花钱了，那么搞个证书才合算。哈哈！