亚洲国产另类久久久精品,亚洲国产成人精品无码区花野真一,中文字幕亚洲综合久久综合

spring事务探烦

Mon, 15 Jan 2007 02:10:00 GMT

引自�Q?a >http://www.javaeye.com/topic/11190?page=1

spring自徏事务��理模块。而且�q�个事务��理是一个抽象设计，可以应用到很多场合，包括普通的DataSource�Q�jta�Q�jms和hibernate上�?/p>

要正��用spring的事务，首先需要了解spring在事务设计上的一些概�?
�l�观spring事务�Q�围�l�着两个核心PlatformTransactionManager和TransactionStatus

PlatformTransactionManager直译�q�来��是�q�_��相关事务�Q�这里的�q�_��指的是“事务源”，包括刚才我说的DataSource�Q�jta�{�等。这些无一不是一个事务源。广义的��_��凡是可以完成事务性操作的对象�Q�都可以设计出相对应的PlatformTransactionManager�Q�只要这个事务源支持commit�Q�rollback和getTransaction语意�?/p>

查看spring代码�Q�可以发现这些manager实现事务�Q�就是调用事务源的事务操作方�?/p>

比如

HibernateTransactionManager

代码

protected void doCommit(DefaultTransactionStatus status) {
HibernateTransactionObject txObject = (HibernateTransactionObject) status.getTransaction();
if (status.isDebug()) {
logger.debug("Committing Hibernate transaction on session [" +
txObject.getSessionHolder().getSession() + "]");
}
try {
txObject.getSessionHolder().getTransaction().commit();
}
...
}

jdbc 的DataSourceTransactionManager

代码

protected void doCommit(DefaultTransactionStatus status) {
DataSourceTransactionObject txObject = (DataSourceTransactionObject) status.getTransaction();
Connection con = txObject.getConnectionHolder().getConnection();
if (status.isDebug()) {
logger.debug("Committing JDBC transaction on connection [" + con + "]");
}
try {
con.commit();
}
...
}

那么PlatformTransactionManager以什么依据处理事务呢�Q?
是TransactionStatus
查看api发现�q�个接口有三个方�?
isNewTransaction() �Q�isRollbackOnly()�Q�setRollbackOnly()
PlatformTransactionManager��是�Ҏ��前两个方法决定是否要创徏一个新事务�Q�是要递交�q�是回滚。至于第三个�Ҏ��是改变事务当前状态的�Q�很多地斚w��要用刎ͼ�偏偏PlatformTransactionManager自��n好像不怎么用，毕竟事务状态的改变是由�E�序员代码决定的�Q�不需要一个manager多管闲事�?/p>

�ȝ��上面所说的�Q�spring的事务由PlatformTransactionManager��理�Q�manager最后调用事务源的方法来实现一个事务过�E�。而manager通过TransactionStatus 来决定如何实现�?
接下去说spring事务中的TransactionTemplate和TransactionInterceptor

TransactionTemplate其实和spring中其他的template的作用类��|��起到化简代码的作用，不要被它那么长的名字吓倒了�Q�事实上�q�个template�q�不是什么非常核心的对象。如果比较学�I�派的，可以�ȝ��看template设计模式�Q�在此就不再�Ҏ��赘述了�?
��Z��么要有TransactionTemplate�Q�先来看看如果没有TransactionTemplate�Q�我们的代码该怎么�?/p>

先来看看spring reference中的一�D�代�?

代码

DefaultTransactionDefinition def = new DefaultTransactionDefinition()
def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
TransactionStatus status = transactionManager.getTransaction(def);
try {
// execute your business logic here
} catch (MyException ex) {
transactionManager.rollback(status);
throw ex;
}
transactionManager.commit(status);

�q�是直接使用transactionManager的例子，可以看到真正执行business logic 的地�Ҏ��在try当中那段�Q�前后的代码都是��Z��完成事务��理的。如果每个business logic都要写上那么一�D�，我肯定是疯了。我们翻出TransactionTemplate的代码看看他怎么化简了我们的代码

代码

public Object execute(TransactionCallback action) throws TransactionException {
TransactionStatus status = this.transactionManager.getTransaction(this);
Object result = null;
try {
result = action.doInTransaction(status);
}
catch (RuntimeException ex) {
// transactional code threw application exception -> rollback
rollbackOnException(status, ex);
throw ex;
}
catch (Error err) {
// transactional code threw error -> rollback
rollbackOnException(status, err);
throw err;
}
this.transactionManager.commit(status);
return result;
}

同上面的代码如出一辙，前后是事务处理代码，当中那段result = action.doInTransaction(status);是我们的应用代码。至于action是什么，全看各位的需要了。但是有一点要主要�Q�如果利用TransactionTemplate�Q�那么他不管你扔��Z��么异帔R��会回滚事务，但是回滚的是哪个事务呢？�l�箋挖代�?

代码

private void rollbackOnException(TransactionStatus status, Throwable ex) throws TransactionException {
if (logger.isDebugEnabled()) {
logger.debug("Initiating transaction rollback on application exception", ex);
}
try {
this.transactionManager.rollback(status);
}
catch (RuntimeException ex2) {
logger.error("Application exception overridden by rollback exception", ex);
throw ex2;
}
catch (Error err) {
logger.error("Application exception overridden by rollback error", ex);
throw err;
}
}

真相大白�Q�是对template所持有的某个transactionManager�q�行回滚。所以如果你的应用代码用的是事务源a的一些资源，比如到服务器a的一个datasource�Q�但是你的transactionManager��理的是另一些资源，比如服务器b的一个datasource�Q�代码铁定不会正常运�?

特别是在一些多事务源的�E�序里，�q�点千万不能搞错。如果多个事务源之间要完成全局事务�Q�还是老老实实用分布式事务管理服务吧�Q�jta�Q?/p>

那么TransactionInterceptor是干什么的�Q�这个是spring 的声明式事务的支持方式。因为用TransactionTemplate要硬�~�码�Q�而且调整事务�{�略很麻烦（不是说不能调。�D个例子原来程序抛出异常A需要回滚，现在不需要要�Q�我��可以把a catch吃掉。这时候template��׃��会回滚了。但是每�ơ调整都要重写编码。）而用TransactionInterceptor��可以将�q�些调整写在配置中。我们再来挖TransactionInterceptor的代�?/p>

代码

public Object invoke(MethodInvocation invocation) throws Throwable {
// Work out the target class: may be null.
// The TransactionAttributeSource should be passed the target class
// as well as the method, which may be from an interface
Class targetClass = (invocation.getThis() != null) ? invocation.getThis().getClass() : null;
// Create transaction if necessary
TransactionInfo txInfo = createTransactionIfNecessary(invocation.getMethod(), targetClass);
Object retVal = null;
try {
// This is an around advice.
// Invoke the next interceptor in the chain.
// This will normally result in a target object being invoked.
retVal = invocation.proceed();
}
catch (Throwable ex) {
// target invocation exception
doCloseTransactionAfterThrowing(txInfo, ex);
throw ex;
}
finally {
doFinally(txInfo);
}
doCommitTransactionAfterReturning(txInfo);
return retVal;
}

万变不离其宗�?

所以��用spring的事务管理需要作�q�些�?
1�Q�设�|�好事务源，比如DataSource�Q�hibernate的session。如果有多个事务源要考虑他们之间是否有全局事务�Q�如果有�Q�老老实实用jta�Q�否则就需要自己写一个manager�?
2�Q�设�|�manager�Q�根据你的事务源选择对应的PlatformTransactionManager
3�Q�选择实现事物的方式，用template�q�是interceptor。用template代码直观点，但是template所��辖的manager和你应用代码所用的事务源要一致。如果用interceptor千万注意�Q�一定要调用interceptor那个bean�Q�而不是原始的那个target。在坛子上我已经看到臛_��有两个朋友说spring事物不�v作用�Q�从配置和代码上看都正确�Q�这时要好好查查�Q�调用的bean是哪一个�?
4�Q�这个是设计问题了，推荐事务处于一个较高层�ơ，比如service上的某个函数�Q�而底层的dao可以不考虑事务�Q�否则可能会出现事务嵌套�Q�增加程序复杂度�?/p>

王�R锋的技术实�?/a> 2007-01-15 10:10 发表评论

理解 java中String

Mon, 15 Jan 2007 01:56:00 GMT

http://www.javaeye.com/post/199106

要理�?java中String的运作方式，必须明确一点：String是一个非可变�c�（immutable�Q�。什么是非可变类呢？��单说来，非可变类的实例是不能被修改的�Q�每个实例中包含的信息都必须在该实例创徏的时候就提供出来�Q��ƈ且在对象的整个生存周期内固定不变。java��Z��么要把String设计为非可变�c�d��Q�你可以问问 james Gosling �Q�）。但是非可变�cȝ��实有着自��n的优势，如状态单一�Q�对象简单，便于�l�护。其�ơ，该类对象对象本质上是�U�程安全的，不要求同步。此外用户可以共享非可变对象�Q�甚臛_��以共享它们的内部信息。（详见《Effective java》item 13�Q�。String�c�d��java中被大量�q�用�Q�甚臛_��class文�g中都有其�w�媄�Q�因此将其设计�ؓ��单轻便的非可变类是比较合适的�?

一、创建�?br /> 好了�Q�知道String是非可变�c�M��后，我们可以�q�一步了解String的构造方式了。创��Z��个Stirng对象�Q�主要就有以下两�U�方式：

java 代码

String str1 = new String("abc");
Stirng str2 = "abc";

虽然两个语句都是�q�回一个String对象的引用，但是jvm对两者的处理方式是不一��L��。对于第一�U�，jvm会马上在heap中创��Z��个String对象�Q�然后将该对象的引用�q�回�l�用戗��对于第二种�Q�jvm首先会在内部�l�护的strings pool中通过String�?equels �Ҏ��查找是对象池中是否存放有该String对象�Q�如果有�Q�则�q�回已有的String对象�l�用��P��而不会在heap中重新创��Z��个新的String对象�Q�如果对象池中没有该String对象�Q�jvm则在heap中创建新的String对象�Q�将其引用返回给用户�Q�同时将该引用添加至strings pool中。注意：使用�W�一�U�方法创建对象时�Q�jvm是不会主动把该对象放到strings pool里面的，除非�E�序调用 String的intern�Ҏ��。看下面的例子：

java 代码

String str1 = new String("abc"); //jvm 在堆上创��Z��个String对象
//jvm 在strings pool中找不到��gؓ“abc”的字符�Ԍ��因此
//在堆上创��Z��个String对象�Q��ƈ��该对象的引用加入至strings pool�?
//此时堆上有两个String对象
Stirng str2 = "abc";
if(str1 == str2){
System.out.println("str1 == str2");
}else{
System.out.println("str1 != str2");
}
//打印�l�果是 str1 != str2,因�ؓ它们是堆上两个不同的对象
String str3 = "abc";
//此时�Q�jvm发现strings pool中已有“abc”对象了�Q�因为“abc”equels “abc�?
//因此直接�q�回str2指向的对象给str3�Q�也��是说str2和str3是指向同一个对象的引用
if(str2 == str3){
System.out.println("str2 == str3");
}else{
System.out.println("str2 != str3");
}
//打印�l�果为 str2 == str3

再看下面的例子：

java 代码

String str1 = new String("abc"); //jvm 在堆上创��Z��个String对象
str1 = str1.intern();
//�E�序昑ּ��str1攑ֈ�strings pool中，intern�q�行�q�程是这��L��Q�首先查看strings pool
//有没“abc”对象的引用�Q�没有，则在堆中新徏一个对象，然后��新对象的引用加入至
//strings pool中。执行完该语句后�Q�str1原来指向的String对象已经成�ؓ垃圾对象了，随时�?
//被GC攉��?
//此时�Q�jvm发现strings pool中已有“abc”对象了�Q�因为“abc”equels “abc�?
//因此直接�q�回str1指向的对象给str2�Q�也��是说str2和str1引用着同一个对象，
//此时�Q�堆上的有效对象只有一个�?
Stirng str2 = "abc";
if(str1 == str2){
System.out.println("str1 == str2");
}else{
System.out.println("str1 != str2");
}
//打印�l�果是 str1 == str2

��Z��么jvm可以�q�样处理String对象呢？��是因�ؓString的非可变性。既然所引用的对象一旦创建就�怸�更改�Q�那么多个引用共用一个对象时互不影响�?/p>

二、串接（Concatenation�Q��?br /> java�E�序员应该都知道滥用String的串接操作符是会影响�E�序的性能的。性能问题从何而来呢？归根�l�底��是String�cȝ��非可变性。既然String对象都是非可变的�Q�也��是对象一旦创��Z��׃��能够改变其内在状态了�Q�但是串接操作明显是要增长字�W�串的，也就是要改变String的内部状态，两者出��C��矛盾。怎么办呢�Q�要�l�护String的非可变性，只好在串接完成后新徏一个String 对象来表�C�新产生的字�W�串了。也��是��_��每一�ơ执行串接操作都会导致新对象的��生，如果串接操作执行很频�J�，��׃��D��大量对象的创建，性能问题也就随之而来了�?br /> ��Z��解决�q�个问题�Q�jdk为String�c�L��供了一个可变的配套�c�，StringBuffer。��用StringBuffer对象�Q�由于该�c�L��可变的，串接时仅仅时改变了内部数据结构，而不会创建新的对象，因此性能上有很大的提高。针对单�U�程�Q�jdk 5.0�q�提供了StringBuilder�c�，在单�U�程环境下，�׃��不用考虑同步问题�Q��用该�c�M��性能得到�q�一步的提高�?/p>

三、String的长�?br /> 我们可以使用串接操作�W�得��C��个长度更长的字符�Ԍ��那么�Q�String对象最多能容纳多少字符呢？查看String的源代码我们可以得知�c�String中是使用�?count 来记录对象字�W�的数量�Q�而count 的类型�ؓ int�Q�因此，我们可以推测最长的长度�?2^32�Q�也��是4G�?br /> 不过�Q�我们在�~�写源代码的时候，如果使用 Sting str = "aaaa";的�Ş式定义一个字�W�串�Q�那么双引号里面的ASCII字符最多只能有 65534 个。�ؓ什么呢�Q�因为在class文�g的规范中�Q?CONSTANT_Utf8_info表中使用一�?6位的无符��h��数来记录字符串的长度的，最多能表示 65536个字节，而java class 文�g是��用一�U�变体UTF-8格式来存攑֭��W�的�Q�null��g��用两个字节来表示�Q�因此只剩下 65536�Q?2 �Q?65534个字节。也正是变体UTF-8的原因，如果字符串中含有中文�{�非ASCII字符�Q�那么双引号中字�W�的数量会更��（一个中文字�W�占用三个字节）。如果超��个数量，在编译的时候编译器会报错�?/p>

王�R锋的技术实�?/a> 2007-01-15 09:56 发表评论

解惑 spring 嵌套事务

Fri, 29 Dec 2006 06:06:00 GMT

http://www.javaeye.com/topic/35907

解惑 spring 嵌套事务

/**
* @author 王政
* @date 2006-11-24
* @note 转蝲��h��明出�?
*/

在所有��?spring 的应用中, 声明式事务管理可能是使用率最高的功能�? 但是, 从我观察到的情况�?
�l�大多数人�ƈ不能深刻理解事务声明中不同事务传播属性配�|�的的含�? 让我们来看一�?TransactionDefinition 接口中的定义

代码

/**
* Support a current transaction, create a new one if none exists.
* Analogous to EJB transaction attribute of the same name.
* This is typically the default setting of a transaction definition.
*/
int PROPAGATION_REQUIRED = 0 ;
/**
* Support a current transaction, execute non-transactionally if none exists.
* Analogous to EJB transaction attribute of the same name.
* Note: For transaction managers with transaction synchronization,
* PROPAGATION_SUPPORTS is slightly different from no transaction at all,
* as it defines a transaction scopp that synchronization will apply for.
* As a consequence, the same resources (JDBC Connection, Hibernate Session, etc)
* will be shared for the entire specified scope. Note that this depends on
* the actual synchronization configuration of the transaction manager.
* @see org.springframework.transaction.support.AbstractPlatformTransactionManager#setTransactionSynchronization
*/
int PROPAGATION_SUPPORTS = 1 ;
/**
* Support a current transaction, throw an exception if none exists.
* Analogous to EJB transaction attribute of the same name.
*/
int PROPAGATION_MANDATORY = 2 ;
/**
* Create a new transaction, suspend the current transaction if one exists.
* Analogous to EJB transaction attribute of the same name.
* Note: Actual transaction suspension will not work on out-of-the-box
* on all transaction managers. This in particular applies to JtaTransactionManager,
* which requires the < code > javax.transaction.TransactionManager code > to be
* made available it to it (which is server-specific in standard J2EE).
* @see org.springframework.transaction.jta.JtaTransactionManager#setTransactionManager
*/
int PROPAGATION_REQUIRES_NEW = 3 ;
/**
* Execute non-transactionally, suspend the current transaction if one exists.
* Analogous to EJB transaction attribute of the same name.
* Note: Actual transaction suspension will not work on out-of-the-box
* on all transaction managers. This in particular applies to JtaTransactionManager,
* which requires the < code > javax.transaction.TransactionManager code > to be
* made available it to it (which is server-specific in standard J2EE).
* @see org.springframework.transaction.jta.JtaTransactionManager#setTransactionManager
*/
int PROPAGATION_NOT_SUPPORTED = 4 ;
/**
* Execute non-transactionally, throw an exception if a transaction exists.
* Analogous to EJB transaction attribute of the same name.
*/
int PROPAGATION_NEVER = 5 ;
/**
* Execute within a nested transaction if a current transaction exists,
* behave like PROPAGATION_REQUIRED else. There is no analogous feature in EJB.
* Note: Actual creation of a nested transaction will only work on specific
* transaction managers. Out of the box, this only applies to the JDBC
* DataSourceTransactionManager when working on a JDBC 3.0 driver.
* Some JTA providers might support nested transactions as well.
* @see org.springframework.jdbc.datasource.DataSourceTransactionManager
*/
int PROPAGATION_NESTED = 6 ;

我们可以看到, �?spring 中一共定义了六种事务传播属�? 如果你觉得看��h��不够直观, 那么我来转脓一个满大街都有的翻�?/p>

引用

PROPAGATION_REQUIRED -- 支持当前事务�Q�如果当前没有事务，��新��Z��个事务。这是最常见的选择�?
PROPAGATION_SUPPORTS -- 支持当前事务�Q�如果当前没有事务，��׃��非事务方式执行�?
PROPAGATION_MANDATORY -- 支持当前事务�Q�如果当前没有事务，��抛出异常�?
PROPAGATION_REQUIRES_NEW -- 新徏事务�Q�如果当前存在事务，把当前事务挂赗��?
PROPAGATION_NOT_SUPPORTED -- 以非事务方式执行操作�Q�如果当前存在事务，��把当前事务挂�v�?
PROPAGATION_NEVER -- 以非事务方式执行�Q�如果当前存在事务，则抛出异常�?
PROPAGATION_NESTED -- 如果当前存在事务�Q�则在嵌套事务内执行。如果当前没有事务，则进行与PROPAGATION_REQUIRED�c�M��的操作�?
前六个策略类��g��EJB CMT�Q�第七个�Q�PROPAGATION_NESTED�Q�是Spring所提供的一个特�D�变量�?
它要求事务管理器或者��用JDBC 3.0 Savepoint API提供嵌套事务行�ؓ�Q�如Spring的DataSourceTransactionManager�Q?

在我所见过的误解中, 最常见的是下面�q�种:

引用

假如有两个业务接�?ServiceA �?ServiceB, 其中 ServiceA 中有一个方法实现如�?

/**
* 事务属性配�|��ؓ PROPAGATION_REQUIRED
*/
void methodA() {
// 调用 ServiceB 的方�?
ServiceB.methodB();
}

那么如果 ServiceB �?methodB 如果配置了事�? ��必��配�|��ؓ PROPAGATION_NESTED

�q�种��x��可能害了不少�? 认�ؓ Service 之间应该避免互相调用, 其实�Ҏ��不用担心�q�点�Q�PROPAGATION_REQUIRED 已经说得很明�?
如果当前�U�程中已�l�存在事�? �Ҏ��调用会加入此事务, 果当前没有事务，��新��Z��个事�? 所�?ServiceB#methodB() 的事务只要遵循最普通的规则配置�?PROPAGATION_REQUIRED 卛_��, 如果 ServiceB#methodB (我们�U�C��为内部事�? ��Z��文打下基��) 抛了异常, 那么 ServiceA#methodA(我们�U�C��为外部事�? 如果没有�Ҏ��配置此异常时事务提交 (�?+MyCheckedException的用�?, 那么整个事务是一定要 rollback �? 什�?Service 只能�?Dao 之类的言论纯属无�E�之�? spring 只负责配�|�了事务属性方法的拦截, 它怎么知道你这个方法是�?Service �q�是 Dao �??

说了�q�么半天, 那到底什么是真正的事务嵌套呢, 解释之前我们来看一�?Juergen Hoeller 的原�?/p>

Juergen Hoeller 写道

PROPAGATION_REQUIRES_NEW starts a new, independent "inner" transaction for the given scope. This transaction will be committed or rolled back completely independent from the outer transaction, having its own isolation scope, its own set of locks, etc. The outer transaction will get suspended at the beginning of the inner one, and resumed once the inner one has completed.

Such independent inner transactions are for example used for id generation through manual sequences, where the access to the sequence table should happen in its own transactions, to keep the lock there as short as possible. The goal there is to avoid tying the sequence locks to the (potentially much longer running) outer transaction, with the sequence lock not getting released before completion of the outer transaction.

PROPAGATION_NESTED on the other hand starts a "nested" transaction, which is a true subtransaction of the existing one. What will happen is that a savepoint will be taken at the start of the nested transaction. �Tf the nested transaction fails, we will roll back to that savepoint. The nested transaction is part of of the outer transaction, so it will only be committed at the end of of the outer transaction.

Nested transactions essentially allow to try some execution subpaths as subtransactions: rolling back to the state at the beginning of the failed subpath, continuing with another subpath or with the main execution path there - all within one isolated transaction, and not losing any previous work done within the outer transaction.

For example, consider parsing a very large input file consisting of account transfer blocks: The entire file should essentially be parsed within one transaction, with one single commit at the end. But if a block fails, its transfers need to be rolled back, writing a failure marker somewhere. You could either start over the entire transaction every time a block fails, remembering which blocks to skip - or you mark each block as a nested transaction, only rolling back that specific set of operations, keeping the previous work of the outer transaction. The latter is of course much more efficient, in particular when a block at the end of the file fails.

Juergen Hoeller 写道

Rolling back the entire transaction is the choice of the demarcation code/config that started the outer transaction.

So if an inner transaction throws an exception and is supposed to be rolled back (according to the rollback rules), the transaction will get rolled back to the savepoint taken at the start of the inner transaction. The immediate calling code can then decide to catch the exception and proceed down some other path within the outer transaction.

If the code that called the inner transaction lets the exception propagate up the call chain, the exception will eventually reach the demarcation code of the outer transaction. At that point, the rollback rules of the outer transaction decide whether to trigger a rollback. That would be a rollback of the entire outer transaction then.

So essentially, it depends on your exception handling. If you catch the exception thrown by the inner transaction, you can proceed down some other path within the outer transaction. If you let the exception propagate up the call chain, it's eventually gonna cause a rollback of the entire outer transaction.

也就是说, 最�Ҏ��弄�؜淆的其实�?PROPAGATION_REQUIRES_NEW �?PROPAGATION_NESTED, 那么�q�两�U�方式又有何区别�? 我简单的��译一�?Juergen Hoeller 的话 :

PROPAGATION_REQUIRES_NEW 启动一个新�? 不依赖于环境�?"内部" 事务. �q�个事务��被完全 commited �?rolled back 而不依赖于外部事�? 它拥有自��q��隔离范围, 自己的锁, �{�等. 当内部事务开始执行时, 外部事务��被挂�v, 内务事务�l�束�? 外部事务��l�执�?

另一斚w��, PROPAGATION_NESTED 开始一�?"嵌套�? 事务, 它是已经存在事务的一个真正的子事�? 潜套事务开始执行时, 它将取得一�?savepoint. 如果�q�个嵌套事务��p�|, 我们��回滚到�?savepoint. 潜套事务是外部事务的一部分, 只有外部事务�l�束后它才会被提�?

由此可见, PROPAGATION_REQUIRES_NEW �?PROPAGATION_NESTED 的最大区别在�? PROPAGATION_REQUIRES_NEW 完全是一个新的事�? �?PROPAGATION_NESTED 则是外部事务的子事务, 如果外部事务 commit, 潜套事务也会�?commit, �q�个规则同样适用�?roll back.

那么外部事务如何利用嵌套事务�?savepoint �Ҏ��呢, 我们用代码来说话

代码

ServiceA {
/**
* 事务属性配�|��ؓ PROPAGATION_REQUIRED
*/
void methodA() {
ServiceB.methodB();
}
}
ServiceB {
/**
* 事务属性配�|��ؓ PROPAGATION_REQUIRES_NEW
*/
void methodB() {
}
}

�q�种情况�? 因�ؓ ServiceB#methodB 的事务属性�ؓ PROPAGATION_REQUIRES_NEW, 所以两者不会发生�Q何关�p? ServiceA#methodA �?ServiceB#methodB 不会因�ؓ�Ҏ��的执行情况而媄响事务的�l�果, 因�ؓ它们�Ҏ��是两个事务, �?ServiceB#methodB 执行�?ServiceA#methodA 的事务已�l�挂起了 (关于事务挂�v的内容已�l�超��Z��本文的讨��? 有时间我会再写一些挂��L��文章) .

那么 PROPAGATION_NESTED 又是怎么回事�? �l�箋看代�?/p>

代码

ServiceA {
/**
* 事务属性配�|��ؓ PROPAGATION_REQUIRED
*/
void methodA() {
ServiceB.methodB();
}
}
ServiceB {
/**
* 事务属性配�|��ؓ PROPAGATION_NESTED
*/
void methodB() {
}
}

现在的情况就变得比较复杂�? ServiceB#methodB 的事务属性被配置�?PROPAGATION_NESTED, 此时两者之间又��如何协作呢? �?Juergen Hoeller 的原话中我们可以扑ֈ��{�案, ServiceB#methodB 如果 rollback, 那么内部事务(�?ServiceB#methodB) ��回滚到它执行前�?SavePoint(注意, �q�是本文中第一�ơ提到它, 潜套事务中最核心的概�?, 而外部事�?�?ServiceA#methodA) 可以有以下两�U�处理方�?

1. 改写 ServiceA 如下

代码

ServiceA {
/**
* 事务属性配�|��ؓ PROPAGATION_REQUIRED
*/
void methodA() {
try {
ServiceB.methodB();
} catch (SomeException) {
// 执行其他业务, 如 ServiceC.methodC();
}
}
}

�q�种方式也是潜套事务最有�h值的地方, 它�v��C��分支执行的效�? 如果 ServiceB.methodB ��p�|, 那么执行 ServiceC.methodC(), �?ServiceB.methodB 已经回滚到它执行之前�?SavePoint, 所以不会��生脏数据(相当于此�Ҏ��从未执行�q?, �q�种�Ҏ��可以用在某些特�D�的业务�? �?PROPAGATION_REQUIRED �?PROPAGATION_REQUIRES_NEW 都没有办法做到这一�? (题外�?: 看到�q�种代码, ��g��似曾相识, 惌��v�?prototype.js 中的 Try 函数 )

2. 代码不做��M��修改, 那么如果内部事务(�?ServiceB#methodB) rollback, 那么首先 ServiceB.methodB 回滚到它执行之前�?SavePoint(在�Q何情况下都会如此),
外部事务(�?ServiceA#methodA) ��根据具体的配置军_��自己�?commit �q�是 rollback (+MyCheckedException).

上面大致讲述了潜套事务的使用场景, 下面我们来看如何�?spring 中��?PROPAGATION_NESTED, 首先来看 AbstractPlatformTransactionManager

代码

/**
* Create a TransactionStatus for an existing transaction.
*/
private TransactionStatus handleExistingTransaction(
TransactionDefinition definition, Object transaction, boolean debugEnabled)
throws TransactionException {
... 省略
if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
if (!isNestedTransactionAllowed()) {
throw new NestedTransactionNotSupportedException(
"Transaction manager does not allow nested transactions by default - " +
"specify 'nestedTransactionAllowed' property with value 'true'" );
}
if (debugEnabled) {
logger.debug( "Creating nested transaction with name [" + definition.getName() + "]" );
}
if (useSavepointForNestedTransaction()) {
// Create savepoint within existing Spring-managed transaction,
// through the SavepointManager API implemented by TransactionStatus.
// Usually uses JDBC 3.0 savepoints. Never activates Spring synchronization.
DefaultTransactionStatus status =
newTransactionStatus(definition, transaction, false , false , debugEnabled, null );
status.createAndHoldSavepoint();
return status;
}
else {
// Nested transaction through nested begin and commit/rollback calls.
// Usually only for JTA: Spring synchronization might get activated here
// in case of a pre-existing JTA transaction.
doBegin(transaction, definition);
boolean newSynchronization = ( this .transactionSynchronization != SYNCHRONIZATION_NEVER);
return newTransactionStatus(definition, transaction, true , newSynchronization, debugEnabled, null );
}
}
}

一目了�?

1. 我们要设�|?transactionManager �?nestedTransactionAllowed 属性�ؓ true, 注意, 此属性默认�ؓ false!!!

再看 AbstractTransactionStatus#createAndHoldSavepoint() �Ҏ��

代码

/**
* Create a savepoint and hold it for the transaction.
* @throws org.springframework.transaction.NestedTransactionNotSupportedException
* if the underlying transaction does not support savepoints
*/
public void createAndHoldSavepoint() throws TransactionException {
setSavepoint(getSavepointManager().createSavepoint());
}

可以看到 Savepoint �?SavepointManager.createSavepoint 实现�? 再看 SavepointManager 的层�ơ结�? 发现
�?Template 实现�?JdbcTransactionObjectSupport, 常用�?DatasourceTransactionManager, HibernateTransactionManager
中的 TransactonObject 都是它的子类 :

JdbcTransactionObjectSupport 告诉我们必须要满��两个条件才�?createSavepoint :

2. java.sql.Savepoint 必须存在, �?jdk 版本�?1.4+
3. Connection.getMetaData().supportsSavepoints() 必须�?true, �?jdbc drive 必须支持 JDBC 3.0
��保以上条�g都满��_��, 你就可以��试使用 PROPAGATION_NESTED �? (全文�?

王�R锋的技术实�?/a> 2006-12-29 14:06 发表评论

Servlet和Filter的url匚w��以及url-pattern详解

Thu, 21 Dec 2006 01:23:00 GMT

Servlet�?/span>Filter�?/span>url匚w��以及url-pattern详解

Servlet�?/span>filter�?/span>J2EE开发中常用的技术，使用方便�Q�配�|�简单，老少皆宜。估计大多数朋友都是直接配置用，也没有关心过具体的细节，今天遇到一个问题，上网查了servlet的规范才发现�Q?/span>servlet�?/span>filter中的url-pattern�q�是有一些文章在里面的，�ȝ��了一些东西，攑և�来供大家参考，以免遇到问题又要��费旉��?/span>

一�Q?/font>servlet容器�?/span>url的匹配过�E�：

当一个请求发送到servlet容器的时候，容器先会��请求的url减去当前应用上下文的路径作�ؓservlet的映��?/span>url�Q�比如我讉K��的是http://localhost/test/aaa.html�Q�我的应用上下文�?/span>test�Q�容器会��?/span>http://localhost/test��L��Q�剩下的/aaa.html部分拿来�?/span>servlet的映��匹配。这个映��匹配过�E�是有顺序的�Q�而且当有一�?/span>servlet匚w��成功以后�Q�就不会�ȝ��会剩下的servlet了（filter不同�Q�后文会提到�Q�。其匚w��规则和顺序如下：

1. �_��路径匚w��。例子：比如servletA �?/span>url-pattern�?/span> /test�Q?/span>servletB�?/span>url-pattern�?/span>/* �Q�这个时候，如果我访问的url�?/span>http://localhost/test�Q�这个时候容器就会先�q�行�_��路径匚w��Q�发�?/span>/test正好�?/span>servletA�_��匚w��Q�那么就去调�?/span>servletA�Q�也不会�ȝ��会其他的servlet了�?/span>

2. 最长�\径匹配。例子：servletA�?/span>url-pattern�?/span>/test/*�Q��?/span>servletB�?/span>url-pattern�?/span>/test/a/*�Q�此时访�?/span>http://localhost/test/a�Ӟ��容器会选择路径最长的servlet来匹配，也就是这里的servletB�?/span>

3. 扩展匚w��Q�如�?/span>url最后一�D�包含扩展，容器��会�Ҏ��扩展选择合适的servlet。例子：servletA�?/span>url-pattern�Q?/span>*.action

4. 如果前面三条规则都没有找��C��?/span>servlet�Q�容器会�Ҏ��url选择对应的请求资源。如果应用定义了一�?/span>default servlet�Q�则容器会将��h��丢给default servlet�Q�什么是default servlet�Q�后面会�Ԍ��?/span>

�Ҏ��q�个规则表，��p��很清楚的知道servlet的匹配过�E�，所以定�?/span>servlet的时候也要考虑url-pattern的写法，以免出错�?/span>

对于filter�Q�不会像servlet那样只匹配一�?/span>servlet�Q�因�?/span>filter的集合是一个链�Q�所以只会有处理的顺序不同，而不会出现只选择一�?/span>filter�?/span>Filter的处理顺序和filter-mapping�?/span>web.xml中定义的��序相同�?/span>

二，url-pattern详解

�?/span>web.xml文�g中，以下语法用于定义映射�Q?/span>

l �?/span>�?�?/span>开头和�?/span>�?*�?/span>�l�尾的是用来做�\径映��的�?/span>

l 以前�~��?.�?/span>开头的是用来做扩展映射的�?/span>

l �?�?是用来定�?/span>default servlet映射的�?/span>

l 剩下的都是用来定义详�l�映��的。比如： /aa/bb/cc.action

所以，��Z��么定�?/span>�?*.action�?/span>�q�样一个看��h��很正常的匚w��会错�Q�因��个匹配即属于路径映射�Q�也属于扩展映射�Q�导致容器无法判断�?/span>

【参考内宏V�?/span>

Java Servlet 2.4 Specification

http://www.javaeye.com/topic/39332?page=1

王�R锋的技术实�?/a> 2006-12-21 09:23 发表评论

关于�|�页采集

Wed, 15 Nov 2006 09:24:00 GMT

http://m.tkk7.com/ekinglong/archive/2006/11/12/80704.html

http://m.tkk7.com/ekinglong/archive/2006/10/27/77688.html

王�R锋的技术实�?/a> 2006-11-15 17:24 发表评论

Fri, 03 Nov 2006 02:20:00 GMT

我们看到有些数据库表中有两个字段�Q�类型分别�ؓ varchar(8000)、varchar(8000)�Q�我们说�q�种设计是错误的�Q��ؓ什么呢�Q?/font>

SQL Server 存储中有个“页”的概念�Q�一个“页”是 8K 大小�Q�而一个数据行�Q�一条记录）必须存储在一个页中，不能拆开存储在多个页中，也就是说一个数据行�Q�一条记录）的大��最多是 8K�Q�实际上�׃�� SQL Server 的页�q�具有页��_��某些�c�d��的字�D�还要额外占用一些空��_��一个数据行�Q�一条记录）的最大大��常�怹�只有七千多字�?/strong>�?/font>

上述表设计中一个字�D�就辑ֈ��?8000 字节�Q�不要说一个数据行�Q�一条记录）了�?/font>

有�h��_��我虽然指定的�?8000 字节�Q�但我存储时不存储满��d��以了吧。技术上是允许的�Q�但既然我们用不了那么多字节�Q��ؓ什么要写那么大呢？是不是考虑我们得用 text 字段�Q�或者修改一下表�l�构�?/font>

如果一个数据行�Q�一条记录）��_��的小�Q�一个页��可以存储更多的数据行（记录�Q�，SQL Server 查询时就不用��d��多的��，查询��h��׃��更快�?br />
引用地址�Q?a >http://www.cftea.com/c/2006/10/TNRWRCF871NS33K4.asp

王�R锋的技术实�?/a> 2006-11-03 10:20 发表评论

Wed, 01 Nov 2006 02:00:00 GMT

转－SQL Server开发�h员应聘常被问的问题妙解汇�?

关键�? 工作

目前在职��Z��很难扑ֈ�非常合格的数据库开发�h员。我的一个同事曾�l�说�q?“SQL开发是一门语�a��Q�它很容易学�Q�但是很难掌握。�?/p>
　　在面试应聘的SQL Server数据库开发�h员时�Q�我�q�用了一套标准的基准技术问题。下面这些问题是我觉得能够真正有助于淘汰不合格应聘者的问题。它们按照从易到隄��序排列。当您问到关于主键和外键的问题时�Q�后面的问题都十分有隑ֺ��Q�因为答案可能会更难解释和说明，��其是在面试的情形下�?/p>
　　您能向我��要叙�q�C��下SQL Server 2000中��用的一些数据库对象�?

　　您希望听到的�{�案包括�q�样一些对�?表格、视图、用户定义的函数�Q�以及存储过�E?如果他们�q�能够提到像触发器这��L��对象��更好了。如果应聘者不能回�{�这个基本的问题�Q�那么这不是一个好兆头�?/p>
　　什么是索引?SQL Server 2000里有什么类型的索引?

　　��M��有经验的数据库开发�h员都应该能够很轻易地回答�q�个问题。一些经验不太多的开发�h员能够回�{�这个问题，但是有些地方会说不清楚�?/p>
　　��单地��_��索引是一个数据结构，用来快速访问数据库表格或者视��N��的数据。在SQL Server里，它们有两�U��Ş�?聚集索引和非聚集索引。聚集烦引在索引的叶�U�保存数据。这意味着不论聚集索引里有表格的哪�?或哪�?字段�Q�这些字�D�都会按��序被保存在表格。由于存在这�U�排序，所以每个表格只会有一个聚集烦引。非聚集索引在烦引的叶��有一个行标识�W�。这个行标识�W�是一个指向磁盘上数据的指针。它允许每个表格有多个非聚集索引�?/p>
　　NULL是什么意�?

　　NULL(�I?�q�个值是数据库世界里一个非帔R��~�的东西�Q�所以有不少应聘者会在这个问题上跌跟头您也不要觉得意外�?/p>
　　NULL�q�个��D��C�UNKNOWN(未知):它不表示“�?�I�字�W�串)。假设您的SQL Server数据库里有ANSI_NULLS�Q�当然在默认情况下会有，对NULL�q�个值的��M��比较都会生��一个NULL倹{��您不能把�Q何��g��一�?UNKNOWN��D��行比较，�q�在逻辑上希望获得一个答案。您必须使用IS NULL操作�W��?/p>
　　什么是主键?什么是外键?

　　主键是表格里�?一个或多个)字段�Q�只用来定义表格里的�?主键里的值��L��唯一的。外键是一个用来徏立两个表��g��间关�pȝ��U�束。这�U�关�p�M��般都涉及一个表格里的主键字�D�与另外一个表�?��管可能是同一个表�?里的一�p�d��相连的字�D�c��那么这些相�q�的字段��是外键�?/p>
　　什么是触发�?SQL Server 2000有什么不同类型的触发�?

　　让未来的数据库开发�h员知道可用的触发器类型以及如何实现它们是非常有益的�?/p>
　　触发器是一�U�专用类型的存储�q�程�Q�它被捆�l�到SQL Server 2000的表格或者视图上。在SQL Server 2000里，有INSTEAD-OF和AFTER两种触发器。INSTEAD-OF触发器是替代数据操控语言(Data Manipulation Language�Q�DML)语句对表格执行语句的存储�q�程。例如，如果我有一个用于TableA的INSTEAD-OF-UPDATE触发器，同时对这个表格执行一个更新语句，那么INSTEAD-OF-UPDATE触发器里的代码会执行�Q�而不是我执行的更新语句则不会执行操作�?/p>
　　AFTER触发器要在DML语句在数据库里��用之后才执行。这些类型的触发器对于监视发生在数据库表格里的数据变化十分好用�?/p>
　　您如何确一个带有名为Fld1字段的TableB表格里只��h��Fld1字段里的那些��|��而这些值同时在名�ؓTableA的表格的Fld1字段�?

　　�q�个与关�pȝ��关的问题有两个可能的�{�案。第一个答�?而且是您希望听到的答�?是��用外键限制。外键限制用来维护引用的完整性。它被用来确保表格里的字�D�只保存有已�l�在不同�?或者相同的)表格里的另一个字�D�里定义了的倹{��这个字�D�就是候选键(通常是另外一个表格的主键)�?/p>
　　另外一�U�答案是触发器。触发器可以被用来保证以另外一�U�方式实��C��限制相同的作用，但是它非帔R��讄��与维护，而且性能一般都很糟�p�。由于这个原因，微��Y��开发�h员��用外键限制而不是触发器来维护引用的完整性�?/p>
对一个投入��用的在线事务处理表格有过多烦引需要有什么样的性能考虑?

　　您正在寻找进行与数据操控有关的应聘�h员。对一个表格的索引��多�Q�数据库引擎用来更新、插入或者删除数据所需要的旉��p��多，因�ؓ在数据操控发生的时候烦引也必须要维护�?/p>
　　您可以用什么来��保表格里的字段只接受特定范围里的�?

　　�q�个问题可以用多�U�方式来回答�Q�但是只有一个答案是“好”答案。您希望听到的回�{�是Check限制�Q�它在数据库表格里被定义�Q�用来限制输入该列的倹{�?/p>
　　触发器也可以被用来限制数据库表格里的字段能够接受的��|��但是�q�种办法要求触发器在表格里被定义�Q�这可能会在某些情况下媄响到性能。因此，微��Y��使用Check限制而不是其他的方式来限制域的完整性�?/p>
　　�q�回参数和OUTPUT参数之间的区别是什�?

　　如果应聘者能够正��地回答�q�个问题�Q�那么他的机会就非常大了�Q�因��表明他们��h��使用存储�q�程的经验�?/p>
　　�q�回参数��L��由存储过�E�返回，它用来表�C�存储过�E�是成功�q�是��p�|。返回参数��L��INT数据�c�d��?/p>
　　OUTPUT参数明确要求由开发�h员来指定�Q�它可以�q�回其他�c�d��的数据，例如字符型和数值型的倹{�?可以用作输出参数的数据类型是有一些限制的�?您可以在一个存储过�E�里使用多个OUTPUT参数�Q�而您只能够��用一个返回参数�?/p>
　　什么是相关子查�?如何使用�q�些查询?

　　�l�验更加丰富的开发�h员将能够准确地描�q�这�U�类型的查询�?/p>
　　相关子查询是一�U�包含子查询的特�D�类型的查询。查询里包含的子查询会真正请求外部查询的��|��从而�Ş成一个类��g��循环的状��c�?/p>
　　关于面试�q�程的思�?/p>
　　�q�些问题只不�q�是��定一个SQL Server数据库开发�h员是否合格的��L��。根据应聘者对上面�q�些问题的回�{�情况，我可能会要求他们参加我的TSQL�~�程考试�Q�这一般是一套根据不同情况进行的10�?2个数据库查询�?/p>
　　您需要自己决定将要雇用的开发�h员具有什么样的专业技能。然后，需要通过自己的经验、判断以及在面试时对应聘者的感受(来做最�l�决�?�?/p>
　　您在面试数据库开发�h员时一般会问哪些问题呢?让我们一��h��讨论一下吧�?/p>
　　Tim Chapman是肯塔基州�\易维��市一安��行的SQL Server数据库管理员�Q�他有超�q?�q�的行业�l�验。他�q�通过了微软SQL Server 2000和SQL Server 2005的认证�?

引：http://jaaacky.javaeye.com/blog/31571

王�R锋的技术实�?/a> 2006-11-01 10:00 发表评论