在Eclipse中安装jbosside建立servlet-

昵称17030 2007-01-08

展开全文

·在Eclipse中安装jbosside建立servlet-

1、jboss－ide的安装。
   jboss－ide是通过software update安装的。
   从help－software update－update manager打开update manager，
   建立新的site bookmark，命名为jbosside，地址：http://jboss./jbosside/updates.
   选择建立的jbosside下的jboss－ide1.0/Eclipse2.1，选择最新的版本安装。

2、增加快捷按钮到TOP Menu中
   jboss－ide插件提供了一组按钮，用来启动、停止、终止server，和查看server console和logfiles。这些
   按钮只能操作默认的server而且只能操作一个，显示这些按钮，如下：
   1、右键在top menu上单击。
   2、选择customize persective。
   3、展开other。
   4、选择default server。
   5、点击ok。

3、配置和开始一个server。

    需要独立的安装jboss。
    在run－debug中选择机器安装的jboss的版本，点击new，建立一个jboss的配置实例，设定配置的名称
    和jboss server的主目录，点击close，然后到window－》preferences－》jboss_ide－》launcher，
    指定一个default server。现在可以使用前面增加到top menu中的按钮了。

4、建立一个servlet.
现在来学习如何使用这个JBOSS_IDE插件，我们将建立一个简单的“hello world”servlet并且发布到jboss上。
把你的源代码放在一个源代码目录中，把编译结果放在一个输出目录中。下面的步骤将配置源代码目录和输出目录。
1、在Package Explorer中右键单击你的项目。
2、到Properities ->Java build path.
3、点击source tab.
4、click on ADD　Folder。
5、click on create new folder.
6、set the folder name to "src".
7、选择“yes”当询问你删除项目的原目录并且建立“bin”目录时。

下边需要设定你的CLASSPATH,通过设定the libraties(JAR files),Eclipse将用它来编译你的代码。你也需要增加
JAR file ，允许你编译servlet的jar 文件。在Eclipse的tomcat插件中包含需要的servlet。

1、click on the libraries tab(while under the properities->java build path)
2、click add variable.
3\ select Eclipse_home and click extend.
4\ Navigate to the plugin/org.eclipse.tomcat.4.1 directory.
5\ select the servlet.jar and click OK.
6\ click Ok to exit the properities dialog.

现在建立一个名为HelloWorldServlet的类，在包com.jiawh.test中。
代码如下：

/*
* Created on 2004-5-21
*
* To change the template for this generated file go to
* Window>Preferences>Java>Code Generation>Code and Comments
*/
package com.jiawh.test.jboss;

import java.io.IOException;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
* @author Administrator
*
* To change the template for this generated type comment go to
* Window>Preferences>Java>Code Generation>Code and Comments
*/
public class HelloWorldServlet extends HttpServlet {
protected void service(HttpServletRequest request, HttpServletResponse response) throws IOException{
ServletOutputStream out = response.getOutputStream();
out.println("<html><body><h1>Hello World!</h1></body></html>");
}
}

现在需要建立一个发布描述文件，这样jboss就知道如何使用你的servlet了。
发布描述文件（web.xml）被放在WEB-INF目录中，都在一个war文件中。在原代码目录下建立目录WEB-INF，然后建立一个文件
web.xml在这个目录下，文件的内容如下：

<!DOCTYPE web-app PUBLIC
  ‘-//Sun Microsystems, Inc.//DTD Web Application 2.2//EN‘
‘http://java./j2ee/dtds/web-app_2.2.dtd‘>
<web-app>
  <servlet>
  <servlet-name>HelloWorldServlet</servlet-name>
  <servlet-class>com.jiawh.test.jboss.HelloWorldServlet</servlet-class>
</servlet>
  <servlet-mapping>
  <servlet-name>HelloWorldServlet</servlet-name>
  <url-pattern>/Hello</url-pattern>
</servlet-mapping>
</web-app>

5、定义war文件结构。
在你发布你的应用到jboss之前，你需要定义的的war文件的结构，通过Packaging configuration可以定义war文件结构，
然后你就可以建立war文件了：

1、在Packager Explorer中右键点击你的项目。
2、选择Properties－>Packaging configuration。
3、Right click in the right frame and click Add Std. Archive.
4、Select Standard-WAR.war and click OK.
5、Right click on the configuration and click Edit.
6、重新命名为 helloworld.war.
7、Expand the configuration（扩展配置）.
8、在Manifest.MF这行上右键点击，并且删除它.
点击OK，你将在你的项目中看到一个文件（packaging－build.xml）。

6、建立并且部署这个war文件。
通过在你的项目上右键点击run packaging建立war文件。然后你需要点击Refresh就可以看到这个war文件了。
这个文件应该在你项目的顶层目录中。
在这个war文件上点击右键，选择Deployment－Deploy to，来发布这个文件。
会出现一个Target choice对话框，让你选择要发布到的应用服务器上，选择后会有个提示发布成功的确认框。

记得要启动server哦。
发布成功，可以去看了。。。http://localhost:8080/helloworld/hello

- 作者： moses 2004年05月21日,星期五 20:58:13 回复（0 ） | 引用（0 ） | URL

·线程同步-

使用synchronized修饰一个方法，可以保证当一个线程在一个同步方法内部，所有试图调用该方法的同实例的其他线程必须等待。注意是同实例的同步方法。也即，一旦线程进入实例的同步方法，没有其他线程可以进入相同实例的的同步方法。但是该实例的其他不同步方法可以使用。

public class CallMe {
synchronized void call(String msg){
  System.out.print("[" + msg);
  try{
   Thread.sleep(1000);
  }catch(InterruptedException e){
   System.out.println("Interrupted");
  }
  System.out.print("]");
}
}

可以保证相同实例对同步方法的调用的线程限制。

synchronized块确保对object成员方法的调用仅在当前线程成功进入object管程后发生。每一个对象都有与之对应的隐式管程。进入某一个对象的管程，就是调用被synchronized关键字修饰的方法。

public void run() {
  // TODO Auto-generated method stub
  synchronized(targer){
   targer.call(msg);
  }
}

- 作者： moses 2004年05月8日,星期六 16:14:32 回复（0 ） | 引用（0 ） | URL

·多线程处理中的优先级-

线程处理类

/*
* Created on 2004-5-8
*
* To change the template for this generated file go to
* Window>Preferences>Java>Code Generation>Code and Comments
*/
package com.jiawh.test.threadPriority;

/**
* @author Administrator
*
* To change the template for this generated type comment go to
* Window>Preferences>Java>Code Generation>Code and Comments
*/
public class Clicker implements Runnable {
int click = 0;
Thread t;
private volatile boolean runing = true;

public Clicker(int p){
  t = new Thread(this);
  t.setPriority(p);
}

/* (non-Javadoc)
* @see java.lang.Runnable#run()
*/
public void run() {
  while(runing){
   click++;
  }

}

public void stop(){
  runing = false;
}

public void start(){
  runing = true;
  t.start();
}

}

主线程类

/*
* Created on 2004-5-8
*
* To change the template for this generated file go to
* Window>Preferences>Java>Code Generation>Code and Comments
*/
package com.jiawh.test.threadPriority;

/**
* @author Administrator
*
* To change the template for this generated type comment go to
* Window>Preferences>Java>Code Generation>Code and Comments
*/
public class Hilo {

public static void main(String[] args) {
  Thread.currentThread().setPriority(Thread.MAX_PRIORITY);
  Clicker c1 = new Clicker(Thread.NORM_PRIORITY + 2);
  Clicker c2 = new Clicker(Thread.NORM_PRIORITY - 2);

  c2.start();
  c1.start();

  try{
   Thread.sleep(10000);
  }catch(InterruptedException e){
   System.out.println("Main thread Interrupted.");
  }

  c1.stop();
  c2.stop();
  try{
   c1.t.join();
   c2.t.join();
  }catch(InterruptedException e){
   System.out.println("InterruptedException caught");
  }
  System.out.println("low priority clicker: " + c2.click);
  System.out.println("hight priority clicker: " + c1.click);
}
}

优先级(priority)的高低影响实际的运行情况，当然程序同样受到操作系统的影响，操作系统必须是有优先级划分的。

注意线程处理类中的volatile关键字，它确保在下边的循环中每次得到验证；

while(runing){
click++;
}

设置主线程的优先级为最大优先级，确保主线程能够抢夺回操作权限，能够进行下边的处理。

- 作者： moses 2004年05月8日,星期六 11:19:41 回复（0 ） | 引用（0 ） | URL

·RequisitePro和Rose和Word结合使用-

在RequisitePro中建立项目，定义项目的需求类型。比如：词汇表、用例、涉众请求、软件需求等。
另外可以定位项目的文档类型，可以建立相应的需求的文档类型。定义文档类型时可以设置关联的需
求类型。另外可以给定义的文档类型选择文档类型的模板。
文档类型的模板的可选列表是在RequisitePro安装目录下的outlines目录下，一个可选项由两个
文件构成，一个文件是模板本身，令一个是前缀同名的def文件，此文件共有3行，第一行，是模板在
RequisitePro中显示的名称，第二行是在RequisitePro中显示的描述，第三行是定义和模板的关
系，是模板的文件名称。
文档类型和需求类型定义完成后可以定义需求属性，默认的需求属性有：优先级、困难程度、稳定性、
等，用户可以自己修改定义需求属性。
以上完成项目的基本设置，为了很好的管理项目，可以在项目里分包管理需求和文档。

建立rose文件，可以为rose文件下的包建立和RequisitePro项目的关联，建立关联时会要求指定
关联的文档类型和需求类型，当在这个包内定义需求时定义的需求的类型和定义的文件的类型都是在
包关联时定义的。
然后在rose中可以为用例定义关联的需求和关联的文档。需求的类型是包关联时指定的。文档的
模板来自于包关联时指定的文档类型的文档模板。

可以在RequisitePro中的用例需求和用例规约文档关联，设置用例规约文档的文档模板为RUP的
用例实现规约。

这样当在rose中定义用例时，可以自动的在需求关联中定义需求的优先级、困难程度等属性，便于
以后的需求跟踪，同时为用例建立用例实现规约文档，清楚的描述用例，在rose中就可以之间打开
用例需求规约文件进行编辑。

用例需求规约文件包括的机构：简要说明，事件流（基本流、备选流），特殊需求，前置条件，后置
条件，扩展点等。
在需求分析过程中关键的是对用例的定义和清楚的描述，描述的主要是在用例的需求规约和rose中，
rose中可以通过各种图形描述用例的不同方面。状态图，活动图和时序图。

- 作者： moses 2004年04月13日,星期二 18:02:29 回复（0 ） | 引用（0 ） | URL

·自定义标签-

使用自定义标签能够减少jsp中使用java script的机会，使得jsp页面更容易的维护。

创建自定义标签的过程：

1、建立标签处理程序。

标签处理程序是一个执行自定义标签操作的java对象。需要实现TAG接口，不必直接实现TAG接口，从TagSupport类继承，TagSupper类实现了Tag接口。

方法	作用
`int doStartTag() throws JspException`	处理开始标签
`int doEndTag() throws JspException`	处理结束标签
`Tag getParent()`/`void setParent(Tag t)`	获得/设置标签的父标签
`void setPageContext(PageContext pc)`	`pageContext` 属性的 setter 方法
`void release()`	释放获得的所有资源

2、创建一个TLD文件。

TLD 文件有一个 导言（preamble），在这里标识 JSP 技术的版本和使用的标签库。这个导言通常看起来像这样：

 <?xml version="1.0" encoding="UTF-8"?>
                        <!DOCTYPE taglib PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN"
                        "http://java./dtd/web-jsptaglibrary_1_2.dtd">
                        <taglib>
                        <tlib-version>1.0</tlib-version>  <!--标签库版本-->
                        <jsp-version>1.2</jsp-version>  <!--对应于标签库所依赖的 JSP 技术的版本-->
                        <short-name>map</short-name>  <!--定义了 IDE 和其他开发工具可以使用的标签库的简单名-->

<tag> <!--定义标签-->
                        <name>mapDefine</name> <!--标签名称-->
                        <tag-class>trivera.tags.map.MapDefineTag</tag-class> <!--标签对应的标签处理类-->
                        <body-content>JSP</body-content>
                           3、在标签处理程序java类中创建属性。

4、在TLD文件中定义和java类中对应的属性。

TLD中的属性必须在java类中有对应的定义，java类中的属性不一定要在TLD中实现。

5、在TLD中声明script变量。

要理解 scriptlet 变量，必须理解 TLD 文件的作用。这个文件基本上是元数据的一个储存库，当

JSP 页转换为 servlet 时，标签会使用这些元数据。在生成的 servlet 中，scriptlet 变量成了本地变量。

要让 JSP 转换引擎知道这些变量应当声明的类型，需要像下面这样在 TLD 文件中增加项：

       <variable>
                        <name-from-attribute>id</name-from-attribute>
                        <variable-class>java.util.Map</variable-class>
                        <scope>AT_BEGIN</scope>
                        </variable>
                        	将上面的代码片断放在 TLD 文件中 body-content 元素之后、attribute 元素之前。

在 variable 元素下面，我们声明了三个子元素：name-from-attribute、variable-class 和

 scope。 name-from-attribute 指定 id 属性的值是转换引擎将要定义的 scriptlet 变量的名字。

variable-class 是转换将要定义的变量的类类型。scope 指定变量什么时候可用：

它可以嵌套到标签的正文中 （NESTED）、在标签结束后 （AT_END）、或者在标签的开始时

（AT_BEGIN）。我们使用 AT_BEGIN 这一范围，它意味着变量的范围将是从标签的开始到当前 JSP

页的结束。

6、实现 java类中的doStartTag() 方法。在标签处理程序类中，根据属性将值设置到 script 变量中。

标签使用：

在jsp中引入标签：<%@taglib uri="map" prefix="map"%>

注意这一页用 map 的 URI 导入了一个自定义标签。之所以能这样是因为我们在 web.xml 文件中声明了这个 TLD，如下所示：

 <web-app>
                        ...
                        <taglib>
                        <taglib-uri>map</taglib-uri>
                        <taglib-location>/WEB-INF/tlds/map.tld</taglib-location>
                        </taglib>

本文来自于对DeveloperWorks中自定义标签教程的学习，参考

http://www-900.ibm.com/developerWorks/cn

/cnonlinetutorial.nsf/gethtml?OpenAgent&url=/developerWorks/cn/education/java

/j-customtags/tutorial/index.html

- 作者： moses 2004年04月8日,星期四 10:32:01 回复（0 ） | 引用（0 ） | URL

·UML业务建模和需求建模-

在使用UML进行面向对象的分析设计过程中应该建立的模型包括

业务模型－业务用例模型

－业务对象模型

需求模型－ use case 建模

分析和设计模型－分析模型

－设计模型

实现模型－ implement 。

模型是逐层深入，逐层细化。

业务用例模型和业务对象模型是对客户现有业务的描述和整理，方便和用户的交流和理清分析人员的思路，他们同属于业务建模的范畴。在现有分析人员中对此部分的重视程度不足，普遍没有建立起业务用例模型而是直接建立需求模型（use case系统用例）。业务对象模型是描述业务用例实现的各个对象，以及对象关系的模型，主要包括业务实体和业务Actor。

业务用例模型中用活动图描述用例的过程。

需求模型（use case模型）（系统用例模型）是建立在对业务用例模型的理解上对系统实现的一种规划的用例。他是系统将要实现的基础。一般分析人员是没有建立业务用例模型而直接建立Use case模型，这并不是不可以，但是要建立在分析人员对所描述的业务有比较充分的了解的基础上。

分析模型是对设计模型的抽象，设计模型是对系统原码框架的描述。具有设计模型，就可以导出系统的原码框架。

设计模型是说明用例实现的对象模型。在用例模型（use case）和设计模型之间应该包括分析模型，分析模型对设计模型的抽象是很重要的，他对于建立强壮的系统至关重要，没有分析模型也可以，但是建立的系统是脆弱的，是直白的，是无法应对业务变化的。

类图描述对象间的静态关系。协作图和序列图是等价的关系，可以相互转换，协作图描述的是对象之间消息的发送关系。

状态图标示一个对象受不同事件影响而表现的不同状态的变化。

设计模型之下就是实现模型了。

- 作者： moses 2004年04月5日,星期一 15:33:11 回复（0 ） | 引用（0 ） | URL

·扩展msn邮箱到25M-

首先告诉大家我已经安装成功。还有就是先记住下面文章的步骤。

这是他的原文

现在很多用msn messenger的朋友都有@msn.com或者@hotmail.com的信箱，因为信箱和im联动实在是很方便的。但是仅仅2m大小的信箱是不能满足大多数人的要求，如果想要升级到msn资深用户，每月9块多美元的服务费估计国内也没谁愿意出。现在可以通过使用微软给付费用户发行的msn9服务光盘里面的安装程序来实现对自己的msn账号升级，不出一分钱可以终身享受资深m sn用户待遇，大家说是不是爽死了？
下面就来说说方法
下载 http://windirt./msn.rar意目录，执行msnsusiisetup.exe

填入你的hotmail/msn邮件和密码。
确定是verizon的dsl用户
关键部分！！！verizon online email就是你的hotmail的用户名，比如你有aaa@hotmail.com的邮箱。那么就是aaa@verizon.net。
地址：任意英文组合
城市：redmond
州：wa（华盛顿）
zip：98052
电话：以 000-0000000 的格式任意数字组合
等看到三个安装项目选择的时候，直接退出就可以了，没有必要安装，因为我们的目标已经达成。
登陆msn信箱察看你的邮箱大小吧

·23种设计模式介绍-

23个设计模式列表

创建型模式... 2

1. Abstract Factory.. 2提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。

2. Builder 2 将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

3. Factory Method.. 3定义一个用于创建对象的接口，让子类决定实例化哪一个类。使一个类的实例化延迟到其子类。

4. Prototype.. 3用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象。

5. Singleton. 3 保证一个类仅有一个实例，并提供一个访问它的全局访问点。

结构型模式... 4

1. Adapter. 4将一个类的接口转换成客户希望的另外一个接口。

2. Bridge.. 4将抽象部分与它的实现部分分离，使它们都可以独立的变化。

3. Composite.. 5将对象组合成树形结构以表示“部分-整体”的层次结构。

4. Decorator. 5动态地给一个对象添加一些额外的职责。

5. Façade.. 6为子系统中的一组接口提供一个一致的界面，Facade模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。

6. Flyweight. 6运用共享技术有效地支持大量细粒度的对象。

7. Proxy.. 7为其它对象提供一种代理以控制对这个对象的访问。

行为模式... 7

1. Chain of Responsibility. 7 使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。

2. Command. 7 将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可撤消的操作。

3. Interpreter. 8给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语句中的句子。

4. Iterator 8 提供一种方法顺序访问一个聚合对象中的各个元素，而不需要暴露该对象的内部表示。

5. Mediator 8 用一个中介对象来封装一系列的对象交互。

6. Memento.. 9在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。

7. Observer 9 定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并自动更新。

8. State.. 9允许一个对象在其内部状态改变时改变它的行为。

9. Strategy. 10 定义一系列的算法，把它们一个个封装起来，并且使它们可以相互替换。

10. Template Method.. 10定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。

11. Visitor. 10表示一个作用于某对象结构中的各元素的操作。

创建型模式

共5种

1. Abstract Factory

抽象工厂
提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。（别名：Kit）
实例描述：

交互图

优缺点

优点：(1)封装创建过程。客户不用知道类厂是如何创建类实例的，类厂封闭了所有创建的细节。这样可选择不同的创建方法，增加了灵活性。 (2)将客户与具体类隔离，提高了各自的可重用性。
缺点：Factory类层次与具体类层次通常是平行的(即一一对应的)。增加一个具体类，一般也要相应地增加一个factory类，增加了系统复杂度。

实现

(1)Abstract Factory类中通常是一组Factory Method的集合。个人认为与Factory Method模式没有本质区别。
(2)通常可以把工厂作为单件。

2. Builder

生成器
将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
各类之间的交互关系如下图所示：

3. Factory Method

工厂方法
定义一个用于创建对象的接口，让子类决定实例化哪一个类。使一个类的实例化延迟到其子类。（别名：虚构造器 Virtual Constructor）

4. Prototype

原型
用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象。

5. Singleton

单件
保证一个类仅有一个实例，并提供一个访问它的全局访问点。

结构型模式

共7种

1. Adapter

适配器
将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能在一起工作的那些类可以一起工作。（别名：包装器 Wrapper）

2. Bridge

桥接
将抽象部分与它的实现部分分离，使它们都可以独立的变化。（别名：Handle/Body）

例如

3. Composite

组合
将对象组合成树形结构以表示“部分-整体”的层次结构。Composite使得用户对单个对象和组合对象的使用具有一致性。

4. Decorator

装饰
动态地给一个对象添加一些额外的职责。就增加功能来说，Decorator模式相比生成子类更为灵活。（别名：包装器Wrapper）

5. Façade

外观
为子系统中的一组接口提供一个一致的界面，Facade模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。

6. Flyweight

享元
运用共享技术有效地支持大量细粒度的对象。

这么模式中最重要的概念是内部状态和外部状态。内部状态存储于flyweight中，包含了独立于flyweight场景的外部状态，这些信息使得flyweight可以被共享；外部状态取决于flyweight场景，并根据场景变化，因此不可共享。用户负责在必要的时候将外部状态传递给flyweight.

1) Remote Proxy 可以隐藏一个对象存在于不同地址空间的事实；
2) Virtual Proxy 可以进行优化，例如在显示包含大图片的文档时，在初始时可以不显示图片，只显示图片的大小，根据需要再创建图片对象，显示图片；
3) Protection Proxies 可以在访问一个对象是附加一些内务处理，如权限验证等
4) Smart Reference 可以智能地管理代理引用的对象，如对引用的对象记数，没有引用时释放对象；为引用对象加锁等；