﻿<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:trackback="http://madskills.com/public/xml/rss/module/trackback/" xmlns:wfw="http://wellformedweb.org/CommentAPI/" xmlns:slash="http://purl.org/rss/1.0/modules/slash/"><channel><title>BlogJava-joan-文章分类-JAVA</title><link>http://www.blogjava.net/joan/category/32988.html</link><description>私は张で

QQ:774199038</description><language>zh-cn</language><lastBuildDate>Fri, 18 Sep 2009 18:12:47 GMT</lastBuildDate><pubDate>Fri, 18 Sep 2009 18:12:47 GMT</pubDate><ttl>60</ttl><item><title>Java 命令行报错E xception in thread "main" java.lang.UnsupportedClassVersionError:</title><link>http://www.blogjava.net/joan/articles/294770.html</link><dc:creator>joan</dc:creator><author>joan</author><pubDate>Fri, 11 Sep 2009 09:26:00 GMT</pubDate><guid>http://www.blogjava.net/joan/articles/294770.html</guid><wfw:comment>http://www.blogjava.net/joan/comments/294770.html</wfw:comment><comments>http://www.blogjava.net/joan/articles/294770.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/joan/comments/commentRss/294770.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/joan/services/trackbacks/294770.html</trackback:ping><description><![CDATA[<p><span style="font-family: Comic Sans MS">好久没有命令行写代码了，今天用下<br />
命令行出错Exception in thread "main" java.lang.UnsupportedClassVersionError: Filter(Unsupp<br />
orted major.minor version 50.0).</span></p>
<p><span style="font-family: Comic Sans MS"><img alt="" src="/CuteSoft_Client/CuteEditor/images/face2.gif" align="absMiddle" border="0" />&nbsp; 一运行就报main 函数出错了，意思是没有找到main 函数的入口。可是代码正确啊。到Eclipse 下试试，一切正常，看来不是它的问题。<br />
<br />
<br />
命令行下输入：javac -version 显示：javac 1.4.2...&nbsp;&nbsp;&nbsp;&nbsp;<br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; java&nbsp; -version 显示：java &nbsp;1.6...&nbsp;&nbsp;&nbsp; <br />
<br />
编译和运行环境的版本怎么不一样，JDK 不是明明1.6 吗？装的是jdk 1.6 的怎么就变成1.4 了？<br />
报错原来是用低版本的JDK编译高版本的.class就会报这个错<br />
<br />
到环境变量查看了半天也没发现问题，忽然发现PATH中oracle中怎么是1.4.2 了，<img alt="" src="/CuteSoft_Client/CuteEditor/images/face7.gif" align="absMiddle" border="0" /><br />
<br />
<br />
C:\Program Files\MySQL\MySQL Server 5.0\bin;D:\oracle\product\10.1.0\Db_4\bin;D:\oracle\product\10.1.0\Db_4\jre\1.4.2\bin\client;D:\oracle\product\10.1.0\Db_4\jre\1.4.2\bin;%SystemRoot%\system32;%SystemRoot%;%SystemRoot%\System32\Wbem;C:\Program Files\Microsoft SQL Server\90\Tools\binn\;C:\Program Files\Microsoft SQL Server\80\Tools\Binn\;C:\Program Files\TortoiseSVN\bin;%JAVA_HOME%\bin;%Path%<br />
<br />
改为：在PATH 最前面加上 %JAVA_HOME%\<br />
<br />
%JAVA_HOME%\bin;C:\Program Files\MySQL\MySQL Server 5.0\bin;D:\oracle\product\10.1.0\Db_4\bin;D:\oracle\product\10.1.0\Db_4\jre\1.4.2\bin\client;D:\oracle\product\10.1.0\Db_4\jre\1.4.2\bin;%SystemRoot%\system32;%SystemRoot%;%SystemRoot%\System32\Wbem;C:\Program Files\Microsoft SQL Server\90\Tools\binn\;C:\Program Files\Microsoft SQL Server\80\Tools\Binn\;C:\Program Files\TortoiseSVN\bin;<br />
<br />
再到DOS 下试试 ，OK ！运行通过。<br />
C:\Documents and Settings\joan&gt;javac -version<br />
javac 1.6.0_02</p>
<p>C:\Documents and Settings\joan&gt;java -version<br />
java version "1.6.0_02"<br />
Java(TM) SE Runtime Environment (build 1.6.0_02-b05)<br />
Java HotSpot(TM) Client VM (build 1.6.0_02-b05, mixed mode, sharing)</p>
<p>C:\Documents and Settings\joan&gt;javac test.java</p>
<p>C:\Documents and Settings\joan&gt;java test</p>
<p>C:\Documents and Settings\joan&gt;<br />
</p>
<p><br />
<br />
<br />
JDK&nbsp;配置 eg：<br />
</p>
<p style="text-indent: 2em">set JAVA_HOME=&nbsp;C:\Program Files\Java\jdk1.6.0_02</p>
<p style="text-indent: 2em">set PATH=%JAVA_HOME%\bin;%PATH%</p>
<p style="text-indent: 2em">set CLASSPATH=.;%JAVA_HOME%\lib</p>
<p>&nbsp;</p>
<p>&nbsp;</p>
<p><br />
</span></p>
<img src ="http://www.blogjava.net/joan/aggbug/294770.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/joan/" target="_blank">joan</a> 2009-09-11 17:26 <a href="http://www.blogjava.net/joan/articles/294770.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>怎样编写Action测试用例 </title><link>http://www.blogjava.net/joan/articles/269891.html</link><dc:creator>joan</dc:creator><author>joan</author><pubDate>Sun, 10 May 2009 05:48:00 GMT</pubDate><guid>http://www.blogjava.net/joan/articles/269891.html</guid><wfw:comment>http://www.blogjava.net/joan/comments/269891.html</wfw:comment><comments>http://www.blogjava.net/joan/articles/269891.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/joan/comments/commentRss/269891.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/joan/services/trackbacks/269891.html</trackback:ping><description><![CDATA[&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 我们通常在开发web应用过程中，展现层Action的单元测试经常被我们忽视了，主要原因是：
<p>　　1、Action层的业务逻辑比较简单。大家潜意识认为这一部分的代码不重要。</p>
<p>　　2、Action层难以模拟http请求传递参数，需要依赖web容器，因此给单元测试编写带来一定的难度。</p>
<p>　　下面是一个简单的Action单元测试用例，供大家参考。基于struts的mock和webwork的ActionProxyFactory都可以进行Action的单元测试。我个人比较倾向与ActionProxyFactory做单元测试。其实写action单元测试非常简单，大致分为三步就可以完成单元测试：</p>
<p>　　一、设置ActionContext上下文参数</p>
<p>　　将表单传递的请求参数添加到map中</p>
<p>　　二、创建Action动态代理对象</p>
<p>　　通过public abstract ActionProxy createActionProxy(String namespace, String actionName, Map extraContext) throws Exception 创建action代理对象。</p>
<p>　　三、junit断言执行结果</p>
<div style="border-right: #cccccc 1px solid; padding-right: 5px; border-top: #cccccc 1px solid; padding-left: 5px; background: #f3f3f3; padding-bottom: 5px; margin: 5px 20px; border-left: #cccccc 1px solid; padding-top: 5px; border-bottom: #cccccc 1px solid">assertEquals(testAction.login(),&#8221;success&#8221;)</div>
<p>　　详细用例参考:</p>
<div style="border-right: #cccccc 1px solid; padding-right: 5px; border-top: #cccccc 1px solid; padding-left: 5px; background: #f3f3f3; padding-bottom: 5px; margin: 5px 20px; border-left: #cccccc 1px solid; padding-top: 5px; border-bottom: #cccccc 1px solid">
<p>　　public class TestActionTest extends BaseCaseTest{</p>
<p>　　private ActionProxy proxy = null;</p>
<p>　　private IVoucherService voucherService;</p>
<p>　　@Before</p>
<p>　　public void setUp() throws Exception {</p>
<p>　　IMocksControl control = EasyMock.createControl();</p>
<p>　　voucherService = control.createMock(IVoucherService.class);</p>
<p>　　Map&lt;String, Object&gt; params = new HashMap&lt;String, Object&gt;();</p>
<p>　　params.put(&#8221;loginId&#8221;,&#8221;test&#8221;);</p>
<p>　　params.put(&#8221;password&#8221;,&#8221;111111&#8243;);</p>
<p>　　params.put(&#8221;voucherService&#8221;, voucherService);</p>
<p>　　Map extraContext = new HashMap();</p>
<p>　　extraContext.put(ActionContext.PARAMETERS,params);</p>
<p>　　try {</p>
<p>　　proxy = ActionProxyFactory.getFactory().createActionProxy(&#8221;/user&#8221;, &#8220;testAction&#8221;, extraContext);</p>
<p>　　proxy.setExecuteResult(false);</p>
<p>　　assertEquals(proxy.execute(),&#8221;success&#8221;);</p>
<p>　　} catch (Exception e) {</p>
<p>　　e.printStackTrace();</p>
<p>　　}</p>
<p>　　}</p>
<p>　　@Test</p>
<p>　　public void testLogin() {</p>
<p>　　TestAction testAction = (TestAction) proxy.getAction();</p>
<p>　　assertEquals(testAction.login(),&#8221;success&#8221;);</p>
<p>　　}</p>
<p>　　}<br />
</p>
</div>
<p>　　注：创建代理action一定要执行proxy.execute()方法，否则参数不能够增加到actionContext上下文中。因为 proxy.execute()中会执行 invocation.invoke()核心方法，遍历执行action中所有的拦截器，包括其中的参数拦截器。<br />
（转载）：testage.net</p>
<img src ="http://www.blogjava.net/joan/aggbug/269891.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/joan/" target="_blank">joan</a> 2009-05-10 13:48 <a href="http://www.blogjava.net/joan/articles/269891.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>Annotation 手册</title><link>http://www.blogjava.net/joan/articles/247211.html</link><dc:creator>joan</dc:creator><author>joan</author><pubDate>Thu, 18 Dec 2008 12:56:00 GMT</pubDate><guid>http://www.blogjava.net/joan/articles/247211.html</guid><wfw:comment>http://www.blogjava.net/joan/comments/247211.html</wfw:comment><comments>http://www.blogjava.net/joan/articles/247211.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/joan/comments/commentRss/247211.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/joan/services/trackbacks/247211.html</trackback:ping><description><![CDATA[<span style="color: red">版权声明：本文可以自由转载，转载时请务必以超链接形式标明文章原始出处和作者信息及本声明</span> <br />
作者:cleverpig(作者的Blog:<a href="http://blog.matrix.org.cn/page/cleverpig" target="_new">http://blog.matrix.org.cn/page/cleverpig</a>)<br />
原文:<a href="http://www.matrix.org.cn/resource/article/44/44055_Java+Annotation+Reflect.html" target="_new">http://www.matrix.org.cn/resource/article/44/44055_Java+Annotation+Reflect.html</a><br />
关键字:java,annotation,reflect<br />
<br />
<br />
<br />
<span style="color: red">阅读提示：文中提到的程序成员或者程序元素是一个概念，指组成程序代码的单元：如类、方法、成员变量。</span><br />
<br />
<span style="color: blue">一、Annotation究竟是什么？</span><br />
<br />
Annotation提供了一条与程序元素关联任何信息或者任何元数据（metadata）的途径。从某些方面看，annotation就像修饰符一样被使用，并应用于包、类型、构造方法、方法、成员变量、参数、本地变量的声明中。这些信息被存储在annotation的&#8220;name=value&#8221;结构对中。annotation类型是一种接口，能够通过java反射API的方式提供对其信息的访问。<br />
<br />
annotation能被用来为某个程序元素（类、方法、成员变量等）关联任何的信息。需要注意的是，这里存在着一个基本的潜规则：annotaion不能影响程序代码的执行，无论增加、删除annotation，代码都始终如一的执行。另外，尽管一些annotation通过java的反射api方法在运行时被访问，而java语言解释器在工作时忽略了这些annotation。正是由于java虚拟机忽略了annotation，导致了annotation类型在代码中是&#8220;不起作用&#8221;的；只有通过某种配套的工具才会对annotation类型中的信息进行访问和处理。本文中将涵盖标准的annotation和meta-annotation类型，陪伴这些annotation类型的工具是java编译器（当然要以某种特殊的方式处理它们）。<br />
<br />
由于上述原因，annotation在使用时十分简便。一个本地变量可以被一个以NonNull命名的annotation类型所标注，来作为对这个本地变量不能被赋予null值的断言。而我们可以编写与之配套的一个annotation代码分析工具，使用它来对具有前面变量的代码进行解析，并且尝试验证这个断言。当然这些代码并不必自己编写。在JDK安装后，在JDK/bin目录中可以找到名为&#8220;apt&#8221;的工具，它提供了处理annotation的框架：它启动后扫描源代码中的annotation，并调用我们定义好的annotation处理器完成我们所要完成的工作（比如验证前面例子中的断言）。说到这里，annotation的强大功能似乎可以替代XDoclet这类的工具了，随着我们的深入，大家会更加坚信这一点。<br />
注：详细描述请参看jsr250规范：<br />
<a href="http://www.jcp.org/aboutJava/communityprocess/pfd/jsr250/" target="_new">http://www.jcp.org/aboutJava/communityprocess/pfd/jsr250/</a><br />
<br />
<span style="color: blue">二、Annotation的定义：</span><br />
<br />
这段文字开始介绍annotation相关技术。在此大家将看到java5.0的标准annotation类型，这种标准类型就是前文中所说的&#8220;内建&#8221;类型，它们可以直接被javac支持。可喜的是，在java6.0beta版中的javac已经加入了对自定义annotation的支持。<br />
<br />
<span style="color: blue">1。Annotation的概念和语法：</span><br />
<br />
首先，关键的概念是理解annotation是与一个程序元素相关联信息或者元数据的标注。它从不影响java程序的执行，但是对例如编译器警告或者像文档生成器等辅助工具产生影响。<br />
<br />
下面是常用的annotation列表，我们应该注意在annotation和annotation类型之间的不同：<br />
<br />
<span style="color: green">A.annotation：</span><br />
annotation使用了在java5.0所带来的新语法，它的行为十分类似public、final这样的修饰符。每个annotation具有一个名字和成员个数&gt;=0。每个annotation的成员具有被称为name=value对的名字和值（就像javabean一样），name=value装载了annotation的信息。<br />
<br />
<span style="color: green">B.annotation类型：</span><br />
annotation类型定义了annotation的名字、类型、成员默认值。一个annotation类型可以说是一个特殊的java接口，它的成员变量是受限制的，而声明annotation类型时需要使用新语法。当我们通过java反射api访问annotation时，返回值将是一个实现了该annotation类型接口的对象，通过访问这个对象我们能方便的访问到其annotation成员。后面的章节将提到在java5.0的java.lang包里包含的3个标准annotation类型。<br />
<br />
<span style="color: green">C.annotation成员：</span><br />
annotation的成员在annotation类型中以无参数的方法的形式被声明。其方法名和返回值定义了该成员的名字和类型。在此有一个特定的默认语法：允许声明任何annotation成员的默认值：一个annotation可以将name=value对作为没有定义默认值的annotation成员的值，当然也可以使用name=value对来覆盖其它成员默认值。这一点有些近似类的继承特性，父类的构造函数可以作为子类的默认构造函数，但是也可以被子类覆盖。<br />
<br />
<span style="color: green">D.marker annotation类型：</span><br />
一个没有成员定义的annotation类型被称为marker annotation。这种annotation类型仅使用自身的存在与否来为我们提供信息。如后面要说的Override。<br />
<br />
<span style="color: green">E.meta-annotation：</span><br />
meta-annotation也称为元annotation，它是被用来声明annotation类型的annotation。Java5.0提供了一些标准的元-annotation类型。下面介绍的target、retention就是meta-annotation。<br />
<br />
<span style="color: green">F.target：</span><br />
annotation的target是一个被标注的程序元素。target说明了annotation所修饰的对象范围：annotation可被用于packages、types（类、接口、枚举、annotation类型）、类型成员（方法、构造方法、成员变量、枚举值）、方法参数和本地变量（如循环变量、catch参数）。在annotation类型的声明中使用了target可更加明晰其修饰的目标。<br />
<br />
<span style="color: green">G.retention：</span><br />
annotation的retention定义了该annotation被保留的时间长短：某些annotation仅出现在源代码中，而被编译器丢弃；而另一些却被编译在class文件中；编译在class文件中的annotation可能会被虚拟机忽略，而另一些在class被装载时将被读取（请注意并不影响class的执行，因为annotation与class在使用上是被分离的）。使用这个meta-annotation可以对annotation的&#8220;生命周期&#8221;限制。<br />
<br />
<span style="color: green">H.metadata：</span><br />
由于metadata被广泛使用于各种计算机开发过程中，所以当我们在这里谈论的metadata即元数据通常指被annotation装载的信息或者annotation本身。<br />
<br />
<span style="color: blue">2。使用标准Annotation：</span><br />
java5.0在java.lang包中定义了3种标准的annotation类型：<br />
<br />
<span style="color: green">A.Override：</span><br />
java.lang.Override是一个marker annotation类型，它被用作标注方法。它说明了被标注的方法重载了父类的方法，起到了断言的作用。如果我们使用了这种annotation在一个没有覆盖父类方法的方法时，java编译器将以一个编译错误来警示。<br />
这个annotaton常常在我们试图覆盖父类方法而确又写错了方法名时发挥威力。<br />
<br />
使用方法极其简单：在使用此annotation时只要在被修饰的方法前面加上@Override。<br />
下面的代码是一个使用@Override修饰一个企图重载父类的toString方法，而又存在拼写错误的sample：<br />
<strong>清单1：</strong><br />
<pre class="overflow"><br />
@Override<br />
public String toSting() {&nbsp;&nbsp; // 注意方法名拼写错了<br />
&nbsp;&nbsp;&nbsp;&nbsp;return "[" + super.toString() + "]";<br />
}<br />
</pre>
<br />
<br />
<span style="color: green">B.Deprecated：</span><br />
同样Deprecated也是一个marker annotation。当一个类型或者类型成员使用@Deprecated修饰的话，编译器将不鼓励使用这个被标注的程序元素。而且这种修饰具有一定的&#8220;延续性&#8221;：如果我们在代码中通过继承或者覆盖的方式使用了这个过时的类型或者成员，虽然继承或者覆盖后的类型或者成员并不是被声明为@Deprecated，但编译器仍然要报警。<br />
值得注意，@Deprecated这个annotation类型和javadoc中的@deprecated这个tag是有区别的：前者是java编译器识别的，而后者是被javadoc工具所识别用来生成文档（包含程序成员为什么已经过时、它应当如何被禁止或者替代的描述）。<br />
在java5.0，java编译器仍然象其从前版本那样寻找@deprecated这个javadoc tag，并使用它们产生警告信息。但是这种状况将在后续版本中改变，我们应在现在就开始使用@Deprecated来修饰过时的方法而不是@deprecated javadoc tag。<br />
<strong>清单2：</strong><br />
<pre class="overflow"><br />
下面是一段使用@Deprecated的代码：<br />
/**<br />
* 这里是javadoc的@deprecated声明.<br />
* @deprecated No one has players for this format any more.&nbsp;&nbsp;Use VHS instead.<br />
*/<br />
@Deprecated public class Betamax { ... }<br />
</pre>
<br />
<br />
<span style="color: green">C.SuppressWarnings：</span><br />
@SuppressWarnings被用于有选择的关闭编译器对类、方法、成员变量、变量初始化的警告。在java5.0，sun提供的javac编译器为我们提供了-Xlint选项来使编译器对合法的程序代码提出警告，此种警告从某种程度上代表了程序错误。例如当我们使用一个generic collection类而又没有提供它的类型时，编译器将提示出"unchecked warning"的警告。<br />
<br />
通常当这种情况发生时，我们就需要查找引起警告的代码。如果它真的表示错误，我们就需要纠正它。例如如果警告信息表明我们代码中的switch语句没有覆盖所有可能的case，那么我们就应增加一个默认的case来避免这种警告。<br />
相仿，有时我们无法避免这种警告，例如，我们使用必须和非generic的旧代码交互的generic collection类时，我们不能避免这个unchecked warning。此时@SuppressWarning就要派上用场了，在调用的方法前增加@SuppressWarnings修饰，告诉编译器停止对此方法的警告。<br />
SuppressWarning不是一个marker annotation。它有一个类型为String[]的成员，这个成员的值为被禁止的警告名。对于javac编译器来讲，被-Xlint选项有效的警告名也同样对@SuppressWarings有效，同时编译器忽略掉无法识别的警告名。<br />
<br />
annotation语法允许在annotation名后跟括号，括号中是使用逗号分割的name=value对用于为annotation的成员赋值：<br />
<strong>清单3：</strong><br />
<pre class="overflow"><br />
@SuppressWarnings(value={"unchecked","fallthrough"})<br />
public void lintTrap() { /* sloppy method body omitted */ }<br />
</pre>
<br />
<br />
在这个例子中SuppressWarnings annotation类型只定义了一个单一的成员，所以只有一个简单的value={...}作为name=value对。又由于成员值是一个数组，故使用大括号来声明数组值。<br />
<br />
注意：我们可以在下面的情况中缩写annotation：当annotation只有单一成员，并成员命名为"value="。这时可以省去"value="。比如将上面的SuppressWarnings annotation进行缩写：<br />
<strong>清单4：</strong><br />
<pre class="overflow"><br />
@SuppressWarnings({"unchecked","fallthrough"})<br />
</pre>
<br />
如果SuppressWarnings所声明的被禁止警告个数为一个时，可以省去大括号：<br />
<pre class="overflow"><br />
@SuppressWarnings("unchecked")<br />
</pre>
<br />
<br />
<span style="color: blue">3。Annotation语法：</span><br />
<br />
在上一个章节中，我们看到书写marker annotation和单一成员annotation的语法。下面本人来介绍一下完整的语法：<br />
<br />
annotation由&#8220;@+annotation类型名称+(..逗号分割的name-value对...)&#8221;组成。其中成员可以按照任何的顺序。如果annotation类型定义了某个成员的默认值，则这个成员可以被省略。成员值必须为编译时常量、内嵌的annotation或者数组。<br />
<br />
下面我们将定义一个annotation类型名为Reviews，它有一个由@Review annotation数组构成的成员。这个@Review annotation类型有三个成员："reviewer"是一个字符串，"comment" 是一个具有默认值的可选的字符串，"grade"是一个Review.Grade枚举类型值。<br />
<strong>清单5：</strong><br />
<pre class="overflow"><br />
@Reviews({&nbsp;&nbsp;// Single-value annotation, so "value=" is omitted here<br />
&nbsp;&nbsp;&nbsp;&nbsp;@Review(grade=Review.Grade.EXCELLENT,<br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;reviewer="df"),<br />
&nbsp;&nbsp;&nbsp;&nbsp;@Review(grade=Review.Grade.UNSATISFACTORY,<br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;reviewer="eg",<br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;comment="This method needs an @Override annotation")<br />
})<br />
</pre>
<br />
annotation语法的另一个重要规则是没有程序成员可以有多于一个的同一annotation实例。例如在一个类中简单的放置多个@Review annotation。这也是在上面代码中定义@Reviews annotation类型数组的原因。<br />
<br />
<span style="color: blue">4。Annotation成员类型和值：</span><br />
<br />
annotation成员必须是非空的编译时常量表达式。可用的成员类型为：primitive类型、, String, Class, enumerated类型, annotation类型, 和前面类型的数组。<br />
<br />
下面我们定义了一个名为UncheckedExceptions 的annotation类型，它的成员是一个扩展了RuntimeException类的类数组。<br />
<strong>清单6：</strong><br />
<pre class="overflow"><br />
@UncheckedExceptions({<br />
&nbsp;&nbsp;&nbsp;&nbsp;IllegalArgumentException.class, StringIndexOutOfBoundsException.class<br />
})<br />
</pre>
<br />
<br />
<span style="color: blue">5。Annotation的目标：</span><br />
<br />
annotation通常被放在类型定义和成员定义的前面。然而它也出现在package、方法参数、本地变量的前面。下面，我们来讨论一下这些不大常用的写法：<br />
<br />
package annotation出现在package声明的前面。<br />
下面的例子package-info.java中不包含任何的公共类型定义，却包含一个可选的javadoc注释。<br />
<strong>清单7：</strong><br />
<pre class="overflow"><br />
/**<br />
* This package holds my custom annotation types.<br />
*/<br />
@com.davidflanagan.annotations.Author("David Flanagan")<br />
package com.davidflanagan.annotations;<br />
</pre>
<br />
当package-info.java文件被编译时，它将产生名为包含annotation（特殊的接口）声明的package-info.class的类。这个接口没有成员，它的名字package-info不是一个合法的java标识，所以它不能用在java源代码中。这个接口的存在只是简单的被看作一个为package annotation准备的占位符。<br />
<br />
用于修饰方法参数、catch参数、本地变量的annotation只是简单的出现在这些程序成员的修饰符位置。java类文件格式没有为本地变量或者catch参数存储annotation作准备，所以这些annotation总是保留在源代码级别（source retention）；方法参数annotation能够保存在类文件中，也可以在保留到运行时。<br />
<br />
最后，请注意，枚举类型定义中不允许任何的修饰符修饰其枚举值。<br />
<br />
<span style="color: blue">6。Annotation和默认值：</span><br />
在Annotation中，没有默认值的成员必须有一个成员值。而如何理解默认值是如何被处理就是一个很重要的细节：annotation类型所定义的成员默认值被存储在class文件中，不被编译到annotation里面。如果我们修改一个annotation类型使其成员的默认值发生了改变，这个改变对于所有此类型的annotation中没有明确提供成员值的成员产生影响（即修改了该成员的成员值）。即使在annotation类型使其成员的默认值被改变后annotation从没被重新编译过，该类型的annotation(改变前已经被编译的)也受到影响。<br />
<br />
<span style="color: blue">三、Annotation工作原理：</span><br />
<br />
<span style="color: blue">Annotation与反射</span><br />
在java5.0中Java.lang.reflect提供的反射API被扩充了读取运行时annotation的能力。让我们回顾一下前面所讲的：一个annotation类型被定义为runtime retention后，它才是在运行时可见，当class文件被装载时被保存在class文件中的annotation才会被虚拟机读取。那么reflect是如何帮助我们访问class中的annotation呢？<br />
<br />
下文将在java.lang.reflect用于annotation的新特性，其中java.lang.reflect.AnnotatedElement是重要的接口，它代表了提供查询annotation能力的程序成员。这个接口被java.lang.Package、java.lang.Class实现，并间接地被Method类、Constructor类、java.lang.reflect的Field类实现。而annotation中的方法参数可以通过Method类、Constructor类的getParameterAnnotations()方法获得。<br />
<br />
下面的代码使用了AnnotatedElement类的isAnnotationPresent()方法判断某个方法是否具有@Unstable annotation，从而断言此方法是否稳定：<br />
<strong>清单8：</strong><br />
<pre class="overflow"><br />
import java.lang.reflect.*;<br />
<br />
Class c = WhizzBangClass.class;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <br />
Method m = c.getMethod("whizzy", int.class, int.class);&nbsp;&nbsp;<br />
boolean unstable = m.isAnnotationPresent(Unstable.class);<br />
</pre>
<br />
isAnnotationPresent()方法对于检查marker annotation是十分有用的，因为marker annotation没有成员变量，所以我们只要知道class的方法是否使用了annotation修饰就可以了。而当处理具有成员的annotation时，我们通过使用getAnnotation()方法来获得annotation的成员信息（成员名称、成员值）。这里我们看到了一套优美的java annotation系统：如果annotation存在，那么实现了相应的annotation类型接口的对象将被getAnnotation()方法返回，接着调用定义在annotation类型中的成员方法可以方便地获得任何成员值。<br />
<br />
回想一下，前面介绍的@Reviews annotation，如果这个annotation类型被声明为runtime retention的话，我们通过下面的代码来访问@Reviews annotation的成员值：<br />
<strong>清单9：</strong><br />
<pre class="overflow"><br />
AnnotatedElement target = WhizzBangClass.class; //获得被查询的AnnotatedElement<br />
// 查询AnnotatedElement的@Reviews annotation信息<br />
Reviews annotation = target.getAnnotation(Reviews.class);<br />
// 因为@Reviews annotation类型的成员为@Review annotation类型的数组，<br />
// 所以下面声明了Review[] reviews保存@Reviews annotation类型的value成员值。<br />
Review[] reviews = annotation.value();<br />
// 查询每个@Review annotation的成员信息<br />
for(Review r : reviews) {<br />
&nbsp;&nbsp;&nbsp;&nbsp;Review.Grade grade = r.grade();<br />
&nbsp;&nbsp;&nbsp;&nbsp;String reviewer = r.reviewer();<br />
&nbsp;&nbsp;&nbsp;&nbsp;String comment = r.comment();<br />
&nbsp;&nbsp;&nbsp;&nbsp;System.out.printf("%s assigned a grade of %s and comment '%s'%n",<br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;reviewer, grade, comment);<br />
}<br />
</pre>
<br />
<br />
<span style="color: blue">四、如何自定义Annotation？</span><br />
<br />
<span style="color: blue">1．详解annotation与接口的异同：</span><br />
因为annotation类型是一个非凡的接口，所以两者之间存在着某些差异：<br />
<br />
<span style="color: green">A.Annotation类型使用关键字@interface而不是interface。</span><br />
这个关键字声明隐含了一个信息：它是继承了java.lang.annotation.Annotation接口，并非声明了一个interface。<br />
<br />
<span style="color: green">B.Annotation类型、方法定义是独特的、受限制的。</span><br />
Annotation类型的方法必须声明为无参数、无异常抛出的。这些方法定义了annotation的成员：方法名成为了成员名，而方法返回值成为了成员的类型。而方法返回值类型必须为primitive类型、Class类型、枚举类型、annotation类型或者由前面类型之一作为元素的一维数组。方法的后面可以使用default和一个默认数值来声明成员的默认值，null不能作为成员默认值，这与我们在非annotation类型中定义方法有很大不同。<br />
Annotation类型和它的方法不能使用annotation类型的参数、成员不能是generic。只有返回值类型是Class的方法可以在annotation类型中使用generic，因为此方法能够用类转换将各种类型转换为Class。<br />
<br />
<span style="color: green">C.Annotation类型又与接口有着近似之处。</span><br />
它们可以定义常量、静态成员类型（比如枚举类型定义）。Annotation类型也可以如接口一般被实现或者继承。<br />
<br />
<span style="color: blue">2．实例：</span><br />
下面，我们将看到如何定义annotation类型的example。它展示了annotation类型声明以及@interface与interface之间的不同：<br />
<strong>清单10：</strong><br />
<pre class="overflow"><br />
package com.davidflanagan.annotations;<br />
import java.lang.annotation.*;<br />
<br />
/**<br />
* 使用annotation来描述那些被标注的成员是不稳定的，需要更改<br />
*/<br />
@Retention(RetentionPolicy.RUNTIME)<br />
public @interface Unstable {}<br />
</pre>
<br />
<br />
下面的另一个example只定义了一个成员。并通过将这个成员命名为value，使我们可以方便的使用这种annotation的快捷声明方式：<br />
<strong>清单11：</strong><br />
<pre class="overflow"><br />
/**<br />
* 使用Author这个annotation定义在程序中指出代码的作者<br />
*/<br />
public @interface Author {<br />
&nbsp;&nbsp;&nbsp;&nbsp;/** 返回作者名 */<br />
&nbsp;&nbsp;&nbsp;&nbsp;String value();<br />
}<br />
</pre>
<br />
<br />
以下的example更加复杂。Reviews annotation类型只有一个成员，但是这个成员的类型是复杂的：由Review annotation组成的数组。Review annotation类型有3个成员：枚举类型成员grade、表示Review名称的字符串类型成员Reviewer、具有默认值的字符串类型成员Comment。<br />
<strong>清单12：</strong><br />
<pre class="overflow"><br />
import java.lang.annotation.*;<br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<br />
/**<br />
* Reviews annotation类型只有一个成员，<br />
* 但是这个成员的类型是复杂的：由Review annotation组成的数组<br />
*/<br />
@Retention(RetentionPolicy.RUNTIME)<br />
public @interface Reviews {<br />
&nbsp;&nbsp;&nbsp;&nbsp;Review[] value();<br />
}<br />
<br />
/**<br />
* Review annotation类型有3个成员： <br />
* 枚举类型成员grade、<br />
&nbsp;&nbsp;* 表示Review名称的字符串类型成员Reviewer、<br />
&nbsp;&nbsp;* 具有默认值的字符串类型成员Comment。<br />
*/<br />
public @interface Review {<br />
&nbsp;&nbsp;&nbsp;&nbsp;// 内嵌的枚举类型<br />
&nbsp;&nbsp;&nbsp;&nbsp;public static enum Grade { EXCELLENT, SATISFACTORY, UNSATISFACTORY };<br />
<br />
&nbsp;&nbsp;&nbsp;&nbsp;// 下面的方法定义了annotation的成员<br />
&nbsp;&nbsp;&nbsp;&nbsp;Grade grade();&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<br />
&nbsp;&nbsp;&nbsp;&nbsp;String reviewer();&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<br />
&nbsp;&nbsp;&nbsp;&nbsp;String comment() default "";&nbsp;&nbsp;<br />
}<br />
</pre>
<br />
<br />
最后，我们来定义一个annotation方法用于罗列出类运行中所有的unchecked异常（上文已经提到这种情况不一定是错误）。这个annotation类型将一个数组作为了唯一的成员。数组中的每个元素都是异常类。为了加强对未检查的异常（此类异常都是在运行时抛出）进行报告，我们可以在代码中对异常的类型进行限制：<br />
<strong>清单13：</strong><br />
<pre class="overflow"><br />
public @interface UncheckedExceptions {<br />
&nbsp;&nbsp;&nbsp;&nbsp;Class&lt;? extends RuntimeException&gt;[] value();<br />
}<br />
</pre>
<br />
<br />
<span style="color: blue">五、Meta-Annotation</span><br />
<br />
Annotation类型可以被它们自己所标注。Java5.0定义了4个标准的meta-annotation类型，它们被用来提供对其它annotation类型作说明。这些类型和它们所支持的类在java.lang.annotation包中可以找到。如果需要更详细的信息可以参考jdk5.0手册。<br />
<br />
<span style="color: blue">1．再谈Target</span><br />
作为meta-annotation类型的Target,它描述了annotation所修饰的程序成员的类型。当一个annotation类型没有Target时，它将被作为普通的annotation看待。当将它修饰一个特定的程序成员时，它将发挥其应用的作用，例如：Override用于修饰方法时，增加了@Target这个meta-annotation就使编译器对annotation作检查，从而去掉修饰错误类型的Override。<br />
<br />
Target meta-annotation类型有唯一的value作为成员。这个成员的类型是java.lang.annotation.ElementType[]类型的，ElementType类型是可以被标注的程序成员的枚举类型。<br />
<br />
<span style="color: blue">2．Retention的用法</span><br />
我们在文章的开头曾经提到过Retention，但是没有详细讲解。Retention描述了annotation是否被编译器丢弃或者保留在class文件；如果保留在class文件中，是否在class文件被装载时被虚拟机读取。默认情况下，annotation被保存在class文件中，但在运行时并不能被反射访问。Retention具有三个取值：source、class、runtime，这些取值来自java.lang.annotation.RetentionPolicy的枚举类型值。<br />
<br />
Retention meta-annotation类型有唯一的value作为成员，它的取值来自java.lang.annotation.RetentionPolicy的枚举类型值。<br />
<br />
<span style="color: blue">3．Documented</span><br />
Documented是一个meta-annotation类型，用于描述其它类型的annotation应该被作为被标注的程序成员的公共API，因此可以被例如javadoc此类的工具文档化。<br />
<br />
Documented是一个marker annotation，没有成员。<br />
<br />
<span style="color: blue">4．Inherited</span><br />
@Inherited meta-annotation也是一个marker annotation，它阐述了某个被标注的类型是被继承的。如果一个使用了@Inherited修饰的annotation类型被用于一个class，则这个annotation将被用于该class的子类。<br />
<br />
注意：@Inherited annotation类型是被标注过的class的子类所继承。类并不从它所实现的接口继承annotation，方法并不从它所重载的方法继承annotation。<br />
<br />
值得思考的是，当@Inherited annotation类型标注的annotation的Retention是RetentionPolicy.RUNTIME，则反射API增强了这种继承性。如果我们使用java.lang.reflect去查询一个@Inherited annotation类型的annotation时，反射代码检查将展开工作：检查class和其父类，直到发现指定的annotation类型被发现，或者到达类继承结构的顶层。<br />
<br />
<span style="color: blue">六、总结：</span><br />
<br />
本文几乎覆盖了所有的Annotation的概念和知识点，从annotation的定义、语法到工作原理、如何自定义annotation，直至meta-annotation。其中也具有一些配套的代码片断可参考，虽然不是很多，但是可谓言简意赅、着其重点，本人认为用好annotation的关键还在于使用。希望本手册能够帮助大家用好annotation，这也是本人的最大快乐。<br />
<img src ="http://www.blogjava.net/joan/aggbug/247211.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/joan/" target="_blank">joan</a> 2008-12-18 20:56 <a href="http://www.blogjava.net/joan/articles/247211.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>Spring,hibernate,struts的面试笔试题（含答案） </title><link>http://www.blogjava.net/joan/articles/245101.html</link><dc:creator>joan</dc:creator><author>joan</author><pubDate>Mon, 08 Dec 2008 13:06:00 GMT</pubDate><guid>http://www.blogjava.net/joan/articles/245101.html</guid><wfw:comment>http://www.blogjava.net/joan/comments/245101.html</wfw:comment><comments>http://www.blogjava.net/joan/articles/245101.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/joan/comments/commentRss/245101.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/joan/services/trackbacks/245101.html</trackback:ping><description><![CDATA[1 Hibernate工作原理及为什么要用？ <br />
原理： <br />
1.读取并解析配置文件 <br />
2.读取并解析映射信息，创建SessionFactory <br />
3.打开Sesssion <br />
4.创建事务Transation <br />
5.持久化操作 <br />
6.提交事务 <br />
7.关闭Session <br />
8.关闭SesstionFactory <br />
<br />
为什么要用： <br />
1.&nbsp; &nbsp; 对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码。 <br />
<br />
2.&nbsp; &nbsp; Hibernate是一个基于JDBC的主流持久化框架，是一个优秀的ORM实现。他很大程度的简化DAO层的编码工作 <br />
<br />
3.&nbsp; &nbsp; hibernate使用Java反射机制，而不是字节码增强程序来实现透明性。 <br />
<br />
4.&nbsp; &nbsp; hibernate的性能非常好，因为它是个轻量级框架。映射的灵活性很出色。它支持各种关系数据库，从一对一到多对多的各种复杂关系。 <br />
<br />
2． Hibernate是如何延迟加载? <br />
1.&nbsp; Hibernate2延迟加载实现：a)实体对象 b)集合（Collection） <br />
<br />
2. Hibernate3 提供了属性的延迟加载功能 <br />
<br />
当Hibernate在查询数据的时候，数据并没有存在与内存中，当程序真正对数据的操作时，对象才存在与内存中，就实现了延迟加载，他节省了服务器的内存开销，从而提高了服务器的性能。 <br />
<br />
3．Hibernate中怎样实现类之间的关系?(如：一对多、多对多的关系) <br />
<br />
类与类之间的关系主要体现在表与表之间的关系进行操作，它们都市对对象进行操作，我们程序中把所有的表与类都映射在一起，它们通过配置文件中的many-to-one、one-to-many、many-to-many、 <br />
<br />
4． 说下Hibernate的缓存机制 <br />
<br />
1. 内部缓存存在Hibernate中又叫一级缓存，属于应用事物级缓存 <br />
<br />
2. 二级缓存： <br />
a) 应用及缓存 <br />
b) 分布式缓存 <br />
条件：数据不会被第三方修改、数据大小在可接受范围、数据更新频率低、同一数据被系统频繁使用、非&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; 关键数据 <br />
c) 第三方缓存的实现 <br />
<br />
5． Hibernate的查询方式 <br />
Sql、Criteria,object comptosition <br />
Hql： <br />
1、 属性查询 <br />
2、 参数查询、命名参数查询 <br />
3、 关联查询 <br />
4、 分页查询 <br />
5、 统计函数 <br />
<br />
6． 如何优化Hibernate？ <br />
1.使用双向一对多关联，不使用单向一对多 <br />
2.灵活使用单向一对多关联 <br />
3.不用一对一，用多对一取代 <br />
4.配置对象缓存，不使用集合缓存 <br />
5.一对多集合使用Bag,多对多集合使用Set <br />
6. 继承类使用显式多态 <br />
7. 表字段要少，表关联不要怕多，有二级缓存撑腰 <br />
<br />
<br />
7． Struts工作机制？为什么要使用Struts？ <br />
工作机制： <br />
Struts的工作流程: <br />
在web应用启动时就会加载初始化ActionServlet,ActionServlet从 <br />
struts-config.xml文件中读取配置信息,把它们存放到各种配置对象 <br />
当ActionServlet接收到一个客户请求时,将执行如下流程. <br />
&nbsp; &nbsp; -(1)检索和用户请求匹配的ActionMapping实例,如果不存在,就返回请求路径无效信息; <br />
&nbsp; &nbsp; -(2)如果ActionForm实例不存在,就创建一个ActionForm对象,把客户提交的表单数据保存到ActionForm对象中; <br />
&nbsp; &nbsp; -(3)根据配置信息决定是否需要表单验证.如果需要验证,就调用ActionForm的validate()方法; <br />
&nbsp; &nbsp; -(4)如果ActionForm的validate()方法返回null或返回一个不包含ActionMessage的ActuibErrors对象, 就表示表单验证成功; <br />
&nbsp; &nbsp; -(5)ActionServlet根据ActionMapping所包含的映射信息决定将请求转发给哪个Action,如果相应的&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; Action实例不存在,就先创建这个实例,然后调用Action的execute()方法; <br />
&nbsp; &nbsp; -(6)Action的execute()方法返回一个ActionForward对象,ActionServlet在把客户请求转发给 ActionForward对象指向的JSP组件; <br />
&nbsp; &nbsp; -(7)ActionForward对象指向JSP组件生成动态网页,返回给客户; <br />
<br />
为什么要用： <br />
JSP、Servlet、JavaBean技术的出现给我们构建强大的企业应用系统提供了可能。但用这些技术构建的系统非常的繁乱，所以在此之上，我们需要一个规则、一个把这些技术组织起来的规则，这就是框架，Struts便应运而生。 <br />
<br />
基于Struts开发的应用由3类组件构成：控制器组件、模型组件、视图组件 <br />
<br />
8． Struts的validate框架是如何验证的？ <br />
在struts配置文件中配置具体的错误提示，再在FormBean中的validate()方法具体调用。 <br />
<br />
9． 说下Struts的设计模式 <br />
MVC模式: web应用程序启动时就会加载并初始化ActionServler。用户提交表单时，一个配置好的ActionForm对象被创建，并被填入表单相应的数据，ActionServler根据Struts-config.xml文件配置好的设置决定是否需要表单验证，如果需要就调用ActionForm的Validate（）验证后选择将请求发送到哪个Action，如果Action不存在，ActionServlet会先创建这个对象，然后调用Action的execute（）方法。Execute（）从ActionForm对象中获取数据，完成业务逻辑，返回一个ActionForward对象，ActionServlet再把客户请求转发给ActionForward对象指定的jsp组件，ActionForward对象指定的jsp生成动态的网页，返回给客户。 <br />
<br />
10． spring工作机制及为什么要用? <br />
1.spring mvc请所有的请求都提交给DispatcherServlet,它会委托应用系统的其他模块负责负责对请求进行真正的处理工作。 <br />
2.DispatcherServlet查询一个或多个HandlerMapping,找到处理请求的Controller. <br />
3.DispatcherServlet请请求提交到目标Controller <br />
4.Controller进行业务逻辑处理后，会返回一个ModelAndView <br />
5.Dispathcher查询一个或多个ViewResolver视图解析器,找到ModelAndView对象指定的视图对象 <br />
6.视图对象负责渲染返回给客户端。 <br />
<br />
为什么用： <br />
{AOP 让开发人员可以创建非行为性的关注点，称为横切关注点，并将它们插入到应用程序代码中。使用 AOP 后，公共服务&nbsp; （比 如日志、持久性、事务等）就可以分解成方面并应用到域对象上，同时不会增加域对象的对象模型的复杂性。 <br />
&nbsp; &nbsp; IOC 允许创建一个可以构造对象的应用环境，然后向这些对象传递它们的协作对象。正如单词 倒置 所表明的，IOC 就像反 过来的 JNDI。没有使用一堆抽象工厂、服务定位器、单元素（singleton）和直接构造（straight construction），每一个对象都是用其协作对象构造的。因此是由容器管理协作对象（collaborator）。 <br />
Spring即使一个AOP框架，也是一IOC容器。 Spring 最好的地方是它有助于您替换对象。有了 Spring，只要用 JavaBean 属性和配置文件加入依赖性（协作对象）。然后可以很容易地在需要时替换具有类似接口的协作对象。} <br />
<img src ="http://www.blogjava.net/joan/aggbug/245101.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/joan/" target="_blank">joan</a> 2008-12-08 21:06 <a href="http://www.blogjava.net/joan/articles/245101.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>构建linux下IDE环境--Eclipse篇</title><link>http://www.blogjava.net/joan/articles/232598.html</link><dc:creator>joan</dc:creator><author>joan</author><pubDate>Mon, 06 Oct 2008 01:44:00 GMT</pubDate><guid>http://www.blogjava.net/joan/articles/232598.html</guid><wfw:comment>http://www.blogjava.net/joan/comments/232598.html</wfw:comment><comments>http://www.blogjava.net/joan/articles/232598.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/joan/comments/commentRss/232598.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/joan/services/trackbacks/232598.html</trackback:ping><description><![CDATA[<table cellspacing="0" cellpadding="0" width="90%" align="center" border="0">
    <tbody>
        <tr>
            <th class="f24">
            <h1><span style="color: #000000"><span style="color: #003366">构建linux下IDE环境--Eclipse篇</span></span></h1>
            </th>
        </tr>
        <tr>
            <td align="center" height="20"><span style="color: #000000"></span></td>
        </tr>
        <tr>
            <td><span style="color: #000000"><br />
            </span></td>
        </tr>
        <tr>
            <td class="l17"><font class="f14" id="zoom"><font color="#cccccc"><!-- 正文begin --><!--startfragment --><span style="color: #000000"><span style="color: #003366">&nbsp;<br />
            <!-- message --></span></span>
            <div><span style="color: #000000"><span style="color: #003366">摘要 <br />
            <br />
            Eclipse是一由ibm，borland等资助的开源开发环境；其功能可以通过插件方式进行扩展；本文在linux下构建java、c、c＋＋的IDE。 <br />
            <br />
            我用的环境是 red hat linux 9 （自编译gnome2.4） <br />
            <br />
            一：下载所需软件（所有下载的软件均放在/opt下） <br />
            <br />
            先下载 Eclipse，网址为 </span></span><a href="http://www.eclipse.org/" target="_blank"><span style="color: #000000"><span style="color: #003366">http://www.eclipse.org</span></span></a><span style="color: #000000"><span style="color: #003366"> 目前，Eclipse的最新版本为2.1.1，3.0版也正在测试中。我使用eclipse2.1；下载其gtk版本：eclipse-SDK-2.1.1-linux-gtk.zip <br />
            <br />
            执行 Eclipse是须用到JDK，但Eclipse的安装程序和Red Hat Linux 9 里没有包含JDK，Sun 最新版本的 JDK可到 </span></span><a href="http://java.sun.com%e4%b8%8b%e8%bd%bd%ef%bc%8c%e5%9c%a8%e6%ad%a4%e6%88%91%e4%bb%ac%e4%bd%bf%e7%94%a8%e7%9a%84%e6%98%afsun/" target="_blank"><span style="color: #000000"><span style="color: #003366">http://java.sun.com下载，在此我们使用的是sun</span></span></a><span style="color: #000000"><span style="color: #003366"> jdk (J2SE) 1.4.2_01版（也可使用IBM的jdk）。 <br />
            <br />
            要在Eclipse 上面开发C/C++程序，需要另外安装plug-ins，在此我们使用的是C/C++ Development Tools（CDT）。CDT 整合了gcc、make、gdb等GUN 工具，（CDT 与Eclipse 中内建的JDT（Java 开发环境）比起来，功能还差得远。例如，在JDT 中相当好用的Refactor、Refactoring、Organize Imports等在CDT 中都没有。）CDT 可从</span></span><a href="http://www.eclipse.org/cdt/" target="_blank"><span style="color: #000000"><span style="color: #003366">http://www.eclipse.org/cdt/</span></span></a><span style="color: #000000"><span style="color: #003366"> 下载，目前最新版本为CDT 1.1 GA2 . <br />
            <br />
            二 ：安装 <br />
            <br />
            1.由于cdt需要gcc等工具，所以要先把red hat9的软件开发包装上， <br />
            <br />
            2.安装JDK（需以root身分安装）： <br />
            <br />
            [root@redarmy] chmod ＋x j2sdk-1_4_2_01-linux-i586-rpm.bin<br />
            [root@redarmy] ./j2sdk-1_4_2_01-linux-i586-rpm.bin<br />
            [root@redarmy] rpm &#8211;ivh j2sdk-1_4_2_01-linux-i586-rpm.bin<br />
            <br />
            <br />
            <br />
            安装好的JDK 会存在 /usr/java/j2sdk1.4.2_01 目录中。 <br />
            <br />
            设定JAVA_HOME,CLASSPATH,PATH; 在/etc/profile文件最后加如下四行： <br />
            <br />
            export JAVA_HOME = /usr/java/j2sdk1.4.2_01 <br />
            export PATH = $JAVA_HOME/bin:$PATH<br />
            CLASSPATH=.:/usr/java/j2sdk1.4.2_01/lib/tools.jar:$CLASSPATH<br />
            export CLASSPATH<br />
            <br />
            <br />
            <br />
            3.安裝Eclipse <br />
            <br />
            在此我把Eclipse安装在 /opt 下，安装Eclipse很简单，只要把下载回来的压缩包解压就可以了；解压后得到eclipse目录； <br />
            <br />
            [root@redarmy] unzip &#8211;d /opt eclipse-SDK-2.1.1-linux-gtk.zip <br />
            <br />
            为让每一个帐号都可以执行Eclipse，我写了个小脚本（eclipse.sh）： <br />
            <br />
            #!/bin/bash<br />
            #<br />
            # 执行 eclipse 2.1.1 <br />
            #<br />
            export JAVA_HOME=/usr/java/j2sdk1.4.2_01<br />
            export CLASSPATH=/usr/java/j2sdk1.4.2_01/lib<br />
            /opt/eclipse/eclipse -vm /usr/java/j2sdk1.4.2_01/bin/java -data ~/workspace &amp;<br />
            # -vm 参数用以指定使用哪一个 jvm 来执行Eclipse，<br />
            # -date参数用以指定Eclipse的数据目录。在此指定其存在用户根目录(~)下的workspace目录中<br />
            <br />
            <br />
            <br />
            将eclipse.sh 复制到/usr/local/bin中，并为它加上权限755；现在执行 eclipse.sh 即可启动 Eclipse。 <br />
            <br />
            [root@redarmy] cp eclipse.sh /usr/local/bin<br />
            [root@redarmy] chmod 755 /usr/local/bin/eclipse.sh<br />
            <br />
            <br />
            <br />
            将eclipse添加到桌面。首先，在桌面上按下鼠标右键，在弹出菜单中选择&#8220;新增启动&#8221;，之后分別在&#8220;名称&#8221;中输入Eclipse、&#8220;命令&#8221;中填 /usr/local/bin/eclipse.sh，然后再为它随便找个喜欢的图标（我用的是/opt/eclipse/icon.xpm）;再后按 &#8220;确定&#8221;，桌面上就有eclipse的快捷方式了，以后可以直接双击这个图标启动Eclipse。 <br />
            <br />
            Eclipse 安装好后，已经内建了java开发环境（JDT）就可以直接开发Java 程序。 <br />
            <br />
            4.安装cdt，CDT 1.1 GA 目前只支持Eclipse 2.1 版。 <br />
            <br />
            将下载的包解压，会得到features 和plugins 这两个目录 <br />
            <br />
            [root@redarmy] unzip &#8211;d /opt org.eclipse.cdt-linux.gtk_1.1.0.bin.dist.zip <br />
            <br />
            分别将这两个目录中的所有文件分别剪到/opt/eclipse下的对应目录里，即可。（Eclipse 的插件安裝方法几乎都这样安装： 把文件下载后， 直接解到eclipse所安装的目录中对应的features 和plugins 中即可。） <br />
            <br />
            三：附 <br />
            <br />
            要是不习惯，eclipse英文环境，可以在eclipse.org的主站上下，它的语言包；装了语言包后，不光菜单成中文了，它的帮助文档也成中文了，爽吧^_^ </span></span></div>
            <!-- 正文end --><br />
            <span style="color: #000000"><span style="color: #003366">(http://www.fanqiang.com)<br />
            </span></span></font></font></td>
        </tr>
    </tbody>
</table>
  <img src ="http://www.blogjava.net/joan/aggbug/232598.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/joan/" target="_blank">joan</a> 2008-10-06 09:44 <a href="http://www.blogjava.net/joan/articles/232598.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item></channel></rss>