1. 对于get方法，hibernate会确认一下该id对应的数据是否存在，首先在session缓存中查找，然后在二级缓存中查找，还没有就查询数据库，数据库中没有就返回null。这个相对比较简单，也没有太大的争议。主要要说明的一点就是在这个版本中get方法也会查找二级缓存！

2. load方法加载实体对象的时候，根据映射文件上类级别的lazy属性的配置(默认为true)，分情况讨论：

(1)若为true,则首先在Session缓存中查找，看看该id对应的对象是否存在，不存在则使用延迟加载，返回实体的代理类对象(该代理类为实体类的子类，由CGLIB动态生成)。等到具体使用该对象(除获取OID以外)的时候，再查询二级缓存和数据库，若仍没发现符合条件的记录，则会抛出一个ObjectNotFoundException。

(2)若为false,就跟get方法查找顺序一样，只是最终若没发现符合条件的记录，则会抛出一个ObjectNotFoundException。

这里get和load有两个重要区别:

1. 如果未能发现符合条件的记录，get方法返回null，而load方法会抛出一个ObjectNotFoundException。
2. load方法可返回没有加载实体数据的代理类实例，而get方法永远返回有实体数据的对象。(对于load和get方法返回类型：好多书中都说：“get方法永远只返回实体类”，实际上并不正确，get方法如果在session缓存中找到了该id对应的对象，如果刚好该对象前面是被代理过的，如被load方法使用过，或者被其他关联对象延迟加载过，那么返回的还是原先的代理对象，而不是实体类对象，如果该代理对象还没有加载实体数据（就是id以外的其他属性数据），那么它会查询二级缓存或者数据库来加载数据，但是返回的还是代理对象，只不过已经加载了实体数据。)

总之对于get和load的根本区别，一句话，hibernate对于load方法认为该数据在数据库中一定存在，可以放心的使用代理来延迟加载，如果在使用过程中发现了问题，只能抛异常；而对于get方法，hibernate一定要获取到真实的数据，否则返回null。

最后，我们分析下为什么网路上那么多关于二者区别的文章不太准确！首先可能是版本问题，Hibernate版 本不同，运行机制不太一样；其次就是很多朋友只是把自己经验所得与人分享，并没有经过全方位代码的检测；最后就是有些技术牛人，表达比较随意。所以我希望 大家以后学习知识的时候不要盲从他人迷信权威，一定要综合多方资料，比较和整理，再经过自己实践检验，这样得到的知识才是真实有效的。

5、总结：
     native2ascii是一个非常的好转码工具，并且转码是可逆的！而其真正的含义并非本地编码——>转码为ASCII码，而是一个通用的文本文件编码转换工具。在做编码转换的时候有两类指定编码的情形，分别指输出文件编码和输入文件编码，具体可以看看最佳实践部分。

For example, we can use Regular Expression to check whether the user input is a valid Social Security number, a valid phone number or a valid email number, etc.

Regular Expressions are supported by many languages. Sun added support for regualer expression in Java 1.4 by introducing java.util.regex package. This package provides the necessary classes for using Regular Expressions in a java application. It consists of following three main classes ,

• Pattern
• Matcher
• PatternSyntaxException

The java.util.regex package has several other features for appending, text replacement, and greedy/non-greedy pattern matching. See the JDK Documentation on java.util.regex to learn more about using regular expressions in Java.

Using this package I created a utility class to validate some commonly used data elements. My FieldsValidation class has following methods:

1. isEmailValid:

Validate email address using Java regex

/** isEmailValid: Validate email address using Java reg ex.
* This method checks if the input string is a valid email address.
* @param email String. Email address to validate
* @return boolean: true if email address is valid, false otherwise.
*/


public static boolean isEmailValid(String email){
boolean isValid = false;


/*
Email format: A valid email address will have following format:

• [""w"".-]+ : Begins with word characters, (may include periods and hypens).
• @ : It must have a ‘@’ symbol after initial characters.
• ([""w""-]+"".)+ : ‘@’ must follow by more alphanumeric characters (may include hypens.).
  This part must also have a “.” to separate domain and subdomain names.
• [A-Z]{2,4}$ : Must end with two to four alaphabets.
  (This will allow domain names with 2, 3 and 4 characters e.g pa, com, net, wxyz)

Examples: Following email addresses will pass validation
abc@xyz.net; ab.c@tx.gov
*/



//Initialize reg ex for email.
String expression = “^[""w"".-]+@([""w""-]+"".)+[A-Z]{2,4}$”;
CharSequence inputStr = email;


//Make the comparison case-insensitive.


Pattern pattern = Pattern.compile(expression,Pattern.CASE_INSENSITIVE);
Matcher matcher = pattern.matcher(inputStr);
if(matcher.matches()){
isValid = true;
}
return isValid;
}

Update: Read this post for a more thorough Java regular expression to validate email address.

2. isPhoneNumberValid:

Validate phone number using Java reg ex.

/** isPhoneNumberValid: Validate phone number using Java reg ex.
* This method checks if the input string is a valid phone number.
* @param email String. Phone number to validate
* @return boolean: true if phone number is valid, false otherwise.
*/


public static boolean isPhoneNumberValid(String phoneNumber){
boolean isValid = false;


/* Phone Number format: (nnn)nnn-nnnn; nnnnnnnnnn; nnn-nnn-nnnn

• ^""(? : May start with an option “(” .
• (""d{3}): Followed by 3 digits.
• "")? : May have an optional “)”
• [- ]? : May have an optional “-” after the first 3 digits or after optional ) character.
• (""d{3}) : Followed by 3 digits.
• [- ]? : May have another optional “-” after numeric digits.
• (""d{4})$ : ends with four digits.

Examples: Matches following phone numbers:
(123)456-7890, 123-456-7890, 1234567890, (123)-456-7890

//Initialize reg ex for phone number.
String expression = “^""(?(""d{3})"")?[- ]?(""d{3})[- ]?(""d{4})$”;
CharSequence inputStr = phoneNumber;
Pattern pattern = Pattern.compile(expression);
Matcher matcher = pattern.matcher(inputStr);
if(matcher.matches()){
isValid = true;
}
return isValid;
}


3. isValidSSN:

Validate Social Security Number (SSN) using Java reg ex.

/** isSSNValid: Validate Social Security number (SSN) using Java reg ex.
* This method checks if the input string is a valid SSN.
* @param email String. Social Security number to validate
* @return boolean: true if social security number is valid, false otherwise.
*/


public static boolean isSSNValid(String ssn){
boolean isValid = false;


/*SSN format xxx-xx-xxxx, xxxxxxxxx, xxx-xxxxxx; xxxxx-xxxx:

• ^""d{3} : Starts with three numeric digits.
• [- ]? : Followed by an optional “-”
• ""d{2} : Two numeric digits after the optional “-”
• [- ]? : May contain an optional second “-” character.
• ""d{4} : ends with four numeric digits.

Examples: 879-89-8989; 869878789 etc.
*/



//Initialize reg ex for SSN.
String expression = “^""d{3}[- ]?""d{2}[- ]?""d{4}$”;
CharSequence inputStr = ssn;
Pattern pattern = Pattern.compile(expression);
Matcher matcher = pattern.matcher(inputStr);
if(matcher.matches()){
isValid = true;
}
return isValid;
}


4. isNumeric:

Validate a number using Java regex.

/**isNumeric: Validate a number using Java regex.
* This method checks if the input string contains all numeric characters.
* @param email String. Number to validate
* @return boolean: true if the input is all numeric, false otherwise.
*/


public static boolean isNumeric(String number){
boolean isValid = false;


/*Number: A numeric value will have following format:

• ^[-+]? : Starts with an optional “+” or “-” sign.
• [0-9]* : May have one or more digits.
• "".? : May contain an optional “.” (decimal point) character.
• [0-9]+$ : ends with numeric digit.

*/



//Initialize reg ex for numeric data.
String expression = “^[-+]?[0-9]*"".?[0-9]+$”;
CharSequence inputStr = number;
Pattern pattern = Pattern.compile(expression);
Matcher matcher = pattern.matcher(inputStr);
if(matcher.matches()){
isValid = true;
}
return isValid;
}


This example demonstrates how easy it is to validate email address, ssn, phone number in Java using regular expressions. You can read more about regular expression format here .

You can download complete Java code for this class here .

Feel free to modify and use this class in your projects. Let me know if you have any questions or comments.

Enjoy.

If you enjoyed this post, make sure you subscribe to my RSS feed!

Related posts:

• #1 Programming Language - Java
• (Ultimate) Java Regular Expression to validate (any) email address.
• Edit and Test Regular expressions online using RegExr.
• Extract substring from end of a Java String
• How to read properties file in Java.

Jan 10, 2008
Filed under: Java
Tags: Java, Phone number, RegEx, Regular Expression, SSN, utility, Validate email

这样，当你的Session不过期，那么语言种类始终保持正确的说。我一直是这样子用的，我觉得还是Session的好，老外们用了很满意。

3、基于Cookie的国际化配置

这个我就不说了，反正用的不多，至少我做的项目能不用Cookie就不用Cookie，所以，基于Cookie的国际化配置我就不细说了，如果想知道怎么配置，那么下载一个Spring，其中的例子程序就是用Cookie配置的，你自己读代码就OK了。

三、注意事项

如果不用默认的浏览器语言国际化方式，那么拦截器一定要配置，如果你有多个UrlMapping，那么就每个都配上拦截器。
至于配置的LocaleResolver的名字，一定要用上面的配置中的名字localeResolver当然了，这个是默认的名字来的，自己设置成别的也可以，但是就是麻烦，反正我用默认的就感觉不错

在Spring中，两个最基本最重要的包是 org.springframework.beans 和 org.springframework.context. 这两个包中的代码为Spring的反向控制 特性（也叫作依赖注射）提供了基础。 BeanFactory提供了一种先进的配置机制来管理任何种类bean(对象)，这种配置机制考虑到任何一种可能的存储方式。 ApplicationContext建立在BeanFactory之上，并增加了其他的功能,比如更容易同Spring AOP特性整合， 消息资源处理（用于国际化），事件传递，以声明的方式创建ApplicationContext， 可选的父上下文和与应用层相关的上下文（比如WebApplicationContext），以及其他方面的增强。

简而言之，BeanFactory提供了配置框架和基本的功能， 而 ApplicationContext为 它增加了更强的功能，这些功能中的一些或许更加接近J2EE并且围绕企业级应用。一般来说，ApplicationContext是 BeanFactory的完全超集， 任何BeanFactory功能和行为的描述也同样被认为适用于ApplicationContext

用户有时不能确定BeanFactory和ApplicationContext中哪一个在特定场合下更适合。 通常大部分在J2EE环境的应用中，最好选择使用ApplicationContext， 因为它不仅提供了BeanFactory所有的特性以及它自己附加的特性，而且还提供以声明的方式使用一些功能， 这通常是令人满意的。BeanFactory主要是在非常关注内存使用的情况下 （比如在一个每kb都要计算的applet中）使用，而且你也不需要用到ApplicationContext的所有特性。

这一章粗略地分为两部分，第一部分包括对BeanFactory和ApplicationContext都适用的一些基本原则。第二部分包括仅仅适用于ApplicationContext的一些特性

Beans被定义为两种部署模式中的一种：singleton或non-singleton。 （后一种也别叫作prototype，尽管这个名词用的不精确因为它并不是非常适合）。 如果一个bean是singleton形态的，那么就只有一个共享的实例存在， 所有和这个bean定义的id符合的bean请求都会返回这个唯一的、特定的实例。

如果bean以non-singleton，prototype模式部署的话，对这个bean的每次请求都会创建一个新的bean实例。这对于例如每个user需要一个独立的user对象这样的情况是非常理想的。

      同时向你提供了一些解决这些问题的技巧。

      首先解释一些Java异常处理中必须搞清楚的定义和机制。Java语言规范将自Error类或RuntimeException类衍生出来的任何违例都称作“不可检查”(Unchecked)异常；其他所有异常则称作“可检查”(Checked)异常。

所谓可检查异常，是指我们应该自行处理的异常。至于处理的手段，要么加以控制(try catch)，要么通告(throws)他们有可能产生。通常，应捕捉那些已知如何处理的异常，而通告那些不知如何处理的异常。

而对那些不可检查异常来说，他们要么在我们的控制之外(Error)，要么是我们首先就不该允许的情况(RuntimeException)。

至于异常的指定，Java的规则非常简单：一个方法必须通告自己可能产生的所有可 检查异常。编写自己的方法时，并不一定要通告出方法实际可能产生的每一个异常对象，要想理解什么时候必须要方法的throws丛句来通告异常，就必须知道 对一个异常来说，他只有可能在下面四种情况下才会产生：

1、调用了可能产生异常的方法。比如BufferedReader类的readLine方法。该方法通告java.io.IOException异常。

2、侦测到一个错误，并用throw语句产生异常。

3、出现一个编程错误。比如a[-1] = 0。

4、Java产生内部错误。

如果出现头两种情况之一，必须告诉打算使用自己方法的人：假如使用这个方法，可能造成一个异常的产生(即在方法头上使用throws)，一个简单的记忆方法：

只要含有throw，就要通告throws。如果一个方法必须同时处理多个异常，就必须在头内指出所有异常。就像下例展示的那样，用逗号对他们进行分割：

1234567 class Animation { public Image loadImage(Strint s)   throws EOFException,MalformedURLException{ 　………… } }

然而，我们不需要通告内部java错误，也不应该通告自RuntimeException衍生出来的异常。

好的异常处理

好异常处理提供了处理程序错误的统一机制。事实上，Java语言通过向调用者提出 异常警告的方式而显著地提升了软件开发中的异常处理能力。这种方式把Java语言中的“方法（method）”进行了扩展和增强，使之包括了自身的错误条 件。下面就让我们看一个例子，这个例子说明了这种情况。

以下是FileInputStream构造器之一的原型：

public FileInputStream(String name) throws FileNotFoundException Java

的方法和构造器必须声明他们在被调用时可能“扔出”的异常，采用的关键字就是“throws”。这种在方法原型中出现的异常提示增加了编程的可靠性。

显而易见，这种方式是向方法的调用者提示了可能出现的异常条件，这样调用者就可以对这些异常作出适当的相应处理。以下代码示意我们是如何捕获并且处理FileNotFoundException 这一异常的：

1234567891011 try {   FileInputStream fis = new FileInputStream(args[0]);     // other code here ...   } catch (FileNotFoundException fnfe) { System.out.println("File: " + args[0] + " not found. Aborting."); System.exit(1); }

Java异常处理还有其他一些优秀的特性，这就是可检查异常、用户定义异常和在JDK 1.4中推出的新型Java记录API（Java Logging API）。java.lang.Exception的所有子类都属于可检查异常。可检查异常（checked exception）是扔出该异常的方法所必须提示的异常，这种异常必须被捕获或者向调用者提示。用户定义异常（User-defined exceptions）是定制的异常类，这种异常类扩展了java.lang.Exception类。优良的Java程序规定定制异常封装、报告和处理他 们自己独有的情况。最新的Java记录API（logging API）则可以集中记录异常。

不好的Java异常处理

不好的一面包括两种情况：滥用不可检查异常（unchecked exceptions）和滥用catchall构造器等。这两种方式都使得问题变得复杂起来。

有一种类别的异常属于RuntimeException的子类，这种异常不会受到 编译器的检查。比如，NullPointerException和 ArrayStoreException就是这种类型异常的实例。程序员可以对RuntimeException进行子类化以回避检查异常的限制，从而便 于产生这些异常的方法为其调用者所使用。

专业的开发团队应当只允许在很少的情况下才可以这样做。

第二种异常处理的陋习是catchall构造器。所谓的“catchall 构造器”就是一种异常捕获代码模块，它可以处理所有扔给它的可能异常。

以下是catchall处理器的实例：

123456789   try { // code here with checked exceptions } catch (Throwable t) { t.printStackTrace(); }

我得承认，我自己在编写一般程序的时候就曾经用过这种技术；但是，在编写关键程序的时候这种类型的构造器一定要避免使用，除非他们被授权可以和中央错误处理器联合使用才可以这样做。

除此之外，catchall构造器不过只是一种通过避免错误处理而加快编程进度的机制。

异常处理的一个不足之处是难以采用优良的错误处理策略。从低容内存状态恢复、写入错误和算法错误等异常情况都不是轻易能得到解决的。你可以尝试一下循环、垃圾收集和提醒用户等常用技术来应付以上的局面。

恶劣的处理方法

和许多Java特性及其API类似，Java的异常处理机制也有“霸王硬上弓”类的滑稽错误。比方说，为了扔出某个异常竟然毫不犹豫地用“new”关键词为其分配内存就是这样的例子。

我自己不知道有多少次就因为犯了这种错误而在严肃的编译器面前屡屡碰壁。在这种情况下，我们其实都是在伺候语言而不是让语言为我们所用。还有我们碰到的OutOfMemoryErrors就是异常处理的缺陷。这一处理过程是：

使用finally模块关闭文件，解析异常以得到出现问题的方法和代码行。在这一 过程之内最大的缺陷是需要捕获OutOfMemoryError，而这一异常却并不是可检查异常！想想看，内存耗尽是相当常见的情况。任何与内存使用状态 紧密相关的程序都应当捕获和处理这一错误。

使用异常时的一些建议

1、异常控制的设计宗旨并不是用来代替一些简单的测试。只有在异常情况下才使用异常！

2、不要过分细化异常。不要在每个语句上都加上异常处理，最好将整个任务都放在try块内。如果其中有一项操作失败，可以随即放弃任务。

3、不要“压制”异常。对于需要通告异常的方法，我们可以改用捕捉的方法来将异常强行关闭，如果真的出现异常，那个异常会被“静悄悄”的忽略。如果觉得产生的异常会非常重要，就必须多费些功夫，对其进行正确的控制。

4、不要介意异常的传递。如果调用的方法会产生异常，比如readLine方法，他们天生就能捕捉自己可能产生的异常，在这种情况下，一种更好地做法是将这些异常传递出去，而不是自己动手来捕捉它。

本文出自 “熔 岩” 博客