• byte: The byte data type is an 8-bit signed two's complement integer. It has a minimum value of -128 and a maximum value of 127 (inclusive). The byte data type can be useful for saving memory in large arrays, where the memory savings actually matters. They can also be used in place of int where their limits help to clarify your code; the fact that a variable's range is limited can serve as a form of documentation.
• short: The short data type is a 16-bit signed two's complement integer. It has a minimum value of -32,768 and a maximum value of 32,767 (inclusive). As with byte, the same guidelines apply: you can use a short to save memory in large arrays, in situations where the memory savings actually matters.
• int: The int data type is a 32-bit signed two's complement integer. It has a minimum value of -2,147,483,648 and a maximum value of 2,147,483,647 (inclusive). For integral values, this data type is generally the default choice unless there is a reason (like the above) to choose something else. This data type will most likely be large enough for the numbers your program will use, but if you need a wider range of values, use long instead.
• long: The long data type is a 64-bit signed two's complement integer. It has a minimum value of -9,223,372,036,854,775,808 and a maximum value of 9,223,372,036,854,775,807 (inclusive). Use this data type when you need a range of values wider than those provided by int.
• float: The float data type is a single-precision 32-bit IEEE 754 floating point. Its range of values is beyond the scope of this discussion, but is specified in section 4.2.3 of the Java Language Specification. As with the recommendations for byte and short, use a float (instead of double) if you need to save memory in large arrays of floating point numbers. This data type should never be used for precise values, such as currency. For that, you will need to use the java.math.BigDecimal class instead. Numbers and Strings covers BigDecimal and other useful classes provided by the Java platform.
• double: The double data type is a double-precision 64-bit IEEE 754 floating point. Its range of values is beyond the scope of this discussion, but is specified in section 4.2.3 of the Java Language Specification. For decimal values, this data type is generally the default choice. As mentioned above, this data type should never be used for precise values, such as currency.
• boolean: The boolean data type has only two possible values: true and false. Use this data type for simple flags that track true/false conditions. This data type represents one bit of information, but its "size" isn't something that's precisely defined.
• char: The char data type is a single 16-bit Unicode character. It has a minimum value of '\u0000' (or 0) and a maximum value of '\uffff' (or 65,535 inclusive).

Note that thanks to the Session, which is also a transaction-scoped cache, Hibernate provides repeatable reads for lookup by identifier and entity queries (not reporting queries that return scalar values).

Hibernate 没有提供在内存中对对象加锁的功能，因此应用的事务隔离级别是完全由数据库来提供的。

借助于session，Hibernate 提供了可重复读的事务隔离级别，但是前提是只有使用identifier and entity queries的可以，使用标量查询则不可以，其原因是hibernate的cache的对象需要是能够被唯一识别的实体对象，标量查询返回的结果是数组，不满足该要求，无法在session级别进行事务的cache

在事务和并发性方面，hibernate不仅提供了基于版本的控制的自动乐观锁机制，同时还提供了API来实现悲观锁机制（通过SELECT FOR UPDATE 语法）

A SessionFactory is an expensive-to-create, threadsafe object intended to be shared by all application threads. It is created once, usually on application startup, from a Configuration instance.

A Session is an inexpensive, non-threadsafe object that should be used once, for a single request, a conversation, single unit of work, and then discarded. A Session will not obtain a JDBC Connection (or a Datasource) unless it is needed, hence consume no resources until used.

Database transactions are never optional, all communication with a database has to occur inside a transaction, no matter if you read or write data.

事务并不是可有可无的，所有的数据库操作都是在事务环境下发生的，不管是read 操作还是write操作。这点一定要名明确，以前曾经误解。

As explained, auto-commit behavior for reading data should be avoided, as many small transactions are unlikely to perform better than one clearly defined unit of work. The latter is also much more maintainable and extensible.

最好关闭自动提交功能，因为使用大量的短数据库事务在性能上未必比一个清晰定义的unit work强，后者更加易于维护和扩展。（以前曾经误解）

乐观锁的处理方式

Hibernate checks instance versions at flush time, throwing an exception if concurrent modification is detected.It's up to the developer to catch and handle this exception (common options are the opportunity for the user to merge changes or to restart the business conversation with non-stale data).

在flush的时候检查version，如果发现更改会抛出异常，开发人员可以捕捉该异常，并决定如何处理（要么合并修改，要么放弃修改）

悲观锁的处理方式

悲观锁基本上是靠数据库本身提供的机制来实现，通常只要为jdbc connection指定事务隔离的级别即可。The LockMode class defines the different lock levels that may be acquired by Hibernate.

悲观锁会在读取数据之前获取，因此能够保证当前事务的数据就是最新数据。

hibernate的查询分类：

1、标量查询（Scalar queries）：返回的记录数组的集合

标量是与数组相对的概念，是一种由单一的值来表征的量。所谓标量查询，就是直接使用原生sql语句的查询，也即返回的是裸数据（只不过hibernate使用ResultSetMetaData将resultset中的每一条记录放到一个数组Object[]中）。

比如

List list = session.createSQLQuery("select * from t_area_person").list();

for (Object object : list) {
            Object[] ob = (Object[]) object;
            for (int i = 0; i < ob.length; i++)
                System.out.print("  " +ob[i]);
            System.out.println();
        }

2、实体查询(Entity queries)：返回的是实体对象的集合

3、Load方法：lookup by identifier ，返回的是该identifier 对应的对象

java 位操作符：

取反：~x
- flips each bit to the opposite value.

与操作：AND

x & y
- AND operation between the corresponding bits in x and y.

或操作：OR
x | y
- OR operation between the corresponding bits in x and y.

异或操作：XOR
x ^ y
- XOR operation between the corresponding bits in x and y.

左移操作：Shift left
x << y
- shifts x to the left by y bits. The high order bits are lost while zeros fill the right bits.

将x左移y位，移动过程中，高位会丢失

有符号数右移操作：Shift Right - Signed
x >> y
- shifts x to the right by y bits. The low order bits are lost while the sign bit value (0 for positive numbers, 1 for negative) fills in the left bits.

无符号数右移：Shift Right - Unsigned
x >>> y
- shifts x to the right by y bits. The low order bits are lost while zeros fill in the left bits regardless of the sign.

例子：

下面的例子显示如何将一个int数组通过移位操作压缩到一个int内保存，其原理是在java语言中，int类型使用4 bytes来保存，因此对于需要压缩的int数组，其中的每一个int值的大小不能超过255（2的8次方-1），因此这只是一个实例：

  int [] aRGB = {0x56, 0x78, 0x9A, 0xBC};   // 是用16进制保存的4种颜色值
  int color_val = aRGB[3];   
  color_val = color_val | (aRGB[2] << 8);  // 为了压缩，需要放置到color_val值的第二个字节位置上：将aRGB[2] 左移到第二个byte，同时与color_val进行或操作，下面同理
  color_val = color_val | (aRGB[1] << 16);  
  color_val = color_val | (aRBG[0] << 24);

操作完的结果是56 78 9A BC

如果要从colorVal 还原为int数组，或者得到数组中的某个值，只需要对colorVal 进行相应的右移操作即可：

  int alpha_val = (colorVal >>> 24) & 0xFF;
  int red_val   = (colorVal >>> 16) & 0xFF;
  int green_val = (colorVal >>>  8) & 0xFF;
  int blue_val  =  colorVal & 0xFF;

参考资料：

Bits in Java

事务级别：

1>.READ UNCOMMITTED    效率高,但可能会有脏数据(修改数据时不排他读);

2>.READ COMMITTED       避免了脏数据(修改数据时排他读);

3>. REPEATABLE READ      对满足条件的数据行集进行锁定，不允许其他事务修改和删除;

4>.SERIALABLE READ       最高级别,禁止对(数据行集甚至整个数据表）插入，因此能够防止幻影读的发生;

常用的事务属性：

1>.Required 必须运行在事务中,没有现成的就新建一个;

2>.RequiresNew 指明每次运行都必须新建一个事务;

3>.Supports 如目前正处于事务中的话就加入到事务中去,没有就算了;

4>.Mandatory 必须有一个事务正在运行让其加入,否则抛出异常;

5>.NotSupported 不需要运行于任何事务中;

6>.Never 不但不会运行于任何事务中,如果发现运行在事务中会抛出异常。

今天看到Jakarta Commons Lang，发现提供了很多有用的功能,记录下来，留待以后查阅

The Commons Lang library provides much needed additions to the standard JDK's java.lang package. Very generic, very reusable components for everyday use.

lang.*

String manipulation -StringUtils, StringEscapeUtils, RandomStringUtils, Tokenizer, WordUtils

StringEscapeUtils contains methods to escape and unescape Java, JavaScript, HTML, XML and SQL.

RandomStringUtils speaks for itself. It's provides ways in which to generate pieces of text, such as might be used for default passwords.

Character handling - CharSetUtils, CharSet, CharRange, CharUtils

CharUtils exists for this purpose, while CharSetUtils exists for set-manipulation of Strings.Be careful, although CharSetUtils takes an argument of type String, it is only as a set of characters. For example, CharSetUtils.delete("testtest", "tr") will remove all t's and all r's from the String, not just the String "tr".

JVM interaction - SystemUtils, CharEncoding

SystemUtils is a simple little class which makes it easy to find out information about which platform you are on。

The CharEncoding class is also used to interact with the Java environment and may be used to see which character encodings are supported in a particular environment.

Serialization - SerializationUtils, SerializationException

Assorted functions - ObjectUtils, ClassUtils, ArrayUtils, BooleanUtils

ClassUtils is largely a set of helper methods for reflection. Of special note are the comparators hidden away in ClassUtils, useful for sorting Class and Package objects by name。

ArrayUtils. This is a big one with many methods and many overloads of these methods so it is probably worth an in depth look here. Before we begin, assume that every method mentioned is overloaded for all the primitives and for Object. Also, the short-hand 'xxx' implies a generic primitive type, but usually also includes Object.

Flotsam - BitField, Validate

On reaching the end of our package, we are left with a couple of classes that haven't fit any of the topics so far.

The BitField class provides a wrapper class around the classic bitmask integer, whilst the Validate class may be used for assertions

lang.builder.*

HashCodeBuilder will save your day. It, and its buddies (EqualsBuilder, CompareToBuilder, ToStringBuilder), take care of the nasty bits while you focus on the important bits, like which fields will go into making up the hashcode.

帮助提供equals、compare、toString方法

lang.enums.* (formerly lang.enum)

lang.exception.*

lang.math.*

These include classes to represent ranges of numbers, a Fraction class, various utilities for random numbers, and the flagship class, NumberUtils which contains a handful of classic number functions.

lang.mutable.*

mutable package provides mutable wrappers for primitive values (such as int, long, etc.) and Object. These wrappers are simiar to the wrappers provided by the Java API, but allow the wrapped value to be changed without needing to create a separate wrapper object.

lang.text.*

It provides, amongst other classes, a replacement for StringBuffer named StrBuilder, a class for substituting variables within a String named StrSubstitutor and a replacement for StringTokenizer named StrTokenizer. While somewhat ungainly, the Str prefix has been used to ensure we don't clash with any current or future standard Java classes.

lang.time.*

These include a StopWatch for simple performance measurements and an optimised FastDateFormat class.