常见异常解析

ConcurrentHashMap与CopyOnWriteArrayList比较。

博客分类：
Java

ConcurrentHashMap
ConcurrentHashMap引入了Segment，每个Segment又是一个hashtable，相当于是两级Hash表，然后锁是在Segment一级进行的，提高了并发性。缺点是对整个集合进行操作的方法如 size() 或 isEmpty()的实现很困难，基本无法得到精准的数据。Segment的read不加锁，只有在读到null的情况(一般不会有null的，只有在其他线程操作Map的时候，所以就用锁来等他操作完）下调用了readValueUnderLock。数据存储是采用hash表的方式将元素分布在各bucket之间，当遍历一个hash表的bucket以期找到某一特定的key时， get() 必须对大量的候选bucket调用 Object.equals() 。如果key类所使用的 hashCode() 函数不能将value均匀地分布在整个hash表范围内，或者存在大量的hash冲突，那么某些bucket链就会比其他的链长很多，而遍历一个长的hash链以及对该hash链上一定百分比的元素调用 equals() 是一件很慢的事情，所以会影响迭代效率。

CopyOnWriteArrayList
CopyOnWriteArrayList是ArrayList 的一个线程安全的变体，ArrayList实现了RandomAccess接口，表明其支持快速的随机访问。读的时候就是在引用的当前对象上进行读（包括get，iterator等），不存在加锁和阻塞，针对iterator使用了一个叫COWIterator 的阉割版迭代器，因此不支持写操作，当获取CopyOnWriteArrayList的迭代器时，是将迭代器里的数据引用指向当前引用指向的数据对象，无论未来发生什么写操作，都不会再更改迭代器里的数据对象引用，所以迭代器也很安全。CopyOnWriteArrayList中写操作需要大面积复制数组，所以性能肯定很差，读操作和写操作针对的不是同一个对象，所以读之间也不需要加锁，读和写之间的同步处理只是在写完后通过一个简单的“=”将引用指向新的数组对象上来。适合使用在读操作远远大于写操作的场景。

10:24
评论 / 浏览 (2 / 112)
论坛回复 / 浏览 (2 / 735)
收藏
分类:编程语言

2010-03-24
缩略显示
Servlet与Struts action线程安全问题分析

博客分类：
Java

ServletStruts多线程浏览器设计模式

Servlet/JSP技术和ASP、PHP等相比，由于其多线程运行而具有很高的执行效率。由于Servlet/JSP默认是以多线程模式执行的，所以，在编写代码时需要非常细致地考虑多线程的安全性问题。然而，很多人编写Servlet/JSP程序时并没有注意到多线程安全性的问题，这往往造成编写的程序在少量用户访问时没有任何问题，而在并发用户上升到一定值时，就会经常出现一些莫明其妙的问题。

　　Servlet的多线程机制
　
　　Servlet体系结构是建立在Java多线程机制之上的，它的生命周期是由Web容器负责的。当客户端第一次请求某个Servlet时，Servlet容器将会根据web.xml配置文件实例化这个Servlet类。当有新的客户端请求该Servlet时，一般不会再实例化该Servlet类，也就是有多个线程在使用这个实例。Servlet容器会自动使用线程池等技术来支持系统的运行，如图1所示。

图1 Servlet线程池


　　这样，当两个或多个线程同时访问同一个Servlet时，可能会发生多个线程同时访问同一资源的情况，数据可能会变得不一致。所以在用Servlet构建的Web应用时如果不注意线程安全的问题，会使所写的Servlet程序有难以发现的错误。

　　Servlet的线程安全问题

　　Servlet的线程安全问题主要是由于实例变量使用不当而引起的，这里以一个现实的例子来说明。
Import javax.servlet. *;
Import javax.servlet.http. *;
Import java.io. *;
Public class Concurrent Test extends HttpServlet {PrintWriter output;
Public void service (HttpServletRequest request,
HttpServletResponse response) throws ServletException, IOException {String username;
Response.setContentType ("text/html; charset=gb2312");
Username = request.getParameter ("username");
Output = response.getWriter ();
Try {Thread. sleep (5000); //为了突出并发问题，在这设置一个延时
} Catch (Interrupted Exception e){}
output.println("用户名:"+Username+"<BR>");
}
}


　　该Servlet中定义了一个实例变量output，在service方法将其赋值为用户的输出。当一个用户访问该Servlet时，程序会正常的运行，但当多个用户并发访问时，就可能会出现其它用户的信息显示在另外一些用户的浏览器上的问题。这是一个严重的问题。为了突出并发问题，便于测试、观察，我们在回显用户信息时执行了一个延时的操作。假设已在web.xml配置文件中注册了该Servlet，现有两个用户a和b同时访问该Servlet（可以启动两个IE浏览器，或者在两台机器上同时访问）,即同时在浏览器中输入：

　　a： http://localhost: 8080/servlet/ConcurrentTest? Username=a

　　b： http://localhost: 8080/servlet/ConcurrentTest? Username=b

　　如果用户b比用户a回车的时间稍慢一点，将得到如图2所示的输出：

图2 a用户和b用户的浏览器输出


　　从图2中可以看到，Web服务器启动了两个线程分别处理来自用户a和用户b的请求，但是在用户a的浏览器上却得到一个空白的屏幕，用户a的信息显示在用户b的浏览器上。该Servlet存在线程不安全问题。下面我们就从分析该实例的内存模型入手,观察不同时刻实例变量output的值来分析使该Servlet线程不安全的原因。

　　Java的内存模型JMM（Java Memory Model）JMM主要是为了规定了线程和内存之间的一些关系。根据JMM的设计，系统存在一个主内存(Main Memory)，Java中所有实例变量都储存在主存中，对于所有线程都是共享的。每条线程都有自己的工作内存(Working Memory)，工作内存由缓存和堆栈两部分组成，缓存中保存的是主存中变量的拷贝，缓存可能并不总和主存同步，也就是缓存中变量的修改可能没有立刻写到主存中；堆栈中保存的是线程的局部变量，线程之间无法相互直接访问堆栈中的变量。根据JMM，我们可以将论文中所讨论的Servlet实例的内存模型抽象为图3所示的模型。

图3 Servlet实例的JMM模型


　　下面根据图3所示的内存模型，来分析当用户a和b的线程（简称为a线程、b线程）并发执行时，Servlet实例中所涉及变量的变化情况及线程的执行情况，如图4所示。
调度时刻 a线程 b线程
T1 访问Servlet页面
T2 访问Servlet页面
T3 output=a的输出username=a休眠5000毫秒，让出CPU
T4 output=b的输出（写回主存）username=b休眠5000毫秒，让出CPU
T5 在用户b的浏览器上输出a线程的username的值,a线程终止。
T6 在用户b的浏览器上输出b线程的username的值,b线程终止。

　　　　　　　　　　　　　　　　　　图4 Servlet实例的线程调度情况

　　从图4中可以清楚的看到，由于b线程对实例变量output的修改覆盖了a线程对实例变量output的修改，从而导致了用户a的信息显示在了用户b的浏览器上。如果在a线程执行输出语句时，b线程对output的修改还没有刷新到主存，那么将不会出现图2所示的输出结果，因此这只是一种偶然现象，但这更增加了程序潜在的危险性。


设计线程安全的Servlet

　　通过上面的分析，我们知道了实例变量不正确的使用是造成Servlet线程不安全的主要原因。下面针对该问题给出了三种解决方案并对方案的选取给出了一些参考性的建议。

　　1、实现 SingleThreadModel 接口

　　该接口指定了系统如何处理对同一个Servlet的调用。如果一个Servlet被这个接口指定,那么在这个Servlet中的service方法将不会有两个线程被同时执行，当然也就不存在线程安全的问题。这种方法只要将前面的Concurrent Test类的类头定义更改为：
Public class Concurrent Test extends HttpServlet implements SingleThreadModel {
…………
}


　　2、同步对共享数据的操作

　　使用synchronized 关键字能保证一次只有一个线程可以访问被保护的区段，在本论文中的Servlet可以通过同步块操作来保证线程的安全。同步后的代码如下：
…………
Public class Concurrent Test extends HttpServlet { …………
Username = request.getParameter ("username");
Synchronized (this){
Output = response.getWriter ();
Try {
Thread. Sleep (5000);
} Catch (Interrupted Exception e){}
output.println("用户名:"+Username+"<BR>");
}
}
}


　　3、避免使用实例变量

　　本实例中的线程安全问题是由实例变量造成的，只要在Servlet里面的任何方法里面都不使用实例变量，那么该Servlet就是线程安全的。

　　修正上面的Servlet代码，将实例变量改为局部变量实现同样的功能，代码如下：
……
Public class Concurrent Test extends HttpServlet {public void service (HttpServletRequest request, HttpServletResponse
Response) throws ServletException, IOException {
Print Writer output;
String username;
Response.setContentType ("text/html; charset=gb2312");
……
}
}


　　对上面的三种方法进行测试，可以表明用它们都能设计出线程安全的Servlet程序。但是，如果一个Servlet实现了SingleThreadModel接口，Servlet引擎将为每个新的请求创建一个单独的Servlet实例，这将引起大量的系统开销。SingleThreadModel在Servlet2.4中已不再提倡使用；同样如果在程序中使用同步来保护要使用的共享的数据，也会使系统的性能大大下降。这是因为被同步的代码块在同一时刻只能有一个线程执行它，使得其同时处理客户请求的吞吐量降低，而且很多客户处于阻塞状态。另外为保证主存内容和线程的工作内存中的数据的一致性，要频繁地刷新缓存,这也会大大地影响系统的性能。所以在实际的开发中也应避免或最小化 Servlet 中的同步代码；在Serlet中避免使用实例变量是保证Servlet线程安全的最佳选择。从Java 内存模型也可以知道，方法中的临时变量是在栈上分配空间，而且每个线程都有自己私有的栈空间，所以它们不会影响线程的安全。

　　小结

　　Servlet的线程安全问题只有在大量的并发访问时才会显现出来，并且很难发现，因此在编写Servlet程序时要特别注意。线程安全问题主要是由实例变量造成的,因此在Servlet中应避免使用实例变量。如果应用程序设计无法避免使用实例变量，那么使用同步来保护要使用的实例变量，但为保证系统的最佳性能，应该同步可用性最小的代码路径。因为Struts的Action被设计为线程不安全的，所以也涉及到这个问题，所以也使用同样的方法来解决！



原文： http://hi.baidu.com/platon/blog/item/64a20ff3f96e7fce0b46e031.html

19:45
评论 / 浏览 (1 / 143)
收藏
分类:企业架构

2010-03-24
缩略显示
JVM调优

博客分类：
Java

JVM多线程HPperformance中间件
原文： http://blog.csdn.net/tyrone1979/archive/2006/09/25/1274458.aspx

1. Heap设定与垃圾回收
Java Heap分为3个区，Young，Old和Permanent。Young保存刚实例化的对象。当该区被填满时，GC会将对象移到Old区。Permanent区则负责保存反射对象，本文不讨论该区。
JVM的Heap分配可以使用-X参数设定，
-Xms

初始Heap大小
-Xmx

java heap最大值
-Xmn

young generation的heap大小
JVM有2个GC线程。第一个线程负责回收Heap的Young区。第二个线程在Heap不足时，遍历Heap，将Young 区升级为Older区。Older区的大小等于-Xmx减去-Xmn，不能将-Xms的值设的过大，因为第二个线程被迫运行会降低JVM的性能。
为什么一些程序频繁发生GC？有如下原因：
l 程序内调用了System.gc()或Runtime.gc()。
l 一些中间件软件调用自己的GC方法，此时需要设置参数禁止这些GC。
l Java的Heap太小，一般默认的Heap值都很小。
l 频繁实例化对象，Release对象。此时尽量保存并重用对象，例如使用StringBuffer()和String()。
如果你发现每次GC后，Heap的剩余空间会是总空间的50%，这表示你的Heap处于健康状态。许多Server端的Java程序每次GC后最好能有65%的剩余空间。
经验之谈：
1．Server端JVM最好将-Xms和-Xmx设为相同值。为了优化GC，最好让-Xmn值约等于-Xmx的1/3[2]。
2．一个GUI程序最好是每10到20秒间运行一次GC，每次在半秒之内完成[2]。

注意：
1．增加Heap的大小虽然会降低GC的频率，但也增加了每次GC的时间。并且GC运行时，所有的用户线程将暂停，也就是GC期间，Java应用程序不做任何工作。
2．Heap大小并不决定进程的内存使用量。进程的内存使用量要大于-Xmx定义的值，因为Java为其他任务分配内存，例如每个线程的Stack等。

2．Stack的设定
每个线程都有他自己的Stack。
-Xss

每个线程的Stack大小
Stack的大小限制着线程的数量。如果Stack过大就好导致内存溢漏。-Xss参数决定Stack大小，例如-Xss1024K。如果Stack太小，也会导致Stack溢漏。
3．硬件环境
硬件环境也影响GC的效率，例如机器的种类，内存，swap空间，和CPU的数量。
如果你的程序需要频繁创建很多transient对象，会导致JVM频繁GC。这种情况你可以增加机器的内存，来减少Swap空间的使用[2]。
4．4种GC
第一种为单线程GC，也是默认的GC。，该GC适用于单CPU机器。
第二种为Throughput GC，是多线程的GC，适用于多CPU，使用大量线程的程序。第二种GC与第一种GC相似，不同在于GC在收集Young区是多线程的，但在Old区和第一种一样，仍然采用单线程。-XX:+UseParallelGC参数启动该GC。
第三种为Concurrent Low Pause GC，类似于第一种，适用于多CPU，并要求缩短因GC造成程序停滞的时间。这种GC可以在Old区的回收同时，运行应用程序。-XX:+UseConcMarkSweepGC参数启动该GC。
第四种为Incremental Low Pause GC，适用于要求缩短因GC造成程序停滞的时间。这种GC可以在Young区回收的同时，回收一部分Old区对象。-Xincgc参数启动该GC。
4种GC的具体描述参见[3]。

参考文章：
1. JVM Tuning. http://www.caucho.com/resin-3.0/performance/jvm-tuning.xtp#garbage-collection
2. Performance tuning Java: Tuning steps
http://h21007.www2.hp.com/dspp/tech/tech_TechDocumentDetailPage_IDX/1,1701,1604,00.html
3. Tuning Garbage Collection with the 1.4.2 JavaTM Virtual Machine .
http://java.sun.com/docs/hotspot/gc1.4.2/

19:37
评论 / 浏览 (0 / 179)
收藏
分类:编程语言

2010-03-16
缩略显示
HttpURLConnection VS HttpClient性能测试

博客分类：
Java

JavaApache.netHibernate多线程

版本： HttpURLConnection jdk1.6；HttpClient 3.0.1

在项目中有一个特别小的相关应用，在选择时做了一下测试，之前先对两个类进行下说明：

HttpURLConnection java的标准类(java.net)

HttpClient Jakarta Commons HttpClient，提供对HTTP协议访问的封装，包括http的请求头，参数，内容体，响应等及多线程的应用。



测试代码：
Java代码

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;

import org.apache.commons.httpclient.DefaultHttpMethodRetryHandler;
import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.HttpException;
import org.apache.commons.httpclient.HttpStatus;
import org.apache.commons.httpclient.methods.GetMethod;
import org.apache.commons.httpclient.params.HttpMethodParams;

public class HttpClientTest {

private static String link = "http://www.baidu.com";

public static void main(String[] args) {
long a = System.currentTimeMillis();
useHttpURlConnection();
long b = System.currentTimeMillis();
System.out.println("use httpurlconnection: "+(b-a));
long c = System.currentTimeMillis();
useHttpClient();
long d = System.currentTimeMillis();
System.out.println("use httpclient: "+(d-c));
}

public static void useHttpURlConnection(){
HttpURLConnection conn = null;
URL url = null;
String result = "";
try {
url = new java.net.URL(link);
conn = (HttpURLConnection) url.openConnection();
conn.setConnectTimeout(10000);
conn.connect();

InputStream urlStream = conn.getInputStream();
BufferedReader reader = new BufferedReader(new InputStreamReader(urlStream));
String s = "";
while ((s = reader.readLine()) != null) {
result += s;
}
System.out.println(result);
reader.close();
urlStream.close();
conn.disconnect();
} catch (MalformedURLException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch(Exception e){
e.printStackTrace();
}
}

public static void useHttpClient(){
HttpClient client = new HttpClient();
GetMethod method = new GetMethod(link);
method.getParams().setParameter(HttpMethodParams.RETRY_HANDLER,
new DefaultHttpMethodRetryHandler(3, false));
try {
int statusCode = client.executeMethod(method);

if (statusCode != HttpStatus.SC_OK) {
System.err.println("Method failed: " + method.getStatusLine());
}
byte[] responseBody = method.getResponseBody();
System.out.println(new String(responseBody));
} catch (HttpException e) {
System.err.println("Fatal protocol violation: " + e.getMessage());
e.printStackTrace();
} catch (IOException e) {
System.err.println("Fatal transport error: " + e.getMessage());
e.printStackTrace();
} finally {
method.releaseConnection();
}
}
}



测试结果：

use httpurlconnection: 47

use httpclient: 641



结果很明显示，但是在实际应用中，还是应该根据实际的需求进行取舍。

14:19
评论 / 浏览 (1 / 1808)
收藏
分类:编程语言

2010-02-03
缩略显示
jdk 1.6新特性

博客分类：
Java

JDKJava网络应用应用服务器网络协议

2006 年底，Sun 公司发布了 Java Standard Edition 6（Java SE 6）的最终正式版，代号 Mustang（野马）。Java 平台的第六个版本, Standard Edition (Java SE), 代号Mustang, 发布了第二个Beta版本.

这一次,是时隔4个月发布第二次Beta版本.

Java SE 6 Beta 2 (Mustang) 有什么新东西? 有什么值得开发者关注?

1、简化Web Services

2、整合脚本语言

3、绑定Derby

4、更丰富的Desktop APIs

5、监视和管理

6、 可插入式元数据

7、访问编译器

8、安全性


简化Web Services
Mustang 将 简化Web services 的开发和发布. XML和Web服务一直都是Mustang的关注重点.. Mustang为此引入了JAX-WS(Java Architecture for XML-Web Services) 2.0 以及JAXB(Java Architecture for XML Binding) 2.0.. 同时还有Streaming API for XML (STaX), 它提供了一个双向API，这个API可以通过一个事件流来读取或者写入XML，其中包括跳过某个部分，然后直接关注与文档中的另外一个小部分的能力。


Scripting,整合脚本语言
目前来讲，Java 开发者们必须在Java之外独立地额外编码来使用non-Java 脚本语言。这个头痛的问题将被Mustang 消灭，开发者将更加轻松的使用Perl、PHP、Python、JavaScript 和Ruby等脚本语言。新的框架将允许人们操作任意的脚本语言，和使用Java 对象。

Java SE6中实现了JSR223。这是一个脚本框架，提供了让脚本语言来访问Java内部的方法。你可以在运行的时候找到脚本引擎，然后调用这个引擎去执行脚本。这个脚本API允许你为脚本语言提供Java支持。另外，Web Scripting Framework允许脚本代码在任何的Servlet容器（例如Tomcat）中生成Web内容。

Database,绑定Derby
开源嵌入式数据库 Derby(JavaDB) 绑定在JDK 1.6中.具体可以参考:JDK 1.6 将绑定开源数据库 Derby

更丰富的Desktop APIs
Mustang中拥有更多强的桌面API提供给开发者, 开发者可以更简单地开发更强大的桌面应用, 比如启动界面的支持,系统托盘的支持,JTable排序等等

监视和管理
Java SE 6中对内存泄漏增强了分析以及诊断能力。当遇到java.lang.OutOfMemory异常的时候，可以得到一个完整的堆栈信息，并且当堆已经满了的时候，会产生一个Log文件来记录这个致命错误。另外，JVM还添加了一个选项，允许你在堆满的时候运行脚本。(这也就是提供了另外一种方法来诊断错误)

增强的JMX 监视API在MBean的属性值传入了一个特定的参数的时候，允许这个应用程序发送一个事件通告。（这里的属性值可以在很复杂的类型中）

对于Solaris 10的用户，为Solaris提供的Hotspot JVM中，提供了一种通过Solaris DTrace(这是个系统的调试工具)来追踪显示JVM内部的活动情况，包括垃圾收集，类装载，线程，锁等等。

Pluggable Annotations
从Java SE 5 带来得新特性Annotations,将在Mustang继续扮演重要角色..

Compiler API:访问编译器
对于Java开发工具, 或者Web框架 等的开发者来说, 利用编译器编译动态生成的代码, 是一个普遍的需求.

Mustang实现了JSR 199, 提供了Java编译器API(应用程序接口)，允许你从一个Java应用程序中去编译其他的Java源程序--比如在应用程序中动态生成的一些源代码..

Security:安全性
Java SE 6的安全部分，增加了 XML-Digital Signature (XML-DSIG) APIs, 整合了GSS/Kerberos的操作API，LDAP上的JAAS认证。

Instrumentation
利用 Java 代码，即 java.lang.instrument 做动态 Instrumentation 是 Java SE 5 的新特性，它把 Java 的 instrument 功能从本地代码中解放出来，使之可以用 Java 代码的方式解决问题。在 Java SE 6 里面，instrumentation 包被赋予了更强大的功能：启动后的 instrument、本地代码（native code）instrument，以及动态改变 classpath 等等。在 Java SE 5 当中，开发者只能在 premain 当中施展想象力，所作的 Instrumentation 也仅限与 main 函数执行前，这样的方式存在一定的局限性。在 Java SE 6 的 Instrumentation 当中，有一个跟 premain“并驾齐驱”的“agentmain”方法，可以在 main 函数开始运行之后再运行。

Http
在 Java SE 6 当中，围绕着 HTTP 协议出现了很多实用的新特性：NTLM 认证提供了一种 Window 平台下较为安全的认证机制；JDK 当中提供了一个轻量级的 HTTP 服务器；提供了较为完善的 HTTP Cookie 管理功能；更为实用的 NetworkInterface；DNS 域名的国际化支持等等。
HTTP Cookie管理可以应用客户操作临时变量的保存，如查询条件，当前状态等

<!--JDK1.6 的新特性 (HTTP 增强) start-->

JDK1.6 的新特性 (HTTP 增强)

概述

Java 语言从诞生的那天起，就非常注重网络编程方面的应用。随着互联网应用的飞速发展，Java 的基础类库也不断地对网络相关的 API 进行加强和扩展。在 Java SE 6 当中，围绕着 HTTP 协议出现了很多实用的新特性：NTLM 认证提供了一种 Window 平台下较为安全的认证机制；JDK 当中提供了一个轻量级的 HTTP 服务器；提供了较为完善的 HTTP Cookie 管理功能；更为实用的 NetworkInterface；DNS 域名的国际化支持等等。

NTLM 认证

不可避免，网络中有很多资源是被安全域保护起来的。访问这些资源需要对用户的身份进行认证。下面是一个简单的例子：

import java.net.*;
import java.io.*;

public class Test {
public static void main(String[] args) throws Exception {
URL url = new URL("http://PROTECTED.com");
URLConnection connection = url.openConnection();
InputStream in = connection.getInputStream();
byte[] data = new byte[1024];
while(in.read(data)>0)
{
//do something for data
}
in.close();
}
}


当 Java 程序试图从一个要求认证的网站读取信息的时候，也就是说，从联系于 http://Protected.com 这个 URLConnection 的 InputStream 中 read 数据时，会引发 FileNotFoundException。尽管笔者认为，这个 Exception 的类型与实际错误发生的原因实在是相去甚远；但这个错误确实是由网络认证失败所导致的。

要解决这个问题，有两种方法：

其一，是给 URLConnection 设定一个“Authentication”属性：

String credit = USERNAME + ":" + PASSWORD;
String encoding = new sun.misc.BASE64Encoder().encode (credit.getBytes());
connection.setRequestProperty ("Authorization", "Basic " + encoding);


这里假设 http://PROTECTED.COM 使用了基本（Basic）认证类型。

从上面的例子，我们可以看出，设定 Authentication 属性还是比较复杂的：用户必须了解认证方式的细节，才能将用户名/密码以一定的规范给出，然后用特定的编码方式加以编码。Java 类库有没有提供一个封装了认证细节，只需要给出用户名/密码的工具呢？

这就是我们要介绍的另一种方法，使用 java.net.Authentication 类。

每当遇到网站需要认证的时候，HttpURLConnection 都会向 Authentication 类询问用户名和密码。

Authentication 类不会知道究竟用户应该使用哪个 username/password 那么用户如何向 Authentication 类提供自己的用户名和密码呢?

提供一个继承于 Authentication 的类，实现 getPasswordAuthentication 方法，在 PasswordAuthentication 中给出用户名和密码：

class DefaultAuthenticator extends Authenticator {
public PasswordAuthentication getPasswordAuthentication () {
return new PasswordAuthentication ("USER", "PASSWORD".toCharArray());
}
}


然后，将它设为默认的（全局）Authentication:

Authenticator.setDefault (new DefaultAuthenticator());


那么，不同的网站需要不同的用户名/密码又怎么办呢?

Authentication 提供了关于认证发起者的足够多的信息，让继承类根据这些信息进行判断，在 getPasswordAuthentication 方法中给出了不同的认证信息：

getRequestingHost()
getRequestingPort()
getRequestingPrompt()
getRequestingProtocol()
getRequestingScheme()
getRequestingURL()
getRequestingSite()
getRequestorType()
另一件关于 Authentication 的重要问题是认证类型。不同的认证类型需要 Authentication 执行不同的协议。至 Java SE 6.0 为止，Authentication 支持的认证方式有：

HTTP Basic authentication
HTTP Digest authentication
NTLM
Http SPNEGO Negotiate
Kerberos
NTLM
这里我们着重介绍 NTLM。

NTLM 是 NT LAN Manager 的缩写。早期的 SMB 协议在网络上明文传输口令，这是很不安全的。微软随后提出了 WindowsNT 挑战/响应验证机制，即 NTLM。

NTLM 协议是这样的：

客户端首先将用户的密码加密成为密码散列；
客户端向服务器发送自己的用户名，这个用户名是用明文直接传输的；
服务器产生一个 16 位的随机数字发送给客户端，作为一个 challenge（挑战） ；
客户端用步骤1得到的密码散列来加密这个 challenge ，然后把这个返回给服务器；
服务器把用户名、给客户端的 challenge 、客户端返回的 response 这三个东西，发送域控制器 ；
域控制器用这个用户名在 SAM 密码管理库中找到这个用户的密码散列，然后使用这个密码散列来加密 challenge；
域控制器比较两次加密的 challenge ，如果一样，那么认证成功；
Java 6 以前的版本，是不支持 NTLM 认证的。用户若想使用 HttpConnection 连接到一个使用有 Windows 域保护的网站时，是无法通过 NTLM 认证的。另一种方法，是用户自己用 Socket 这样的底层单元实现整个协议过程，这无疑是十分复杂的。

终于，Java 6 的 Authentication 类提供了对 NTLM 的支持。使用十分方便，就像其他的认证协议一样：

class DefaultAuthenticator extends Authenticator {
private static String username = "username ";
private static String domain = "domain ";
private static String password = "password ";

public PasswordAuthentication getPasswordAuthentication() {
String usernamewithdomain = domain + "/ "+username;
return (new PasswordAuthentication(usernamewithdomain, password.toCharArray()));
}
}


这里，根据 Windows 域账户的命名规范，账户名为域名+”/”+域用户名。如果不想每生成 PasswordAuthentication 时，每次添加域名，可以设定一个系统变量名“http.auth.ntlm.domain“。

Java 6 中 Authentication 的另一个特性是认证协商。目前的服务器一般同时提供几种认证协议，根据客户端的不同能力，协商出一种认证方式。比如，IIS 服务器会同时提供 NTLM with kerberos 和 NTLM 两种认证方式，当客户端不支持 NTLM with kerberos 时，执行 NTLM 认证。

目前，Authentication 的默认协商次序是：

GSS/SPNEGO -> Digest -> NTLM -> Basic


那么 kerberos 的位置究竟在哪里呢?

事实上，GSS/SPNEGO 以 JAAS 为基石，而后者实际上就是使用 kerberos 的。

轻量级 HTTP 服务器

Java 6 还提供了一个轻量级的纯 Java Http 服务器的实现。下面是一个简单的例子：

public static void main(String[] args) throws Exception{
HttpServerProvider httpServerProvider = HttpServerProvider.provider();
InetSocketAddress addr = new InetSocketAddress(7778);
HttpServer httpServer = httpServerProvider.createHttpServer(addr, 1);
httpServer.createContext("/myapp/", new MyHttpHandler());
httpServer.setExecutor(null);
httpServer.start();
System.out.println("started");
}

static class MyHttpHandler implements HttpHandler{
public void handle(HttpExchange httpExchange) throws IOException {
String response = "Hello world!";
httpExchange.sendResponseHeaders(200, response.length());
OutputStream out = httpExchange.getResponseBody();
out.write(response.getBytes());
out.close();
}
}


然后，在浏览器中访问 http://localhost:7778/myapp/，我们得到：


图一 浏览器显示

Hellword !

首先，HttpServer 是从 HttpProvider 处得到的，这里我们使用了 JDK 6 提供的实现。用户也可以自行实现一个 HttpProvider 和相应的 HttpServer 实现。

其次，HttpServer 是有上下文（context）的概念的。比如，http://localhost:7778/myapp/ 中“/myapp/”就是相对于 HttpServer Root 的上下文。对于每个上下文，都有一个 HttpHandler 来接收 http 请求并给出回答。

最后，在 HttpHandler 给出具体回答之前，一般先要返回一个 Http head。这里使用 HttpExchange.sendResponseHeaders(int code, int length)。其中 code 是 Http 响应的返回值，比如那个著名的 404。length 指的是 response 的长度，以字节为单位。

Cookie 管理特性

Cookie 是 Web 应用当中非常常用的一种技术， 用于储存某些特定的用户信息。虽然，我们不能把一些特别敏感的信息存放在 Cookie 里面，但是，Cookie 依然可以帮助我们储存一些琐碎的信息，帮助 Web 用户在访问网页时获得更好的体验，例如个人的搜索参数，颜色偏好以及上次的访问时间等等。网络程序开发者可以利用 Cookie 来创建有状态的网络会话（Stateful Session）。 Cookie 的应用越来越普遍。在 Windows 里面，我们可以在“Documents And Settings”文件夹里面找到IE使用的 Cookie，假设用户名为 admin，那么在 admin 文件夹的 Cookies 文件夹里面，我们可以看到名为“admin@(domain)”的一些文件，其中的 domain 就是表示创建这些 Cookie 文件的网络域， 文件里面就储存着用户的一些信息。

JavaScript 等脚本语言对 Cookie 有着很不错的支持。 .NET 里面也有相关的类来支持开发者对 Cookie 的管理。 不过，在 Java SE 6 之前， Java一直都没有提供 Cookie 管理的功能。在 Java SE 5 里面， java.net 包里面有一个 CookieHandler 抽象类，不过并没有提供其他具体的实现。到了 Java SE 6， Cookie 相关的管理类在 Java 类库里面才得到了实现。有了这些 Cookie 相关支持的类，Java 开发者可以在服务器端编程中很好的操作 Cookie， 更好的支持 HTTP 相关应用，创建有状态的 HTTP 会话。

用 HttpCookie 代表 Cookie
java.net.HttpCookie 类是 Java SE 6 新增的一个表示 HTTP Cookie 的新类， 其对象可以表示 Cookie 的内容， 可以支持所有三种 Cookie 规范：

Netscape 草案
RFC 2109 - http://www.ietf.org/rfc/rfc2109.txt
RFC 2965 - http://www.ietf.org/rfc/rfc2965.txt
这个类储存了 Cookie 的名称，路径，值，协议版本号，是否过期，网络域，最大生命期等等信息。

用 CookiePolicy 规定 Cookie 接受策略
java.net.CookiePolicy 接口可以规定 Cookie 的接受策略。 其中唯一的方法用来判断某一特定的 Cookie 是否能被某一特定的地址所接受。 这个类内置了 3 个实现的子类。一个类接受所有的 Cookie，另一个则拒绝所有，还有一个类则接受所有来自原地址的 Cookie。

用CookieStore 储存 Cookie
java.net.CookieStore 接口负责储存和取出 Cookie。 当有 HTTP 请求的时候，它便储存那些被接受的 Cookie； 当有 HTTP 回应的时候，它便取出相应的 Cookie。 另外，当一个 Cookie 过期的时候，它还负责自动删去这个 Cookie。

用 CookieManger/CookieHandler 管理 Cookie
java.net.CookieManager 是整个 Cookie 管理机制的核心，它是 CookieHandler 的默认实现子类。下图显示了整个 HTTP Cookie 管理机制的结构：


图 2. Cookie 管理类的关系


一个 CookieManager 里面有一个 CookieStore 和一个 CookiePolicy，分别负责储存 Cookie 和规定策略。用户可以指定两者，也可以使用系统默认的 CookieManger。

例子
下面这个简单的例子说明了 Cookie 相关的管理功能：

// 创建一个默认的 CookieManager
CookieManager manager = new CookieManager();

// 将规则改掉，接受所有的 Cookie
manager.setCookiePolicy(CookiePolicy.ACCEPT_ALL);

// 保存这个定制的 CookieManager
CookieHandler.setDefault(manager);

// 接受 HTTP 请求的时候，得到和保存新的 Cookie
HttpCookie cookie = new HttpCookie("...(name)...","...(value)...");
manager.getCookieStore().add(uri, cookie);

// 使用 Cookie 的时候：
// 取出 CookieStore
CookieStore store = manager.getCookieStore();

// 得到所有的 URI
List<URI> uris = store.getURIs();
for (URI uri : uris) {
// 筛选需要的 URI
// 得到属于这个 URI 的所有 Cookie
List<HttpCookie> cookies = store.get(uri);
for (HttpCookie cookie : cookies) {
// 取出了 Cookie
}
}

// 或者，取出这个 CookieStore 里面的全部 Cookie
// 过期的 Cookie 将会被自动删除
List<HttpCookie> cookies = store.getCookies();
for (HttpCookie cookie : cookies) {
// 取出了 Cookie
}

其他新特性

NetworkInterface 的增强

从 Java SE 1.4 开始，JDK 当中出现了一个网络工具类 java.net.NetworkInterface，提供了一些网络的实用功能。 在 Java SE 6 当中，这个工具类得到了很大的加强，新增了很多实用的方法。例如：

public boolean isUp()
用来判断网络接口是否启动并运行

public boolean isLoopback()
用来判断网络接口是否是环回接口（loopback）

public boolean isPointToPoint()
用来判断网络接口是否是点对点（P2P）网络

public boolean supportsMulticast()
用来判断网络接口是否支持多播

public byte[] getHardwareAddress()
用来得到硬件地址（MAC）

public int getMTU()
用来得到最大传输单位（MTU，Maximum Transmission Unit）

public boolean isVirtual()
用来判断网络接口是否是虚拟接口

关于此工具类的具体信息，请参考 Java SE 6 相应文档（见 参考资源）。

域名的国际化

在最近的一些 RFC 文档当中，规定 DNS 服务器可以解析除开 ASCII 以外的编码字符。有一个算法可以在这种情况下做 Unicode 与 ASCII 码之间的转换，实现域名的国际化。java.net.IDN 就是实现这个国际化域名转换的新类，IDN 是“国际化域名”的缩写（internationalized domain names）。这个类很简单，主要包括 4 个静态函数，做字符的转换。

<!--JDK1.6 的新特性 (HTTP 增强) end-->


JMX与系统管理

管理系统的构架
图 1. 管理系统构架


上图分析了管理系统的基本构架模式。其中 Agent / SubAgent 起到的就是翻译的作用：把 IT 资源报告的消息以管理系统能理解的方式传送出去。

也许读者有会问，为什么需要 Agent 和 SubAgent 两层体系呢？这里有两个现实的原因：

管理系统一般是一个中央控制的控制软件，而 SubAgent 直接监控一些资源，往往和这些资源分布在同一物理位置。当这些 SubAgent 把状态信息传输到管理系统或者传达管理系统的控制指令的时候，需要提供一些网络传输的功能。

管理系统的消息是有一定规范的，消息的翻译本身是件复杂而枯燥的事情。
一般来说，管理系统会将同一物理分布或者功能类似的 SubAgent 分组成一组，由一个共用的 Agent 加以管理。在这个 Agent 里封装了 1 和 2 的功能。

JMX 和管理系统

JMX 既是 Java 管理系统的一个标准，一个规范，也是一个接口，一个框架。图 2 展示了 JMX 的基本架构。
图 2. JMX 构架和其它的资源系统一样，JMX 是管理系统和资源之间的一个接口，它定义了管理系统和资源之间交互的标准。javax.management.MBeanServer 实现了 Agent 的功能，以标准的方式给出了管理系统访问 JMX 框架的接口。而 javax.management.MBeans 实现了 SubAgent 的功能，以标准的方式给出了 JMX 框架访问资源的接口。而从类库的层次上看，JMX 包括了核心类库 java.lang.management 和 javax.management 包。java.lang.management 包提供了基本的 VM 监控功能，而 javax.management 包则向用户提供了扩展功能。 JMX帮助开发者监控JVM的信息。

编辑器API
JDK 6 提供了在运行时调用编译器的 API。在传统的 JSP 技术中，服务器处理 JSP 通常需要进行下面 6 个步骤：

分析 JSP 代码；
生成 Java 代码；
将 Java 代码写入存储器；
启动另外一个进程并运行编译器编译 Java 代码；
将类文件写入存储器；
服务器读入类文件并运行；
但如果采用运行时编译，可以同时简化步骤 4 和 5，节约新进程的开销和写入存储器的输出开销，提高系统效率。实际上，在 JDK 5 中，Sun 也提供了调用编译器的编程接口。然而不同的是，老版本的编程接口并不是标准 API 的一部分，而是作为 Sun 的专有实现提供的，而新版则带来了标准化的优点。
新 API 的第二个新特性是可以编译抽象文件，理论上是任何形式的对象 —— 只要该对象实现了特定的接口。有了这个特性，上述例子中的步骤 3 也可以省略。整个 JSP 的编译运行在一个进程中完成，同时消除额外的输入输出操作。
第三个新特性是可以收集编译时的诊断信息。作为对前两个新特性的补充，它可以使开发人员轻松的输出必要的编译错误或者是警告信息，从而省去了很多重定向的麻烦

一些有趣的新特性：

1 本地行为 java.awt.Desktop
比如用默认程序打开文件，用默认浏览器打开url，再也不用那个browserlauncher那么费劲
了
Desktop desk=Desktop.getDesktop();
desk.browse(new URI("http://www.google.com"));
desk.open(file)
desk.print(file)

2 console下密码输入 java.io.Console
再也不用自己写线程去删echo字符了
Console console = System.console();
char password[] = console.readPassword("Enter password: ");

3 获取磁盘空间大小 java.io.File的新方法
File roots[] = File.listRoots();
for (File root : roots) {
System.out.println(root.getPath()+":"+root.getUsableSpace()
+"/"+root.getTotalSpace());
}

4 专利过期，可以提供合法的lzw的gif encoder了
ImageIO.write(input, "GIF", outputFile);

5 JAXB2.0 增加了java-to-xml schema，完成java bean,xml间转换非常容易

6 xml数字签名 javax.xml.crypto，记得以前似乎只有ibm有个类库实现了

7 编译器，以前是com.sun.tools.javac，现在是javax.tools.JavaCompiler
有人写了完全在内存里的生成源文件，编译，反射运行的过程，比较好玩。

8 脚本引擎，javax.script，内嵌的是Mozilla Rhino1.6r2 支持ECMAScript1.6


本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/J2EEWEIWEI/archive/2009/02/24/3932789.aspx

09:27
评论 / 浏览 (1 / 895)
收藏
分类:编程语言

2009-11-06
缩略显示
REST是什么

博客分类：
Java

REST设计模式应用服务器网络应用Web

REST架构风格是全新的针对Web应用的开发风格，是当今世界最成功的互联网超媒体分布式系统架构，它使得人们真正理解了Http协议本来面貌。随着 REST架构成为主流技术，一种全新的互联网网络应用开发的思维方式开始流行。



REST是什么

REST是英文Representational State Transfer的缩写，中文翻译为“表述性状态转移”，他是由Roy Thomas Fielding博士在他的论文《Architectural Styles and the Design of Network-based Software Architectures》中提出的一个术语。REST本身只是为分布式超媒体系统设计的一种架构风格，而不是标准。

基于Web的架构，实际上就是各种规范的集合，这些规范共同组成了Web架构。比如Http协议，比如客户端服务器模式，这些都是规范。每当我们在原有规范的基础上增加新的规范，就会形成新的架构。而REST正是这样一种架构，他结合了一系列的规范，而形成了一种新的基于Web的架构风格。

传统的Web应用大都是B/S架构，它包括了如下一些规范 。



客户－服务器

这种规范的提出，改善了用户接口跨多个平台的可移植性，并且通过简化服务器组件，改善了系统的可伸缩性。最为关键的是通过分离用户接口和数据存储这两个关注点，使得不同用户终端享受相同数据成为了可能。
无状态性

无状态性是在客户－服务器约束的基础上添加的又一层规范。他要求通信必须在本质上是无状态的，即从客户到服务器的每个request都必须包含理解该 request所必须的所有信息。这个规范改善了系统的可见性（无状态性使得客户端和服务器端不必保存对方的详细信息，服务器只需要处理当前 request，而不必了解所有的request历史），可靠性（无状态性减少了服务器从局部错误中恢复的任务量），可伸缩性（无状态性使得服务器端可以很容易的释放资源，因为服务器端不必在多个request中保存状态）。同时，这种规范的缺点也是显而易见得，由于不能将状态数据保存在服务器上的共享上下文中，因此增加了在一系列request中发送重复数据的开销,严重的降低了效率。
缓存

为了改善无状态性带来的网络的低效性，我们填加了缓存约束。缓存约束允许隐式或显式地标记一个response中的数据，这样就赋予了客户端缓存 response数据的功能，这样就可以为以后的request共用缓存的数据，部分或全部的消除一部分交互，增加了网络的效率。但是用于客户端缓存了信息，也就同时增加了客户端与服务器数据不一致的可能，从而降低了可靠性。




B/S架构的优点是其部署非常方便，但在用户体验方面却不是很理想。为了改善这种情况，我们引入了REST。

REST在原有的架构上增加了三个新规范：统一接口，分层系统和按需代码。

统一接口

REST 架构风格的核心特征就是强调组件之间有一个统一的接口，这表现在REST世界里，网络上所有的事物都被抽象为资源，而REST就是通过通用的链接器接口对资源进行操作。这样设计的好处是保证系统提供的服务都是解耦的，极大的简化了系统，从而改善了系统的交互性和可重用性。并且REST针对Web的常见情况做了优化，使得REST接口被设计为可以高效的转移大粒度的超媒体数据，这也就导致了REST接口对其它的架构并不是最优的。
分层系统

分层系统规则的加入提高了各种层次之间的独立性，为整个系统的复杂性设置了边界，通过封装遗留的服务，使新的服务器免受遗留客户端的影响，这也就提高了系统的可伸缩性。
按需代码

REST允许对客户端功能进行扩展。比如，通过下载并执行applet或脚本形式的代码，来扩展客户端功能。但这在改善系统可扩展性的同时，也降低了可见性。所以它只是REST的一个可选的约束。



REST的设计准则

REST架构是针对Web应用而设计的，其目的是为了降低开发的复杂性，提高系统的可伸缩性。REST提出了如下设计准则：

网络上的所有事物都被抽象为资源（resource）；
每个资源对应一个唯一的资源标识符（resource identifier）；
通过通用的连接器接口（generic connector interface）对资源进行操作；
对资源的各种操作不会改变资源标识符；
所有的操作都是无状态的（stateless）。
REST中的资源所指的不是数据，而是数据和表现形式的组合，比如“最新访问的10位会员”和“最活跃的10为会员”在数据上可能有重叠或者完全相同，而由于他们的表现形式不同，所以被归为不同的资源，这也就是为什么REST的全名是Representational State Transfer的原因。资源标识符就是URI(Uniform Resource Identifier)，不管是图片，Word还是视频文件，甚至只是一种虚拟的服务，也不管你是xml格式,txt文件格式还是其它文件格式，全部通过 URI对资源进行唯一的标识。

REST是基于Http协议的，任何对资源的操作行为都是通过Http协议来实现。以往的Web开发大多数用的都是Http协议中的GET和POST方法，对其他方法很少使用，这实际上是因为对Http协议认识片面的理解造成的。Http不仅仅是一个简单的运载数据的协议，而是一个具有丰富内涵的网络软件的协议。他不仅仅能对互联网资源进行唯一定位，而且还能告诉我们如何对该资源进行操作。Http把对一个资源的操作限制在4个方法以内：GET, POST,PUT和DELETE，这正是对资源CRUD操作的实现。由于资源和URI是一一对应的，执行这些操作的时候URI是没有变化的，这和以往的 Web开发有很大的区别。正由于这一点，极大的简化了Web开发，也使得URI可以被设计成更为直观的反映资源的结构，这种URI的设计被称作 RESTful的URI。这位开发人员引入了一种新的思维方式：通过URL来设计系统结构。当然了，这种设计方式对一些特定情况也是不适用的，也就是说不是所有的URI都可以RESTful的。

REST 之所以可以提高系统的可伸缩性，就是因为它要求所有的操作都是无状态的。由于没有了上下文(Context)的约束，做分布式和集群的时候就更为简单，也可以让系统更为有效的利用缓冲池(Pool）。并且由于服务器端不需要记录客户端的一系列访问，也减少了服务器端的性能。



使用REST架构

对于开发人员来说，关心的是如何使用REST架构，这里我们来简单谈谈这个问题。REST不仅仅是一种崭新的架构，它带来的更是一种全新的Web开发过程中的思维方式：通过URL来设计系统结构。在REST中，所有的URL都对应着资源，只要URL的设计是良好的，那么其呈现的系统结构也就是良好的。这点和TDD (Test Driven Development)很相似，他是通过测试用例来设计系统的接口，每一个测试用例都表示一系列用户的需求。开发人员不需要一开始就编写功能，而只需要把需要实现的功能通过测试用例的形式表现出来即可。这个和REST中通过URL设计系统结构的方式类似，我们只需要根据需求设计出合理地URL，这些 URL不一定非要链接到指定的页面或者完成一些行为，只要它们能够直观的表现出系统的用户接口。根据这些URL，我们就可以方便的设计系统结构。从 REST架构的概念上来看，所有能够被抽象成资源的东西都可以被指定为一个URL，而开发人员所需要做的工作就是如何能把用户需求抽象为资源，以及如何抽象的精确。因为对资源抽象的越为精确，对REST的应用来说就越好。这个和传统MVC开发模式中基于Action的思想差别就非常大。设计良好的URL，不但对于开发人员来说可以更明确的认识系统结构，对使用者来说也方便记忆和识别资源，因为URL足够简单和有意义。按照以往的设计模式，很多URL后面都是一堆参数，对于使用者来说也是很不方便的。

既然REST这么好用，那么是不是所有的Web应用都能采取此种架构呢？答案是否定的。我们知道，直到现在为止，MVC(Model-View-Controller) 模式依然是Web开发最普遍的模式，绝大多数的公司和开发人员都采取此种架构来开发Web应用，并且其思维方式也停留于此。MVC模式由数据，视图和控制器构成，通过事件(Event)触发Controller来改变Model和View。加上Webwork,Struts等开源框架的加入，MVC开发模式已经相当成熟，其思想根本就是基于Action来驱动。从开发人员角度上来说，贸然接受一个新的架构会带来风险，其中的不确定因素太多。并且REST新的思维方式是把所有用户需求抽象为资源，这在实际开发中是比较难做到的，因为并不是所有的用户需求都能被抽象为资源，这样也就是说不是整个系统的结构都能通过REST的来表现。所以在开发中，我们需要根据以上2点来在REST和MVC中做出选择。我们认为比较好的办法是混用REST和MVC，因为这适合绝大多数的Web应用开发，开发人员只需要对比较容易能够抽象为资源的用户需求采取REST的开发模式，而对其它需求采取MVC开发即可。这里需要提到的就是ROR(Ruby on Rails)框架，这是一个基于Ruby语言的越来越流行的Web开发框架，它极大的提高了Web开发的速度。更为重要的是，ROR(从1.2版本起)框架是第一个引入REST做为核心思想的Web开发框架，它提供了对REST最好的支持，也是当今最成功的应用REST的Web开发框架。实际上，ROR的 REST实现就是REST和MVC混用，开发人员采用ROR框架，可以更快更好的构建Web应用。


对开发人员来说，REST不仅仅在Web开发上贡献了自己的力量，同时也让我们学到了如何把软件工程原则系统地应用于对一个真实软件的设计和评估上。


本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/wangjj_016/archive/2008/12/26/3615948.aspx

18:27
评论 / 浏览 (0 / 242)
收藏

2009-08-07
缩略显示
jira企业版linux下安装和破解

博客分类：
Java

LinuxMySQLSecuritySUN

1、下载地址：http://www.atlassian.com/software/jira/JIRADownloadCenter.jspa



2、安装

linux下面解压tar包即可，如果没有装数据库的话安装一下数据库（示例采用mysql）

#tar zxf atlassian-jira-enterprise-3.13.5-standalone.tar.gz

#mv atlassian-jira-enterprise-3.13.5-standalone jira

创建数据库

#mysql

>create database jiradb character set 'UTF8';

建立一个用户username 只允许从localhost登陆 密码为password
(不执行也可以)
>grant all on jiradb.* to 'username'@'localhost' identified by 'password' ;



修改jira/bin/catalina.sh ，追加

export CATALINA_HOME=/opt/jira
export CATALINA_BASE=/opt/jira
export CATALINA_TMPDIR=/opt/jira/temp



配置完成后到bin目录下直接运行./startup.sh

如有需要更改端口、数据库连接等其它配置：jira/conf/server.xml，不修改采用默认的也没问题，端口为8080。



3、破解

jira起来后，访问http://ip:8080/时的初始化配置页面的最下面会要求输出授权码，破解方法如下：

新建KeyGen.java，在buildpath里加依赖包atlassian-extras-1.17.jar
Java代码

import com.atlassian.license.LicensePair;
import java.io.*;
import java.security.KeyFactory;
import java.security.Signature;
import java.security.spec.PKCS8EncodedKeySpec;

public class KeyGen {
public static void main(String args[]) throws IOException {
try {
long l = 267L;
long l1 = System.currentTimeMillis();
long l2 = System.currentTimeMillis();
String s = "";
System.out.println("Keygen for JIRA Enterprise Edition.");
System.out.print("created by mydaj[ROR].");
do {
System.out.print("\nEnter your organization name: ");
for (int i = System.in.read(); i != 10 && i != 13; i = System.in
.read())
s = s + (char) i;

} while (s == "");
try {
PKCS8EncodedKeySpec pkcs8encodedkeyspec = new PKCS8EncodedKeySpec(
EncodedPrvKey);
KeyFactory keyfactory = KeyFactory.getInstance("DSA", "SUN");
java.security.PrivateKey privatekey = keyfactory
.generatePrivate(pkcs8encodedkeyspec);
String s1 = Long.toString(l, 10);
s1 = s1 + "^^";
s1 = s1 + Long.toString(l1, 10);
s1 = s1 + "^^";
s1 = s1 + Long.toString(l2, 10);
s1 = s1 + "^^";
s1 = s1 + s;
byte abyte0[] = s1.getBytes();
Signature signature = Signature.getInstance("SHA1withDSA");
signature.initSign(privatekey);
signature.update(abyte0);
byte abyte1[] = signature.sign();
LicensePair licensepair = null;
try {
licensepair = new LicensePair(abyte0, abyte1);
} catch (Exception exception1) {
exception1.printStackTrace();
}

System.out.println("Your license key is: ");
System.out.println(licensepair.toString());
} catch (Exception exception) {
exception.printStackTrace();
}
} catch (IOException ioexception) {
}
}

static byte EncodedPrvKey[] = { 48, -126, 1, 75, 2, 1, 0, 48, -126, 1, 44,
6, 7, 42, -122, 72, -50, 56, 4, 1, 48, -126, 1, 31, 2, -127, -127,
0, -3, 127, 83, -127, 29, 117, 18, 41, 82, -33, 74, -100, 46, -20,
-28, -25, -10, 17, -73, 82, 60, -17, 68, 0, -61, 30, 63, -128, -74,
81, 38, 105, 69, 93, 64, 34, 81, -5, 89, 61, -115, 88, -6, -65,
-59, -11, -70, 48, -10, -53, -101, 85, 108, -41, -127, 59, -128,
29, 52, 111, -14, 102, 96, -73, 107, -103, 80, -91, -92, -97, -97,
-24, 4, 123, 16, 34, -62, 79, -69, -87, -41, -2, -73, -58, 27, -8,
59, 87, -25, -58, -88, -90, 21, 15, 4, -5, -125, -10, -45, -59, 30,
-61, 2, 53, 84, 19, 90, 22, -111, 50, -10, 117, -13, -82, 43, 97,
-41, 42, -17, -14, 34, 3, 25, -99, -47, 72, 1, -57, 2, 21, 0, -105,
96, 80, -113, 21, 35, 11, -52, -78, -110, -71, -126, -94, -21,
-124, 11, -16, 88, 28, -11, 2, -127, -127, 0, -9, -31, -96, -123,
-42, -101, 61, -34, -53, -68, -85, 92, 54, -72, 87, -71, 121, -108,
-81, -69, -6, 58, -22, -126, -7, 87, 76, 11, 61, 7, -126, 103, 81,
89, 87, -114, -70, -44, 89, 79, -26, 113, 7, 16, -127, -128, -76,
73, 22, 113, 35, -24, 76, 40, 22, 19, -73, -49, 9, 50, -116, -56,
-90, -31, 60, 22, 122, -117, 84, 124, -115, 40, -32, -93, -82, 30,
43, -77, -90, 117, -111, 110, -93, 127, 11, -6, 33, 53, 98, -15,
-5, 98, 122, 1, 36, 59, -52, -92, -15, -66, -88, 81, -112, -119,
-88, -125, -33, -31, 90, -27, -97, 6, -110, -117, 102, 94, -128,
123, 85, 37, 100, 1, 76, 59, -2, -49, 73, 42, 4, 22, 2, 20, 42, 50,
-88, 30, 125, -37, 118, -50, 20, -82, -63, 0, 8, -36, 106, -9,
-110, 124, 107, 68 };
}



运行代码，在输入框里输入jiraId，回车生成授权码。





完成！







13:42
评论 / 浏览 (0 / 2552)
收藏

2009-05-20
缩略显示
log4j输出到文件和数据库

博客分类：
Java

log4jJDBCApacheSQLOracle

官方API地址：http://logging.apache.org/log4j/1.2/apidocs/index.html?org/apache/log4j/PatternLayout.html

控制台的实现就不说了，这里提供两种实例的配置，一种是输出为文件的（每天输出一个文件），一种为输出到数据库的配置。

1、输出到文件：
Properties代码

log4j.rootCategory=WARN, CONSOLE, FILE

log4j.logger.com.surfilter.bt=FATAL,TOFILE

log4j.appender.TOFILE=org.apache.log4j.DailyRollingFileAppender
log4j.appender.TOFILE.Threshold=FATAL
log4j.appender.TOFILE.File=E:/javascpace/bt/logs/union.html
log4j.appender.TOFILE.Append=true
log4j.appender.TOFILE.ImmediateFlush=true
log4j.appender.TOFILE.DatePattern='.'yyyy-MM-dd'.html'
log4j.appender.TOFILE.layout=com.surfilter.bt.util.FormatHTMLLayout



这里的com.surfilter.bt.util.FormatHTMLLayout是重写了log4j提供的HTMLLayout类，具体代码如下：
Java代码

import java.text.SimpleDateFormat;
import java.util.Map;

import org.apache.log4j.HTMLLayout;
import org.apache.log4j.Layout;
import org.apache.log4j.Level;
import org.apache.log4j.helpers.Transform;
import org.apache.log4j.spi.LocationInfo;
import org.apache.log4j.spi.LoggingEvent;

import com.opensymphony.xwork2.ActionContext;
import com.surfilter.core.Constants;
import com.surfilter.security.domain.User;

public class FormatHTMLLayout extends HTMLLayout {

public FormatHTMLLayout() {
}

protected final int BUF_SIZE = 256;

protected final int MAX_CAPACITY = 1024;

static String TRACE_PREFIX = "<br>    ";

// output buffer appended to when format() is invoked
private StringBuffer sbuf = new StringBuffer(BUF_SIZE);

String title="系统操作日志";

/**
* A string constant used in naming the option for setting the the HTML
* document title. Current value of this string constant is <b>Title</b>.
*/
public static final String TITLE_OPTION = "Title";

// Print no location info by default
boolean locationInfo = true;

public String format(LoggingEvent event) {
if (sbuf.capacity() > MAX_CAPACITY) {
sbuf = new StringBuffer(BUF_SIZE);
} else {
sbuf.setLength(0);
}
sbuf.append(Layout.LINE_SEP + "<tr>" + Layout.LINE_SEP);

/* sbuf.append("<td>");
sbuf.append(String.valueOf(i));
sbuf.append("</td>" + Layout.LINE_SEP);
*/
sbuf.append("<td>");
sbuf.append(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new java.util.Date()));
sbuf.append("</td>" + Layout.LINE_SEP);

/* String escapedThread = Transform.escapeTags(event.getThreadName());
sbuf.append("<td title=\"" + escapedThread + " thread\">");
sbuf.append(escapedThread);
sbuf.append("</td>" + Layout.LINE_SEP);
*/
sbuf.append("<td title=\"级别\">");
if (event.getLevel().equals(Level.FATAL)) {
sbuf.append("<font color=\"#339933\">");
sbuf.append(Transform.escapeTags(String.valueOf(event.getLevel())));
sbuf.append("</font>");
} else if (event.getLevel().isGreaterOrEqual(Level.WARN)) {
sbuf.append("<font color=\"#993300\"><strong>");
sbuf.append(Transform.escapeTags(String.valueOf(event.getLevel())));
sbuf.append("</strong></font>");
} else {
sbuf.append(Transform.escapeTags(String.valueOf(event.getLevel())));
}
sbuf.append("</td>" + Layout.LINE_SEP);

/* String escapedLogger = Transform.escapeTags(event.getLoggerName().substring(event.getLoggerName().lastIndexOf(".")));
sbuf.append("<td title=\"类名\">");
sbuf.append(escapedLogger);
sbuf.append("</td>" + Layout.LINE_SEP);
*/
if (locationInfo) {
LocationInfo locInfo = event.getLocationInformation();
sbuf.append("<td title=\"行号\">");
sbuf.append(Transform.escapeTags(locInfo.getFileName()));
sbuf.append(':');
sbuf.append(locInfo.getLineNumber());
sbuf.append("</td>" + Layout.LINE_SEP);
}
Map session = ActionContext.getContext().getSession();
if(session!=null){
User user = (User) session.get(Constants.USER_IN_SESSION);
sbuf.append("<td>"+user.getName()+"</td>");
}else{
sbuf.append("<td> </td>");
}
sbuf.append("<td title=\"日志信息\">");
sbuf.append(Transform.escapeTags(event.getRenderedMessage()));
sbuf.append("</td>" + Layout.LINE_SEP);
sbuf.append("</tr>" + Layout.LINE_SEP);

if (event.getNDC() != null) {
sbuf.append("<tr><td bgcolor=\"#EEEEEE\" style=\"font-size : xx-small;\" colspan=\"6\" title=\"Nested Diagnostic Context\">");
sbuf.append("NDC: " + Transform.escapeTags(event.getNDC()));
sbuf.append("</td></tr>" + Layout.LINE_SEP);
}

String[] s = event.getThrowableStrRep();
if (s != null) {
sbuf.append("<tr><td bgcolor=\"#993300\" style=\"color:White; font-size : xx-small;\" colspan=\"4\">");
appendThrowableAsHTML(s, sbuf);
sbuf.append("</td></tr>" + Layout.LINE_SEP);
}
return sbuf.toString();
}

private void appendThrowableAsHTML(String[] s, StringBuffer sbuf) {
if (s != null) {
int len = s.length;
if (len == 0)
return;
sbuf.append(Transform.escapeTags(s[0]));
sbuf.append(Layout.LINE_SEP);
for (int i = 1; i < len; i++) {
sbuf.append(TRACE_PREFIX);
sbuf.append(Transform.escapeTags(s[i]));
sbuf.append(Layout.LINE_SEP);
}
}
}

/**
* Returns appropriate HTML headers.
*/
public String getHeader() {
StringBuffer sbuf = new StringBuffer();
sbuf.append("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">" + Layout.LINE_SEP);
sbuf.append("<html>" + Layout.LINE_SEP);
sbuf.append("<head>" + Layout.LINE_SEP);
// sbuf.append("<meta http-equiv=\"content-type\" content=\"text/html; charset=UTF-8\">");
sbuf.append("<title>" + title + "</title>" + Layout.LINE_SEP);
sbuf.append("<style type=\"text/css\">" + Layout.LINE_SEP);
sbuf.append("<!--" + Layout.LINE_SEP);
sbuf.append("body, table {font-family: '宋体',arial,sans-serif; font-size: 12px;}" + Layout.LINE_SEP);
sbuf.append("th {background: #336699; color: #FFFFFF; text-align: left;}" + Layout.LINE_SEP);
sbuf.append("-->" + Layout.LINE_SEP);
sbuf.append("</style>" + Layout.LINE_SEP);
sbuf.append("</head>" + Layout.LINE_SEP);
sbuf.append("<body bgcolor=\"#FFFFFF\" topmargin=\"6\" leftmargin=\"6\">" + Layout.LINE_SEP);
// sbuf.append("<hr size=\"1\" noshade>" + Layout.LINE_SEP);
// sbuf.append("Log session start time " + new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").format(new java.util.Date()) + "<br>" + Layout.LINE_SEP);
// sbuf.append("<p>" + Layout.LINE_SEP);
sbuf.append("<table cellspacing=\"0\" cellpadding=\"4\" border=\"1\" bordercolor=\"#224466\" width=\"100%\">" + Layout.LINE_SEP);
sbuf.append("<tr>" + Layout.LINE_SEP);
// sbuf.append("<th>序列</th>" + Layout.LINE_SEP);
sbuf.append("<th>执行时间</th>" + Layout.LINE_SEP);
sbuf.append("<th>级别</th>" + Layout.LINE_SEP);
// sbuf.append("<th>所在类</th>" + Layout.LINE_SEP);
if (locationInfo) {
sbuf.append("<th>所在行</th>" + Layout.LINE_SEP);
}
sbuf.append("<th>操作人</th>");
sbuf.append("<th>信息</th>" + Layout.LINE_SEP);
sbuf.append("</tr>" + Layout.LINE_SEP);
sbuf.append("<br></br>" + Layout.LINE_SEP);
return sbuf.toString();
}

}

注，上面输出里包含了从当前session里取到的用户信息，只需要重写getHeader，format，appendThrowableAsHTML三个方法就可以了。LoggingEvent 提供的方法可以获取各种日志信息。



2、输入到数据库，现在配置是将日志信息同时输出到文件和数据库
Properties代码

log4j.rootCategory=WARN, CONSOLE, FILE

log4j.logger.com.surfilter.bt=FATAL,TOFILE,JDBC

log4j.appender.TOFILE=org.apache.log4j.DailyRollingFileAppender
log4j.appender.TOFILE.Threshold=FATAL
log4j.appender.TOFILE.File=E:/javascpace/bt/logs/union.html
log4j.appender.TOFILE.Append=true
log4j.appender.TOFILE.ImmediateFlush=true
log4j.appender.TOFILE.DatePattern='.'yyyy-MM-dd'.html'
log4j.appender.TOFILE.layout=com.surfilter.bt.util.FormatHTMLLayout

Properties代码

log4j.appender.JDBC=org.apache.log4j.jdbc.JDBCAppender
#log4j.appender.JDBC=com.surfilter.bt.util.Log4jToDBAppender
log4j.appender.JDBC.Threshold=FATAL
log4j.appender.JDBC.URL=jdbc:oracle:thin:@127.0.0.1:1521:orcl
log4j.appender.JDBC.driver=oracle.jdbc.driver.OracleDriver
log4j.appender.JDBC.user=db_user
log4j.appender.JDBC.password=db_password
log4j.appender.JDBC.sql=insert into sys_log(id,loginid,PRIORITY,LOGDATE,CLASS,METHOD,MSG) values (seq_sys_log.nextval,'0','%p','%d{yyyy-MM-dd HH:mm:ss}','%c{1}','%-10.50l','%m')
log4j.appender.JDBC.layout=org.apache.log4j.PatternLayout



以上配置将会同时输出到文件和数据库，注意这里有一行注释掉的实现com.surfilter.bt.util.Log4jToDBAppender，如果你要使用连接池可以继承JDBCAppender重写实现，下面是JDBCAppender的实现源码，可以从log4j官网上down到：
Java代码

package org.apache.log4j.jdbc;

import org.apache.log4j.spi.*;
import org.apache.log4j.PatternLayout;

import java.util.ArrayList;
import java.util.Iterator;

import java.sql.DriverManager;
import java.sql.Connection;
import java.sql.Statement;
import java.sql.SQLException;

public class JDBCAppender extends org.apache.log4j.AppenderSkeleton
implements org.apache.log4j.Appender {

protected String databaseURL = "jdbc:odbc:myDB";

protected String databaseUser = "me";

protected String databasePassword = "mypassword";

protected Connection connection = null;

protected String sqlStatement = "";

protected int bufferSize = 1;

protected ArrayList buffer;

protected ArrayList removes;

public JDBCAppender() {
super();
buffer = new ArrayList(bufferSize);
removes = new ArrayList(bufferSize);
}

public void append(LoggingEvent event) {
buffer.add(event);

if (buffer.size() >= bufferSize)
flushBuffer();
}

protected String getLogStatement(LoggingEvent event) {
return getLayout().format(event);
}

protected void execute(String sql) throws SQLException {

Connection con = null;
Statement stmt = null;

try {
con = getConnection();

stmt = con.createStatement();
stmt.executeUpdate(sql);
} catch (SQLException e) {
if (stmt != null)
stmt.close();
throw e;
}
stmt.close();
closeConnection(con);

//System.out.println("Execute: " + sql);
}

protected void closeConnection(Connection con) {
}

protected Connection getConnection() throws SQLException {
if (!DriverManager.getDrivers().hasMoreElements())
setDriver("sun.jdbc.odbc.JdbcOdbcDriver");

if (connection == null) {
connection = DriverManager.getConnection(databaseURL, databaseUser,
databasePassword);
}

return connection;
}

public void close()
{
flushBuffer();

try {
if (connection != null && !connection.isClosed())
connection.close();
} catch (SQLException e) {
errorHandler.error("Error closing connection", e, ErrorCode.GENERIC_FAILURE);
}
this.closed = true;
}

public void flushBuffer() {
//Do the actual logging
removes.ensureCapacity(buffer.size());
for (Iterator i = buffer.iterator(); i.hasNext();) {
try {
LoggingEvent logEvent = (LoggingEvent)i.next();
String sql = getLogStatement(logEvent);
execute(sql);
removes.add(logEvent);
}
catch (SQLException e) {
errorHandler.error("Failed to excute sql", e,
ErrorCode.FLUSH_FAILURE);
}
}

// remove from the buffer any events that were reported
buffer.removeAll(removes);

// clear the buffer of reported events
removes.clear();
}

public void finalize() {
close();
}

public boolean requiresLayout() {
return true;
}

public void setSql(String s) {
sqlStatement = s;
if (getLayout() == null) {
this.setLayout(new PatternLayout(s));
}
else {
((PatternLayout)getLayout()).setConversionPattern(s);
}
}

public String getSql() {
return sqlStatement;
}


public void setUser(String user) {
databaseUser = user;
}

public void setURL(String url) {
databaseURL = url;
}

public void setPassword(String password) {
databasePassword = password;
}

public void setBufferSize(int newBufferSize) {
bufferSize = newBufferSize;
buffer.ensureCapacity(bufferSize);
removes.ensureCapacity(bufferSize);
}

public String getUser() {
return databaseUser;
}

public String getURL() {
return databaseURL;
}

public String getPassword() {
return databasePassword;
}

public int getBufferSize() {
return bufferSize;
}

public void setDriver(String driverClass) {
try {
Class.forName(driverClass);
} catch (Exception e) {
errorHandler.error("Failed to load driver", e,
ErrorCode.GENERIC_FAILURE);
}
}
}


然后说一下PatternLayout里的ConversionPattern主要的格式化输开形式，Log4J采用类似C语言中的printf函数的打印，格式化日志信息，打印参数如下：

　%m 输出代码中指定的消息


　%p 输出优先级，即DEBUG，INFO，WARN，ERROR，FATAL


　%r 输出自应用启动到输出该log信息耗费的毫秒数


　%c 输出所属的类目，通常就是所在类的全名，例%c{1}： 类名"a.b.c" 时输出 "c"


　%t 输出产生该日志事件的线程名


　%n 输出一个回车换行符，Windows平台为“rn”，Unix平台为“n”

　%d 输出日志时间点的日期或时间，默认格式为ISO8601，也可以在其后指定格式，比　如：%d{yyyy MMM dd HH:mm:ss,SSS}，输出类似：2002年10月18日 22：10：28，921

　%l 输出日志事件的发生位置，包括类目名、发生的线程，以及在代码中的行数。

21:07
评论 / 浏览 (2 / 1928)
收藏

2009-05-19
缩略显示
Log4j详细配置

博客分类：
Java

log4jApacheSocketCC++
一、前言：
log4j 是一个开放源码项目，是广泛使用的以Java编写的日志记录包。由于log4j出色的表现，当时在log4j完成
时，log4j开发组织曾建议sun在jdk1.4中用log4j取代jdk1.4 的日志工具类，但当时jdk1.4已接近完成，所以sun拒绝使用log4j，当在java开发中实际使用最多的还是log4j，人们遗忘了sun的日志工具类。它的一个独有特性包括在类别中继承的概念。通过使用类别层次结构，这样就减少了日志记录输出量，并将日志记录的开销降到最低。
它允许开发者控制以任意间隔输出哪些日志语句。通过使用外部配置文件，完全可以在运行时进行配置。几乎每个大的应用程序都包括其自己的日志记录或跟踪 API。经验表明日志记录是开发周期中的重要组成部分。同样，日志记录提供一些优点。首先，它可以提供运行应用程序的确切上下文。一旦插入到代码中，生成日志记录输出就不需要人为干涉。其次，日志输出可以保存到永久媒体中以便以后研究。最后，除了在开发阶段中使用，十分丰富的日志记录包还可以用作审计工具。
依照该规则，在 1996 年初，EU SEMPER（欧洲安全电子市场）项目就决定编写自己的跟踪 API。在无数次改进、几次具体化和许多工作之后，该 API 已经演变成 log4j，一种流行的 Java 日志记录包。这个包按 IBM 公共许可证分发，由开放源码权威机构认证。
日志记录有其自己的缺点。它会降低应用程序的速度。如果太详细，它可能会使屏幕滚动变得看不见。为了减低
这些影响，log4j 被设计成快速且灵活的。由于应用程序很少将日志记录当作是主要功能，log4j API 力争易于了解
和使用。
log4j，它可以控制以任意间隔输出哪些日志语句。
二、主要组件
1、根类别（在类别层次结构的顶部，即全局性的日志级别）
配置根Logger，其语法为：
log4j.rootLogger = [ level ] , appenderName, appenderName, ...
level 是日志记录的类别
appenderName就是指定日志信息输出到哪个地方。您可以同时指定多个输出目的地。
类别level 为 OFF、FATAL、ERROR、WARN、INFO、DEBUG、log、ALL或自定义的优先级。
log4j常用的优先级FATAL>ERROR>WARN>INFO>DEBUG

如果为log4j.rootLogger=WARN，则意味着只有WARN,ERROR,FATAL被输出，DEBUG,INFO将被屏蔽掉。
举例：log4j.rootCategory=INFO,stdout,Runlog,Errorlog
根日志类别为INFO，DEBUG将被屏蔽，其他的将被输出。 stdout,Runlog,Errorlog分别为3个输出目的地。
2、常用输出格式
-X号:X信息输出时左对齐；
%p:日志信息级别
%d{}:日志信息产生时间
%c:日志信息所在地（类名）
%m:产生的日志具体信息
%n:输出日志信息换行
举例：
log4j.appender.stdout.layout.ConversionPattern= %5p %d{yyyy-MM-dd HH:mm:ss} %c %m %n
log4j.appender.Runlog.layout.ConversionPattern= %5p %d{yyyy-MM-dd HH:mm:ss} %c %m %n
log4j.appender.Errorlog.layout.ConversionPattern= %5p %d{yyyy-MM-dd HH:mm:ss} %c %m %n
3、布局
使用的输出布局，其中log4j提供4种布局：
org.apache.log4j.HTMLLayout（以HTML表格形式布局）
org.apache.log4j.PatternLayout（可以灵活地指定布局模式），
org.apache.log4j.SimpleLayout（包含日志信息的级别和信息字符串），
org.apache.log4j.TTCCLayout（包含日志产生的时间、线程、类别等等信息）
举例：
输出格式为HTML表格
log4j.appender.stdout.layout=org.apache.log4j.HTMLLayout
输出格式为可以灵活地指定布局模式
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
输出格式为包含日志信息的级别和信息字符串
log4j.appender.stdout.layout=org.apache.log4j.SimpleLayout
输出格式为包含日志产生的时间、线程、类别等等信息
log4j.appender.stdout.layout=org.apache.log4j.TTCCLayout
4、目的地

配置日志信息输出目的地Appender，其语法为
log4j.appender.appenderName = fully.qualified.name.of.appender.class
log4j.appender.appenderName.option1 = value1
...
log4j.appender.appenderName.option = valueN
appenderName就是指定日志信息输出到哪个地方。您可以同时指定多个输出目的地。
log4j支持的输出目的地：
org.apache.log4j.ConsoleAppender 控制台
org.apache.log4j.FileAppender 文件
org.apache.log4j.DailyRollingFileAppender 每天产生一个日志文件
org.apache.log4j.RollingFileAppender （文件大小到达指定尺寸的时候产生一个新的文件），
org.apache.log4j.WriterAppender （将日志信息以流格式发送到任意指定的地方）
org.apache.log4j.net.SMTPAppender 邮件
org.apache.log4j.jdbc.JDBCAppender 数据库
其他如：GUI组件、甚至是套接口服务器、NT的事件记录器、UNIX Syslog守护进程等
举例：
输出到控制台
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender（指定输出到控制台）
log4j.appender.Threshold=DEBUG（指定输出类别）
log4j.appender.CONSOLE.Target=System.out
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout（指定输出布局）
log4j.appender.CONSOLE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n（指定输出格式）
输出到文件
log4j.appender.FILE=org.apache.log4j.FileAppender（指定输出到文件）
log4j.appender.FILE.File=file.log（指定输出的路径及文件名）
log4j.appender.FILE.Append=false
log4j.appender.FILE.layout=org.apache.log4j.PatternLayout（指定输出的布局）
log4j.appender.FILE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n（指定输出的格式）
输出到文件（轮换"日志文件",当日志文件达到指定大小时，该文件就被关闭并备份，然后创建一个新的日志文件）
log4j.appender.ROLLING_FILE=org.apache.log4j.RollingFileAppender（指定输出到文件）
log4j.appender.ROLLING_FILE.Threshold=ERROR（指定输出类别）
log4j.appender.ROLLING_FILE.File=rolling.log（指定输出的路径及文件名）
log4j.appender.ROLLING_FILE.Append=true
log4j.appender.ROLLING_FILE.MaxFileSize=10KB（指定输出到文件的大小）
log4j.appender.ROLLING_FILE.MaxBackupIndex=1
log4j.appender.ROLLING_FILE.layout=org.apache.log4j.PatternLayout（指定采用输出布局）
log4j.appender.ROLLING_FILE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n（指定采用输出格式）
输出到Socket
log4j.appender.SOCKET=org.apache.log4j.RollingFileAppender（指定输出到Socket）
log4j.appender.SOCKET.RemoteHost=localhost（远程主机）
log4j.appender.SOCKET.Port=5001（远程主机端口）
log4j.appender.SOCKET.LocationInfo=true
log4j.appender.SOCKET.layout=org.apache.log4j.PatternLayout（布局）
log4j.appender.SOCET.layout.ConversionPattern =[start]%d{DATE}[DATE]%n%p[PRIORITY]%n%x[NDC]%n%t[THREAD]%n%c[CATEGORY]%n %m[MESSAGE]%n%n（输出格式）
输出到邮件
log4j.appender.MAIL=org.apache.log4j.net.SMTPAppender（指定输出到邮件）
log4j.appender.MAIL.Threshold=FATAL
log4j.appender.MAIL.BufferSize=10
log4j.appender.MAIL.From=chenyl@hollycrm.com（发件人）
log4j.appender.MAIL.SMTPHost=mail.hollycrm.com（SMTP服务器）
log4j.appender.MAIL.Subject=Log4J Message
log4j.appender.MAIL.To=chenyl@hollycrm.com（收件人）
log4j.appender.MAIL.layout=org.apache.log4j.PatternLayout（布局）
log4j.appender.MAIL.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n（格式）
输出到数据库
log4j.appender.DATABASE=org.apache.log4j.jdbc.JDBCAppender（指定输出到数据库）
log4j.appender.DATABASE.URL=jdbc:mysql://localhost:3306/test（指定数据库URL）
log4j.appender.DATABASE.driver=com.mysql.jdbc.Driver（指定数据库driver）
log4j.appender.DATABASE.user=root（指定数据库用户）
log4j.appender.DATABASE.password=root（指定数据库用户密码）
log4j.appender.DATABASE.sql=INSERT INTO LOG4J (Message) VALUES ('[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n')（组织SQL语句）
log4j.appender.DATABASE.layout=org.apache.log4j.PatternLayout（布局）
log4j.appender.DATABASE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n（格式）
5、日志类别补充
有时我们需要对某个特定的部分指定有别于根类别的日志类别，可以指定某个包的优先级
如：
log4j.category.com.neusoft.mbip.dm.util=ERROR ，其中com.neusoft.mbip.dm.util为我们需要特别指定日志类别的部分。
或者可以指定输出文件的优先级
log4j.appender.Errorlog.Threshold=ERROR
三、 常用log4j配置
常用log4j配置，一般可以采用两种方式，.properties和.xml,下面举两个简单的例子：
1、log4j.properties
### 设置org.zblog域对应的级别INFO,DEBUG,WARN,ERROR和输出地A1，A2 ##
log4j.category.org.zblog=ERROR,A1
log4j.category.org.zblog=INFO,A2
log4j.appender.A1=org.apache.log4j.ConsoleAppender
### 设置输出地A1，为ConsoleAppender(控制台) ##
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
### 设置A1的输出布局格式PatterLayout,(可以灵活地指定布局模式）##
log4j.appender.A1.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss,SSS} [%c]-[%p] %m%n
### 配置日志输出的格式##
log4j.appender.A2=org.apache.log4j.RollingFileAppender
### 设置输出地A2到文件（文件大小到达指定尺寸的时候产生一个新的文件）##
log4j.appender.A2.File=E:/study/log4j/zhuwei.html
### 文件位置##
log4j.appender.A2.MaxFileSize=500KB
### 文件大小##
log4j.appender.A2.MaxBackupIndex=1
log4j.appender.A2.layout=org.apache.log4j.HTMLLayout
##指定采用html方式输出
2、log4j.xml
<?xml version="1.0" encoding="GB2312" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
<appender name="org.zblog.all" class="org.apache.log4j.RollingFileAppender">
<!-- 设置通道ID:org.zblog.all和输出方式：org.apache.log4j.RollingFileAppender -->
<param name="File" value="E:/study/log4j/all.output.log" /><!-- 设置File参数：日志输出文件名 -->
<param name="Append" value="false" /><!-- 设置是否在重新启动服务时，在原有日志的基础添加新日志 -->
<layout class="org.apache.log4j.PatternLayout">
<param name="ConversionPattern" value="%p (%c:%L)- %m%n" /><!-- 设置输出文件项目和格式 -->
</layout>
</appender>
<appender name="org.zblog.zcw" class="org.apache.log4j.RollingFileAppender">
<param name="File" value="E:/study/log4j/zhuwei.output.log" />
<param name="Append" value="true" />
<param name="MaxFileSize" value="10240" /> <!-- 设置文件大小 -->
<layout class="org.apache.log4j.PatternLayout">
<param name="ConversionPattern" value="%p (%c:%L)- %m%n" />
</layout>
</appender>
<logger name="zcw.log"> <!-- 设置域名限制，即zcw.log域及以下的日志均输出到下面对应的通道中 -->
<level value="debug" /><!-- 设置级别 -->
<appender-ref ref="org.zblog.zcw" /><!-- 与前面的通道id相对应 -->
</logger>
<root> <!-- 设置接收所有输出的通道 -->
<appender-ref ref="org.zblog.all" /><!-- 与前面的通道id相对应 -->
</root>
</log4j:configuration>
3、配置文件加载方法：
import org.apache.log4j.Logger;
import org.apache.log4j.PropertyConfigurator;
import org.apache.log4j.xml.DOMConfigurator;
public class Log4jApp {
public static void main(String[] args) {
DOMConfigurator.configure("E:/study/log4j/log4j.xml");//加载.xml文件
//PropertyConfigurator.configure("E:/study/log4j/log4j.properties");//加载.properties文件
Logger log=Logger.getLogger("org.zblog.test");
log.info("测试");
}
}
4、项目使用log4j
在web应用中，可以将配置文件的加载放在一个单独的servlet中，并在web.xml中配置该servlet在应用启动时候加载。
对于在多人项目中，可以给每一个人设置一个输出通道，这样在每个人在构建Logger时，用自己的域名称，让调试信
息输出到自己的log文件中。
四、log4j配置举例（properties）
#log4j.rootLogger = [ level ] , appenderName, appenderName,
#类别level 为 OFF、FATAL、ERROR、WARN、INFO、DEBUG、log、ALL或自定义的优先级
#Log4j常用的优先级FATAL>ERROR>WARN>INFO>DEBUG
#stdout为控制台 ，Errorlog为错误记录日志 ，
log4j.rootCategory=INFO,stdout,Runlog,Errorlog
#输出的appender的格式为
#log4j.appender.appenderName = fully.qualified.name.of.appender.class
#log4j.appender.appenderName.option1 = value1
#log4j.appender.appenderName.option = valueN
#Log4j中appender支持的输出
#org.apache.log4j.ConsoleAppender 控制台
#org.apache.log4j.FileAppender 文件
#org.apache.log4j.DailyRollingFileAppender 每天产生一个日志文件
#org.apache.log4j.RollingFileAppender （文件大小到达指定尺寸的时候产生一个新的文件），
#org.apache.log4j.WriterAppender （将日志信息以流格式发送到任意指定的地方）
#org.apache.log4j.net.SMTPAppender 邮件
#org.apache.log4j.jdbc.JDBCAppender 数据库
＃定义输出的形式
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.Runlog=org.apache.log4j.DailyRollingFileAppender
log4j.appender.Errorlog=org.apache.log4j.DailyRollingFileAppender
#可以指定输出文件的优先级
log4j.appender.Errorlog.Threshold=ERROR
#指定输出的文件
log4j.appender.Runlog.File=D:""UserInfoSyn""WebRoot""WEB-INF""runlog""runlog.log
log4j.appender.Errorlog.File=D:""UserInfoSyn""WebRoot""WEB-INF""errorlog""errorlog.log
#Log4j的layout布局
#org.apache.log4j.HTMLLayout 以HTML表格形式布局
#org.apache.log4j.PatternLayout 可以灵活地指定布局模式
#org.apache.log4j.SimpleLayout 包含日志信息的级别和信息字符串
#org.apache.log4j.TTCCLayout 包含日志产生的时间、线程、类别等等信息
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.Runlog.layout=org.apache.log4j.PatternLayout
log4j.appender.Errorlog.layout=org.apache.log4j.PatternLayout
#输出格式,log4j javadoc org.apache.log4j.PatternLayout
#-X号:X信息输出时左对齐；
#%p:日志信息级别
# %d{}:日志信息产生时间
# %c:日志信息所在地（类名）
# %m:产生的日志具体信息
# %n:%n:输出日志信息换行
log4j.appender.stdout.layout.ConversionPattern= %5p %d{yyyy-MM-dd HH:mm:ss} %c %m %n
log4j.appender.Runlog.layout.ConversionPattern= %5p %d{yyyy-MM-dd HH:mm:ss} %c %m %n
log4j.appender.Errorlog.layout.ConversionPattern= %5p %d{yyyy-MM-dd HH:mm:ss} %c %m %n
#指定某个包的优先级
log4j.category.com.neusoft.mbip.dm.util=ERROR
#示例
###################
# Console Appender
###################
#log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
#log4j.appender.Threshold=DEBUG
#log4j.appender.CONSOLE.Target=System.out
#log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
#log4j.appender.CONSOLE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n
#log4j.appender.CONSOLE.layout.ConversionPattern=[start]%d{DATE}[DATE]%n%p[PRIORITY]%n%x[NDC]%n%t[THREAD] n%c[CATEGORY]%n%m[MESSAGE]%n%n
#####################
# File Appender
#####################
#log4j.appender.FILE=org.apache.log4j.FileAppender
#log4j.appender.FILE.File=file.log
#log4j.appender.FILE.Append=false
#log4j.appender.FILE.layout=org.apache.log4j.PatternLayout
#log4j.appender.FILE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n
# Use this layout for LogFactor 5 analysis
########################
# Rolling File????? RollingFileAppender??????????????????
########################
#log4j.appender.ROLLING_FILE=org.apache.log4j.RollingFileAppender
#log4j.appender.ROLLING_FILE.Threshold=ERROR
# 文件位置
#log4j.appender.ROLLING_FILE.File=rolling.log
#log4j.appender.ROLLING_FILE.Append=true
#文件大小
#log4j.appender.ROLLING_FILE.MaxFileSize=10KB
#指定采用输出布局和输出格式
#log4j.appender.ROLLING_FILE.MaxBackupIndex=1
#log4j.appender.ROLLING_FILE.layout=org.apache.log4j.PatternLayout
#log4j.appender.ROLLING_FILE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n
####################
# Socket Appender
####################
#log4j.appender.SOCKET=org.apache.log4j.RollingFileAppender
#log4j.appender.SOCKET.RemoteHost=localhost
#log4j.appender.SOCKET.Port=5001
#log4j.appender.SOCKET.LocationInfo=true
# Set up for Log Facter 5
#log4j.appender.SOCKET.layout=org.apache.log4j.PatternLayout
#log4j.appender.SOCET.layout.ConversionPattern=[start]%d{DATE}[DATE]%n%p[PRIORITY]%n%x[NDC]%n%t[THREAD]%n%c[CATEGORY]%n%m[MESSAGE]%n%n
########################
# SMTP Appender
#######################
#log4j.appender.MAIL=org.apache.log4j.net.SMTPAppender
#log4j.appender.MAIL.Threshold=FATAL
#log4j.appender.MAIL.BufferSize=10
#log4j.appender.MAIL.From=chenyl@hollycrm.com
#log4j.appender.MAIL.SMTPHost=mail.hollycrm.com
#log4j.appender.MAIL.Subject=Log4J Message
#log4j.appender.MAIL.To=chenyl@hollycrm.com
#log4j.appender.MAIL.layout=org.apache.log4j.PatternLayout
#log4j.appender.MAIL.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n
########################
# JDBC Appender
#######################
#log4j.appender.DATABASE=org.apache.log4j.jdbc.JDBCAppender
#log4j.appender.DATABASE.URL=jdbc:mysql://localhost:3306/test
#log4j.appender.DATABASE.driver=com.mysql.jdbc.Driver
#log4j.appender.DATABASE.user=root
#log4j.appender.DATABASE.password=
#log4j.appender.DATABASE.sql=INSERT INTO LOG4J (Message) VALUES ('[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n')
#log4j.appender.DATABASE.layout=org.apache.log4j.PatternLayout
#log4j.appender.DATABASE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n
########################
# Log Factor 5 Appender
########################
#log4j.appender.LF5_APPENDER=org.apache.log4j.lf5.LF5Appender
#log4j.appender.LF5_APPENDER.MaxNumberOfRecords=2000
###################
#自定义Appender
###################
#log4j.appender.im = net.cybercorlin.util.logger.appender.IMAppender
#log4j.appender.im.host = mail.cybercorlin.net
#log4j.appender.im.username = username
#log4j.appender.im.password = password
#log4j.appender.im.recipient = corlin@cybercorlin.net
#log4j.appender.im.layout=org.apache.log4j.PatternLayout
#log4j.appender.im.layout.ConversionPattern =[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n

10:51
评论 / 浏览 (0 / 156)
收藏

2009-03-12
缩略显示
ANT-build.xml文件详解

博客分类：
Java

XMLAnt设计模式项目管理Linux

Ant的概念




可能有些读者并不连接什么是Ant以及入可使用它，但只要使用通过Linux系统得读者，应该知道make这个命令。当编译Linux内核及一些软件的源程序时，经常要用这个命令。Make命令其实就是一个项目管理工具，而Ant所实现功能与此类似。像make，gnumake和nmake这些编译工具都有一定的缺陷，但是Ant却克服了这些工具的缺陷。最初Ant开发者在开发跨平台的应用时，用样也是基于这些缺陷对Ant做了更好的设计。



Ant 与 makefile
Makefile有一些不足之处，比如很多人都会碰到的烦人的Tab问题。最初的Ant开发者多次强调”只是我在Tab前面加了一个空格，所以我的命令就不能执行”。有一些工具在一定程度上解决了这个问题，但还是有很多其他的问题。Ant则与一般基于命令的工具有所不同，它是Java类的扩展。Ant运行需要的XML格式的文件不是Shell命令文件。它是由一个Project组成的，而一个Project又可分成可多target，target再细分又分成很多task，每一个task都是通过一个实现特定接口的java类来完成的。



Ant的优点

Ant是Apache软件基金会JAKARTA目录中的一个子项目，它有以下的优点。
跨平台性。Ant是存Java语言编写的，所示具有很好的跨平台性。
操作简单。Ant是由一个内置任务和可选任务组成的。Ant运行时需要一个XML文件(构建文件)。

Ant通过调用target树，就可以执行各种task。每个task实现了特定接口对象。由于Ant构建文件时XML格式的文件，所以和容易维护和书写，而且结构很清晰。
Ant可以集成到开发环境中。由于Ant的跨平台性和操作简单的特点，它很容易集成到一些开发环境中去。



Ant 开发

Ant的构建文件
当开始一个新的项目时，首先应该编写Ant构建文件。构建文件定义了构建过程，并被团队开发中每个人使用。Ant构建文件默认命名为build.xml，也可以取其他的名字。只不过在运行的时候把这个命名当作参数传给Ant。构建文件可以放在任何的位置。一般做法是放在项目顶层目录中，这样可以保持项目的简洁和清晰。下面是一个典型的项目层次结构。
(1) src存放文件。
(2) class存放编译后的文件。
(3) lib存放第三方JAR包。
(4) dist存放打包，发布以后的代码。
Ant构建文件是XML文件。每个构建文件定义一个唯一的项目(Project元素)。每个项目下可以定义很多目标(target元素)，这些目标之间可以有依赖关系。当执行这类目标时，需要执行他们所依赖的目标。
每个目标中可以定义多个任务，目标中还定义了所要执行的任务序列。Ant在构建目标时必须调用所定义的任务。任务定义了Ant实际执行的命令。Ant中的任务可以为3类。
（1） 核心任务。核心任务是Ant自带的任务。
（2） 可选任务。可选任务实来自第三方的任务，因此需要一个附加的JAR文件。
（3） 用户自定义的任务。用户自定义的任务实用户自己开发的任务。
1.<project>标签
每个构建文件对应一个项目。<project>标签时构建文件的根标签。它可以有多个内在属性，就如代码中所示，其各个属性的含义分别如下。
(1) default表示默认的运行目标，这个属性是必须的。
(2) basedir表示项目的基准目录。
(3) name表示项目名。
(4) description表示项目的描述。
每个构建文件都对应于一个项目，但是大型项目经常包含大量的子项目，每一个子项目都可以有自己的构建文件。

2.<target>标签
一个项目标签下可以有一个或多个target标签。一个target标签可以依赖其他的target标签。例如，有一个target用于编译程序，另一个target用于声称可执行文件。在生成可执行文件之前必须先编译该文件，因策可执行文件的target依赖于编译程序的target。Target的所有属性如下。
(1).name表示标明，这个属性是必须的。
(2).depends表示依赖的目标。
(3)if表示仅当属性设置时才执行。
(4)unless表示当属性没有设置时才执行。
(5)description表示项目的描述。
Ant的depends属性指定了target的执行顺序。Ant会依照depends属性中target出现顺序依次执行每个target。在执行之前，首先需要执行它所依赖的target。程序中的名为run的target的depends属性compile，而名为compile的target的depends属性是prepare，所以这几个target执行的顺序是prepare->compile->run。
一个target只能被执行一次，即使有多个target依赖于它。如果没有if或unless属性，target总会被执行。

3.<mkdir>标签
该标签用于创建一个目录，它有一个属性dir用来指定所创建的目录名，其代码如下：
<mkdir dir=”＄{class.root}”/>
通过以上代码就创建了一个目录，这个目录已经被前面的property标签所指定。

4<jar>标签
该标签用来生成一个JAR文件，其属性如下。
(1) destfile表示JAR文件名。
(2) basedir表示被归档的文件名。
(3) includes表示别归档的文件模式。
(4) exchudes表示被排除的文件模式。

5．<javac标签>
该标签用于编译一个或一组java文件，其属性如下。
(1).srcdir表示源程序的目录。
(2).destdir表示class文件的输出目录。
(3).include表示被编译的文件的模式。
(4).excludes表示被排除的文件的模式。
(5).classpath表示所使用的类路径。
(6).debug表示包含的调试信息。
(7).optimize表示是否使用优化。
(8).verbose 表示提供详细的输出信息。
(9).fileonerror表示当碰到错误就自动停止。

6．<java>标签
该标签用来执行编译生成的.class文件，其属性如下。
(1).classname 表示将执行的类名。
(2).jar表示包含该类的JAR文件名。
(3).classpath所表示用到的类路径。
(4).fork表示在一个新的虚拟机中运行该类。
(5).failonerror表示当出现错误时自动停止。
(6).output 表示输出文件。
(7).append表示追加或者覆盖默认文件。

7.<delete>标签
该标签用于删除一个文件或一组文件，去属性如下。
(1)/file表示要删除的文件。
(2).dir表示要删除的目录。
(3).includeEmptyDirs 表示指定是否要删除空目录，默认值是删除。
(4).failonerror 表示指定当碰到错误是否停止，默认值是自动停止。
(5).verbose表示指定是否列出所删除的文件，默认值为不列出。

8.<copy>标签
该标签用于文件或文件集的拷贝，其属性如下。
(1).file 表示源文件。
(2).tofile 表示目标文件。
(3).todir 表示目标目录。
(4).overwrite 表示指定是否覆盖目标文件，默认值是不覆盖。
(5).includeEmptyDirs 表示制定是否拷贝空目录，默认值为拷贝。
(6).failonerror 表示指定如目标没有发现是否自动停止，默认值是停止。
(7).verbose 表示制定是否显示详细信息，默认值不显示。



Ant的数据类型
在构建文件中为了标识文件或文件组，经常需要使用数据类型。数据类型包含在

org.apache.tool.ant.types包中。下面镜简单介绍构建文件中一些常用的数据类型。

1. argument 类型
由Ant构建文件调用的程序，可以通过<arg>元素向其传递命令行参数，如apply,exec和java任

务均可接受嵌套<arg>元素，可以为各自的过程调用指定参数。以下是<arg>的所有属性。
(1).values 是一个命令参数。如果参数种有空格，但又想将它作为单独一个值，则使用此属性

。
(2).file表示一个参数的文件名。在构建文件中，此文件名相对于当前的工作目录。
(3).line表示用空格分隔的多个参数列表。
(4).path表示路径。

2.ervironment 类型
由Ant构建文件调用的外部命令或程序，<env>元素制定了哪些环境变量要传递给正在执行的系

统命令，<env>元素可以接受以下属性。
(1).file表示环境变量值得文件名。此文件名要被转换位一个绝对路径。
(2).path表示环境变量的路径。Ant会将它转换为一个本地约定。
(3).value 表示环境变量的一个直接变量。
(4).key 表示环境变量名。
注意 file path 或 value只能取一个。

3.filelist类型
Filelist 是一个支持命名的文件列表的数据类型，包含在一个filelist类型中的文件不一定是存在的文件。以下是其所有的属性。
(1).dir是用于计算绝对文件名的目录。
(2).files 是用逗号分隔的文件名列表。
(3).refid 是对某处定义的一个<filelist>的引用。
注意 dir 和 files 都是必要的，除非指定了refid(这种情况下，dir和files都不允许使用)。

4.fileset类型
Fileset 数据类型定义了一组文件，并通常表示为<fileset>元素。不过，许多ant任务构建成了隐式的fileset,这说明他们支持所有的fileset属性和嵌套元素。以下为fileset 的属性列表。
(1).dir表示fileset 的基目录。
(2).casesensitive的值如果为false，那么匹配文件名时，fileset不是区分大小写的，其默认值为true.
(3).defaultexcludes 用来确定是否使用默认的排除模式，默认为true。
(4).excludes 是用逗号分隔的需要派出的文件模式列表。
(5).excludesfile 表示每行包含一个排除模式的文件的文件名。
(6).includes 是用逗号分隔的，需要包含的文件模式列表。
(7).includesfile 表示每行包括一个包含模式的文件名。

5.patternset 类型
Fileset 是对文件的分组，而patternset是对模式的分组，他们是紧密相关的概念。

<patternset>支持4个属性：includes excludex includexfile 和 excludesfile,与fileset相

同。Patternset 还允许以下嵌套元素：include,exclude,includefile 和 excludesfile.

6.filterset 类型
Filterset定义了一组过滤器，这些过滤器将在文件移动或复制时完成文件的文本替换。
主要属性如下：
(1).begintoken 表示嵌套过滤器所搜索的记号，这是标识其开始的字符串。
(2).endtoken表示嵌套过滤器所搜索的记号这是标识其结束的字符串。
(3).id是过滤器的唯一标志符。
(4).refid是对构建文件中某处定义一个过滤器的引用。

7.Path类型
Path元素用来表示一个类路径，不过它还可以用于表示其他的路径。在用作揖个属性时，路经中的各项用分号或冒号隔开。在构建的时候，此分隔符将代替当前平台中所有的路径分隔符，其拥有的属性如下。
(1).location 表示一个文件或目录。Ant在内部将此扩展为一个绝对路径。
(2).refid 是对当前构建文件中某处定义的一个path的引用。
(3).path表示一个文件或路径名列表。

8.mapper类型
Mapper类型定义了一组输入文件和一组输出文件间的关系，其属性如下。
(1).classname 表示实现mapper类的类名。当内置mapper不满足要求时，用于创建定制mapper.
(2).classpath表示查找一个定制mapper时所用的类型路径。
(3).classpathref是对某处定义的一个类路径的引用。
(4).from属性的含义取决于所用的mapper.
(5).to属性的含义取决于所用的mapper.
(6).type属性的取值为identity，flatten glob merge regexp 其中之一，它定义了要是用的内置mapper的类型。


Ant 的运行
安装好Ant并且配置好路径之后，在命令行中切换到构建文件的目录，输入Ant命令就可以运行Ant.若没有指定任何参数，Ant会在当前目录下查询build.xml文件。如果找到了就用该文件作为构建文件。如果使用了 –find 选项，Ant 就会在上级目录中找构建文件，直至到达文件系统得跟目录。如果构建文件的名字不是build.xml ，则Ant运行的时候就可以使用 –buildfile file,这里file 指定了要使用的构建文件的名称，示例如下：
Ant
如下说明了表示当前目录的构建文件为build.xml 运行 ant 执行默认的目标。

Ant –buildfile test.xml
使用当前目录下的test.xml 文件运行Ant ,执行默认的目标

13:54
评论 / 浏览 (0 / 473)
收藏

2009-03-05
缩略显示
tomcat配置说明和内存扩容

博客分类：
Java

Tomcat配置管理WindowsUnixLinux
1. 如何加大tomcat连接数

在tomcat配置文件server.xml中的<Connector ... />配置中，和连接数相关的参数有：
minProcessors：最小空闲连接线程数，用于提高系统处理性能，默认值为10
maxProcessors：最大连接线程数，即：并发处理的最大请求数，默认值为75
acceptCount：允许的最大连接数，应大于等于maxProcessors，默认值为100
enableLookups：是否反查域名，取值为：true或false。为了提高处理能力，应设置为false
connectionTimeout：网络连接超时，单位：毫秒。设置为0表示永不超时，这样设置有隐患的。通常可设置为30000毫秒。

其中和最大连接数相关的参数为maxProcessors和acceptCount。如果要加大并发连接数，应同时加大这两个参数。

web server允许的最大连接数还受制于操作系统的内核参数设置，通常Windows是2000个左右，Linux是1000个左右。Unix中如何设置这些参数，请参阅Unix常用监控和管理命令
tomcat4中的配置示例：
<Connector className="org.apache.coyote.tomcat4.CoyoteConnector"
port="8080" minProcessors="10" maxProcessors="1024"
enableLookups="false" redirectPort="8443"
acceptCount="1024" debug="0" connectionTimeout="30000" />

对于其他端口的侦听配置，以此类推。

2. tomcat中如何禁止列目录下的文件
在{tomcat_home}/conf/web.xml中，把listings参数设置成false即可，如下：
<servlet>
...
<init-param>
<param-name>listings</param-name>
<param-value>false</param-value>
</init-param>
...
</servlet>

3. 如何加大tomcat可以使用的内存

tomcat默认可以使用的内存为128MB，在较大型的应用项目中，这点内存是不够的，需要调大。

Unix下，在文件{tomcat_home}/bin/catalina.sh的前面，增加如下设置：
JAVA_OPTS='-Xms【初始化内存大小】 -Xmx【可以使用的最大内存】'
需要把这个两个参数值调大。例如：
JAVA_OPTS='-Xms256m -Xmx512m'
表示初始化内存为256MB，可以使用的最大内存为512MB 。


Windows下：

绿色安装在tomcat5/bin/catalina.bat最前面加入set JAVA_OPTS=-Xms128m -Xmx256m ，用startup.bat启动,设置生效.

如果不是执行startup.bat启动，而是利用windows的系统服务启动tomcat服务,上面的设置就不生效了。

windows服务执行的是bin\tomcat.exe.他读取注册表中的值,而不是catalina.bat的设置.

解决办法:
修改注册表HKEY_LOCAL_MACHINE\SOFTWARE\Apache Software Foundation\Tomcat Service Manager\Tomcat5\Parameters\JavaOptions
原值为
-Dcatalina.home="C:\ApacheGroup\Tomcat 5.0"
-Djava.endorsed.dirs="C:\ApacheGroup\Tomcat 5.0\common\endorsed"
-Xrs

加入 -Xms128m -Xmx256m
重起tomcat服务,设置生效

4. 如何添加默认访问页面
修改文件web.xml，在welcome-list里面添加index.wml作为默认的访问页面
<welcome-file-list>
<welcome-file>index.html</welcome-file>
<welcome-file>index.htm</welcome-file>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>







14:37
评论 / 浏览 (0 / 693)
收藏

2009-03-03
缩略显示
ehCache在acegi中的应用

博客分类：
Java

AcegiCacheBean配置管理DAO

EhCache一般用途如下：Hibernate缓存，DAO缓存，安全性凭证缓存（Acegi），Web缓存，应用持久化和分布式缓存。
EhCache在默认情况下，即在用户未提供自身配置文件ehcache.xml或ehcache-failsafe.xml时，EhCache会依据其自身Jar存档包含的ehcache-failsafe.xml文件所定制的策略来管理缓存。如果用户在classpath下提供了ehcache.xml或ehcache-failsafe.xml文件，那么EhCache将会应用这个文件。如果两个文件同时提供，那么EhCache会使用ehcache.xml文件的配置。EhCache默认内容如下：


<ehcache>

<diskStore path="C:\Acegi6" />
<defaultCache
maxElementsInMemory="10000"
eternal="false"
timeToIdleSeconds="120"
timeToLiveSeconds="120"
overflowToDisk="true"
maxElementsOnDisk="10000000"
diskPersistent="false"
diskExpiryThreadIntervalSeconds="120"
memoryStoreEvictionPolicy="LRU"
/>
</ehcache>

属性说明：
 diskStore：指定数据在磁盘中的存储位置。
 defaultCache：当借助CacheManager.add("demoCache")创建Cache时，EhCache便会采用<defalutCache/>指定的的管理策略
以下属性是必须的：
 maxElementsInMemory - 在内存中缓存的element的最大数目
 maxElementsOnDisk - 在磁盘上缓存的element的最大数目
 eternal - 设定缓存的elements是否永远不过期。如果为true，则缓存的数据始终有效，如果为false那么还要根据timeToIdleSeconds，timeToLiveSeconds判断
 overflowToDisk - 设定当内存缓存溢出的时候是否将过期的element缓存到磁盘上
以下属性是可选的：
 timeToIdleSeconds - 当缓存在EhCache中的数据前后两次访问的时间超过timeToIdleSeconds的属性取值时，这些数据便会删除.
 timeToLiveSeconds - 缓存element的有效生命期
 diskPersistent - 在VM重启的时候是否启用磁盘保存EhCache中的数据，默认是false。
 diskExpiryThreadIntervalSeconds - 磁盘缓存的清理线程运行间隔，默认是120秒。每个120s，相应的线程会进行一次EhCache中数据的清理工作
 memoryStoreEvictionPolicy - 当内存缓存达到最大，有新的element加入的时候， 移除缓存中element的策略。默认是LRU（最近最少使用），可选的有LFU（最不常使用）和FIFO（先进先出）

import net.sf.ehcache.Cache;
import net.sf.ehcache.CacheManager;
import net.sf.ehcache.Element;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

/**
* 缓存管理器中不存在名为demoCache的缓存，所以需要先添加：
* manager.addCache("demoCache");
*/
public class EhCacheTestDemo {

protected static final Log log = LogFactory.getLog(EhCacheTestDemo.class);

public static void main(String[] args) {

CacheManager manager = new CacheManager();
manager.addCache("demoCache");

String[] cacheNames = manager.getCacheNames();
for (String cacheName : cacheNames) {
log.info("缓存的名字：" + cacheName);
}

//获得缓存

Cache cache = manager.getCache("demoCache");

Element element = new Element("data1", "缓存数据1");
//往缓存中存放数据，EhCache会依据一定的策略将数据存储到内存或磁盘中

cache.put(element);
//获得已缓存的数据

log.info(cache.get("data1").getValue());

element = new Element("data2", "缓存数据2");
cache.put(element);
log.info(cache.get("data2").getValue());

log.info(cache);
//打印出内存中已缓存的Element数量

log.info(cache.getMemoryStoreSize());
//打印出磁盘中已缓存的Element数量

log.info(cache.getDiskStoreSize());

//将“data1”从缓存中销毁掉

cache.remove("data1");

log.info(cache.getMemoryStoreSize());
log.info(cache.getDiskStoreSize());

System.exit(-1);
}

}

如果需要开发着可以提供自身的EhCache缓存配置文件：

<diskStore path="C:\Acegi6" />

<cache name="cacheAcegi"
maxElementsInMemory="1"
maxElementsOnDisk="1000"
eternal="false"
overflowToDisk="true"
timeToIdleSeconds="300"
timeToLiveSeconds="600"
memoryStoreEvictionPolicy="FIFO"
/>

默认放在src目录下，即classpath下面

import net.sf.ehcache.Cache;
import net.sf.ehcache.CacheManager;
import net.sf.ehcache.Element;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

/**
* 配置文件中已存在名称为cacheAcegi的缓存，不用添加到缓存管理器中
*/
public class EhCacheTestDemoVersion2 {

protected static final Log log = LogFactory.getLog(EhCacheTestDemoVersion2.class);

public static void main(String[] args) {

CacheManager manager = new CacheManager();

String[] cacheNames = manager.getCacheNames();
for (String cacheName : cacheNames) {
log.info("缓存的名字：" + cacheName);
}

//获得缓存
Cache cache = manager.getCache("cacheAcegi");

Element element = new Element("data1", "缓存数据1");
//往缓存中存放数据，EhCache会依据一定的策略将数据存储到内存或磁盘中
cache.put(element);
//获得已缓存的数据
log.info(cache.get("data1").getValue());

element = new Element("data2", "缓存数据2");
cache.put(element);
log.info(cache.get("data2").getValue());

log.info(cache);
//打印出内存中已缓存的Element数量
log.info(cache.getMemoryStoreSize());
//打印出磁盘中已缓存的Element数量
log.info(cache.getDiskStoreSize());

//将“data1”从缓存中销毁掉
cache.remove("data1");

log.info(cache.getMemoryStoreSize());
log.info(cache.getDiskStoreSize());

System.exit(-1);
}
}

spring EhCache集成：

<!-- EhCacheBasedUserCache是EhCache的一个缓存实现，提供了向缓存中放入、取得和删除用户明细信息的功能，Acegi需要用它来管理缓存。 -->

<!-- EhCacheFactoryBean是用于维护Cache实例的工厂Bean，Cache需要依赖于CacheManager而存在 -->
<bean id="userCacheBackend"
class="org.springframework.cache.ehcache.EhCacheFactoryBean">
<property name="cacheManager" ref="cacheManager" />
<property name="cacheName" value="userCache" />缓存名称
</bean>

<!-- 缓存管理器，一个CacheManager能够创建和维护多个Cache实例 -->
<bean id="cacheManager"
class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean" />

还可以指定相应的缓存管理策略：

<bean id="userCacheBackend"
class="org.springframework.cache.ehcache.EhCacheFactoryBean">
<property name="cacheManager" ref="cacheManager" />
<property name="cacheName" value="userCache" />缓存名称

<property name="maxElementsInMemory" value="10000" />
.....

</bean>

Spring EhCache集成引入Acegi：

每次当请求一个受保护的资源时，认证管理器就被调用以获取用户的安全信息。但如果获取用户信息涉及到查询数据库，每次都查询相同的数据可能在性能上表现得很糟糕。注意到用户信息不会频繁改变，也许更好的做法是在第一次查询时缓存用户信息，并在后续的查询中直接从缓存中获取用户信息。
DaoAuthenticationProvider通过org.acegisecurity.providers.dao.UserCache接口的实现类支持对用户信息进行缓存。
public interface UserCache {
public abstract UserDetails getUserFromCache(String s);
public abstract void putUserInCache(UserDetails userdetails);
public abstract void removeUserFromCache(String s);
}

顾名思义，接口UserCache中方法提供了向缓存中放入、取得和删除用户明细信息的功能。我们可以写一个自己的UserCache实现类，实现对用户信息的缓存。然而，在你考虑开发自己的UserCache实现类之前，应该首先考虑Acegi提供的两个方便的UserCache实现类：
 org.acegisecurity.providers.dao.cache.NullUserCache
 org.acegisecurity.providers.dao.cache.EhCacheBasedUserCache

NullUserCache事实上不进行任何缓存。任何时候调用它的getUserFromCache方法，得到的返回值都是null。这是DaoAuthenticationProvider使用的默认UserCache实现。
public class NullUserCache implements UserCache {
public NullUserCache() {}
public UserDetails getUserFromCache(String username) { return null; }
public void putUserInCache(UserDetails userdetails) {}
public void removeUserFromCache(String s) {}
}

EhCacheBasedUserCache是一个更实用的缓存实现。类如其名，它是基于开源项目ehcache实现的。ehcache是一个简单快速的针对Java的缓存解决方案，同时也是Hibernate默认的和推荐的缓存方案。

Acegi配置如下：

<bean id="daoAuthenticationProvider"
class="org.acegisecurity.providers.dao.DaoAuthenticationProvider">
......
<!-- 增加 -->
<property name="userCache"><ref local="userCache"/></property>
</bean>

<!-- EhCacheBasedUserCache是EhCache的一个缓存实现，提供了向缓存中放入、取得和删除用户明细信息的功能，Acegi需要用它来管理缓存。 -->
<bean id="userCache" class="org.acegisecurity.providers.dao.cache.EhCacheBasedUserCache">
<property name="cache" ref="userCacheBackend" />
</bean>

<!-- EhCacheFactoryBean是用于维护Cache实例的工厂Bean，Cache需要依赖于CacheManager而存在 -->
<bean id="userCacheBackend"
class="org.springframework.cache.ehcache.EhCacheFactoryBean">
<property name="cacheManager" ref="cacheManager" />
<property name="cacheName" value="userCache" /> 缓存名称
</bean>

<!-- 缓存管理器，一个CacheManager能够创建和维护多个Cache实例 -->
<bean id="cacheManager"
class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean" />

16:56
评论 / 浏览 (0 / 1044)
收藏

2009-02-24
缩略显示
特殊字符转义

博客分类：
Java

请看附件图片。

查看图片附件

10:52
评论 / 浏览 (0 / 124)
收藏

2009-02-16
缩略显示
Eclipse快捷键大全

博客分类：
Java

EclipseJ#项目管理F#IDEA
Eclipse中自定义设置快捷键：
Window --> Preferences --> General -->Keys
-----------------------------------------------------------
Ctrl+1 快速修复(最经典的快捷键,就不用多说了)
Ctrl+D: 删除当前行
Ctrl+Alt+↓ 复制当前行到下一行(复制增加)
Ctrl+Alt+↑ 复制当前行到上一行(复制增加)
Alt+↓ 当前行和下面一行交互位置(特别实用,可以省去先剪切,再粘贴了)
Alt+↑ 当前行和上面一行交互位置(同上)
Alt+← 前一个编辑的页面
Alt+→ 下一个编辑的页面(当然是针对上面那条来说了)
Alt+Enter 显示当前选择资源(工程,or 文件 or文件)的属性
Shift+Enter 在当前行的下一行插入空行(这时鼠标可以在当前行的任一位置,不一定是最后)
Shift+Ctrl+Enter 在当前行插入空行(原理同上条)
Ctrl+Q 定位到最后编辑的地方
Ctrl+L 定位在某行 (对于程序超过100的人就有福音了)
Ctrl+M 最大化当前的Edit或View (再按则反之)
Ctrl+/ 注释当前行,再按则取消注释
Ctrl+O 快速显示 OutLine
Ctrl+T 快速显示当前类的继承结构
Ctrl+W 关闭当前Editer
Ctrl+K 参照选中的Word快速定位到下一个
Ctrl+E 快速显示当前Editer的下拉列表(如果当前页面没有显示的用黑体表示)
Ctrl+/(小键盘) 折叠当前类中的所有代码
Ctrl+×(小键盘) 展开当前类中的所有代码
Ctrl+Space 代码助手完成一些代码的插入(但一般和输入法有冲突,可以修改输入法的热键,也可以暂用Alt+/来代替)
Ctrl+Shift+E 显示管理当前打开的所有的View的管理器(可以选择关闭,激活等操作)
Ctrl+J 正向增量查找(按下Ctrl+J后,你所输入的每个字母编辑器都提供快速匹配定位到某个单词,如果没有,则在stutes line中显示没有找到了,查一个单词时,特别实用,这个功能Idea两年前就有了)
Ctrl+Shift+J 反向增量查找(和上条相同,只不过是从后往前查)
Ctrl+Shift+F4 关闭所有打开的Editer
Ctrl+Shift+X 把当前选中的文本全部变味小写
Ctrl+Shift+Y 把当前选中的文本全部变为小写
Ctrl+Shift+F 格式化当前代码
Ctrl+Shift+P 定位到对于的匹配符(譬如{}) (从前面定位后面时,光标要在匹配符里面,后面到前面,则反之)

下面的快捷键是重构里面常用的,本人就自己喜欢且常用的整理一下(注:一般重构的快捷键都是Alt+Shift开头的了)
Alt+Shift+R 重命名 (是我自己最爱用的一个了,尤其是变量和类的Rename,比手工方法能节省很多劳动力)
Alt+Shift+M 抽取方法 (这是重构里面最常用的方法之一了,尤其是对一大堆泥团代码有用)
Alt+Shift+C 修改函数结构(比较实用,有N个函数调用了这个方法,修改一次搞定)
Alt+Shift+L 抽取本地变量( 可以直接把一些魔法数字和字符串抽取成一个变量,尤其是多处调用的时候)
Alt+Shift+F 把Class中的local变量变为field变量 (比较实用的功能)
Alt+Shift+I 合并变量(可能这样说有点不妥Inline)
Alt+Shift+V 移动函数和变量(不怎么常用)
Alt+Shift+Z 重构的后悔药(Undo)

编辑
作用域 功能 快捷键
全局 查找并替换 Ctrl+F
文本编辑器 查找上一个 Ctrl+Shift+K
文本编辑器 查找下一个 Ctrl+K
全局 撤销 Ctrl+Z
全局 复制 Ctrl+C
全局 恢复上一个选择 Alt+Shift+↓
全局 剪切 Ctrl+X
全局 快速修正 Ctrl1+1
全局 内容辅助 Alt+/
全局 全部选中 Ctrl+A
全局 删除 Delete
全局 上下文信息 Alt+？
Alt+Shift+?
Ctrl+Shift+Space
Java编辑器 显示工具提示描述 F2
Java编辑器 选择封装元素 Alt+Shift+↑
Java编辑器 选择上一个元素 Alt+Shift+←
Java编辑器 选择下一个元素 Alt+Shift+→
文本编辑器 增量查找 Ctrl+J
文本编辑器 增量逆向查找 Ctrl+Shift+J
全局 粘贴 Ctrl+V
全局 重做 Ctrl+Y


查看
作用域 功能 快捷键
全局 放大 Ctrl+=
全局 缩小 Ctrl+-


窗口
作用域 功能 快捷键
全局 激活编辑器 F12
全局 切换编辑器 Ctrl+Shift+W
全局 上一个编辑器 Ctrl+Shift+F6
全局 上一个视图 Ctrl+Shift+F7
全局 上一个透视图 Ctrl+Shift+F8
全局 下一个编辑器 Ctrl+F6
全局 下一个视图 Ctrl+F7
全局 下一个透视图 Ctrl+F8
文本编辑器 显示标尺上下文菜单 Ctrl+W
全局 显示视图菜单 Ctrl+F10
全局 显示系统菜单 Alt+-


导航
作用域 功能 快捷键
Java编辑器 打开结构 Ctrl+F3
全局 打开类型 Ctrl+Shift+T
全局 打开类型层次结构 F4
全局 打开声明 F3
全局 打开外部javadoc Shift+F2
全局 打开资源 Ctrl+Shift+R
全局 后退历史记录 Alt+←
全局 前进历史记录 Alt+→
全局 上一个 Ctrl+,
全局 下一个 Ctrl+.
Java编辑器 显示大纲 Ctrl+O
全局 在层次结构中打开类型 Ctrl+Shift+H
全局 转至匹配的括号 Ctrl+Shift+P
全局 转至上一个编辑位置 Ctrl+Q
Java编辑器 转至上一个成员 Ctrl+Shift+↑
Java编辑器 转至下一个成员 Ctrl+Shift+↓
文本编辑器 转至行 Ctrl+L


搜索
作用域 功能 快捷键
全局 出现在文件中 Ctrl+Shift+U
全局 打开搜索对话框 Ctrl+H
全局 工作区中的声明 Ctrl+G
全局 工作区中的引用 Ctrl+Shift+G


文本编辑
作用域 功能 快捷键
文本编辑器 改写切换 Insert
文本编辑器 上滚行 Ctrl+↑
文本编辑器 下滚行 Ctrl+↓


文件
作用域 功能 快捷键
全局 保存 Ctrl+X
Ctrl+S
全局 打印 Ctrl+P
全局 关闭 Ctrl+F4
全局 全部保存 Ctrl+Shift+S
全局 全部关闭 Ctrl+Shift+F4
全局 属性 Alt+Enter
全局 新建 Ctrl+N


项目
作用域 功能 快捷键
全局 全部构建 Ctrl+B


源代码
作用域 功能 快捷键
Java编辑器 格式化 Ctrl+Shift+F
Java编辑器 取消注释 Ctrl+\
Java编辑器 注释 Ctrl+/
Java编辑器 添加导入 Ctrl+Shift+M
Java编辑器 组织导入 Ctrl+Shift+O
Java编辑器 使用try/catch块来包围 未设置，太常用了，所以在这里列出,建议自己设置。
也可以使用Ctrl+1自动修正。


运行
作用域 功能 快捷键
全局 单步返回 F7
全局 单步跳过 F6
全局 单步跳入 F5
全局 单步跳入选择 Ctrl+F5
全局 调试上次启动 F11
全局 继续 F8
全局 使用过滤器单步执行 Shift+F5
全局 添加/去除断点 Ctrl+Shift+B
全局 显示 Ctrl+D
全局 运行上次启动 Ctrl+F11
全局 运行至行 Ctrl+R
全局 执行 Ctrl+U


重构
作用域 功能 快捷键
全局 撤销重构 Alt+Shift+Z
全局 抽取方法 Alt+Shift+M
全局 抽取局部变量 Alt+Shift+L
全局 内联 Alt+Shift+I
全局 移动 Alt+Shift+V
全局 重命名 Alt+Shift+R
全局 重做 Alt+Shift+Y

15:06
评论 / 浏览 (0 / 143)
收藏

2009-02-12
缩略显示
Mime类型收集

博客分类：
Java

WAPQtMicrosoftTclJavaScript

网方网站：http://www.mimetype.org/





Mime-Typ

Dateiendung(en)

Bedeutung
application/acad

*.dwg

AutoCAD-Dateien (nach NCSA)
application/applefile

AppleFile-Dateien
application/astound

*.asd *.asn

Astound-Dateien
application/dsptype

*.tsp

TSP-Dateien
application/dxf

*.dxf

AutoCAD-Dateien (nach CERN)
application/futuresplash

*.spl

Flash Futuresplash-Dateien
application/gzip

*.gz

GNU Zip-Dateien
application/listenup

*.ptlk

Listenup-Dateien
application/mac-binhex40

*.hqx

Macintosh Binär-Dateien
application/mbedlet

*.mbd

Mbedlet-Dateien
application/mif

*.mif

FrameMaker Interchange Format Dateien
application/msexcel

*.xls *.xla

Microsoft Excel Dateien
application/mshelp

*.hlp *.chm

Microsoft Windows Hilfe Dateien
application/mspowerpoint

*.ppt *.ppz *.pps *.pot

Microsoft Powerpoint Dateien
application/msword

*.doc *.dot

Microsoft Word Dateien
application/octet-stream

*.bin *.exe *.com *.dll *.class

Ausführbare Dateien
application/oda

*.oda

Oda-Dateien
application/pdf

*.pdf

Adobe PDF-Dateien
application/postscript

*.ai *.eps *.ps

Adobe Postscript-Dateien
application/rtc

*.rtc

RTC-Dateien
application/rtf

*.rtf

Microsoft RTF-Dateien
application/studiom

*.smp

Studiom-Dateien
application/toolbook

*.tbk

Toolbook-Dateien
application/vocaltec-media-desc

*.vmd

Vocaltec Mediadesc-Dateien
application/vocaltec-media-file

*.vmf

Vocaltec Media-Dateien
application/x-bcpio

*.bcpio

BCPIO-Dateien
application/x-compress

*.z

-Dateien
application/x-cpio

*.cpio

CPIO-Dateien
application/x-csh

*.csh

C-Shellscript-Dateien
application/x-director

*.dcr *.dir *.dxr

-Dateien
application/x-dvi

*.dvi

DVI-Dateien
application/x-envoy

*.evy

Envoy-Dateien
application/x-gtar

*.gtar

GNU tar-Archiv-Dateien
application/x-hdf

*.hdf

HDF-Dateien
application/x-httpd-php

*.php *.phtml

PHP-Dateien
application/x-javascript

*.js

serverseitige JavaScript-Dateien
application/x-latex

*.latex

Latex-Quelldateien
application/x-macbinary

*.bin

Macintosh Binärdateien
application/x-mif

*.mif

FrameMaker Interchange Format Dateien
application/x-netcdf

*.nc *.cdf

Unidata CDF-Dateien
application/x-nschat

*.nsc

NS Chat-Dateien
application/x-sh

*.sh

Bourne Shellscript-Dateien
application/x-shar

*.shar

Shell-Archiv-Dateien
application/x-shockwave-flash

*.swf *.cab

Flash Shockwave-Dateien
application/x-sprite

*.spr *.sprite

Sprite-Dateien
application/x-stuffit

*.sit

Stuffit-Dateien
application/x-supercard

*.sca

Supercard-Dateien
application/x-sv4cpio

*.sv4cpio

CPIO-Dateien
application/x-sv4crc

*.sv4crc

CPIO-Dateien mit CRC
application/x-tar

*.tar

tar-Archivdateien
application/x-tcl

*.tcl

TCL Scriptdateien
application/x-tex

*.tex

TEX-Dateien
application/x-texinfo

*.texinfo *.texi

TEXinfo-Dateien
application/x-troff

*.t *.tr *.roff

TROFF-Dateien (Unix)
application/x-troff-man

*.man *.troff

TROFF-Dateien mit MAN-Makros (Unix)
application/x-troff-me

*.me *.troff

TROFF-Dateien mit ME-Makros (Unix)
application/x-troff-ms

*.me *.troff

TROFF-Dateien mit MS-Makros (Unix)
application/x-ustar

*.ustar

tar-Archivdateien (Posix)
application/x-wais-source

*.src

WAIS Quelldateien
application/x-www-form-urlencoded

HTML-Formulardaten an CGI
application/zip

*.zip

ZIP-Archivdateien
audio/basic

*.au *.snd

Sound-Dateien
audio/echospeech

*.es

Echospeed-Dateien
audio/tsplayer

*.tsi

TS-Player-Dateien
audio/voxware

*.vox

Vox-Dateien
audio/x-aiff

*.aif *.aiff *.aifc

AIFF-Sound-Dateien
audio/x-dspeeh

*.dus *.cht

Sprachdateien
audio/x-midi

*.mid *.midi

MIDI-Dateien
audio/x-mpeg

*.mp2

MPEG-Dateien
audio/x-pn-realaudio

*.ram *.ra

RealAudio-Dateien
audio/x-pn-realaudio-plugin

*.rpm

RealAudio-Plugin-Dateien
audio/x-qt-stream

*.stream

-Dateien
audio/x-wav

*.wav

Wav-Dateien
drawing/x-dwf

*.dwf

Drawing-Dateien
image/cis-cod

*.cod

CIS-Cod-Dateien
image/cmu-raster

*.ras

CMU-Raster-Dateien
image/fif

*.fif

FIF-Dateien
image/gif

*.gif

GIF-Dateien
image/ief

*.ief

IEF-Dateien
image/jpeg

*.jpeg *.jpg *.jpe

JPEG-Dateien
image/tiff

*.tiff *.tif

TIFF-Dateien
image/vasa

*.mcf

Vasa-Dateien
image/vnd.wap.wbmp

*.wbmp

Bitmap-Dateien (WAP)
image/x-freehand

*.fh4 *.fh5 *.fhc

Freehand-Dateien
image/x-portable-anymap

*.pnm

PBM Anymap Dateien
image/x-portable-bitmap

*.pbm

PBM Bitmap Dateien
image/x-portable-graymap

*.pgm

PBM Graymap Dateien
image/x-portable-pixmap

*.ppm

PBM Pixmap Dateien
image/x-rgb

*.rgb

RGB-Dateien
image/x-windowdump

*.xwd

X-Windows Dump
image/x-xbitmap

*.xbm

XBM-Dateien
image/x-xpixmap

*.xpm

XPM-Dateien
message/external-body

Nachricht mit externem Inhalt
message/http

HTTP-Headernachricht
message/news

Newsgroup-Nachricht
message/partial

Nachricht mit Teilinhalt
message/rfc822

Nachricht nach RFC 1822
model/vrml

*.wrl

Visualisierung virtueller Welten
multipart/alternative

mehrteilige Daten gemischt
multipart/byteranges

mehrteilige Daten mit Byte-Angaben
multipart/digest

mehrteilige Daten / Auswahl
multipart/encrypted

mehrteilige Daten verschlüsselt
multipart/form-data

mehrteilige Daten aus HTML-Formular (z.B. File-Upload)
multipart/mixed

mehrteilige Daten gemischt
multipart/parallel

mehrteilige Daten parallel
multipart/related

mehrteilige Daten / verbunden
multipart/report

mehrteilige Daten / Bericht
multipart/signed

mehrteilige Daten / bezeichnet
multipart/voice-message

mehrteilige Daten / Sprachnachricht
text/comma-separated-values

*.csv

komma-separierte Datendateien
text/css

*.css

CSS Stylesheet-Dateien
text/html

*.htm *.html *.shtml

-Dateien
text/javascript

*.js

JavaScript-Dateien
text/plain

*.txt

reine Textdateien
text/richtext

*.rtx

Richtext-Dateien
text/rtf

*.rtf

Microsoft RTF-Dateien
text/tab-separated-values

*.tsv

tabulator-separierte Datendateien
text/vnd.wap.wml

*.wml

WML-Dateien (WAP)
application/vnd.wap.wmlc

*.wmlc

WMLC-Dateien (WAP)
text/vnd.wap.wmlscript

*.wmls

WML-Scriptdateien (WAP)
application/vnd.wap.wmlscriptc

*.wmlsc

WML-Script-C-dateien (WAP)
text/xml-external-parsed-entity

extern geparste XML-Dateien
text/x-setext

*.etx

SeText-Dateien
text/x-sgml

*.sgm *.sgml

SGML-Dateien
text/x-speech

*.talk *.spc

Speech-Dateien
video/mpeg

*.mpeg *.mpg *.mpe

MPEG-Dateien
video/quicktime

*.qt *.mov

Quicktime-Dateien
video/vnd.vivo

*viv *.vivo

Vivo-Dateien
video/x-msvideo

*.avi

Microsoft AVI-Dateien
video/x-sgi-movie

*.movie

Movie-Dateien
workbook/formulaone

*.vts *.vtts

FormulaOne-Dateien
x-world/x-3dmf

*.3dmf *.3dm *.qd3d *.qd3

3DMF-Dateien
x-world/x-vrml

*.wrl

VRML-Dateien

15:41
评论 / 浏览 (0 / 124)
收藏

2008-12-30
缩略显示
lukeall-0.8.1.jar Lucene索引查看工具

博客分类：
Java

luceneSwingWindowsGoogle.net
lukeall-0.8.1.jar

在windows下双击，出现swing界面。

打开你的索引看看创建起了没就知道了。

lukeall-0.9.1.jar (1.7 MB)
下载次数: 1369

查看图片附件

12:54
评论 / 浏览 (7 / 4316)
收藏

2008-12-29
缩略显示
EJB3.0-JPA实体的注解规范以及Hibernate特有的扩展（下）

博客分类：
Java

HibernateJPA嵌入式SQL设计模式
有时候,你想让数据库,而非JVM,来替你完成一些计算,也可能想创建某种虚拟列.
你可以使用SQL片段(亦称为公式),而不是将属性映射到(物理)列. 这种属性是只读的(属性值由公求得).
@Formula("obj_length * obj_height * obj_width")
public long getObjectVolume()

SQL片段可以是任意复杂的,甚至可包含子查询.

@org.hibernate.annotations.Type
覆盖了Hibernate所用的默认类型:这通常不是必须的,因为类型可以由Hibernate正确推得.
关于Hibernate类型的详细信息,请参考Hibernate使用手册.
@org.hibernate.annotations.TypeDef 和@org.hibernate.annotations.TypeDefs允许你来声明类型定义.
这些注解被置于类或包一级.注意,对session factory来说,这些定义将是全局的(即使定义于类一级),并且类型定义必须先于任何使用.
@TypeDefs(
{
@TypeDef(
name="caster",
typeClass = CasterStringType.class,
parameters = {
@Parameter(name="cast", value="lower")
}
)
}
)
package org.hibernate.test.annotations.entity;

...
public class Forest {
@Type(type="caster")
public String getSmallText() {
...
}

当使用组合的用户自定义类型时,你必须自己表示列的定义.
@Columns就是为了此目的而引入的.
@Type(type="org.hibernate.test.annotations.entity.MonetaryAmountUserType")
@Columns(columns = {
@Column(name="r_amount"),
@Column(name="r_currency")
})
public MonetaryAmount getAmount() {
return amount;
}

public class MonetaryAmount implements Serializable {
private BigDecimal amount;
private Currency currency;
...
}

通过在列属性(property)上使用@Index注解,可以在特定列上定义索引,columnNames属性(attribute)将随之被忽略.

@Column(secondaryTable="Cat1")
@Index(name="story1index")
public String getStoryPart1() {
return storyPart1;
}

在嵌入式对象内部,你可以在那些指向该嵌入式对象所属元素的属性上定义该注解.
@Entity
public class Person {
@Embeddable public Address address;
...
}

@Embeddable
public class Address {
@Parent public Person owner;
...
}

person == person.address.owner

某些属性可以在对数据库做插入或更新操作的时候生成.
Hibernate能够处理这样的属性,并触发一个后续的查询来读取这些属性.

@Entity
public class Antenna {
@Id public Integer id;
@Generated(GenerationTime.ALWAYS) @Column(insertable = false, updatable = false)
public String longitude;

@Generated(GenerationTime.INSERT) @Column(insertable = false)
public String latitude;
}

你可以将属性注解为@Generated.
但是你要注意insertability和updatability不要和你选择的生成策略冲突.
如果选择了GenerationTime.INSERT,该属性不能包含insertable列,
如果选择了GenerationTime.ALWAYS,该属性不能包含insertable和updatable列.

@Version属性不可以为
@Generated(INSERT)(设计时), 只能是
NEVER或ALWAYS.

SINGLE_TABLE 是个功能强大的策略,但有时,特别对遗留系统而言,
是无法加入一个额外的辨别符列.
由此,Hibernate引入了辨别符公式(discriminator formula)的概念:
@DiscriminatorFormula是@DiscriminatorColumn的替代品,
它使用SQL片段作为辨别符解决方案的公式( 不需要有一个专门的字段).

@Entity
@DiscriminatorForumla("case when forest_type is null then 0 else forest_type end")
public class Forest { ... }

默认情况下查询顶级实体,Hibernate不会加入带鉴别器列的约束条件子句.
但是如果该列中还包含了和继承层次无关的值(通过@DiscriminatorValue)
就会很不方便.为了解决这个问题,你可以在类上使用@ForceDiscriminator注解
(将该注解放在@DiscriminatorColumn后面).
这样Hibernate在加载实体的时候就可以列出对应的值.

默认情况下,当预期的被关联元素不在数据库中(关乎关联列的错误id),致使Hiberante无法解决关联性问题时,Hibernate就会抛出异常.
这对遗留schema和历经拙劣维护的schema而言,这或有许多不便.
此时,你可用 @NotFound 注解让Hibernate略过这样的元素而不是抛出异常.
该注解可用于 @OneToOne (有外键)、 @ManyToOne 、
@OneToMany 或 @ManyToMany 关联.

@Entity
public class Child {
...
@ManyToOne
@NotFound(action=NotFoundAction.IGNORE)
public Parent getParent() { ... }
...
}

有时候删除某实体的时候需要触发数据库的级联删除.

@Entity
public class Child {
...
@ManyToOne
@OnDelete(action=OnDeleteAction.CASCADE)
public Parent getParent() { ... }
...
}

上面这个例子中,Hibernate将生成一个数据库级的级联删除约束.

Hibernate生成的外键约束的名字可读性相当差,
你可以使用@ForeignKey注解覆盖自动生成的值.

@Entity
public class Child {
...
@ManyToOne
@ForeignKey(name="FK_PARENT")
public Parent getParent() { ... }
...
}

alter table Child add constraint FK_PARENT foreign key (parent_id) references Parent

EJB3为延迟加载和获取模式提供了fetch选项,而Hibernate
这方面提供了更丰富的选项集.为了更好的调整延迟加载和获取策略,Hibernate引入了
一些附加的注解:
@LazyToOne: 定义了@ManyToOne 和 @OneToOne
关联的延迟选项. LazyToOneOption 可以是PROXY (例如:基于代理的延迟加载),NO_PROXY (例如:基于字节码增强的延迟加载 - 注意需要在构建期处理字节码)和 FALSE (非延迟加载的关联)

@LazyCollection: 定义了@ManyToMany和@OneToMany 关联的延迟选项. LazyCollectionOption可以是TRUE (集合具有延迟性,只有在访问的时候才加载), EXTRA (集合具有延迟性,并且所有的操作都会尽量避免加载集合,对于一个巨大的集合特别有用,因为这样的集合中的元素没有必要全部加载)和 FALSE(非延迟加载的关联)

@Fetch:
定义了加载关联关系的获取策略. FetchMode 可以是SELECT (在需要加载关联的时候触发select操作), SUBSELECT(只对集合有效,使用了子查询策略,详情参考Hibernate参考文档) or JOIN (在加载主实体(owner entity)的时候使用SQL JOIN来加载关联关系).
JOIN 将覆写任何延迟属性(通过JOIN策略加载的关联将不再具有延迟性).
The Hibernate annotations overrides the EJB3 fetching options.

Hibernate注解覆写了EJB3提供的获取(fetch)选项.

Annotations
Lazy
Fetch

@[One|Many]ToOne](fetch=FetchType.LAZY)
@LazyToOne(PROXY)
@Fetch(SELECT)
@[One|Many]ToOne](fetch=FetchType.EAGER)
@LazyToOne(FALSE)
@Fetch(JOIN)
@ManyTo[One|Many](fetch=FetchType.LAZY)
@LazyCollection(TRUE)
@Fetch(SELECT)
@ManyTo[One|Many](fetch=FetchType.EAGER)
@LazyCollection(FALSE)
@Fetch(JOIN)

以下是可能的设置方式
用@BatchSizebatch设置集合的batch大小
用@Where或@WhereJoinTable注解设置Where子句,
这两种注解分别应用于目标实体和关联表

用注解@Check来设置check子句
用注解@OrderBy来设置SQL的order by子句
利用@OnDelete(action=OnDeleteAction.CASCADE) 注解设置级连删除策略

你也可以利用@Sort注解定义一个排序比较器(sort comparator),表明希望的比较器类型,无序、自然顺序或自定义排序,三者择一.若你想用你自己实现的comparator,你还需要利用comparator属性(attribute)指明实现类.
注意你需要使用SortedSet或SortedMap接口

@OneToMany(cascade=CascadeType.ALL, fetch=FetchType.EAGER)
@JoinColumn(name="CUST_ID")
@Sort(type = SortType.COMPARATOR, comparator = TicketComparator.class)
@Where(clause="1=1")
@OnDelete(action=OnDeleteAction.CASCADE)
public SortedSet<Ticket> getTickets() {
return tickets;
}

关于这些注解更详细的信息,请参阅此前的描述.
Hibernate生成的外键约束的名字可读性相当差,你可以使用@ForeignKey注解覆盖自动生成的值. 注意该注解应该置于关联关系的主体端,inverseName
指向另一端的约束.
@Entity
public class Woman {
...
@ManyToMany(cascade = {CascadeType.ALL})
@ForeignKey(name = "TO_WOMAN_FK", inverseName = "TO_MAN_FK")
public Set<Man> getMens() {
return mens;
}
}

alter table Man_Woman add constraint TO_WOMAN_FK foreign key (woman_id) references Woman
alter table Man_Woman add constraint TO_MAN_FK foreign key (man_id) references Man

比EJB3更胜一筹的是,Hibernate Annotations支持真正的List和Array.
映射集合的方式和以前完全一样,只不过要新增@IndexColumn注解.
该注解允许你指明存放索引值的字段.你还可以定义代表数据库中首个元素的索引值(亦称为索引基数).
常见取值为0或1.
@OneToMany(cascade = CascadeType.ALL)
@IndexColumn(name = "drawer_position", base=1)
public List<Drawer> getDrawers() {
return drawers;
}

假如你忘了设置@IndexColumn,Hibernate会采用bag语义(译注:即允许重复元素的无序集合).
如果你既想使用bag语义,但是又不希望受制于其约束语义,可以考虑使用@CollectionId注解.

Hibernate注解支持true Map映射,如果没有设置@javax.persistence.MapKey,hibernate将key元素或嵌入式对象直接映射到他们所属的列.
要覆写默认的列,可以使用以下注解:
@org.hibernate.annotations.MapKey适用的key为基本类型
(默认为mapkey)或者嵌入式对象,
@org.hibernate.annotations.MapKey适用的key为实体.

双向关联的其中一端在使用@IndexColumn或者 @org.hibernate.annotations.MapKey[ManyToMany]注解需要考虑一些特殊的因素.如果子类存在某个属性映射到索引列,这种情况下是没有问题的,我们可以继续在集合映射的时候使用mappedBy,如下:
@Entity
public class Parent {
@OneToMany(mappedBy="parent")
@org.hibernate.annotations.MapKey(columns=@Column(name="name"))
private Map<String, Child> children;
...
}

@Entity
public class Parent {
...
@Basic
private String name;

@ManyToOne
@JoinColumn(name="parent_id", nullable=false)
private Parent parent;
...
}

但是,如果在子类中没有该属性,我们就不能认为这种关联是真正的双向关联(也就是在关联的一端有信息而另一端没有).因此在这种情况下,我们就不能使用mappedBy将其映射集合.取而代之为下面这种映射方式:
@Entity
public class Parent {
@OneToMany
@org.hibernate.annotations.MapKey(columns=@Column(name="name"))
@JoinColumn(name="parent_id", nullable=false)
private Map<String, Child> children;
...
}

@Entity
public class Parent {
...
@ManyToOne
@JoinColumn(name="parent_id", insertable=false, updatable=false, nullable=false)
private Parent parent;
...
}

注意在上面的映射中,关联的集合端负责更新外键.
另外一个有趣的特征就是可以给bag集合定义一个代理主键.通过这种方式优雅的去除了bag的缺点:update和remove操作更加有效率,每次查询或每个实体可以超过一个EAGER bag.该主键被保存在集合表的一个附加列,该列对于Java应用不可见.@CollectionId注解将一个集合标注为id bag,同时还可以覆写主键列,主键类型以及生成器策略.生成器策略可以是identity,也可以是应用中任何已定义的生成器的名字.

@Entity
@TableGenerator(name="ids_generator", table="IDS")
public class Passport {
...

@ManyToMany(cascade = CascadeType.ALL)
@JoinTable(name="PASSPORT_VISASTAMP")
@CollectionId(
columns = @Column(name="COLLECTION_ID"),
type=@Type(type="long"),
generator = "ids_generator"
)
private Collection<Stamp> visaStamp = new ArrayList();
...
}

Hibernate Annotations还支持核心类型集合(Integer, String, Enums, ......)、
可内嵌对象的集合,甚至基本类型数组.这就是所谓的元素集合.
元素集合可用@CollectionOfElements来注解(作为@OneToMany的替代).
为了定义集合表(译注:即存放集合元素的表,与下面提到的主表对应),要在关联属性上使用@JoinTable注解,joinColumns定义了介乎实体主表与集合表之间的连接字段(inverseJoincolumn是无效的且其值应为空).
对于核心类型的集合或基本类型数组,你可以在关联属性上用@Column来覆盖存放元素值的字段的定义.
你还可以用@AttributeOverride来覆盖存放可内嵌对象的字段的定义.
要访问集合元素,需要将该注解的name属性值设置为"element"("element"用于核心类型,而"element.serial"用于嵌入式对象的serial属性).要访问集合的index/key,则将该注解的name属性值设置为"key".
@Entity
public class Boy {
private Integer id;
private Set<String> nickNames = new HashSet<String>();
private int[] favoriteNumbers;
private Set<Toy> favoriteToys = new HashSet<Toy>();
private Set<Character> characters = new HashSet<Character>();

@Id @GeneratedValue
public Integer getId() {
return id;
}

@CollectionOfElements
public Set<String> getNickNames() {
return nickNames;
}

@CollectionOfElements
@JoinTable(
table=@Table(name="BoyFavoriteNumbers"),
joinColumns = @JoinColumn(name="BoyId")
)
@Column(name="favoriteNumber", nullable=false)
@IndexColumn(name="nbr_index")
public int[] getFavoriteNumbers() {
return favoriteNumbers;
}

@CollectionOfElements
@AttributeOverride( name="element.serial", column=@Column(name="serial_nbr") )
public Set<Toy> getFavoriteToys() {
return favoriteToys;
}

@CollectionOfElements
public Set<Character> getCharacters() {
return characters;
}
...
}

public enum Character {
GENTLE,
NORMAL,
AGGRESSIVE,
ATTENTIVE,
VIOLENT,
CRAFTY
}

@Embeddable
public class Toy {
public String name;
public String serial;
public Boy owner;

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public String getSerial() {
return serial;
}

public void setSerial(String serial) {
this.serial = serial;
}

@Parent
public Boy getOwner() {
return owner;
}

public void setOwner(Boy owner) {
this.owner = owner;
}


public boolean equals(Object o) {
if ( this == o ) return true;
if ( o == null || getClass() != o.getClass() ) return false;

final Toy toy = (Toy) o;

if ( !name.equals( toy.name ) ) return false;
if ( !serial.equals( toy.serial ) ) return false;

return true;
}

public int hashCode() {
int result;
result = name.hashCode();
result = 29 * result + serial.hashCode();
return result;
}
}

在嵌入式对象的集合中,可以使用 @Parent注解嵌入式对象的某属性.
该属性指向该嵌入式对象所属的集合实体.

旧版的Hibernate Annotations用@OneToMany来标识集合元素.
由于语义矛盾,我们引入了@CollectionOfElements注解.
用@OneToMany来标识集合元素的这种旧有方式目前尚有效,
但是不推荐使用,而且在以后的发布版本中不再支持这种方式.

为了优化数据库访问,你可以激活所谓的Hibernate二级缓存.该缓存是可以按每个实体和集合进行配置的.
@org.hibernate.annotations.Cache定义了缓存策略及给定的二级缓存的范围.
此注解适用于根实体(非子实体),还有集合.

@Entity
@Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
public class Forest { ... }

@OneToMany(cascade=CascadeType.ALL, fetch=FetchType.EAGER)
@JoinColumn(name="CUST_ID")
@Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
public SortedSet<Ticket> getTickets() {
return tickets;
}

@Cache(
CacheConcurrencyStrategy usage();
String region() default "";
String include() default "all";
)

usage: 给定缓存的并发策略(NONE,READ_ONLY, NONSTRICT_READ_WRITE, READ_WRITE, TRANSACTIONAL)

region (可选的):缓存范围(默认为类的全限定类名或是集合的全限定角色名)

include (可选的):值为all时包括了所有的属性(proterty),为non-lazy时仅含非延迟属性(默认值为all)

Hibernate具有在数据上应用任意过滤器的能力,可在运行期应用于一个给定的session.过滤器需要事先定义好.

@org.hibernate.annotations.FilterDef 或@FilterDefs 定义过滤器声明,为同名过滤器所用.
过滤器声明带有一个name()和一个parameters()数组. 参数提供了在运行时调整过滤器行为的能力,过滤器通过@ParamDef注解定义,该注解包含name和type,你还可以为给定的@FilterDef定义一个defaultCondition()参数,当所有的@Filter中没有任何定义时,可使用该参数定义缺省条件.
@FilterDef (s)可以在类或包一级进行定义.

现在我们来定义应用于实体或集合加载时的SQL过滤器子句.我们使用@Filter,并将其置于实体或集合元素上.

@Entity
@FilterDef(name="minLength", parameters={ @ParamDef( name="minLength", type="integer" ) } )
@Filters( {
@Filter(name="betweenLength", condition=":minLength <= length and :maxLength >= length"),
@Filter(name="minLength", condition=":minLength <= length")
} )
public class Forest { ... }

当这些集合使用关联表来表示关系的时候,你可能需要对于关联表或者目标实体表应用过滤条件.使用@Filter注解可以在目标实体上添加改类约束.
但是如果你打算在关联表上使用,就需要使用@FilterJoinTable注解.

@OneToMany
@JoinTable
//filter on the target entity table
@Filter(name="betweenLength", condition=":minLength <= length and :maxLength >= length")
//filter on the association table
@FilterJoinTable(name="security", condition=":userlevel >= requredLevel")
public Set<Forest> getForests() { ... }

由于Hibernate引入了
@org.hibernate.annotations.NamedQuery,
@org.hibernate.annotations.NamedQueries,
@org.hibernate.annotations.NamedNativeQuery 和
@org.hibernate.annotations.NamedNativeQueries 命名式查询,
因此Hibernate在命名式查询上比EBJ3规范中所定义的命名式查询提供了更多的特性.
他们在标准版中添加了可作为替代品的一些属性(attributes):
flushMode: 定义查询的刷新模式(Always, Auto, Commit或Never)
cacheable: 查询该不该被缓存
cacheRegion: 若查询已被缓存时所用缓存的范围
fetchSize: 针对该查询的JDBC statement单次获取记录的数目
timeout: 查询超时
callable: 仅用于本地化查询(native query),对于存储过程设为true
comment: 一旦激活注释功能,我们会在向数据库交送查询请求时看到注释
cacheMode: 缓存交护模式(get, ignore,normal,或refresh)
readOnly: 不管是否从查询获取元素都是在只读模式下

通过@QueryHint注解可以在
@javax.persistence.NamedQuery
中设置hints.另一个重要的优势是可以将这些注解应用到包上

17:13
评论 / 浏览 (0 / 3648)
收藏

2008-12-29
缩略显示
EJB3.0-JPA实体的注解规范以及Hibernate特有的扩展（上）

博客分类：
Java

HibernateJPA嵌入式BeanSQL
本章内容覆盖了EJB3.0(也就是JPA)实体的注解规范以及Hibernate特有的扩展.
现在EJB3实体Bean是纯粹的POJO.实际上这表达了和Hibernate持久化实体对象同样的概念.
它们的映射都通过JDK5.0注解来定义(EJB3规范已经定义了对应的XML描述语法).
注解分为两个部分,分别是逻辑映射注解和物理映射注解, 通过逻辑映射注解可以描述对象模型,类之间的关系等等, 而物理映射注解则描述了物理的schema,表,列,索引等等.
下面我们在代码中将混合使用这两种类型的注解.
EJB3注解的API定义在javax.persistence.*包里面.
大部分和JDK5兼容的IDE(象Eclipse, IntelliJ IDEA 和Netbeans等等)都提供了注解接口和属性的自动完成功能.(这些不需要IDE提供特别的EJB3支持模块,因为EJB3注解是标准的JDK5注解)请阅读JBoss EJB 3.0指南或者直接阅读Hibernate Annotations测试代码以获取更多的可运行实例.Hibernate Annotations提供的大部分单元测试代码都演示了实际的例子,是一个获取灵感的好地方.
每一个持久化POJO类都是一个实体bean,这可以通过在类的定义中使用@Entity注解来进行声明:
@Entity
public class Flight implements Serializable {
Long id;

@Id
public Long getId() { return id; }

public void setId(Long id) { this.id = id; }
}
通过@Entity注解将一个类声明为一个实体bean(即一个持久化POJO类),
@Id注解则声明了该实体bean的标识属性.
其他的映射定义是隐式的.这种以隐式映射为主体,以显式映射为例外的配置方式在新的EJ3规范中处于非常重要的位置,
和以前的版本相比有了质的飞跃.
在上面这段代码中:Flight类映射到Flight表,并使用id列作为主键列.

在对一个类进行注解时,你可以选择对它的的属性或者方法进行注解,根据你的选择,Hibernate的访问类型分别为
field或property.
EJ3规范要求在需要访问的元素上进行注解声明,例如,如果访问类型为
property就要在getter方法上进行注解声明,
如果访问类型为 field就要在字段上进行注解声明.应该尽量避免混合使用这两种访问类型.
Hibernate根据@Id 或 @EmbeddedId的位置来判断访问类型.


@Table是类一级的注解,
通过@Table注解可以为实体bean映射指定表(table),目录(catalog)和schema的名字.
如果没有定义@Table,那么系统自动使用默认值:实体的短类名(不附带包名).

@Entity
@Table(name="tbl_sky")
public class Sky implements Serializable {
...

@Table元素包括了一个schema
和一个 catalog属性,如果需要可以指定相应的值.
结合使用@UniqueConstraint注解可以定义表的唯一约束(unique constraint)
(对于绑定到单列的唯一约束,请参考@Column注解)

@Table(name="tbl_sky",
uniqueConstraints = {@UniqueConstraint(columnNames={"month", "day"})}
)

上面这个例子中,在month和day这两个字段上定义唯一约束.
注意columnNames数组中的值指的是逻辑列名.

Hibernate在NamingStrategy的实现中定义了逻辑列名.
默认的EJB3命名策略将物理字段名当作逻辑字段名来使用.
注意该字段名和它对应的属性名可能不同(如果字段名是显式指定的话).
除非你重写了NamingStrategy,否则不用担心这些区别..

你可以在实体bean中使用@Version注解,通过这种方式可添加对乐观锁定的支持:

@Entity
public class Flight implements Serializable {
...
@Version
@Column(name="OPTLOCK")
public Integer getVersion() { ... }
}

上面这个例子中,version属性将映射到 OPTLOCK列,
entity manager使用该字段来检测更新冲突(防止更新丢失,请参考last-commit-wins策略).

根据EJB3规范,version列可以是numeric类型(推荐方式)也可以是timestamp类型.
Hibernate支持任何自定义类型,只要该类型实现了UserVersionType.

Every non static non transient property (field or method) of an
entity bean is considered persistent, unless you annotate it as
@Transient. Not having an annotation for your
property is equivalent to the appropriate @Basic
annotation. The @Basic annotation allows you to
declare the fetching strategy for a property:

实体bean中所有的非static非transient的属性都可以被持久化,
除非你将其注解为@Transient.所有没有定义注解的属性等价于在其上面添加了@Basic注解.
通过 @Basic注解可以声明属性的获取策略(fetch strategy):

public transient int counter; //transient property

private String firstname; //persistent property

@Transient
String getLengthInMeter() { ... } //transient property

String getName() {... } // persistent property

@Basic
int getLength() { ... } // persistent property

@Basic(fetch = FetchType.LAZY)
String getDetailedComment() { ... } // persistent property

@Temporal(TemporalType.TIME)
java.util.Date getDepartureTime() { ... } // persistent property

@Enumerated(STRING)
Starred getNote() { ... } //enum persisted as String in database

上面这个例子中,counter是一个transient的字段,
lengthInMeter的getter方法被注解为@Transient,
entity manager将忽略这些字段和属性.
而name,length,firstname
这几个属性则是被定义为可持久化和可获取的.对于简单属性来说,默认的获取方式是即时获取(early fetch).
当一个实体Bean的实例被创建时,Hibernate会将这些属性的值从数据库中提取出来,保存到Bean的属性里.
与即时获取相对应的是延迟获取(lazy fetch).如果一个属性的获取方式是延迟获取
(比如上面例子中的detailedComment属性),
Hibernate在创建一个实体Bean的实例时,不会即时将这个属性的值从数据库中读出.
只有在该实体Bean的这个属性第一次被调用时,Hibernate才会去获取对应的值.
通常你不需要对简单属性设置延迟获取(lazy simple property),千万不要和延迟关联获取(lazy association fetch)混淆了
(译注:这里指不要把lazy simple property和lazy association fetch混淆了).

为了启用属性级的延迟获取,你的类必须经过特殊处理(instrumented):
字节码将被织入原始类中来实现延迟获取功能,
详情参考Hibernate参考文档.如果不对类文件进行字节码特殊处理,
那么属性级的延迟获取将被忽略.

推荐的替代方案是使用EJB-QL或者Criteria查询的投影(projection)功能.

Hibernate和EJB3都支持所有基本类型的属性映射.
这些基本类型包括所有的Java基本类型,及其各自的wrapper类和serializable类.
Hibernate Annotations还支持将内置的枚举类型映射到一个顺序列(保存了相应的序列值)或一个字符串类型的列(保存相应的字符串).默认是保存枚举的序列值,
但是你可以通过@Enumerated注解来进行调整(见上面例子中的note属性).

在核心的Java API中并没有定义时间精度(temporal precision).
因此处理时间类型数据时,你还需要定义将其存储在数据库中所预期的精度.
在数据库中,表示时间类型的数据有DATE, TIME,
和 TIMESTAMP三种精度(即单纯的日期,时间,或者两者兼备).
可使用@Temporal注解来调整精度.

@Lob注解表示属性将被持久化为Blob或者Clob类型,
具体取决于属性的类型,
java.sql.Clob,
Character[],
char[] 和
java.lang.String这些类型的属性都被持久化为Clob类型,
而java.sql.Blob,
Byte[],
byte[] 和
serializable类型则被持久化为Blob类型.

@Lob
public String getFullText() {
return fullText;
}

@Lob
public byte[] getFullCode() {
return fullCode;
}

如果某个属性实现了java.io.Serializable同时也不是基本类型,
并且没有在该属性上使用@Lob注解,
那么Hibernate将使用自带的serializable类型.

使用 @Column 注解可将属性映射到列.
使用该注解来覆盖默认值(关于默认值请参考EJB3规范).
在属性级使用该注解的方式如下:

不进行注解

和 @Basic一起使用

和 @Version一起使用

和 @Lob一起使用

和 @Temporal一起使用

和
@org.hibernate.annotations.CollectionOfElements一起使用
(只针对Hibernate )

@Entity
public class Flight implements Serializable {
...
@Column(updatable = false, name = "flight_name", nullable = false, length=50)
public String getName() { ... }

在上面这个例子中,name属性映射到flight_name列.
该字段不允许为空,长度为50,并且是不可更新的(也就是属性值是不变的).

上面这些注解可以被应用到正规属性上例如@Id 或@Version属性

@Column(name="columnName";
boolean unique() default false;
boolean nullable() default true;
boolean insertable() default true;
boolean updatable() default true;
String columnDefinition() default "";
String table() default "";
int length() default 255;
int precision() default 0; // decimal precision
int scale() default 0; // decimal scale

name 可选,列名(默认值是属性名)

unique 可选,是否在该列上设置唯一约束(默认值false)

nullable 可选,是否设置该列的值可以为空(默认值false)

insertable 可选,该列是否作为生成的insert语句中的一个列(默认值true)

updatable 可选,该列是否作为生成的update语句中的一个列(默认值true)

columnDefinition 可选: 为这个特定列覆盖SQL DDL片段 (这可能导致无法在不同数据库间移植)

table 可选,定义对应的表(默认为主表)

length 可选,列长度(默认值255)

precision 可选,列十进制精度(decimal precision)(默认值0)

scale 可选,如果列十进制数值范围(decimal scale)可用,在此设置(默认值0)

在实体中可以定义一个嵌入式组件(embedded component),甚至覆盖该实体中原有的列映射.
组件类必须在类一级定义@Embeddable注解.
在特定的实体的关联属性上使用@Embedded和
@AttributeOverride注解可以覆盖该属性对应的嵌入式对象的列映射:

@Entity
public class Person implements Serializable {

// Persistent component using defaults
Address homeAddress;

@Embedded
@AttributeOverrides( {
@AttributeOverride(name="iso2", column = @Column(name="bornIso2") ),
@AttributeOverride(name="name", column = @Column(name="bornCountryName") )
} )
Country bornIn;
...
}

@Embeddable
public class Address implements Serializable {
String city;
Country nationality; //no overriding here
}

@Embeddable
public class Country implements Serializable {
private String iso2;
@Column(name="countryName") private String name;

public String getIso2() { return iso2; }
public void setIso2(String iso2) { this.iso2 = iso2; }


public String getName() { return name; }
public void setName(String name) { this.name = name; }
...
}
嵌入式对象继承其所属实体中定义的访问类型
(注意:这可以通过使用Hibernate提供的@AccessType注解来覆盖原有值)(请参考 linkend="entity-hibspec" />).

在上面的例子中,实体bean Person 有两个组件属性,
分别是homeAddress和bornIn.
我们可以看到homeAddress 属性并没有注解.
但是Hibernate自动检测其对应的Address类中的@Embeddable注解,
并将其看作一个持久化组件.对于Country中已映射的属性,
则使用@Embedded和@AttributeOverride
注解来覆盖原来映射的列名.
正如你所看到的, Address对象中还内嵌了Country对象,
这里和homeAddress一样使用了Hibernate和EJB3自动检测机制.
目前EJB3规范还不支持覆盖多层嵌套(即嵌入式对象中还包括其他嵌入式对象)的列映射.
不过Hibernate通过在表达式中使用"."符号表达式提供了对此特征的支持.

@Embedded
@AttributeOverrides( {
@AttributeOverride(name="city", column = @Column(name="fld_city") )
@AttributeOverride(name="nationality.iso2", column = @Column(name="nat_Iso2") ),
@AttributeOverride(name="nationality.name", column = @Column(name="nat_CountryName") )
//nationality columns in homeAddress are overridden
} )
Address homeAddress;
Hibernate注解支持很多EJB3规范中没有明确定义的特性.
例如,可以在嵌入式对象上添加 @MappedSuperclass注解,
这样可以将其父类的属性持久(详情请查阅@MappedSuperclass).

Hibernate现在支持在嵌入式对象中使用关联注解(如@*ToOne和@*ToMany).
而EJB3规范尚不支持这样的用法.你可以使用 @AssociationOverride注解来覆写关联列.

在同一个实体中使用两个同类型的嵌入对象, 其默认列名是无效的:至少要对其中一个进行明确声明.
Hibernate在这方面走在了EJB3规范的前面,Hibernate提供了NamingStrategy, 在使用Hibernate时, 通过NamingStrategy你可以对默认的机制进行扩展.
DefaultComponentSafeNamingStrategy在默认的EJB3NamingStrategy上进行了小小的提升,允许在同一实体中使用两个同类型的嵌入对象而无须额外的声明.
如果某属性没有注解,该属性将遵守下面的规则:

如果属性为单一类型,则映射为@Basic
否则,如果属性对应的类型定义了@Embeddable注解,则映射为@Embedded
否则,如果属性对应的类型实现了Serializable,
则属性被映射为@Basic并在一个列中保存该对象的serialized版本
否则,如果该属性的类型为java.sql.Clob 或 java.sql.Blob,则作为@Lob并映射到适当的LobType.

xreflabel="Mapping identifier properties">

使用@Id注解可以将实体bean中的某个属性定义为标识符(identifier).
该属性的值可以通过应用自身进行设置,也可以通过Hiberante生成(推荐).
使用 @GeneratedValue注解可以定义该标识符的生成策略:
AUTO - 可以是identity column类型,或者sequence类型或者table类型,取决于不同的底层数据库.
TABLE - 使用表保存id值
IDENTITY - identity column
SEQUENCE - sequence
和EJB3规范相比,Hibernate提供了更多的id生成器.详情请查阅 .

下面的例子展示了使用SEQ_STORE配置的sequence生成器
@Id @GeneratedValue(strategy=GenerationType.SEQUENCE, generator="SEQ_STORE")
public Integer getId() { ... }

下面这个例子使用的是identity生成器
@Id @GeneratedValue(strategy=GenerationType.IDENTITY)
public Long getId() { ... }

AUTO生成器适用于可移植的应用(在多个DB间切换).
多个@Id可以共享同一个identifier生成器,只要把generator属性设成相同的值就可以了.
通过@SequenceGenerator 和@TableGenerator,你可以配置不同的identifier生成器.
每一个identifier生成器都有自己的适用范围,可以是应用级(application level)和类一级(class level).
类一级的生成器在外部是不可见的,而且类一级的生成器可以覆盖应用级的生成器.
应用级的生成器则定义在XML级(请参阅):
<table-generator name="EMP_GEN"
table="GENERATOR_TABLE"
pk-column-name="key"
value-column-name="hi"
pk-column-value="EMP"
allocation-size="20"/>
//and the annotation equivalent
@javax.persistence.TableGenerator(
name="EMP_GEN",
table="GENERATOR_TABLE",
pkColumnName = "key",
valueColumnName = "hi"
pkColumnValue="EMP",
allocationSize=20
)
<sequence-generator name="SEQ_GEN"
sequence-name="my_sequence"
allocation-size="20"/>

//and the annotation equivalent
@javax.persistence.SequenceGenerator(
name="SEQ_GEN",
sequenceName="my_sequence",
allocationSize=20
)

如果JPA XML(如META-INF/orm.xml)用于定义生成器, 那么该文件中定义的 EMP_GEN
和SEQ_GEN都是应用级的生成器.
EMP_GEN定义了一个使用hilo算法
(max_lo为20)的id生成器(该生成器将id的信息存在数据库的某个表中.).
id的hi值保存在GENERATOR_TABLE中.
在该表中 pkColumnName"key"等价于pkColumnValue "EMP",
而valueColumnName "hi"中存储的是下一个要使用的最大值.
SEQ_GEN定义了一个sequence生成器,
其使用名为my_sequence的sequence.
该hilo算法基于sequence,该sequence分配的大小为20.
注意,现在这个版本还不能处理sequence生成器的initialValue属性.
默认分配的大小为50,因此如果你打算使用sequence,并且希望每次都重新获取新的值,务必将
分配的大小设置为1.
EJB3.0规范已经不再支持Package级别的定义. 但是你仍然可以在包上使用
@GenericGenerator注解(详情请参考 linkend="entity-hibspec-identifier" />).

SEQ_GEN则定义了一个sequence 生成器,
其对应的sequence名为 my_sequence.
注意目前Hibernate Annotations还不支持sequence 生成器中的
initialValue和 allocationSize参数.

下面这个例子展示了定义在类范围(class scope)的sequence生成器:

@Entity
@javax.persistence.SequenceGenerator(
name="SEQ_STORE",
sequenceName="my_sequence"
)
public class Store implements Serializable {
private Long id;

@Id @GeneratedValue(strategy=GenerationType.SEQUENCE, generator="SEQ_STORE")
public Long getId() { return id; }
}

在这个例子中,Store类使用名为my_sequence的sequence,并且SEQ_STORE 生成器对于其他类是不可见的.
注意在org.hibernate.test.metadata.id包下的测试代码有更多演示Hibernate Annotations用法的例子..

下面是定义组合主键的几种语法:
将组件类注解为@Embeddable,并将组件的属性注解为@Id
将组件的属性注解为@EmbeddedId
将类注解为@IdClass,并将该实体中所有属于主键的属性都注解为@Id
对于EJB2的开发人员来说 @IdClass是很常见的,但是对于Hibernate的用户来说就是一个崭新的用法.
组合主键类对应了一个实体类中的多个字段或属性, 而且主键类中用于定义主键的字段或属性和实体类中对应的字段或属性在类型上必须一致.下面我们看一个例子:
@Entity
@IdClass(FootballerPk.class)
public class Footballer {
//part of the id key
@Id public String getFirstname() {
return firstname;
}

public void setFirstname(String firstname) {
this.firstname = firstname;
}

//part of the id key
@Id public String getLastname() {
return lastname;
}

public void setLastname(String lastname) {
this.lastname = lastname;
}

public String getClub() {
return club;
}

public void setClub(String club) {
this.club = club;
}

//appropriate equals() and hashCode() implementation
}

@Embeddable
public class FootballerPk implements Serializable {
//same name and type as in Footballer
public String getFirstname() {
return firstname;
}

public void setFirstname(String firstname) {
this.firstname = firstname;
}

//same name and type as in Footballer
public String getLastname() {
return lastname;
}

public void setLastname(String lastname) {
this.lastname = lastname;
}

//appropriate equals() and hashCode() implementation
}

如上, @IdClass指向对应的主键类.
Hibernate支持在组合标识符中定义关联(就像使用普通的注解一样),而EJB3规范并不支持此类用法.
@Entity
@AssociationOverride( name="id.channel", joinColumns = @JoinColumn(name="chan_id") )
public class TvMagazin {
@EmbeddedId public TvMagazinPk id;
@Temporal(TemporalType.TIME) Date time;
}

@Embeddable
public class TvMagazinPk implements Serializable {
@ManyToOne
public Channel channel;
public String name;
@ManyToOne
public Presenter presenter;
}
EJB3支持三种类型的继承映射:
每个类一张表(Table per class)策略: 在Hibernate中对应<union-class>元素:
每个类层次结构一张表(Single table per class hierarchy)策略:在Hibernate中对应<subclass>元素
连接的子类(Joined subclasses)策略:在Hibernate中对应 <joined-subclass>元素
你可以用 @Inheritance注解来定义所选择的策略.
这个注解需要在每个类层次结构(class hierarchy) 最顶端的实体类上使用.
目前还不支持在接口上进行注解.

这种策略有很多缺点(例如:多态查询和关联),EJB3规范, Hibernate参考手册,
Hibernate in Action,以及其他许多地方都对此进行了描述和解释.
Hibernate使用SQL UNION查询来实现这种策略.
通常使用场合是在一个继承层次结构的顶端:

@Entity
@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)
public class Flight implements Serializable {
这种策略支持双向的一对多关联.
这里不支持IDENTITY生成器策略,因为id必须在多个表间共享.
当然,一旦使用这种策略就意味着你不能使用
AUTO 生成器和IDENTITY生成器.

整个继承层次结构中的父类和子类的所有属性都映射到同一个表中,他们的实例通过一个辨别符(discriminator)列来区分.:

@Entity
@Inheritance(strategy=InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(
name="planetype",
discriminatorType=DiscriminatorType.STRING
)
@DiscriminatorValue("Plane")
public class Plane { ... }

@Entity
@DiscriminatorValue("A320")
public class A320 extends Plane { ... }

在上面这个例子中,Plane是父类,在这个类里面将继承策略定义为
InheritanceType.SINGLE_TABLE,并通过
@DiscriminatorColumn注解定义了辨别符列(还可以定义辨别符的类型).
最后,对于继承层次结构中的每个类,@DiscriminatorValue注解指定了用来辨别该类的值.
辨别符列的名字默认为 DTYPE,其默认值为实体名(在@Entity.name中定义),其类型
为DiscriminatorType.STRING.
A320是子类,如果不想使用默认的辨别符,只需要指定相应的值即可.
其他的如继承策略,辨别标志字段的类型都是自动设定的.

@Inheritance 和
@DiscriminatorColumn 注解只能用于实体层次结构的顶端.
当每个子类映射到一个表时, @PrimaryKeyJoinColumn
和@PrimaryKeyJoinColumns
注解定义了每个子类表关联到父类表的主键:

@Entity
@Inheritance(strategy=InheritanceType.JOINED)
public class Boat implements Serializable { ... }

@Entity
public class Ferry extends Boat { ... }

@Entity
@PrimaryKeyJoinColumn(name="BOAT_ID")
public class AmericaCupClass extends Boat { ... }

以上所有实体都使用了JOINED策略, Ferry表和Boat表使用同名的主键.
而AmericaCupClass表和Boat表使用了条件
Boat.id = AmericaCupClass.BOAT_ID进行关联.

有时候通过一个(技术上或业务上)父类共享一些公共属性是很有用的,同时还不用将该父类作为映射的实体(也就是该实体没有对应的表).
这个时候你需要使用@MappedSuperclass注解来进行映射.
@MappedSuperclass
public class BaseEntity {
@Basic
@Temporal(TemporalType.TIMESTAMP)
public Date getLastUpdate() { ... }
public String getLastUpdater() { ... }
...
}

@Entity class Order extends BaseEntity {
@Id public Integer getId() { ... }
...
}

在数据库中,上面这个例子中的继承的层次结构最终以Order表的形式出现,该表拥有id, lastUpdate 和lastUpdater三个列.父类中的属性映射将复制到其子类实体.
注意这种情况下的父类不再处在继承层次结构的顶端.
注意,没有注解为@MappedSuperclass的父类中的属性将被忽略.
除非显式使用Hibernate annotation中的@AccessType注解,否则将从继承层次结构的根实体中继承访问类型(包括字段或方法)

这对于@Embeddable对象的父类中的属性持久化同样有效.
只需要使用@MappedSuperclass注解即可(虽然这种方式不会纳入EJB3标准)

可以将处在在映射继承层次结构的中间位置的类注解为@MappedSuperclass.
在继承层次结构中任何没有被注解为@MappedSuperclass或@Entity的类都将被忽略.

你可以通过 @AttributeOverride注解覆盖实体父类中的定义的列.
这个注解只能在继承层次结构的顶端使用.
@MappedSuperclass
public class FlyingObject implements Serializable {

public int getAltitude() {
return altitude;
}

@Transient
public int getMetricAltitude() {
return metricAltitude;
}

@ManyToOne
public PropulsionType getPropulsion() {
return metricAltitude;
}
...
}

@Entity
@AttributeOverride( name="altitude", column = @Column(name="fld_altitude") )
@AssociationOverride( name="propulsion", joinColumns = @JoinColumn(name="fld_propulsion_fk") )
public class Plane extends FlyingObject {
...
}
在上面这个例子中,altitude属性的值最终将持久化到Plane表的fld_altitude列.而名为propulsion的关联则保存在fld_propulsion_fk外间列.

你可以为@Entity和@MappedSuperclass注解的类以及那些对象为@Embeddable的属性定义@AttributeOverride和@AssociationOverride.

使用@OneToOne注解可以建立实体bean之间的一对一的关联.
一对一关联有三种情况:
一是关联的实体都共享同样的主键,
二是其中一个实体通过外键关联到另一个实体的主键
(注意要模拟一对一关联必须在外键列上添加唯一约束).
三是通过关联表来保存两个实体之间的连接关系
(注意要模拟一对一关联必须在每一个外键上添加唯一约束).

首先,我们通过共享主键来进行一对一关联映射:
@Entity
public class Body {
@Id
public Long getId() { return id; }

@OneToOne(cascade = CascadeType.ALL)
@PrimaryKeyJoinColumn
public Heart getHeart() {
return heart;
}
...
}

@Entity
public class Heart {
@Id
public Long getId() { ...}
}

上面的例子通过使用注解@PrimaryKeyJoinColumn定义了一对一关联.
下面这个例子使用外键列进行实体的关联.
@Entity
public class Customer implements Serializable {
@OneToOne(cascade = CascadeType.ALL)
@JoinColumn(name="passport_fk")
public Passport getPassport() {
...
}

@Entity
public class Passport implements Serializable {
@OneToOne(mappedBy = "passport")
public Customer getOwner() {
...
}
上面这个例子中,Customer 通过Customer表中名为的passport_fk 外键列和 Passport关联.
@JoinColumn注解定义了联接列(join column).
该注解和@Column注解有点类似,但是多了一个名为referencedColumnName的参数.
该参数定义了所关联目标实体中的联接列.
注意,当referencedColumnName关联到非主键列的时候,关联的目标类必须实现Serializable,还要注意的是所映射的属性对应单个列(否则映射无效).

一对一关联可能是双向的.在双向关联中,有且仅有一端是作为主体(owner)端存在的:主体端负责维护联接列(即更新).
对于不需要维护这种关系的从表则通过mappedBy属性进行声明.
mappedBy的值指向主体的关联属性.
在上面这个例子中,mappedBy的值为 passport.
最后,不必也不能再在被关联端(owned side)定义联接列了,因为已经在主体端进行了声明.

如果在主体没有声明@JoinColumn,系统自动进行处理:
在主表(owner table)中将创建联接列,
列名为:主体的关联属性名＋下划线＋被关联端的主键列名.
在上面这个例子中是passport_id,
因为Customer中关联属性名为passport,
Passport的主键是id.
The third possibility (using an association table) is very
exotic.
第三种方式也许是最另类的(通过关联表).

@Entity
public class Customer implements Serializable {
@OneToOne(cascade = CascadeType.ALL)
@JoinTable(name = "CustomerPassports"
joinColumns = @JoinColumn(name="customer_fk"),
inverseJoinColumns = @JoinColumns(name="passport_fk")
)
public Passport getPassport() {
...
}

@Entity
public class Passport implements Serializable {
@OneToOne(mappedBy = "passport")
public Customer getOwner() {
...
}


Customer通过名为 CustomerPassports的关联表和Passport关联; 该关联表拥有名为passport_fk的外键列,该外键指向Passport表,该信息定义为inverseJoinColumn的属性值,而customer_fk外键列指向Customer表,该信息定义为 joinColumns的属性值.
你必须明确定义关联表名和关联列名.
在实体属性一级使用@ManyToOne注解来定义多对一关联:
@Entity()
public class Flight implements Serializable {
@ManyToOne( cascade = {CascadeType.PERSIST, CascadeType.MERGE} )
@JoinColumn(name="COMP_ID")
public Company getCompany() {
return company;
}
...
}
其中@JoinColumn是可选的,关联字段默认值和一对一(one to one)关联的情况相似,
列名为:主体的关联属性名＋下划线＋被关联端的主键列名.
在这个例子中是company_id,因为关联的属性是company,Company的主键是id.

@ManyToOne注解有一个名为targetEntity的参数,
该参数定义了目标实体名.通常不需要定义该参数,
因为在大部分情况下默认值(表示关联关系的属性类型)就可以很好的满足要求了.
不过下面这种情况下这个参数就显得有意义了:使用接口作为返回值而不是常见的实体.

@Entity()
public class Flight implements Serializable {
@ManyToOne( cascade = {CascadeType.PERSIST, CascadeType.MERGE}, role="bold">targetEntity=CompanyImpl.class )
@JoinColumn(name="COMP_ID")
public Company getCompany() {
return company;
}
...
}

public interface Company {
...

对于多对一也可以通过关联表的方式来映射.
通过@JoinTable注解可定义关联表,该关联表包含了指回实体表的外键(通过@JoinTable.joinColumns)
以及指向目标实体表的外键(通过@JoinTable.inverseJoinColumns).

@Entity()
public class Flight implements Serializable {
@ManyToOne( cascade = {CascadeType.PERSIST, CascadeType.MERGE} )
@JoinTable(name="Flight_Company",
joinColumns = @JoinColumn(name="FLIGHT_ID"),
inverseJoinColumns = @JoinColumns(name="COMP_ID")
)
public Company getCompany() {
return company;
}
...
}

你可以对 Collection ,List(指有序列表, 而不是索引列表),Map和Set这几种类型进行映射.
EJB3规范定义了怎么样使用@javax.persistence.OrderBy
注解来对有序列表进行映射:
该注解接受的参数格式:用逗号隔开的(目标实体)属性名及排序指令,如firstname asc, age desc,如果该参数为空,则默认以id对该集合进行排序.
如果某个集合在数据库中对应一个关联表(association table)的话,你不能在这个集合属性上面使用@OrderBy注解.
对于这种情况的处理方法,请参考.
EJB3 允许你利用目标实体的一个属性作为Map的key,
这个属性可以用@MapKey(name="myProperty")来声明.
如果使用@MapKey注解的时候不提供属性名,
系统默认使用目标实体的主键.
map的key使用和属性相同的列:不需要为map key定义专用的列,因为map key实际上就表达了一个目标属性.
注意一旦加载,key不再和属性保持同步,也就是说,如果你改变了该属性的值,在你的Java模型中的key不会自动更新
(请参考).
很多人被<map>和@MapKey弄糊涂了.
其他它们有两点区别.@MapKey目前还有一些限制,详情请查看论坛或者我们的JIRA缺陷系统.
注意一旦加载,key不再和属性保持同步,也就是说,如果你改变了该属性的值,在你的Java模型中的key不会自动更新.
(Hibernate 3中Map支持的方式在当前的发布版中还未得到支持). Hibernate将集合分以下几类.
语义
Java实现类
注解

Bag 语义
java.util.List, java.util.Collection
@org.hibernate.annotations.CollectionOfElements 或
@OneToMany 或 @ManyToMany

带主键的Bag语义(没有普通Bag语义的限制)
java.util.List, java.util.Collection
(@org.hibernate.annotations.CollectionOfElements 或
@OneToMany 或 @ManyToMany) 和 @CollectionId

List 语义
java.util.List
(@org.hibernate.annotations.CollectionOfElements 或@OneToMany 或 @ManyToMany)
以及 @org.hibernate.annotations.IndexColumn

Set 语义
java.util.Set
@org.hibernate.annotations.CollectionOfElements 或
@OneToMany 或 @ManyToMany

Map 语义
java.util.Map
(@org.hibernate.annotations.CollectionOfElements 或@OneToMany 或 @ManyToMany)
以及(空或@org.hibernate.annotations.MapKey/MapKeyManyToMany(支持真正的map), 或@javax.persistence.MapKey

从上面可以明确地看到,没有@org.hibernate.annotations.IndexColumn
注解的java.util.List集合将被看作bag类.

EJB3规范不支持原始类型,核心类型,嵌入式对象的集合.但是Hibernate对此提供了支持
(详情参考 ).

@Entity public class City {
@OneToMany(mappedBy="city")
@OrderBy("streetName")
public List<Street> getStreets() {
return streets;
}
...
}

@Entity public class Street {
public String getStreetName() {
return streetName;
}

@ManyToOne
public City getCity() {
return city;
}
...
}

@Entity
public class Software {
@OneToMany(mappedBy="software")
@MapKey(name="codeName")
public Map<String, Version> getVersions() {
return versions;
}
...
}

@Entity
@Table(name="tbl_version")
public class Version {
public String getCodeName() {...}

@ManyToOne
public Software getSoftware() { ... }
...
}
上面这个例子中,City中包括了以streetName排序的Street的集合.而Software中包括了以codeName作为key和以Version作为值的Map.

除非集合为generic类型,否则你需要指定targetEntity.
这个注解属性接受的参数为目标实体的class.
在属性级使用 @OneToMany注解可定义一对多关联.一对多关联可以是双向关联.
在EJB3规范中多对一这端几乎总是双向关联中的主体(owner)端,而一对多这端的关联注解为@OneToMany( mappedBy=...
)

@Entity
public class Troop {
@OneToMany(mappedBy="troop")
public Set<Soldier> getSoldiers() {
...
}

@Entity
public class Soldier {
@ManyToOne
@JoinColumn(name="troop_fk")
public Troop getTroop() {
...
}

Troop 通过troop
属性和Soldier建立了一对多的双向关联.
在mappedBy端不必也不能再定义任何物理映射

对于一对多的双向映射,如果要一对多这一端维护关联关系,你需要删除mappedBy元素并将多对一这端的 @JoinColumn的insertable和updatable设置为false.
很明显,这种方案不会得到什么明显的优化,而且还会增加一些附加的UPDATE语句.

@Entity
public class Troop {
@OneToMany
@JoinColumn(name="troop_fk") //we need to duplicate the physical information
public Set<Soldier> getSoldiers() {
...
}

@Entity
public class Soldier {
@ManyToOne
@JoinColumn(name="troop_fk", insertable=false, updatable=false)
public Troop getTroop() {
...
}
通过在被拥有的实体端(owned entity)增加一个外键列来实现一对多单向关联是很少见的,也是不推荐的.
我们强烈建议通过一个联接表(join table)来实现这种关联(下一节会对此进行解释).
可以通过@JoinColumn注解来描述这种单向关联关系.
@Entity
public class Customer implements Serializable {
@OneToMany(cascade=CascadeType.ALL, fetch=FetchType.EAGER)
@JoinColumn(name="CUST_ID")
public Set<Ticket> getTickets() {
...
}

@Entity
public class Ticket implements Serializable {
... //no bidir
}

Customer 通过CUST_ID列和Ticket 建立了单向关联关系.

通过联接表处理单向一对多关联是首选方式.这种关联通过@JoinTable注解来进行描述.
@Entity
public class Trainer {
@OneToMany
@JoinTable(
name="TrainedMonkeys",
joinColumns = { @JoinColumn( name="trainer_id") },
inverseJoinColumns = @JoinColumn( name="monkey_id")
)
public Set<Monkey> getTrainedMonkeys() {
...
}

@Entity
public class Monkey {
... //no bidir
}

上面这个例子中,Trainer通过TrainedMonkeys表和 Monkey 建立了单向关联.
其中外键trainer_id关联到Trainer(joinColumns), 而外键monkey_id关联到 Monkey
(inversejoinColumns).

通过联接表来建立单向一对多关联不需要描述任何物理映射.
表名由以下三个部分组成:主表(owner table)表名+下划线+从表(the other side table)表名.
指向主表的外键名:主表表名+下划线+主表主键列名
指向从表的外键名:主表所对应实体的属性名+下划线+从表主键列名
指向从表的外键定义为唯一约束,用来表示一对多的关联关系.

@Entity
public class Trainer {
@OneToMany
public Set<Tiger> getTrainedTigers() {
...
}

@Entity
public class Tiger {
... //no bidir
}

上面这个例子中,Trainer和Tiger通过联接表 Trainer_Tiger建立单向关联关系,其中外键trainer_id关联到Trainer(主表表名, _(下划线), trainer id),而外键trainedTigers_id关联到Tiger(属性名称, _(下划线), Tiger表的主键列名).

你可以通过@ManyToMany注解可定义的多对多关联.
同时,你也需要通过注解@JoinTable描述关联表和关联条件.
如果是双向关联,其中一段必须定义为owner,另一端必须定义为inverse(在对关联表进行更新操作时这一端将被忽略):

@Entity
public class Employer implements Serializable {
@ManyToMany(
targetEntity=org.hibernate.test.metadata.manytomany.Employee.class,
cascade={CascadeType.PERSIST, CascadeType.MERGE}
)
@JoinTable(
name="EMPLOYER_EMPLOYEE",
joinColumns={@JoinColumn(name="EMPER_ID")},
inverseJoinColumns={@JoinColumn(name="EMPEE_ID")}
)
public Collection getEmployees() {
return employees;
}
...
}

@Entity
public class Employee implements Serializable {
@ManyToMany(
cascade={CascadeType.PERSIST, CascadeType.MERGE},
mappedBy="employees"
targetEntity=Employer.class
)
public Collection getEmployers() {
return employers;
}
}

至此,我们已经展示了很多跟关联有关的声明定义以及属性细节.
下面我们将深入介绍@JoinTable注解,该注解定义了联接表的表名,联接列数组(注解中定义数组的格式为{ A, B, C }),以及inverse联接列数组.
后者是关联表中关联到Employee主键的列(the "other side").

正如前面所示,被关联端不必也不能描述物理映射:
只需要一个简单的mappedBy参数,该参数包含了主体端的属性名,这样就绑定双方的关系.

和其他许多注解一样,在多对多关联中很多值是自动生成.
当双向多对多关联中没有定义任何物理映射时,Hibernate根据以下规则生成相应的值.
关联表名:主表表名+_下划线+从表表名,关联到主表的外键名:主表名+_下划线+主表中的主键列名.
关联到从表的外键名:主表中用于关联的属性名+_下划线+从表的主键列名.
以上规则对于双向一对多关联同样有效.

@Entity
public class Store {
@ManyToMany(cascade = CascadeType.PERSIST)
public Set<City> getImplantedIn() {
...
}
}

@Entity
public class City {
... //no bidirectional relationship
}

上面这个例子中,Store_City作为联接表.
Store_id列是联接到Store表的外键.
而implantedIn_id列则联接到City表.

当双向多对多关联中没有定义任何物理映射时, Hibernate根据以下规则生成相应的值关联表名: :主表表名+_下划线+从表表名,关联到主表的外键名:从表用于关联的属性名+_下划线+主表中的主键列名.
关联到从表的外键名:主表用于关联的属性名+_下划线+从表的主键列名.
以上规则对于双向一对多关联同样有效.
@Entity
public class Store {
@ManyToMany(cascade = {CascadeType.PERSIST, CascadeType.MERGE})
public Set<Customer> getCustomers() {
...
}
}

@Entity
public class Customer {
@ManyToMany(mappedBy="customers")
public Set<Store> getStores() {
...
}
}

在上面这个例子中,Store_Customer作为联接表.
stores_id列是联接到Store表的外键,而customers_id列联接到Customer表.

也许你已经注意到了cascade属性接受的值为CascadeType数组.
在EJB3中的cascade的概念和Hibernate中的传播性持久化以及cascade操作非常类似,但是在语义上有细微的区别,支持的cascade类型也有点区别:

CascadeType.PERSIST: 如果一个实体是受管状态, 或者当persist()函数被调用时, 触发级联创建(create)操作CascadeType.MERGE: 如果一个实体是受管状态, 或者当merge()函数被调用时, 触发级联合并(merge)操作 CascadeType.REMOVE: 当delete()函数被调用时, 触发级联删除(remove)操作CascadeType.REFRESH: 当refresh()函数被调用时, 触发级联更新(refresh)操作CascadeType.ALL:
以上全部关于cascading, create/merge的语义请参考EJB3规范的6.3章节.

通过Hibernate你可以获得直接或者延迟获取关联实体的功能.
fetch参数可以设置为FetchType.LAZY 或者 FetchType.EAGER.
EAGER通过outer join select直接获取关联的对象,而LAZY(默认值)在第一次访问关联对象的时候才会触发相应的select操作.
EJBQL提供了fetch关键字,该关键字可以在进行特殊查询的时候覆盖默认值.
这对于提高性能来说非常有效,应该根据实际的用例来判断是否选择fetch关键字.

组合主键使用一个可嵌入的类作为主键表示,因此你需要使用@Id和@Embeddable两个注解.
还有一种方式是使用@EmbeddedId注解.注意所依赖的类必须实现serializable以及实现equals()/hashCode()方法.
你也可以如一章中描述的办法使用@IdClass注解.

@Entity
public class RegionalArticle implements Serializable {

@Id
public RegionalArticlePk getPk() { ... }
}

@Embeddable
public class RegionalArticlePk implements Serializable { ... }
或者
@Entity
public class RegionalArticle implements Serializable {

@EmbeddedId
public RegionalArticlePk getPk() { ... }
}

public class RegionalArticlePk implements Serializable { ... }

@Embeddable 注解默认继承了其所属实体的访问类型,除非显式使用了Hibernate的@AccessType注解(这个注解不是EJB3标准的一部分).
而@JoinColumns,即@JoinColumn数组,定义了关联的组合外键(如果不使用缺省值的话).显式指明referencedColumnNames是一个好的实践方式,否则,Hibernate认为你使用的列顺序和主键声明的顺序一致.

@Entity
public class Parent implements Serializable {
@Id
public ParentPk id;
public int age;

@OneToMany(cascade=CascadeType.ALL)
@JoinColumns ({
@JoinColumn(name="parentCivility", referencedColumnName = "isMale"),
@JoinColumn(name="parentLastName", referencedColumnName = "lastName"),
@JoinColumn(name="parentFirstName", referencedColumnName = "firstName")
})
public Set<Child> children; //unidirectional
...
}

@Entity
public class Child implements Serializable {
@Id @GeneratedValue
public Integer id;

@ManyToOne
@JoinColumns ({
@JoinColumn(name="parentCivility", referencedColumnName = "isMale"),
@JoinColumn(name="parentLastName", referencedColumnName = "lastName"),
@JoinColumn(name="parentFirstName", referencedColumnName = "firstName")
})
public Parent parent; //unidirectional
}

@Embeddable
public class ParentPk implements Serializable {
String firstName;
String lastName;
...
}

注意上面的 referencedColumnName显式使用方式.
使用类一级的 @SecondaryTable 或 @SecondaryTables 注解可以实现单个实体到多个表的映射.
使用 @Column 或者 @JoinColumn 注解中的 table 参数可指定某个列所属的特定表.

@Entity
@Table(name="MainCat")
@SecondaryTables({
@SecondaryTable(name="Cat1", pkJoinColumns={
@PrimaryKeyJoinColumn(name="cat_id", referencedColumnName="id")
),
@SecondaryTable(name="Cat2", uniqueConstraints={@UniqueConstraint(columnNames={"storyPart2"})})
})
public class Cat implements Serializable {

private Integer id;
private String name;
private String storyPart1;
private String storyPart2;

@Id @GeneratedValue
public Integer getId() {
return id;
}

public String getName() {
return name;
}

@Column(table="Cat1")
public String getStoryPart1() {
return storyPart1;
}

@Column(table="Cat2")
public String getStoryPart2() {
return storyPart2;
}

在上面这个例子中,name保存在MainCat表中,storyPart1保存在Cat1表中,storyPart2保存在Cat2表中.
Cat1表通过外键cat_id和MainCat表关联,Cat2表通过id列和MainCat表关联(和MainCat的id列同名).
对storyPart2列还定义了唯一约束.
在JBoss EJB 3指南和Hibernate Annotations单元测试代码中还有更多的例子.

使用注解还可以映射EJBQL/HQL查询.
@NamedQuery 和@NamedQueries注解可使用在类和JPA XML文件中.
但是它们的定义在session factory/entity manager factory范围中是都可见的.
命名式查询通过它的名字和实际的查询字符串来定义.
<entity-mappings>
<named-query name="plane.getAll">
<query>select p from Plane p</query>
</named-query>
...
</entity-mappings>
...

@Entity
@NamedQuery(name="night.moreRecentThan", query="select n from Night n where n.date >= :date")
public class Night {
...
}

public class MyDao {
doStuff() {
Query q = s.getNamedQuery("night.moreRecentThan");
q.setDate( "date", aMonthAgo );
List results = q.list();
...
}
...
}

还可以通过定义 QueryHint 数组的hints属性为查询提供一些hint信息.

下面是目前可以使用的一些Hibernate hint:
hint

description

org.hibernate.cacheable
查询是否与二级缓存交互(默认值为false)

org.hibernate.cacheRegion
设置缓存区名称 (默认为otherwise)

org.hibernate.timeout
查询超时设定

org.hibernate.fetchSize
所获取的结果集(resultset)大小

org.hibernate.flushMode
本次查询所用的刷新模式

org.hibernate.cacheMode
本次查询所用的缓存模式

org.hibernate.readOnly
是否将本次查询所加载的实体设为只读(默认为false)

org.hibernate.comment
将查询注释添加入所生成的SQL

你还可以映射本地化查询(也就是普通SQL查询).
不过这需要你使用@SqlResultSetMapping注解来描述SQL的resultset的结构
(如果你打算定义多个结果集映射,可是使用@SqlResultSetMappings).
@SqlResultSetMapping和@NamedQuery,
@SqlResultSetMapping一样,可以定义在类和JPA XML文件中.
但是@SqlResultSetMapping的作用域为应用级.

下面我们会看到,@NamedNativeQuery 注解中 resultSetMapping参数值为@SqlResultSetMapping的名字.
结果集映射定义了通过本地化查询返回值和实体的映射.
该实体中的每一个字段都绑定到SQL结果集中的某个列上.
该实体的所有字段包括子类的所有字段以及关联实体的外键列都必须在SQL查询中有对应的定义.
如果实体中的属性和SQL查询中的列名相同,这种情况下可以不进行定义字段映射.
@NamedNativeQuery(name="night&area", query="select night.id nid, night.night_duration, "
+ " night.night_date, area.id aid, night.area_id, area.name "
+ "from Night night, Area area where night.area_id = area.id", role="bold">resultSetMapping="joinMapping")
@SqlResultSetMapping(name="joinMapping", entities={
@EntityResult(entityClass=org.hibernate.test.annotations.query.Night.class, fields = {
@FieldResult(name="id", column="nid"),
@FieldResult(name="duration", column="night_duration"),
@FieldResult(name="date", column="night_date"),
@FieldResult(name="area", column="area_id"),
discriminatorColumn="disc"
}),
@EntityResult(entityClass=org.hibernate.test.annotations.query.Area.class, fields = {
@FieldResult(name="id", column="aid"),
@FieldResult(name="name", column="name")
})
}
)
在上面这个例子中,名为night&area的查询和joinMapping结果集映射对应.
该映射返回两个实体,分别为Night和Area,其中每个属性都和一个列关联,列名通过查询获取.下面我们看一个隐式声明属性和列映射关系的例子.

@Entity
@SqlResultSetMapping(name="implicit", entities=@EntityResult(entityClass=org.hibernate.test.annotations.query.SpaceShip.class))
@NamedNativeQuery(name="implicitSample", query="select * from SpaceShip", resultSetMapping="implicit")
public class SpaceShip {
private String name;
private String model;
private double speed;

@Id
public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

@Column(name="model_txt")
public String getModel() {
return model;
}

public void setModel(String model) {
this.model = model;
}

public double getSpeed() {
return speed;
}

public void setSpeed(double speed) {
this.speed = speed;
}
}

在这个例子中,我们只需要定义结果集映射中的实体成员.
属性和列名之间的映射借助实体中包含映射信息来完成.
在这个例子中,model属性绑定到model_txt列.
如果和相关实体的关联设计到组合主键,那么应该使用@FieldResult注解来定义每个外键列.
@FieldResult的名字由以下几部分组成:
定义这种关系的属性名字+"."＋主键名或主键列或主键属性.

@Entity
@SqlResultSetMapping(name="compositekey",
entities=@EntityResult(entityClass=org.hibernate.test.annotations.query.SpaceShip.class,
fields = {
@FieldResult(name="name", column = "name"),
@FieldResult(name="model", column = "model"),
@FieldResult(name="speed", column = "speed"),
@FieldResult(name="captain.firstname", column = "firstn"),
@FieldResult(name="captain.lastname", column = "lastn"),
@FieldResult(name="dimensions.length", column = "length"),
@FieldResult(name="dimensions.width", column = "width")
}),
columns = { @ColumnResult(name = "surface"),
@ColumnResult(name = "volume") } )

@NamedNativeQuery(name="compositekey",
query="select name, model, speed, lname as lastn, fname as firstn, length, width, length * width as surface from SpaceShip",
resultSetMapping="compositekey")
} )
public class SpaceShip {
private String name;
private String model;
private double speed;
private Captain captain;
private Dimensions dimensions;

@Id
public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

@ManyToOne(fetch= FetchType.LAZY)
@JoinColumns( {
@JoinColumn(name="fname", referencedColumnName = "firstname"),
@JoinColumn(name="lname", referencedColumnName = "lastname")
} )
public Captain getCaptain() {
return captain;
}

public void setCaptain(Captain captain) {
this.captain = captain;
}

public String getModel() {
return model;
}

public void setModel(String model) {
this.model = model;
}

public double getSpeed() {
return speed;
}

public void setSpeed(double speed) {
this.speed = speed;
}

public Dimensions getDimensions() {
return dimensions;
}

public void setDimensions(Dimensions dimensions) {
this.dimensions = dimensions;
}
}

@Entity
@IdClass(Identity.class)
public class Captain implements Serializable {
private String firstname;
private String lastname;

@Id
public String getFirstname() {
return firstname;
}

public void setFirstname(String firstname) {
this.firstname = firstname;
}

@Id
public String getLastname() {
return lastname;
}

public void setLastname(String lastname) {
this.lastname = lastname;
}
}

观察dimension属性你会发现Hibernate支持用"."符号来表示嵌入式对象.
EJB3实现不必支持这个特征,但是我们做到了:-)

如果查询返回的是单个实体,或者你打算使用系统默认的映射,这种情况下可以不使用resultSetMapping 而是使用resultClass属性:

@NamedNativeQuery(name="implicitSample", query="select * from SpaceShip", resultClass=SpaceShip.class)
public class SpaceShip {

某些本地查询返回的是scalar值,例如报表查询.
你可以通过@ColumnResult将其映射到@SqlResultsetMapping上.
甚至还可以在同一个本地查询的结果中混合实体和scalar类型(不过这种情况比较少见).

@SqlResultSetMapping(name="scalar", columns=@ColumnResult(name="dimension"))
@NamedNativeQuery(name="scalar", query="select length*width as dimension from SpaceShip", resultSetMapping="scalar")

本地查询中还有另外一个hint属性:
org.hibernate.callable.
这个属性的布尔变量值表明这个查询是否是一个存储过程.

Hibernate 3.1 提供了多种附加的注解,这些注解可以与EJB3的实体混合/匹配使用.
他们被设计成EJB3注解的自然扩展.

为了强化EJB3的能力,Hibernate提供了与其自身特性相吻合的特殊注解.
org.hibernate.annotations包已包含了所有的这些注解扩展.

你可以在EJB3规范所能提供的能力之外,就Hibernate对实体所做的一些操作进行优化.

@org.hibernate.annotations.Entity
追加了可能需要的额外的元数据,而这些元数据超出了标准@Entity 中所定义的元数据.
mutable: 此实体是否为可变的
dynamicInsert: 用动态SQL新增
dynamicUpdate: 用动态SQL更新
selectBeforeUpdate: 指明Hibernate从不运行SQL UPDATE除非能确定对象的确已被修改
polymorphism: (指出)实体多态是PolymorphismType.IMPLICIT(默认)还是PolymorphismType.EXPLICIT
persister:允许对默认持久实现(persister implementation)的覆盖
optimisticLock: 乐观锁策略(OptimisticLockType.VERSION, OptimisticLockType.NONE, OptimisticLockType.DIRTY或OptimisticLockType.ALL)

@javax.persistence.Entity仍是必选的(mandatory),
@org.hibernate.annotations.Entity不是取代品.

以下是一些附加的Hibernate注解扩展:
@org.hibernate.annotations.BatchSize
允许你定义批量获取该实体的实例数量(如:@BatchSize(size=4)).
当加载一特定的实体时,Hibernate将加载在持久上下文中未经初始化的同类型实体,直至批量数量(上限).

@org.hibernate.annotations.Proxy
定义了实体的延迟属性.Lazy(默认为true)定义了类是否为延迟(加载).
proxyClassName是用来生成代理的接口(默认为该类本身).

@org.hibernate.annotations.Where
定义了当获取类实例时所用的SQL WHERE子句(该SQL WHERE子句为可选).

@org.hibernate.annotations.Check
定义了在DDL语句中定义的合法性检查约束(该约束为可选).

@OnDelete(action=OnDeleteAction.CASCADE)
定义于被连接的子类(joined subclass):在删除时使用SQL级连删除,而非通常的Hibernate删除机制.

@Table(name="tableName", indexes = {
@Index(name="index1", columnNames={"column1", "column2"} ) } )
在tableName表的列上创建定义好的索引.
该注解可以被应用于关键表或者是其他次要的表.
@Tables 注解允许你在不同的表上应用索引.
此注解预期在使用@javax.persistence.Table或@javax.persistence.SecondaryTable的地方中出现.

@org.hibernate.annotations.Table 是对@javax.persistence.Table的补充而不是它的替代品.特别是当你打算改变表名的默认值的时候,你必须使用@javax.persistence.Table,而不是@org.hibernate.annotations.Table.

@Entity
@BatchSize(size=5)
@org.hibernate.annotations.Entity(
selectBeforeUpdate = true,
dynamicInsert = true, dynamicUpdate = true,
optimisticLock = OptimisticLockType.ALL,
polymorphism = PolymorphismType.EXPLICIT)
@Where(clause="1=1")
@org.hibernate.annotations.Table(name="Forest", indexes = { @Index(name="idx", columnNames = { "name", "length" } ) } )
public class Forest { ... }@Entity
@Inheritance(
strategy=InheritanceType.JOINED
)
public class Vegetable { ... }

@Entity
@OnDelete(action=OnDeleteAction.CASCADE)
public class Carrot extends Vegetable { ... }

@org.hibernate.annotations.GenericGenerator
允许你定义一个Hibernate特定的id生成器.

@Id @GeneratedValue(generator="system-uuid")
@GenericGenerator(name="system-uuid", strategy = "uuid")
public String getId() {

@Id @GeneratedValue(generator="hibseq")
@GenericGenerator(name="hibseq", strategy = "seqhilo",
parameters = {
@Parameter(name="max_lo", value = "5"),
@Parameter(name="sequence", value="heybabyhey")
}
)
public Integer getId() {

strategy可以是Hibernate3生成器策略的简称,或者是一个IdentifierGenerator实现的(带包路径的)全限定类名.你可以通过parameters属性增加一些参数.和标准的对比,@GenericGenerator是可用于包一级的注解, 使之成为应用级的生成器(就象在JPA XML文件里面那样).

@GenericGenerator(name="hibseq", strategy = "seqhilo",
parameters = {
@Parameter(name="max_lo", value = "5"),
@Parameter(name="sequence", value="heybabyhey")
}
)
package org.hibernate.test.model

访问类型是根据@Id或@EmbeddedId在实体继承层次中所处的位置推演而得的.子实体(Sub-entities),内嵌对象和被映射的父类均继承了根实体(root entity)的访问类型.
在Hibernate中,你可以把访问类型覆盖成:
使用定制的访问类型策略优化类级或属性级的访问类型为支持这种行为,Hibernate引入了@AccessType注解.你可以对以下元素定义访问类型:
实体
父类
可内嵌的对象
属性

被注解元素的访问类型会被覆盖,若覆盖是在类一级上,则所有的属性继承访问类型.
对于根实体,其访问类型会被认为是整个继承层次中的缺省设置(可在类或属性一级覆盖).
若访问类型被标以"property",则Hibernate会扫描getter方法的注解,若访问类型被标以"field",
则扫描字段的注解.否则,扫描标为@Id或@embeddedId的元素.
你可以覆盖某个属性(property)的访问类型,但是受注解的元素将不受影响:
例如一个具有field访问类型的实体,(我们)可以将某个字段标注为 @AccessType("property"),则该字段的访问类型随之将成为property,但是其他字段上依然需要携带注解.
若父类或可内嵌的对象没有被注解,则使用根实体的访问类型(即使已经在非直系父类或可内嵌对象上定义了访问类型).
此时俄罗斯套娃(Russian doll)原理就不再适用.(译注:俄罗斯套娃(матрёшка或 матрешка)是俄罗斯特产木制玩具,一般由多个一样图案的空心木娃娃一个套一个组成,最多可达十多个,通常为圆柱形,底部平坦可以直立.)
@Entity
public class Person implements Serializable {
@Id @GeneratedValue //access type field
Integer id;

@Embedded
@AttributeOverrides({
@AttributeOverride(name = "iso2", column = @Column(name = "bornIso2")),
@AttributeOverride(name = "name", column = @Column(name = "bornCountryName"))
})
Country bornIn;
}

@Embeddable
@AccessType("property") //override access type for all properties in Country
public class Country implements Serializable {
private String iso2;
private String name;

public String getIso2() {
return iso2;
}

public void setIso2(String iso2) {
this.iso2 = iso2;
}

@Column(name = "countryName")
public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}
}

15:45
评论 / 浏览 (1 / 2244)
收藏

2008-12-29
缩略显示
常见异常解析

博客分类：
Java

JavaHibernateStruts虚拟机JSP
1. java.lang.nullpointerexception
　　这个异常大家肯定都经常遇到，异常的解释是"程序遇上了空指针"，简单地说就是调用了未经初始化的对象或者是不存在的对象，这个错误经常出现在创建图片，调用数组这些操作中，比如图片未经初始化，或者图片创建时的路径错误等等。对数组操作中出现空指针，很多情况下是一些刚开始学习编程的朋友常犯的错误，即把数组的初始化和数组元素的初始化混淆起来了。数组的初始化是对数组分配需要的空间，而初始化后的数组，其中的元素并没有实例化，依然是空的，所以还需要对每个元素都进行初始化（如果要调用的话）
　　2. java.lang.classnotfoundexception
　　这个异常是很多原本在jb等开发环境中开发的程序员，把jb下的程序包放在wtk下编译经常出现的问题，异常的解释是"指定的类不存在"，这里主要考虑一下类的名称和路径是否正确即可，如果是在jb下做的程序包，一般都是默认加上package的，所以转到wtk下后要注意把package的路径加上。
　　3. java.lang.arithmeticexception
　　这个异常的解释是"数学运算异常"，比如程序中出现了除以零这样的运算就会出这样的异常，对这种异常，大家就要好好检查一下自己程序中涉及到数学运算的地方，公式是不是有不妥了。
　　4. java.lang.arrayindexoutofboundsexception
　　这个异常相信很多朋友也经常遇到过，异常的解释是"数组下标越界"，现在程序中大多都有对数组的操作，因此在调用数组的时候一定要认真检查，看自己调用的下标是不是超出了数组的范围，一般来说，显示（即直接用常数当下标）调用不太容易出这样的错，但隐式（即用变量表示下标）调用就经常出错了，还有一种情况，是程序中定义的数组的长度是通过某些特定方法决定的，不是事先声明的，这个时候，最好先查看一下数组的length，以免出现这个异常。
　　5. java.lang.illegalargumentexception
　　这个异常的解释是"方法的参数错误"，很多j2me的类库中的方法在一些情况下都会引发这样的错误，比如音量调节方法中的音量参数如果写成负数就会出现这个异常，再比如g.setcolor(int red,int green,int blue)这个方法中的三个值，如果有超过２５５的也会出现这个异常，因此一旦发现这个异常，我们要做的，就是赶紧去检查一下方法调用中的参数传递是不是出现了错误。
　　6. java.lang.illegalaccessexception
　　这个异常的解释是"没有访问权限"，当应用程序要调用一个类，但当前的方法即没有对该类的访问权限便会出现这个异常。对程序中用了package的情况下要注意这个异常。
　　其他还有很多异常，我就不一一列举了，我要说明的是，一个合格的程序员，需要对程序中常见的问题有相当的了解和相应的解决办法，否则仅仅停留在写程序而不会改程序的话，会极大影响到自己的开发的。关于异常的全部说明，在api里都可以查阅。
　　算术异常类：ArithmeticExecption
　　空指针异常类：NullPointerException
　　类型强制转换异常：ClassCastException
　　数组负下标异常：NegativeArrayException
　　数组下标越界异常：ArrayIndexOutOfBoundsException
　　违背安全原则异常：SecturityException
　　文件已结束异常：EOFException
　　文件未找到异常：FileNotFoundException
　　字符串转换为数字异常：NumberFormatException
　　操作数据库异常：SQLException
　　输入输出异常：IOException
　　方法未找到异常：NoSuchMethodException
　　java.lang.AbstractMethodError
　　抽象方法错误。当应用试图调用抽象方法时抛出。
　　java.lang.AssertionError
　　断言错。用来指示一个断言失败的情况。
　　java.lang.ClassCircularityError
　　类循环依赖错误。在初始化一个类时，若检测到类之间循环依赖则抛出该异常。
　　java.lang.ClassFormatError
　　类格式错误。当Java虚拟机试图从一个文件中读取Java类，而检测到该文件的内容不符合类的有效格式时抛出。
　　java.lang.Error
　　错误。是所有错误的基类，用于标识严重的程序运行问题。这些问题通常描述一些不应被应用程序捕获的反常情况。
　　java.lang.ExceptionInInitializerError
　　初始化程序错误。当执行一个类的静态初始化程序的过程中，发生了异常时抛出。静态初始化程序是指直接包含于类中的static语句段。
　　java.lang.IllegalAccessError
　　违法访问错误。当一个应用试图访问、修改某个类的域（Field）或者调用其方法，但是又违反域或方法的可见性声明，则抛出该异常。
　　java.lang.IncompatibleClassChangeError
　　不兼容的类变化错误。当正在执行的方法所依赖的类定义发生了不兼容的改变时，抛出该异常。一般在修改了应用中的某些类的声明定义而没有对整个应用重新编译而直接运行的情况下，容易引发该错误。
　　java.lang.InstantiationError
　　实例化错误。当一个应用试图通过Java的new操作符构造一个抽象类或者接口时抛出该异常.
　　java.lang.InternalError
　　内部错误。用于指示Java虚拟机发生了内部错误。
　　java.lang.LinkageError
　　链接错误。该错误及其所有子类指示某个类依赖于另外一些类，在该类编译之后，被依赖的类改变了其类定义而没有重新编译所有的类，进而引发错误的情况。
　　java.lang.NoClassDefFoundError
　　未找到类定义错误。当Java虚拟机或者类装载器试图实例化某个类，而找不到该类的定义时抛出该错误。
　　java.lang.NoSuchFieldError
　　域不存在错误。当应用试图访问或者修改某类的某个域，而该类的定义中没有该域的定义时抛出该错误。
　　java.lang.NoSuchMethodError
　　方法不存在错误。当应用试图调用某类的某个方法，而该类的定义中没有该方法的定义时抛出该错误。
　　java.lang.OutOfMemoryError
　　内存不足错误。当可用内存不足以让Java虚拟机分配给一个对象时抛出该错误。
　　java.lang.StackOverflowError
　　堆栈溢出错误。当一个应用递归调用的层次太深而导致堆栈溢出时抛出该错误。
　　java.lang.ThreadDeath
　　线程结束。当调用Thread类的stop方法时抛出该错误，用于指示线程结束。
　　java.lang.UnknownError
　　未知错误。用于指示Java虚拟机发生了未知严重错误的情况。
　　java.lang.UnsatisfiedLinkError
　　未满足的链接错误。当Java虚拟机未找到某个类的声明为native方法的本机语言定义时抛出。
　　java.lang.UnsupportedClassVersionError
　　不支持的类版本错误。当Java虚拟机试图从读取某个类文件，但是发现该文件的主、次版本号不被当前Java虚拟机支持的时候，抛出该错误。
　　java.lang.VerifyError
　　验证错误。当验证器检测到某个类文件中存在内部不兼容或者安全问题时抛出该错误。
　　java.lang.VirtualMachineError
　　虚拟机错误。用于指示虚拟机被破坏或者继续执行操作所需的资源不足的情况。
　　java.lang.ArithmeticException
　　算术条件异常。譬如：整数除零等。
　　java.lang.ArrayIndexOutOfBoundsException
　　数组索引越界异常。当对数组的索引值为负数或大于等于数组大小时抛出。
　　java.lang.ArrayStoreException
　　数组存储异常。当向数组中存放非数组声明类型对象时抛出。
　　java.lang.ClassCastException
　　类造型异常。假设有类A和B（A不是B的父类或子类），O是A的实例，那么当强制将O构造为类B的实例时抛出该异常。该异常经常被称为强制类型转换异常。
　　java.lang.ClassNotFoundException
　　找不到类异常。当应用试图根据字符串形式的类名构造类，而在遍历CLASSPAH之后找不到对应名称的class文件时，抛出该异常。
　　java.lang.CloneNotSupportedException
　　不支持克隆异常。当没有实现Cloneable接口或者不支持克隆方法时,调用其clone()方法则抛出该异常。
　　java.lang.EnumConstantNotPresentException
　　枚举常量不存在异常。当应用试图通过名称和枚举类型访问一个枚举对象，但该枚举对象并不包含常量时，抛出该异常。
　　java.lang.Exception
　　根异常。用以描述应用程序希望捕获的情况。
　　java.lang.IllegalAccessException
　　违法的访问异常。当应用试图通过反射方式创建某个类的实例、访问该类属性、调用该类方法，而当时又无法访问类的、属性的、方法的或构造方法的定义时抛出该异常。
　　java.lang.IllegalMonitorStateException
　　违法的监控状态异常。当某个线程试图等待一个自己并不拥有的对象（O）的监控器或者通知其他线程等待该对象（O）的监控器时，抛出该异常。
　　java.lang.IllegalStateException
　　违法的状态异常。当在Java环境和应用尚未处于某个方法的合法调用状态，而调用了该方法时，抛出该异常。
　　java.lang.IllegalThreadStateException
　　违法的线程状态异常。当县城尚未处于某个方法的合法调用状态，而调用了该方法时，抛出异常。
　　java.lang.IndexOutOfBoundsException
　　索引越界异常。当访问某个序列的索引值小于0或大于等于序列大小时，抛出该异常。
　　java.lang.InstantiationException
　　实例化异常。当试图通过newInstance()方法创建某个类的实例，而该类是一个抽象类或接口时，抛出该异常。
　　java.lang.InterruptedException
　　被中止异常。当某个线程处于长时间的等待、休眠或其他暂停状态，而此时其他的线程通过Thread的interrupt方法终止该线程时抛出该异常。
　　java.lang.NegativeArraySizeException
　　数组大小为负值异常。当使用负数大小值创建数组时抛出该异常。
　　java.lang.NoSuchFieldException
　　属性不存在异常。当访问某个类的不存在的属性时抛出该异常。
　　java.lang.NoSuchMethodException
　　方法不存在异常。当访问某个类的不存在的方法时抛出该异常。
　　java.lang.NullPointerException
　　空指针异常。当应用试图在要求使用对象的地方使用了null时，抛出该异常。譬如：调用null对象的实例方法、访问null对象的属性、计算null对象的长度、使用throw语句抛出null等等。
　　java.lang.NumberFormatException
　　数字格式异常。当试图将一个String转换为指定的数字类型，而该字符串确不满足数字类型要求的格式时，抛出该异常。
　　java.lang.RuntimeException
　　运行时异常。是所有Java虚拟机正常操作期间可以被抛出的异常的父类。
　　java.lang.SecurityException
　　安全异常。由安全管理器抛出，用于指示违反安全情况的异常。
　　java.lang.StringIndexOutOfBoundsException
　　字符串索引越界异常。当使用索引值访问某个字符串中的字符，而该索引值小于0或大于等于序列大小时，抛出该异常。
　　java.lang.TypeNotPresentException
　　类型不存在异常。当应用试图以某个类型名称的字符串表达方式访问该类型，但是根据给定的名称又找不到该类型是抛出该异常。该异常与ClassNotFoundException的区别在于该异常是unchecked（不被检查）异常，而ClassNotFoundException是checked（被检查）异常。
　　java.lang.UnsupportedOperationException
　　不支持的方法异常。指明请求的方法不被支持情况的异常。
　　异常
　　javax.servlet.jsp.JspException: Cannot retrieve mapping for action /Login （/Login是你的action名字）
　　可能原因
　　action没有再struts-config.xml 中定义，或没有找到匹配的action，例如在JSP文件中使用 >后面使用Struts的html标记。另外要注意可能你不经意使用的无主体的标记，如 ，这样web 服务器解析时就当作一个无主体的标记，随后使用的所有标记都被认为是在这个标记之外的，如又使用了 还有就是在使用taglib引入HTML标记库时，你使用的prefix的值不是html。
　　-----------------------------------------------------------------------------------------------------------------
　　异常
　　javax.servlet.jsp.JspException: Missing message for key xx.xx.xx
　　Probable Causes
　　这个key的值对没有在资源文件ApplicationResources.properties中定义。如果你使用eclipse时经常碰到这样的情况，当项目重新编译时，eclipse会自动将classes目录下的资源文件删除。
　　资源文件ApplicationResources.properties 不在classpath中应将资源文件放到 WEB-INF/classes 目录下，当然要在struts-config.xml中定义)
　　-----------------------------------------------------------------------------------------------------------------
　　异常
　　Cannot find message resources under key org.apache.struts.action.MESSAGE
　　可能原因
　　很显然，这个错误是发生在使用资源文件时，而Struts没有找到资源文件。
　　Implicitly trying to use message resources that are not available (such as using empty html:options tag instead of specifyingthe options in its body -- this assumes options are specified in ApplicationResources.properties file)
　　XML parser issues -- too many, too few, incorrect/incompatible versions
　　-----------------------------------------------------------------------------------------------------------------
　　异常
　　Strange and seemingly random characters in HTML and on screen, but not in original JSP or servlet.
　　可能原因
　　混和使用Struts的html:form标记和标准的HTML标记不正确。
　　使用的编码样式在本页中不支持。
　　-----------------------------------------------------------------------------------------------------------------
　　异常
　　"Document contained no data" in Netscape
　　No data rendered (completely empty) page in Microsoft Internet Explorer
　　可能原因
　　使用一个Action的派生类而没有实现perform()方法或execute()方法。在Struts1.0中实现的是perform()方法，在Struts1.1中实现的是execute()方法，但Struts1.1向后兼容perform()方法。但你使用Struts1.1创建一个Action的派生类，并且实现了execute()方法，而你在Struts1.0中运行的话，就会得到"Document contained nodata" error message in Netscape or a completely empty (no HTML whatsoever) page rendered in Microsoft Internet Explorer.”的错误信息。
　　---------------------------------------------------------------------------------------------------------------------------
　　异常
　　ServletException: BeanUtils.populate
　　解决方案
　　在用Struts上传文件时,遇到了javax.servlet.ServletException: BeanUtils.populate异常。
　　我的ActionServlet并没有用到BeanUtils这些工具类。后来仔细检查代码发现是在jsp文件里的form忘了加enctype="multipart/form-data" 了。所以写程序遇到错误或异常应该从多方面考虑问题存在的可能性，想到系统提示信息以外的东西。
　　----------------------------------------------------------------------------------------------------------------------------
　　1. 定义Action后, 如果指定了name, 那么必须要定义一个与它同名的FormBean才能进行form映射.2. 如果定义Action后, 提交页面时出现 "No input attribute for mapping path..." 错误, 则需要在其input属性中定义转向的页面.3. 如果插入新的数据时出现 "Batch update row count wrong:..." 错误, 则说明XXX.hbm.xml中指定的key的类型为原始类型(int, long),因为这种类型会自动分配值, 而这个值往往会让系统认为已经存在该记录, 正确的方法是使用java.lang.Integer或java.lang.Long对象.4. 如果插入数据时出现 "argument type mismatch" 错误, 可能是你使用了Date等特殊对象, 因为struts不能自动从String型转换成Date型,所以, 你需要在Action中手动把String型转换成Date型.5. Hibernate中, Query的iterator()比list()方法快很多.6. 如果出现 "equal symbol expected" 错误, 说明你的strtus标签中包含另一个标签或者变量, 例如:
　　
　　或者
　　
　　这样的情况...
　　---------------------------------------------------------------------------------------------------------------------------
　　错误：Exception in thread "main" org.hibernate.exception.SQLGrammarException: Could not execute JDBC batch update原因与解决： 因为Hibernate Tools（或者Eclipse本身的Database Explorer）生成*.hbn.xml工具中包含有catalog="***"（*表示数据库名称）这样的属性,将该属性删除就可以了
　　---------------------------------------------------------------------------------------------------------------------------
　　错误：org.hibernate.ObjectDeletedException: deleted object would be re-saved by cascade (remove deleted object from associations)
　　原因与解决：
　　方法1 删除Set方的cascade
　　方法2 解决关联关系后，再删除
　　方法3 在many-to-one方增加cascade 但值不能是none
　　最后一招：
　　检查一下hashCode equals是否使用了id作为唯一标示的选项了；我用uuid.hex时是没有问题的；但是用了native，就不行了，怎么办？删除啊！
　　----------------------------------------------------------------------------------------------------------------------------
　　问题：今天用Tomcat 5.5.12，发现原来很好用的系统不能用了，反复测试发现页面中不能包含 taglib，否则会出现以下提示：HTTP Status 500 -type Exception reportMessage description The server encountered an internal error () that prevented it from fulfilling this request.exceptionorg.apache.jasper.JasperException: /index.jsp(1,1) Unable to read TLD "META-INF/tlds/struts-bean.tld" from JAR file"file:*****/WEB-INF/lib/struts.jar":原因：更新了工程用的lib文件夹下的jar，发布时也发布了servlet.jar和jsp-api.jar。解决：把jsp-api.jar删除就解决这个问题了。-----------------------------------------------------------------------------------------------------------------------------
　　错误： java.lang.NullPointerException
　　原因： 发现 dao 实例、 manage 实例等需要注入的东西没有被注入（俗称空指针异常）解决：这个时候，你应该查看日志文件；默认是应用服务器的 log 文件，比如 Tomcat 就是 [Tomcat 安装目录 ]/logs ；你会发现提示你：可能是：org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'sf' defined in ServletContextresource [/WEB-INF/applicationContext.xml]: Initialization of bean failed; nested exception isorg.hibernate.HibernateException: could not configure from URL: file:src/hibernate.cfg.xmlorg.hibernate.HibernateException: could not configure from URL: file:src/hibernate.cfg.xml……………………….Caused by: java.io.FileNotFoundException: src\hibernate.cfg.xml可能是：org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'sessionFactory' defined inServletContext resource [/WEB-INF/applicationContext.xml]: Initialization of bean failed; nested exception isorg.hibernate.MappingException: Resource: com/mcc/coupon/model/UserRole.hbm.xml not foundorg.hibernate.MappingException: Resource: com/mcc/coupon/model/UserRole.hbm.xml not found然后你就知道原因是因为配置文件的解析出了错误，这个通过 Web 页面是看不出来的。更多的是持久化影射文件出的错误；导致了没有被解析；当然你需要的功能就无法使用了。
　　----------------------------------------------------------------------------------------------------------------------------
　　错误：StandardWrapperValve[action]: Servlet.service() for servlet action threw exception
　　javax.servlet.jsp.JspException: Cannot retrieve mapping for action /settlementTypeManage
　　或者： type Status report message Servlet action is not available description The requested resource (Servlet action is not available) is not available.
　　原因： 同 上
　　----------------------------------------------------------------------------------------------------------------------------
　　错误StandardWrapperValve[jsp]: Servlet.service() for servlet jsp threw exceptionjava.lang.ClassNotFoundException: org.apache.struts.taglib.bean.CookieTei界面错误具体描述：
　　org.apache.jasper.JasperException: Failed to load or instantiate TagExtraInfo class: org.apache.struts.taglib.bean.CookieTei
　　原因与解决： <方案一>你的“html:”开头的标签没有放在一个 >

11:36
评论 / 浏览 (0 / 272)
收藏

2008-12-26
缩略显示
org.apache.commons.lang.builder

博客分类：
Java

Apache单元测试

在org.apache.commons.lang.builder包中一共有7个类，用于帮助实现Java对象的一些基础的方法，如compareTo(), equals(), hashCode(), toString()等。他们分别是：

CompareToBuilder – 用于辅助实现Comparable.compareTo(Object)方法；
EqualsBuilder – 用于辅助实现Object.equals()方法；
HashCodeBuilder – 用于辅助实现Object.hashCode()方法；
ReflectionToStringBuilder – 使用反射机制辅助实现Object.toString()方法；
ToStringBuilder – 用于辅助实现Object.toString()方法；
StandardToStringStyle – 辅助ToStringBuilder控制标准格式；
ToStringStyle – 辅助ToStringBuilder控制输出格式。


Java代码

import java.util.Date;

import org.apache.commons.lang.builder.CompareToBuilder;
import org.apache.commons.lang.builder.EqualsBuilder;
import org.apache.commons.lang.builder.HashCodeBuilder;
import org.apache.commons.lang.builder.ReflectionToStringBuilder;
import org.apache.commons.lang.builder.ToStringBuilder;
import org.apache.commons.lang.builder.ToStringStyle;
import org.apache.commons.lang.builder.StandardToStringStyle;

public class BuilderTest {

public static void main(String[] args) {
Person person1 = new Person("郑致力", 32, new Date());
Person person2 = new Person("高婕", 27, new Date());

System.out.println("person1's info: " + person1);
System.out.println("person2's info: " + person2);
System.out.println("person1's hash code: " + person1.hashCode());
System.out.println("person2's hash code: " + person2.hashCode());
System.out.println("person1 equals person2? " + person1.equals(person2));

System.out.println("--------------More String Style of Object ------------------------------------");
System.out.println("person1's info: " + person1.toString2(ToStringStyle.MULTI_LINE_STYLE));
System.out.println("person1's info: " + person1.toString2(ToStringStyle.NO_FIELD_NAMES_STYLE));
System.out.println("person1's info: " + person1.toString2(ToStringStyle.SHORT_PREFIX_STYLE));
System.out.println("person1's info: " + person1.toString2(ToStringStyle.SIMPLE_STYLE));
System.out.println("person1's info: " + person1.toString2(new StandardToStringStyle()));
}
}

class Person implements Comparable {
private String name;
private int age;
private Date dateJoined;

public Person() {
};

public Person(String name, int age, Date dateJoined) {
this.name = name;
this.age = age;
this.dateJoined = dateJoined;
}

public int compareTo(Object o) {
if (!(o instanceof Person)) {
return -1;
}
Person other = (Person) o;
return new CompareToBuilder().append(name, other.getName()).append(age,
other.getAge()).append(dateJoined, other.getDateJoined())
.toComparison();
}

public boolean equals(Object o) {
if (!(o instanceof Person)) {
return false;
}
Person other = (Person) o;
return new EqualsBuilder().append(name, other.getName()).append(age,
other.getAge()).append(dateJoined, other.getDateJoined())
.isEquals();
}

//注：两个equlas为true的对象在这里会被计算成不同的hash码,慎用
public int hashCode() {
return new HashCodeBuilder().append(name).append(age)
.append(dateJoined).toHashCode();
}

public String toString() {
return new ToStringBuilder(this).append("name", name)
.append("age", age).append("dateJoined", dateJoined).toString();
}

public String toString2(ToStringStyle style) {
ToStringStyle _style = ToStringStyle.DEFAULT_STYLE;
if (null != style) {
_style = style;
}
return new ToStringBuilder(this, _style).append("name", name)
.append("age", age).append("dateJoined", dateJoined).toString();
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}

public Date getDateJoined() {
return dateJoined;
}

public void setDateJoined(Date dateJoined) {
this.dateJoined = dateJoined;
}

}



这些builder用起来很简单，只要new一个实例，append需要参与的信息，然后加上toComparison、isEquals、toHashCode、toString结尾就可以了。如果不需要使用append指定信息，则可直接使用反射机制进行自动化实现，如下面的Student类：


Java代码

class Student extends Person {
private int grad;

public Student() {super();}

public Student(String name, int age, Date dateJoined, int grad) {
super(name, age, dateJoined);
this.grad = grad;
}

public int compareTo(Object o) {
return CompareToBuilder.reflectionCompare(this, o);
}

public boolean equals(Object o) {
return EqualsBuilder.reflectionEquals(this, o);
}

public int hashCode() {
return HashCodeBuilder.reflectionHashCode(this);
}

public String toString() {
return ReflectionToStringBuilder.toString(this);
}
}



这里需要补充一点，对于ToStringStyle类，代码中已经内置了5种，分别为ToStringStyle.DEFAULT_STYLE、ToStringStyle.MULTI_LINE_STYLE、ToStringStyle.NO_FIELD_NAMES_STYLE、ToStringStyle.SHORT_PREFIX_STYLE、ToStringStyle.SIMPLE_STYLE。不知道为什么，这5种内置类的实现都被定义成了private static final类了。所以如果上述5种类不能满足你的要求的话，想继承他们是不可能的。所以你需要创建StandardToStringStyle一个实例，然后调用它的方法来实现自定义的格式。在StandardToStringStyle的单元测试代码中，是这样调用的：


Java代码

private static final StandardToStringStyle STYLE = new StandardToStringStyle();

static {
STYLE.setUseShortClassName(true);
STYLE.setUseIdentityHashCode(false);
STYLE.setArrayStart("[");
STYLE.setArraySeparator(", ");
STYLE.setArrayEnd("]");
STYLE.setNullText("%NULL%");
STYLE.setSizeStartText("%SIZE=");
STYLE.setSizeEndText("%");
STYLE.setSummaryObjectStartText("%");
STYLE.setSummaryObjectEndText("%");
}



10:10
评论 / 浏览 (0 / 743)
收藏
分类:编程语言

2008-11-28
缩略显示
java(Web)中相对路径，绝对路径问题

博客分类：
Java

JavaWebJSPServlet应用服务器
1.基本概念的理解

绝对路径：绝对路径就是你的主页上的文件或目录在硬盘上真正的路径，(URL和物理路径)例如：
C:\xyz\test.txt 代表了test.txt文件的绝对路径。http://www.sun.com/index.htm也代表了一个
URL绝对路径。

相对路径：相对与某个基准目录的路径。包含Web的相对路径（HTML中的相对目录），例如：在Servlet中，"/"代表Web应用的跟目录。和物理路径的相对表示。例如："./" 代表当前目录,"../"代表上级目录。这种类似的表示，也是属于相对路径。

另外关于URI，URL,URN等内容，请参考RFC相关文档标准。

RFC 2396: Uniform Resource Identifiers (URI): Generic Syntax,
(http://www.ietf.org/rfc/rfc2396.txt)


2.关于JSP/Servlet中的相对路径和绝对路径。

2.1服务器端的地址

　　 服务器端的相对地址指的是相对于你的web应用的地址，这个地址是在服务器端解析的（不同于html和javascript中的相对地址，他们是由客户端浏览器解析的）也就是说这时候在jsp和servlet中的相对地址应该是相对于你的web应用，即相对于http://192.168.0.1/webapp/的。

　　其用到的地方有： forward：servlet中的request.getRequestDispatcher(address); 这个address是在服务器端解析的，所以，你要forward到a.jsp应该这么写：request.getRequestDispatcher(“/user/a.jsp”)这个/相对于当前的web应用webapp，其绝对地址就是：http://192.168.0.1/webapp/user/a.jsp。
sendRedirect：在jsp中"/user/a.jsp；
　　提交到servlet为actiom＝"/webapp/handleservlet"
　　Javascript也是在客户端解析的，所以其相对路径和form表单一样。

　　因此，一般情况下，在JSP/HTML页面等引用的CSS,Javascript.Action等属性前面最好都加上,以确保所引用的文件都属于Web应用中的目录。另外，应该尽量避免使用类似".","./","../../"等类似的相对该文件位置的相对路径，这样当文件移动时，很容易出问题。

3. JSP/Servlet中获得当前应用的相对路径和绝对路径
3.1 JSP中获得当前应用的相对路径和绝对路径
根目录所对应的绝对路径:request.getRequestURI()
文件的绝对路径 　:application.getRealPath(request.getRequestURI());
当前web应用的绝对路径 :application.getRealPath("/");
取得请求文件的上层目录:new File(application.getRealPath(request.getRequestURI())).getParent()

3.2 Servlet中获得当前应用的相对路径和绝对路径
根目录所对应的绝对路径:request.getServletPath();
文件的绝对路径 :request.getSession().getServletContext().getRealPath
(request.getRequestURI())
当前web应用的绝对路径 :servletConfig.getServletContext().getRealPath("/");
(ServletContext对象获得几种方式：
javax.servlet.http.HttpSession.getServletContext()
javax.servlet.jsp.PageContext.getServletContext()
javax.servlet.ServletConfig.getServletContext()
)

4.java 的Class中获得相对路径，绝对路径的方法
4.1单独的Java类中获得绝对路径
　　根据java.io.File的Doc文挡，可知:
默认情况下new File("/")代表的目录为：System.getProperty("user.dir")。
一下程序获得执行类的当前路径
package org.cheng.file;
import java.io.File;

public class FileTest {
public static void main(String[] args) throws Exception {

System.out.println(Thread.currentThread().getContextClassLoader().getResource(""));

System.out.println(FileTest.class.getClassLoader().getResource(""));

　　System.out.println(ClassLoader.getSystemResource(""));
System.out.println(FileTest.class.getResource(""));
System.out.println(FileTest.class.getResource("/")); //Class文件所在路径
System.out.println(new File("/").getAbsolutePath());
System.out.println(System.getProperty("user.dir"));
}
}

4.2服务器中的Java类获得当前路径（来自网络）
(1).Weblogic

WebApplication的系统文件根目录是你的weblogic安装所在根目录。
例如：如果你的weblogic安装在c:\bea\weblogic700.....
那么，你的文件根路径就是c:\.
所以，有两种方式能够让你访问你的服务器端的文件：
a.使用绝对路径：
比如将你的参数文件放在c:\yourconfig\yourconf.properties，
直接使用 new FileInputStream("yourconfig/yourconf.properties");
b.使用相对路径：
相对路径的根目录就是你的webapplication的根路径，即WEB-INF的上一级目录，将你的参数文件放在yourwebapp\yourconfig\yourconf.properties，
这样使用：new FileInputStream("./yourconfig/yourconf.properties");
这两种方式均可，自己选择。

(2).Tomcat

在类中输出System.getProperty("user.dir"); 显示的是%Tomcat_Home%/bin

(3).Resin

不是你的JSP放的相对路径,是JSP引擎执行这个JSP编译成SERVLET的路径为根.比如用新建文件法测试File f = new File("a.htm"); 这个a.htm在resin的安装目录下

(4).如何读相对路径哪？

在Java文件中getResource或getResourceAsStream均可

例：getClass().getResourceAsStream(filePath); //filePath可以是"/filename",这里的/代表web

发布根路径下WEB-INF/classes

默认使用该方法的路径是：WEB-INF/classes。已经在Tomcat中测试。

5.读取文件时的相对路径，避免硬编码和绝对路径的使用。（来自网络）
5.1 采用Spring的DI机制获得文件，避免硬编码。
参考下面的连接内容：
http://www.javajia.net/viewtopic.php?p=90213&
5.2 配置文件的读取
参考下面的连接内容：
http://dev.csdn.net/develop/article/39/39681.shtm
5.3 通过虚拟路径或相对路径读取一个xml文件，避免硬编码
参考下面的连接内容：
http://club.gamvan.com/club/clubPage.jsp?iPage=1&tID=10708&ccID=8

6.Java中文件的常用操作（复制，移动，删除，创建等）（来自网络）
常用 java File 操作类
http://www.easydone.cn/014/200604022353065155.htm

Java文件操作大全（JSP中）
http://www.pconline.com.cn/pcedu/empolder/gj/java/0502/559401.html

java文件操作详解（Java中文网）
http://www.51cto.com/html/2005/1108/10947.htm

JAVA 如何创建\删除\修改\复制目录及文件
http://www.gamvan.com/developer/java/2005/2/264.html

总结：
通过上面内容的使用，可以解决在Web应用服务器端，移动文件，查找文件，复制
删除文件等操作，同时对服务器的相对地址，绝对地址概念更加清晰。
建议参考URI,的RFC标准文挡。同时对Java.io.File. Java.net.URI.等内容了解透彻
对其他方面的理解可以更加深入和透彻。
=====================================

参考资料:
java/docs/

java.io.File
java.io.InputStream
java.io.OutputStream
java.io.FileInputStream
java.io.FileReader;
java.io.FileOutputStream
java.io.FileWriter;
java.net.URI
java.net.URL


绝对路径与相对路径祥解
http://www.webjx.com/htmldata/2005-02-26/1109430310.html

[『J道习练』]JSP和Servlet中的绝对路径和相对路径
http://w3china.org/blog/more.asp?name=pcthomas&id=9122&commentid=12376

JSP,Servlet,Class获得当前应用的相对路径和绝对路径
http://cy.lzu.edu.cn/cy/club/clubPage.jsp?ccStyle=0&tID=886&ccID=77

如何获得当前文件路径
http://www.matrix.org.cn/resource/article/44/44113_java.html

通过Spring注入机制，取得文件
http://www.javajia.net/viewtopic.php?p=90213&

配置文件的读取
http://dev.csdn.net/develop/article/39/39681.shtm

读取配置文件,通过虚拟路径或相对路径读取一个xml文件，避免硬编码！
http://club.gamvan.com/club/clubPage.jsp?iPage=1&tID=10708&ccID=8

常用 java File 操作类
http://www.easydone.cn/014/200604022353065155.htm

Java文件操作大全
http://www.pconline.com.cn/pcedu/empolder/gj/java/0502/559401.html

Java文件操作详解
http://www.51cto.com/html/2005/1108/10947.htm

11:51
评论 / 浏览 (0 / 682)
收藏

2008-05-05
缩略显示
Hibernate中No row with the given identifier exists

博客分类：
Java

hibernate关联
今天整理权限和菜单关联的时候，报出了No row with the given identifier exists，查了半天中间表，找了一些资料，转过来记载一下


作者:blurxx 日期:2008-01-17

产生此问题的原因:
有两张表,table1和table2.产生此问题的原因就是table1里做了关联<one-to-one>或者<many-to-one unique="true">(特殊的多对一映射,实际就是一对一)来关联table2.当hibernate查找的时候,table2里的数据没有与table1相匹配的,这样就会报No row with the given identifier exists这个错.(一句话,就是数据的问题!)
假如说,table1里有自身的主键id1,还有table2的主键id2,这两个字段.
如果hibenrate设置的单项关联,即使table1中的id2为null值,table2中id2中有值,查询都不会出错.但是如果table1中的id2字段有值,但是这个值在table2中主键值里并没有,就会报上面的错!
如果hibernate是双向关联,那么table1中的id2为null值,但是table2中如果有值,就会报这个错.这种情况目前的解决办法就是改成单项关联,或者把不对应的数据改对!
这就是报这个错的原因了,知道原因了就相应的改就行了.或许还有些人迷惑hibernate关联都配好了,怎么会出现这样的错?其实这是编程的时候出现的问题,假如说我在添加信息的时候,页面传过来的struts的formbean到dao方法中需要封装成hibernate的po(就是hibenrate的bean),要是一个个po.get(form.set())实在太麻烦了,这样一般都会写个专门的方法来封装,遇到po.get(form.set())这种情况直接把struts的formbean对象传到此方法中封装就行了,假如我有个字段是创建人id,那么这个字段是永远不会改的,我在添加的时候还调用这个方法,这个专门封装的方法是有一些判断的,假如说我判断一下,如果遇到创建人id传过来为空值,我判断如果是空值,我把创建人id设为0,但是用户表中userid是主键从1开始自增的,那么这样数据就对应不上了,一查就会出这个错了.这个错在开发刚开始的时候经常发生,因为每个人的模块都是由相应的人独立开发完成以后再整合在一起的,每个人写单独那一块的时候往往会忽略这些,所以整合的时候这些问题往往就都一下子全冒出来了....整合很辛苦,tnnd!

hibernate的查询的比较
hibernate的查询有很多,Query,find,Criteria,get,load

query使用hsql语句，可以设置参数是常用的一种方式

criteria的方式，尽量避免了写hql语句，看起来更面向对象了。

find方式，这种方式已经被新的hibernate丢弃

get和load方式是根据id取得一个记录
下边详细说一下get和load的不同，因为有些时候为了对比也会把find加进来。

1，从返回结果上对比：
load方式检索不到的话会抛出org.hibernate.ObjectNotFoundException异常
get方法检索不到的话会返回null

2，从检索执行机制上对比：
get方法和find方法都是直接从数据库中检索
而load方法的执行则比较复杂
1,首先查找session的persistent Context中是否有缓存，如果有则直接返回
2,如果没有则判断是否是lazy，如果不是直接访问数据库检索，查到记录返回，查不到抛出异常
3,如果是lazy则需要建立代理对象，对象的initialized属性为false，target属性为null
4, 在访问获得的代理对象的属性时,检索数据库，如果找到记录则把该记录的对象复制到代理对象的target
上，并将initialized=true，如果找不到就抛出异常