superloafer/
共32个网摘 [
1 2 ]
下一页 |
访问superloafer的个人空间
superloafer收录，使用标签：Java类文章，时间：2008-3-10 14:00:43 | 相关网摘，我也收藏
JAVA程序员面试32问
第一，谈谈final, finally, finalize的区别。
final 修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声明为final的。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。被声明为final的方法也同样只能使用，不能重载
finally 再异常处理时提供 finally 块来执行任何清除操作。如果抛出一个异常，那么相匹配的 catch 子句就会执行，然后控制就会进入 finally 块（如果有的话）。
finalize?方法名。Java 技术允许使用 finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是在 Object 类中定义的，因此所有的类都继承了它。子类覆盖 finalize() 方法以整理系统资源或者执行其他清理工作。finalize() 方法是在垃圾收集器删除对象之前对这个对象调用的。
第二，Anonymous Inner Class (匿名内部类) 是否可以extends(继承)其它类，是否可以implements(实现)interface(接口)?
匿名的内部类是没有名字的内部类。不能extends(继承) 其它类，但一个内部类可以作为一个接口，由另一个内部类实现。
第三，Static Nested Class 和 Inner Class的不同，说得越多越好(面试题有的很笼统)。
Nested Class （一般是C++的说法），Inner Class (一般是JAVA的说法)。Java内部类与C++嵌套类最大的不同就在于是否有指向外部的引用上。具体可见http: //www.frontfree.net/articles/services/view.asp?id=704&page=1
注： 静态内部类（Inner Class）意味着1创建一个static内部类的对象，不需要一个外部类对象，2不能从一个static内部类的一个对象访问一个外部类对象
第四，&和&&的区别。
&是位运算符。&&是布尔逻辑运算符。
第五，HashMap和Hashtable的区别。
都属于Map接口的类，实现了将惟一键映射到特定的值上。
HashMap 类没有分类或者排序。它允许一个 null 键和多个 null 值。
Hashtable 类似于 HashMap，但是不允许 null 键和 null 值。它也比 HashMap 慢，因为它是同步的。
第六，Collection 和 Collections的区别。
Collections是个java.util下的类，它包含有各种有关集合操作的静态方法。
Collection是个java.util下的接口，它是各种集合结构的父接口。
第七，什么时候用assert。
断言是一个包含布尔表达式的语句，在执行这个语句时假定该表达式为 true。如果表达式计算为 false，那么系统会报告一个 AssertionError。它用于调试目的：
assert(a > 0); // throws an AssertionError if a <= 0
断言可以有两种形式：
assert Expression1 ;
assert Expression1 : Expression2 ;
Expression1 应该总是产生一个布尔值。
Expression2 可以是得出一个值的任意表达式。这个值用于生成显示更多调试信息的 String 消息。
断言在默认情况下是禁用的。要在编译时启用断言，需要使用 source 1.4 标记：
javac -source 1.4 Test.java
要在运行时启用断言，可使用 -enableassertions 或者 -ea 标记。
要在运行时选择禁用断言，可使用 -da 或者 -disableassertions 标记。
要系统类中启用断言，可使用 -esa 或者 -dsa 标记。还可以在包的基础上启用或者禁用断言。
可以在预计正常情况下不会到达的任何位置上放置断言。断言可以用于验证传递给私有方法的参数。不过，断言不应该用于验证传递给公有方法的参数，因为不管是否启用了断言，公有方法都必须检查其参数。不过，既可以在公有方法中，也可以在非公有方法中利用断言测试后置条件。另外，断言不应该以任何方式改变程序的状态。
第八，GC是什么? 为什么要有GC? (基础)。
GC是垃圾收集器。Java 程序员不用担心内存管理，因为垃圾收集器会自动进行管理。要请求垃圾收集，可以调用下面的方法之一：
System.gc()
Runtime.getRuntime().gc()
第九，String s = new String("xyz");创建了几个String Object?
两个对象，一个是“xyx”,一个是指向“xyx”的引用对象s。
第十，Math.round(11.5)等於多少? Math.round(-11.5)等於多少?
Math.round(11.5)返回（long）12，Math.round(-11.5)返回（long）-11;
第二十一，abstract的method是否可同时是static,是否可同时是native，是否可同时是synchronized?
都不能
第二十二，接口是否可继承接口? 抽象类是否可实现(implements)接口? 抽象类是否可继承实体类(concrete class)?
接口可以继承接口。抽象类可以实现(implements)接口，抽象类是否可继承实体类，但前提是实体类必须有明确的构造函数。
第二十三，启动一个线程是用run()还是start()?
启动一个线程是调用start()方法，
http://bbs.chinaitlab.com/viewthread.php?tid=171232&frameon=no
superloafer收录，使用标签：Java类文章，时间：2008-3-10 13:59:57 | 相关网摘，我也收藏
浅析Java语言中的内部类 热门培训课程
JAVAV工程师权威认证
广州中星报MCSE送CCNA3600元 上海英孚教育急聘
系统管理员 初级程序员 软件开发工程师
数据库工程师 高级项目经理 界面设计经理 中国IT实验室收集整理 佚名 2008-3-6 保存本文 推荐给好友 收藏本页 提起Java内部类(Inner Class)可能很多人不太熟悉，实际上类似的概念在C++里也有，那就是嵌套类(Nested Class)，关于这两者的区别与联系，在下文中会有对比。内部类从表面上看，就是在类中又定义了一个类(下文会看到，内部类可以在很多地方定义)，而实际上并没有那么简单，乍看上去内部类似乎有些多余，它的用处对于初学者来说可能并不是那么显著，但是随着对它的深入了解，你会发现Java的设计者在内部类身上的确是用心良苦。学会使用内部类，是掌握Java高级编程的一部分，它可以让你更优雅地设计你的程序结构。下面从以下几个方面来介绍：
第一次见面
public interface Contents {
int value();
}
public interface Destination {
String readLabel();
}
public class Goods {
private class Content implements Contents {
private int i = 11;
public int value() {
return i;
}
}
protected class GDestination implements Destination {
private String label;
private GDestination(String whereTo) {
label = whereTo;
}
public String readLabel() {
return label;
}
}
public Destination dest(String s) {
return new GDestination(s);
}
public Contents cont() {
return new Content();
}
}
class TestGoods {
public static void main(String[] args) {
Goods p = new Goods();
Contents c = p.cont();
Destination d = p.dest("Beijing");
}
}
在这个例子里类Content和GDestination被定义在了类Goods内部，并且分别有着protected和private修饰符来控制访问级别。Content代表着Goods的内容，而GDestination代表着Goods的目的地。它们分别实现了两个接口Content和Destination。在后面的main方法里，直接用 Contents c和Destination d进行操作，你甚至连这两个内部类的名字都没有看见!这样，内部类的第一个好处就体现出来了??隐藏你不想让别人知道的操作，也即封装性。
同时，我们也发现了在外部类作用范围之外得到内部类对象的第一个方法，那就是利用其外部类的方法创建并返回。上例中的cont()和dest()方法就是这么做的。那么还有没有别的方法呢?当然有，其语法格式如下：
outerObject=new outerClass(Constructor Parameters);
outerClass.innerClass innerObject=outerObject.new InnerClass(Constructor Parameters);
注意在创建非静态内部类对象时，一定要先创建起相应的外部类对象。至于原因，也就引出了我们下一个话题??非静态内部类对象有着指向其外部类对象的引用，对刚才的例子稍作修改：
public class Goods {
private valueRate=2;
private class Content implements Contents {
private int i = 11*valueRate;
public int value() {
return i;
}
}
protected class GDestination implements Destination {
private String label;
private GDestination(String whereTo) {
label = whereTo;
}
public String readLabel() {
return label;
}
}
public Destination dest(String s) {
return new GDestination(s);
}
public Contents cont() {
return new Content();
}
}
修改的部分用蓝色显示了。在这里我们给Goods类增加了一个private成员变量valueRate，意义是货物的价值系数，在内部类Content的方法value()计算价值时把它乘上。我们发现，value()可以访问valueRate，这也是内部类的第二个好处??一个内部类对象可以访问创建它的外部类对象的内容，甚至包括私有变量!这是一个非常有用的特性，为我们在设计时提供了更多的思路和捷径。要想实现这个功能，内部类对象就必须有指向外部类对象的引用。Java编译器在创建内部类对象时，隐式的把其外部类对象的引用也传了进去并一直保存着。这样就使得内部类对象始终可以访问其外部类对象，同时这也是为什么在外部类作用范围之外向要创建内部类对象必须先创建其外部类对象的原因。
有人会问，如果内部类里的一个成员变量与外部类的一个成员变量同名，也即外部类的同名成员变量被屏蔽了，怎么办?没事，Java里用如下格式表达外部类的引用：
outerClass.this
有了它，我们就不怕这种屏蔽的情况了。
静态内部类
和普通的类一样，内部类也可以有静态的。不过和非静态内部类相比，区别就在于静态内部类没有了指向外部的引用。这实际上和C++中的嵌套类很相像了，Java内部类与C++嵌套类最大的不同就在于是否有指向外部的引用这一点上，当然从设计的角度以及以它一些细节来讲还有区别。
除此之外，在任何非静态内部类中，都不能有静态数据，静态方法或者又一个静态内部类(内部类的嵌套可以不止一层)。不过静态内部类中却可以拥有这一切。这也算是两者的第二个区别吧。
局部内部类
是的，Java内部类也可以是局部的，它可以定义在一个方法甚至一个代码块之内。
public class Goods1 {
public Destination dest(String s) {
class GDestination implements Destination {
private String label;
private GDestination(String whereTo) {
label = whereTo;
}
public String readLabel() { return label; }
}
return new GDestination(s);
}
public static void main(String[] args) {
Goods1 g= new Goods1();
Destination d = g.dest("Beijing");
}
}
上面就是这样一个例子。在方法dest中我们定义了一个内部类，最后由这个方法返回这个内部类的对象。如果我们在用一个内部类的时候仅需要创建它的一个对象并创给外部，就可以这样做。当然，定义在方法中的内部类可以使设计多样化，用途绝不仅仅在这一点。
下面有一个更怪的例子：
public class Goods2{
private void internalTracking(boolean b) {
if(b) {
class TrackingSlip {
private String id;
TrackingSlip(String s) {
id = s;
}
String getSlip() { return id; }
}
TrackingSlip ts = new TrackingSlip("slip");
String s = ts.getSlip();
}
}
public void track() { internalTracking(true); }
public static void main(String[] args) {
Goods2 g= new Goods2();
g.track();
}
}
你不能在if之外创建这个内部类的对象，因为这已经超出了它的作用域。不过在编译的时候，内部类TrackingSlip和其他类一样同时被编译，只不过它由它自己的作用域，超出了这个范围就无效，除此之外它和其他内部类并没有区别。
匿名内部类
java的匿名内部类的语法规则看上去有些古怪，不过如同匿名数组一样，当你只需要创建一个类的对象而且用不上它的名字时，使用内部类可以使代码看上去简洁清楚。它的语法规则是这样的：
new interfacename(){......}; 或 new superclassname(){......};
下面接着前面继续举例子：
public class Goods3 {
public Contents cont(){
return new Contents(){
private int i = 11;
public int value() {
return i;
}
};
}
}
这里方法cont()使用匿名内部类直接返回了一个实现了接口Contents的类的对象，看上去的确十分简洁。
在java的事件处理的匿名适配器中，匿名内部类被大量的使用。例如在想关闭窗口时加上这样一句代码：
f rame.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent e){
System.exit(0);
}
});
有一点需要注意的是，匿名内部类由于没有名字，所以它没有构造函数(但是如果这个匿名内部类继承了一个只含有带参数构造函数的父类，创建它的时候必须带上这些参数，并在实现的过程中使用super关键字调用相应的内容)。如果你想要初始化它的成员变量，有下面几种方法：
如果是在一个方法的匿名内部类，可以利用这个方法传进你想要的参数，不过记住，这些参数必须被声明为final。
将匿名内部类改造成有名字的局部内部类，这样它就可以拥有构造函数了。
在这个匿名内部类中使用初始化代码块。
为什么需要内部类?
java内部类有什么好处?为什么需要内部类?
首先举一个简单的例子，如果你想实现一个接口，但是这个接口中的一个方法和你构想的这个类中的一个方法的名称，参数相同，你应该怎么办?这时候，你可以建一个内部类实现这个接口。由于内部类对外部类的所有内容都是可访问的，所以这样做可以完成所有你直接实现这个接口的功能。
不过你可能要质疑，更改一下方法的不就行了吗?
的确，以此作为设计内部类的理由，实在没有说服力。
真正的原因是这样的，java中的内部类和接口加在一起，可以的解决常被C++程序员抱怨java中存在的一个问题??没有多继承。实际上，C++的多继承设计起来很复杂，而java通过内部类加上接口，可以很好的实现多继承的效果。
http://java.chinaitlab.com/base/740313.html
superloafer收录，使用标签：Java类文章，时间：2008-3-10 13:27:42 | 相关网摘，我也收藏
Java极度性能调整 热门培训课程
JAVAV工程师权威认证
广州中星报MCSE送CCNA3600元 上海英孚教育急聘
系统管理员 初级程序员 软件开发工程师
数据库工程师 高级项目经理 界面设计经理 中国IT实验室收集整理 佚名 2008-3-4 保存本文 推荐给好友 收藏本页 有很多介绍基本的Java应用性能调整的文章。他们都讨论些简单的技术，诸如使用StringBuffer而不用String，使用synchronized关键字的开销等等。
这篇文章不再介绍这些东西。相反，我们关注能帮助你的基于Web的应用更快、可升级型更好的技巧。一些技巧很详细，其他的相对简短，但所有的都很有用。最后以一些你可提供给你的管理者的建议结束。
我写这篇文章的灵感来自于当我的同事和我一起回忆我们的.com(dot-com)时代的时候——我们如何设计能支持成千上万的用户和拥有紧密代码的系统，我们如何对有侵略性的致命打击。有时在为复用设计和为性能设计之间有一个权衡。基于我的情况，性能每次都获胜。即使你的商务顾客无需理解代码复用，但是他们知道快速(fast-performing)的系统是怎么回事。让我们开始看看我们的技巧。
如何使用Exception
Exception降低性能。一个异常抛出首先需要创建一个新的对象。Throwable接口中的构造器调用名为fillInStackTrace()的本地方法。这个方法负责巡检栈的整个框架来收集跟踪信息。这样无论何时有异常抛出，它要求虚拟机装载调用栈，因为一个新的对象在中部被创建。
异常应当仅用于有错误发生时，而不要控制流。
我有机会在一个专门用于无线内容市场的网站(名字故意隐去了)看到一段代码，其中开发者完全可以使用一个简单的对照来查看对象是否为空。相反，他或她跳过了这个检查而实际上抛出Null-PointerException。
不要两次初始化变量
Java通过调用独特的类构造器默认地初始化变量为一个已知的值。所有的对象被设置成null，integers (byte, short, int, long)被设置成0，float和double设置成0.0，Boolean变量设置成false。这对那些扩展自其它类的类尤其重要，这跟使用一个新的关键词创建一个对象时所有一连串的构造器被自动调用一样。
对新的关键词使用优选法则
正如前面提到的，通过使用一个新的关键词创建一个类的实例，在这个链中的所有构造器将被调用。如果你需要创建一个类的新实例，你可以使用一个实现了cloneable接口的对象的clone()方法。该clone方法不调用任何类的构造器。
如果你已经使用了设计模式作为你的体系结构的一部分，并且使用了工厂模式创建对象，变化会很简单。下面所列是工厂模式的典型实现。
public static Account getNewAccount() {
return new Account();
}
使用了clone方法的refactored代码看起来可能像下面这样：
private static Account BaseAccount = new Account();
public static Account getNewAccount() {
return (Account) BaseAccount.clone();
}
以上的思路对实现数组同样有用。
如果你在应用中没有使用设计模式，我建议你停止读这篇文章，赶快跑到(不要走)书店挑一本四人著的《设计模式》。
在任何可能的地方让类为Final
标记为final的类不能被扩展。在《核心Java API》中有大量这个技术的例子，诸如java.lang.String。将String类标记为final阻止了开发者创建他们自己实现的长度方法。
更深入点说，如果类是final的，所有类的方法也是final的。Java编译器可能会内联所有的方法(这依赖于编译器的实现)。在我的测试里，我已经看到性能平均增加了50%。
在任何可能的地方使用局部变量
属于方法调用部分的自变量和声明为此调用一部分的临时变量存储在栈中，这比较快。诸如static，实例(instance)变量和新的对象创建在堆中，这比较慢。局部变量的更深入优化依赖于你正在使用的编译器或虚拟机。
使用Nonblocking I/O
当前的JDK版本不支持nonblocking I/O API，很多应用试图通过创建大量的线程(目光长远得用在池中)来避免阻塞。正如前述，在Java中创建线程有严重的开销。
典型的你可能看到应用中实现的线程需要支持并发I/O流，像Web 服务器，并quote and auction components.
JDK1.4介绍了一个nonblocking I/O包(java.nio)。如果你必须保留在较早版本的JDK，有添加了支持nonblocking I/O的第三方包。
：www.cs.berkeley.edu/~mdw/proj/java-nbio/download.html.
停止小聪明
很多开发人员在脑子中编写可复用和灵活的代码，而有时候在他们的程序中就产生额外的开销。曾经或者另外的时候他们编写了类似这样的代码：
public void doSomething(File file) {
FileInputStream fileIn = new FileInputStream(file);
// do something
他够灵活，但是同时他们也产生了更多的开销。这个主意背后做的事情是操纵一个InputStream，而不是一个文件，因此它应该重写如下：
public void doSomething(InputStream inputStream){
// do something
乘法和除法
我有太多的东东适用于摩尔法则——它声明CPU功率每年成倍增长。"摩尔法则"表明每年由开发者所写的差劲的代码数量三倍增加，划去了摩尔法则的任何好处。
考虑下面的代码：
for (val = 0; val < 100000; val +=5) { shiftX = val * 8; myRaise = val * 2; }
如果我们狡猾的利用位移(bit)，性能将会六倍增加。这是重写的代码：
for (val = 0; val < 100000; val += 5) { shiftX = val << 3; myRaise = val << 1; }
代替了乘以8，我们使用同等效果的左移3位。每一个移动相当于乘以2，变量myRaise对此做了证明。同样向右移位相当于除以2，当然这会使执行速度加快，但可能会使你的东东以后难于理解;所以这只是个建议。
选择一个基于垃圾收集实现的虚拟机
许多人可能会对Java规范不需要实现垃圾收集感到惊讶。设想时代已经是我们都拥有无限内存计算机。总之，垃圾收集器日常事务就是负责发现和抛出(hence garbage)不再需要的对象。垃圾收集必须发现那些对象不再被程序指向，并且使被对象占用的栈内存被释放掉。它还负责运行任何被释放对象的finalizer。
垃圾收集故意不允许你释放并非由你分配的内存，从而帮助你确保程序完整，当JVM确定CPU时间的时间表并且当垃圾收集器运行时，这个进程也产生开销。
垃圾收集器有两个不同的步骤执行他们的工作。
实现了定位计算的垃圾收集器在栈中为每一个对象保留一个计数。当一个对象被创建并且对它的一个定位被分配给一个变量，计数增加。当对象越出范围，定位计数被设置成0并且对象可以被垃圾收集。这个步骤允许参考计数器运行在与程序执行有关的短时间增量内。定位计数在父子彼此拥有定位的应用里运行不正常。每次一个对象刷新时也会有定位计数增加和减少的开销。
实现了跟踪的垃圾收集器从根节点开始跟踪一列定位。对象发现跟踪是否被标记。在这个过程完成后，知道不可达的任何没标记的对象可以被垃圾收集。这可能以位图(bitmap)形式实现或者在对象中被设置标志。此技术参考"Mark and Sweep."(reference：定位，翻译成“指向”好像更容易理解，是Java语言对在用对象的一个跟踪指针。译者著)
给你的管理人员提建议
其他方法可被用来使你的基于Web的应用更快并且更可升级。可实现的最简单的技术通常是支持cluster的策略。使用cluster，一组服务器能够一起透明的提供服务。多数应用服务器允许你获得cluster支持而不需要改变你的应用——一个大的胜利。
当然在执行此步骤之前你可能需要考虑来自你使用的应用服务器提供商附加的许可权利。
当看到cluster策略会有许多额外的事情考虑。经常在体系结构中产生的一个缺点是拥有有状态会话。如果cluster中的一个服务器或者进程当掉，cluster会舍弃整个应用。为防止此类事情发生，cluster必须给cluster中的所有成员不断复制会话Bean的状态。确保你也限制了存储在会话中的对象的大小和数量，因为这些也需要被复制。
Cluster也允许你分期度量你的Web站点的部分。如果你需要度量静态部分，你可以添加Web服务器。如果你需要度量动态生成的部分，你可以添加应用服务器。
在你已经把你的系统放入cluster后，下一个让你的应用跑得更快的建议步骤是选择一个更好的虚拟机。看看Hotspot虚拟机或者其他的飞速发展中的执行优化的虚拟机。随同虚拟机，看看更好的编译器是一个更好的主意。
如果你使用了几个这儿提到的行业技术插件，并且仍然不能获得你要的可升级性和高可用性，那么我建议一个可靠的调试策略。策略的第一步是为可能的瓶颈检查整个体系结构。通常，这在你的作为单线程组件或者有很多辅助连接线组件的UML流图中很容易识别出来。
最后的步骤是产生一个整个代码的详细性能估价。
确保你的管理人员至少为此安排了整个项目时间的20%;否则不足的时间可能不止危及你整个成功的安全，还会导致你向系统引入新的缺点。
许多组织者在适当的位置没有严格意义的测试基础而归咎于成本考虑也是错误的。确保你的QA环境真实反映你的生产环境，并且你的QA测试考虑以不同的负载测试应用，包括在最大的预期并发用户时一个基于低负载和一个完全负载的测试。
性能测试，有时测试一个系统的稳定性，可能需要在每天，甚至每周的整个时期的不同关节都运行。
http://java.chinaitlab.com/base/740144.html
superloafer收录，使用标签：技术类书籍，时间：2008-2-28 1:57:40 | 相关网摘，我也收藏
Ruby是一种面向对象的敏捷语言，借鉴了LISP、Smalltalk、Perl、CLU和其他语言的出色特性。在本书第1版面世后的5年内，Ruby得以日益流行。
本书采用“如何解决问题”的方式阐述Ruby编程，涵盖了以下内容：Ruby术语和基本原理；数字、字符串等低级数据类型的操作；正则表达式；国际化和 Ruby消息目录；散列、数组及栈、树和图等其他数据结构的操作；I／O、文件和对象持久化；Ruby特有的OOP技术及动态编程；Tk、GTK+、 Fox和Qt等Ruby图形用户界面；使用RUbY线程实现轻量级多任务：使用Ruby编写脚本和进行系统管理；使用图像文件、PDF、YAML、 xML、RSS和Atom；Ruby代码的测试、调试、性能分析和打包；低级网络编程和客户／服务器交互；Rails、Nitro、Wee、IOWA等 Web开发工具；使用分布式Rkuby、Rinda和Ring。书中包含400多个按主题分类的示例，每个示例都回答了“如何使用Ruby来完成”的问题。首先对要完成的任务进行了描述，并讨论技术方面的约束条件，然后循序渐进地阐述一种优秀的解决方案，并辅以说明和解释以帮助读者理解。
作者Hal Fulton以旁征博引、引人入胜而又清晰易懂的写作手法，全面而详细地阐述了．Ruby，让读者感到犹如有一位知识渊博的老师在身边，并渴望将其掌握的知识悉数传授给你。本书可作为中高级程序员深入了解Ruby以及使用它来解决实际问题的参考手册
http://www.dearbook.com.cn/book/213842
superloafer收录，使用标签：Java类文章，时间：2008-2-28 1:47:07 | 相关网摘，我也收藏
Ajax技术可以提供高度交互的Web应用，给予用户更丰富的页面浏览体验。本书重点介绍Ajax及相关的工具和技术，主要内容包括 XMLHttpRequest对象及其属性和方法、发送请求和处理响应、构建完备的Ajax开发工具、使用JsUnit测试JavaScript、分析 JavaScript调试工具和技术，以及Ajax开发模式和框架等。本书中所有例子的代码都可以从Apress网站本书主页的源代码（Source Code）免费得到。本书适合各层次Web应用开发人员和网页设计人员阅读。
http://book.csdn.net/bookfiles/11/#c1
superloafer收录，使用标签：java类文章，时间：2008-2-27 1:03:31 | 相关网摘，我也收藏
1998年出版的《反模式——危机中软件、架构和项目的重构》（AntiPatterns——Refactoring Software, Architectures, and Projects in Crisis）这本书对于滥用设计模式的趋势来说可谓是一剂很及时的解毒良药。反模式其实也是一种模式（正如设计模式是一种模式一样），不过它主要考察的是这种模式所带来的不良后果。这本书系统地总结了很多种类的反模式，以及如何识别出这些反模式并且加以避免。这些反模式涵盖了软件开发、软件架构和项目管理等方面。虽然这本书并不是专门针对设计模式展开讨论的，但是不当使用设计模式很多时候都会导致出现反模式。平衡感是优秀的面向对象架构师应该拥有的素质，《反模式》这本书可以使架构师拥有更好的平衡感。
http://blog.csdn.net/mozilla/archive/2008/01/20/2054433.aspx
superloafer收录，使用标签：java类文章，时间：2008-2-26 1:27:38 | 相关网摘，我也收藏
在windows下eclipse的带ssh的cvs客户端配置（使用putty tools）
Posted on 2006-04-12 11:16 publisher luo 阅读(1828) 评论(0) 编辑 收藏 所属分类: java技术
在sourceforge上注册了一个开源项目（http://nodepublisher.sourceforge.net/），在后台管理里面其它配置基本上都配置成功，cvs开发人员的访问也按照帮助使用wincvs访问成功，可是现在开发都使用eclipse里面的cvs，如果结合者wincvs使用实在是太麻烦了，所以上网找了找资料，中文的没有，只有一些英文资料，将它们整理翻译一下，供大家参考。
我已经能够使用windows下的eclipse中的cvs访问SourceForge的cvs服务器了，下面是操作过程。
下载 PuTTY tools
下载 PuTTYgen, Pageant, 和 Plink 三个文件到你计算机一个文件目录下。可以象本向导一样放到 "C:\Program Files\PuTTY"下。
生成你自己的一对RSA密钥
运行PuTTYgen. 点击Generate 按钮并且按照上面说明的移动你的鼠标。
在"Key passphrase"中输入一个规整的长密码并且在"Confirm passphrase"中重复输入。
点击"Save public key" 将你生成的共钥保存在你的计算机的某个目录下.例如"C:\Documents and Settings\Matt Whitlock\sf0.pub". 其实在后面的使用中你并不真正使用它,但是保留下来还是挺好的有可能你会在其它地方用到它.
点击"Save private key" 保存私钥到你的计算机上.例如"C:\Documents and Settings\Matt Whitlock\ssh\sf0.ppk". 这个文件已经被你的密码段加密了.
拷贝高亮显示区域"Public key for pasting into OpenSSH authorized_keys file"中的内容到剪贴板中.
保存你的公钥到SourceForge中
登入到SourceForge.
点击工具条上的 "My Settings".
点击"Authorized Keys" .
粘贴你拷贝在剪贴板里的公钥.新的公钥将替换原来已有的其它公钥。
点击 "Update" 保存你的公钥到SourceForge.
使用Pageant来提供ssh的身份认证
启动Pageant. 将会有一个告示图标显示在右下角的任务条中.
右键点击Pageant告示图标并且选择"Add Key".
打开刚才生成并保存的私钥"C:\Documents and Settings\Matt Whitlock\ssh\sf0.ppk".
Pageant 将会提示你输入你加密私钥的密码然后点击 "OK".
缓存SSH服务器的主机公钥
在你能够使用Eclipse连接CVS服务器之前,你必须添加SSH服务器的主机公钥到你的本地缓存中。
方法 1 (如果你有全部的PuTTY客户端)
就是使用PuTTY连接cvs.sourceforge.net，当它询问你是否信任这个服务器的时候你选择 并且添加公钥到你的缓存中,你只要选择yes.然后就可以了，你可以实际并不登入到此服务器。
方法 2 (如果你有Plink,而没有 PuTTY)
打开命令提示框并执行:
"C:\Program Files\PuTTY\plink.exe" cvs.sourceforge.net -l username
username就是你在SourceForge的用户名. (注意在username前面的L是小写的 )
你可能得到一个信息说"the server's host key is not cached in the registry." 你应该回答 'y'.
如果你得到的信息是"This is a restricted shell account. You cannot execute anything here", 你的SSH客户端已经正确设置完成。.
配置Eclipse使用PuTTY's Plink来SSH连接
运行Eclipse. 我运行的是版本3.1
选择 "Preferences" 从 "Window" 菜单中. 选择"Team/CVS/Ext Connection Method".
点击"Browse" 找到"C:\Program Files\PuTTY\plink.exe".
点击"OK" 保存你的参数选择。
添加你的CVS repository到Eclipse
选择 "Window", "Open Perspective", "Other", "CVS Repository Exploring", 点击 "OK".
右键点击 "CVS Repositories" (屏幕左面大块空白区域)选择"New", "Repository Location".
在"Host"处填写"cvs.sourceforge.net".
在"Repository path"处填写你的CVS repository 路径. 你可以在你的 SourceForge工程页的"Source code"处找到. 它应该类似"/cvsroot/projectname".
在"User"处填写你的SourceForge用户名.
password不填写.我们不使用口令认证而是通过Pageant使用SSH2-RSA key .
在"Connection type"处选择"ext"类型。
点击"Finish". 这样Eclipse就能够连接CVS server了。
http://www.blogjava.net/luoqx/archive/2006/04/12/40588.html
superloafer收录，使用标签：java类文章，时间：2008-2-25 23:07:53 | 相关网摘，我也收藏
JNLP使用2007-01-16 19:13JNLP是Java Network Launch Protocol的简写,是一种用来在网络中部署应用程序的一种协议;在客户端只需要安装java web start就可以使用服务器端的软件，它具有自动更新应用程序版本的功能;其实要部署一个jnlp程序也是很简单的，下面我们就来部署一个简单的程序;要在服务器部署应用程序，一个最主要的就是编写一个部署文件，它是一种xml格式的文件，以jnlp为后缀；而你的应用程序就必须打包成jar文件格式；假设你你现在有一个HelloJNLP.jar的文件，我们下面就来编写它的部署文件;新建文件HelloJNLP.jnlp文件，然后使用你喜欢的文件编辑器打开该文件，下面开始来编写该文件首先在文件中写如xml的版本和使用的编码，这行是可选的，不过在实际部署中最好还是写上这行；如下:然后以标记开始，在这里你要把你应用程序的地址写好，这个地址可以以本地文件目录，也可以是一个网络url，如下 在中你可以写入在应用程序下载是显示的一些资料，如标题，描述，图标,程序的存放目录等
Hello
HelloJNLP
还有一个可选的标记，它允许application在断网的情况下也能运行； 在中你可以配置程序运行时的安全咨询,它可以是
这个标记也可以不写； 然后在中你可以配置jre的版本，程序相对codebase的路径
假如你在打包jar文件的时候没有指定主类，那么你必须使用以下方法指定一个主类 一个完整的jnlp文件是:
Hello
Tech Tips Sample
我们下面将它部署到tomcat下，首先你需要在%CATALINA_HOME%conf/web.xml中添加一个mime-mapping:
jnlp
application/x-java-jnlp-file
然后在%CATALINA_HOME%\webapps下建个jnlp的文件夹，把HelloJNLP.jnlp和HelloJNLP.jar文件copy过去，然后在里面建个WEB-INF目录;然后你就可以通过http://localhost:8080/jnlp/HelloJNLP.jnlp来运行程序了 文件打包可以通过jdk中的jar，假如要将当前目录下所以文件打包到HelloJNLP.jar中，你可以在dos下输入:jar -cvf HelloJNLP.jar *.class 你还可以通过keytool、jarsigner来为你的jar文件签名 创建签字
keytool -genkey -keystore myKeys -alias jdc为jar文件签字
jarsigner -keystore myKeys jarName.jar jdc
http://hi.baidu.com/yclt/blog/item/716d1b08a8fd8730e824886d.html
共32个网摘 [
1 2 ]
下一页