亚洲精品字幕在线观看,久久精品亚洲中文字幕无码麻豆,亚洲狠狠久久综合一区77777

obpm — Sun, 07 Nov 2010 05:57:00 GMT

从设计理念层面看abstract class和interface

上面主要从语法定义和�~�程的角度论�q�C��abstract class和interface的区别，�q�些层面的区别是比较低层�ơ的、非本质的。本��节��从另一个层面：abstract class和interface所反映出的设计理念�Q�来分析一下二者的区别。作者认为，从这个层面进行分析才能理解二者概�늚�本质所在�?

前面已经提到�q�，abstarct class在Java语言中体��C��一�U��承关�p�，要想使得�l�承关系合理�Q�父�c�d��z��c�M��间必��d��?is a"关系�Q�即父类和派生类在概忉|��质上应该是相同的�Q�参考文献�?〕中有关�?is a"关系的大��幅深入的论�q�ͼ�有兴��的读者可以参考）。对于interface 来说则不�Ӟ��q�不要求interface的实现者和interface定义在概忉|��质上是一致的�Q�仅仅是实现了interface定义的契�U�而已。�ؓ了��便于理解�Q�下面将通过一个简单的实例�q�行说明�?

考虑�q�样一个例子，假设在我们的问题领域中有一个关于Door的抽象概念，该Door��h��执行两个动作open和close�Q�此时我们可以通过abstract class或者interface来定义一个表�C��抽象概念的类型，定义方式分别如下所�C�：

使用abstract class方式定义Door�Q?

abstract class Door {
abstract void open();
abstract void close()�Q?
}

使用interface方式定义Door�Q?

interface Door {
void open();
void close();
}

其他具体的Door�c�d��可以extends使用abstract class方式定义的Door或者implements使用interface方式定义的Door。看��h��好像使用abstract class和interface没有大的区别�?

如果现在要求Door�q�要��h��报警的功能。我们该如何设计针对该例子的�cȝ��构呢�Q�在本例中，主要是�ؓ了展�C�abstract class和interface反映在设计理念上的区别，其他斚w��无关的问题都做了��化或者忽略）�Q�下面将�|�列出可能的解决�Ҏ(gu��)��Q��ƈ从设计理念层面对�q�些不同的方案进行分析�?

解决�Ҏ(gu��)��一�Q?

��单的在Door的定义中增加一个alarm�Ҏ(gu��)��Q�如下：

abstract class Door {
abstract void open();
abstract void close()�Q?
abstract void alarm();
}

或�?

interface Door {
void open();
void close();
void alarm();
}

那么��h��报警功能的AlarmDoor的定义方式如下：

class AlarmDoor extends Door {
void open() { … }
void close() { … }
void alarm() { … }
}

或�?

class AlarmDoor implements Door �?
void open() { … }
void close() { … }
void alarm() { … }
�?

�q�种�Ҏ(gu��)��q�反了面向对象设计中的一个核心原则ISP�Q�Interface Segregation Priciple�Q�，在Door的定义中把Door概念本��n固有的行为方法和另外一个概�?报警�?的行为方法�؜在了一赗��这样引��L(f��ng)��一个问题是那些仅仅依赖于Door�q�个概念的模块会因�ؓ"报警�?�q�个概念的改变（比如�Q�修改alarm�Ҏ(gu��)��的参敎ͼ�而改变，反之依然�?

解决�Ҏ(gu��)��二：

既然open、close和alarm属于两个不同的概念，�Ҏ(gu��)��ISP原则应该把它们分别定义在代表�q�两个概�늚�抽象�c�M��。定义方式有�Q�这两个概念都��用abstract class方式定义�Q�两个概念都使用interface方式定义�Q�一个概念��用abstract class方式定义�Q�另一个概念��用interface方式定义�?

昄��Q�由于Java语言不支持多重��承，所以两个概念都使用abstract class方式定义是不可行的。后面两�U�方式都是可行的�Q�但是对于它们的选择却反映出对于问题领域中的概念本质的理解、对于设计意囄��反映是否正确、合理。我们一一来分析、说明�?

如果两个概念都��用interface方式来定义，那么��反映出两个问题�Q?、我们可能没有理解清楚问题领域，AlarmDoor在概忉|��质上到底是Door�q�是报警器？2、如果我们对于问题领域的理解没有问题�Q�比如：我们通过对于问题领域的分析发现AlarmDoor在概忉|��质上和Door是一致的�Q�那么我们在实现时就没有能够正确的揭�C�我们的设计意图�Q�因为在�q�两个概�늚�定义上（均��用interface方式定义�Q�反映不��Z��q�含义�?

如果我们对于问题领域的理解是�Q�AlarmDoor在概忉|��质上是Door�Q�同时它有具有报警的功能。我们该如何来设计、实现来明确的反映出我们的意思呢�Q�前面已�l�说�q�，abstract class在Java语言中表�C�Z��U��承关�p�，而��承关�p�d��本质上是"is a"关系。所以对于Door�q�个概念�Q�我们应该��用abstarct class方式来定义。另外，AlarmDoor又具有报警功能，说明它又能够完成报警概念中定义的行�ؓ�Q�所以报警概念可以通过interface方式定义。如下所�C�：

abstract class Door {
abstract void open();
abstract void close()�Q?
}
interface Alarm {
void alarm();
}
class AlarmDoor extends Door implements Alarm {
void open() { … }
void close() { … }
void alarm() { … }
}

�q�种实现方式基本上能够明��的反映出我们对于问题领域的理解�Q�正��的揭示我们的设计意图。其实abstract class表示的是"is a"关系�Q�interface表示的是"like a"关系�Q�大家在选择时可以作��Z��个依据，当然�q�是建立在对问题领域的理解上的，比如�Q�如果我们认为AlarmDoor在概忉|��质上是报警器�Q�同时又��h��Door的功能，那么上述的定义方式就要反�q�来了�?

转蝲人员-Nicholas
package cn.myapps.test;

import java.util.Hashtable;
import javax.naming.Context;
import javax.naming.NamingException;
import javax.naming.directory.Attributes;
import javax.naming.directory.DirContext;
import javax.naming.directory.InitialDirContext;

public class LdapTest {
public void JNDILookup() {
String root = "o=teemlink,c=cn";
Hashtable env = new Hashtable();
env.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.ldap.LdapCtxFactory");
env.put(Context.PROVIDER_URL, "ldap://192.168.0.30/" + root);
env.put(Context.SECURITY_AUTHENTICATION, "simple");
env.put(Context.SECURITY_PRINCIPAL, "cn=Nicholas,ou=develop,o=teemlink,c=cn");
env.put(Context.SECURITY_CREDENTIALS, "123456");
DirContext ctx = null;

try {
ctx = new InitialDirContext(env);
Attributes attrs = ctx.getAttributes("cn=Nicholas,ou=develop");
System.out.println("Last Name: " + attrs.get("sn").get());
System.out.println("认证成功");
} catch (javax.naming.AuthenticationException e) {
e.printStackTrace();
System.out.println("认证��p�|");
} catch (Exception e) {
System.out.println("认证出错�Q?/span>");
e.printStackTrace();
}
if (ctx != null) {
try {
ctx.close();
} catch (NamingException e) {
// ignore
}
}
}

public static void main(String[] args) {
LdapTest LDAPTest = new LdapTest();
LDAPTest.JNDILookup();
}
}

5.2 用JLDAP�q�访�?/h2>

讉K��地址�Q?a >http://www.openldap.org/jldap/ �q�下载相关lib

import com.novell.ldap.*;



import java.io.UnsupportedEncodingException;



public class List



{



public static void main(String[] args)



{

int ldapPort = LDAPConnection.DEFAULT_PORT;

int searchScope = LDAPConnection.SCOPE_ONE;

int ldapVersion = LDAPConnection.LDAP_V3;

boolean attributeOnly = false;

String attrs[] = null;

String ldapHost = "192.168.0.30";

String loginDN = "cn=Manager,o=teemlink,c=cn";

String password = "secret";

String searchBase = "ou=develop,o=teemlink,c=cn";

String searchFilter = "objectClass=*";



LDAPConnection lc = new LDAPConnection();

try {

// connect to the server

            lc.connect(ldapHost, ldapPort);



// bind to the server

            lc.bind(ldapVersion, loginDN, password.getBytes("UTF8"));



LDAPSearchResults searchResults =



lc.search(searchBase, // container to search

                    searchScope, // search scope

                    searchFilter, // search filter

                    attrs, // "1.1" returns entry name only

                    attributeOnly); // no attributes are returned



// print out all the objects

            while (searchResults.hasMore()) {

LDAPEntry nextEntry = null;

try {

nextEntry = searchResults.next();

System.out.println("\n" + nextEntry.getDN());

System.out.println(nextEntry.getAttributeSet());

} catch (LDAPException e) {

System.out.println("Error: " + e.toString());

// Exception is thrown, go for next entry

                    continue;

}

}



// disconnect with the server

            lc.disconnect();



} catch (LDAPException e) {

System.out.println("Error: " + e.toString());

} catch (UnsupportedEncodingException e) {

System.out.println("Error: " + e.toString());

}

System.exit(0);

}

}

5.3 用JDBC-LDAP�q�访�?/h2>

讉K��地址�Q?a >http://www.openldap.org/jdbcldap/ �q�下载相关lib

package jdbcldap;



import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.ResultSet;

import java.sql.Statement;



public class JdbcLdap {



/**

* @param args

* @throws Exception 

*/

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

Class.forName("com.octetstring.jdbcLdap.sql.JdbcLdapDriver");

String ldapConnectString = "jdbc:ldap://192.168.0.30/o=teemlink,c=cn?SEARCH_SCOPE:=subTreeScope";

Connection con = DriverManager.getConnection(ldapConnectString, "cn=Manager,o=teemlink,c=cn", "secret");



String sql = "SELECT * FROM ou=develop,o=teemlink,c=cn";



Statement sat = con.createStatement();

ResultSet rs = sta.executeQuery(sql);

while (rs.next()) {

System.out.println(rs.getString(1));

}



if (con != null)

con.close();

}

}

原创人员�Q�Nicholas

文章来源:http://www.cnblogs.com/obpm/archive/2010/08/28/1811065.html

obpm 2010-08-28 14:38 发表评论

重构实战案例一�Q�以子类取代�c�d��~�码(原创)

obpm — Tue, 13 Jul 2010 15:22:00 GMT

以子�c�d��代类型编�?/span>

Replace Type Code with Subclasses

1. 何谓重构

1.1名词解释

　　对��Y件内部结构的㆒种调整�Q�目的是在不改变「��Y件之可察行�ؓ」前提下�Q�提高其可理解性，降低其修�Ҏ(gu��)��本�?/span>

1.2动词解释

　　使用一�p�d��重构准则�Q�手法）�Q�在不改变「��Y件之可察行�ؓ」前提下�Q�调整其�l�构�?/span>

2. ��Z��重构

2.1「重构」改�q��Y件设�?/h2>
　　同样完成一件事�Q�设计不良的�E�序往往需要更多代码，�q�常常是因�ؓ代码在不同的�?/b>方��用完全相同的语句做同��L(f��ng)��?/b>。因此改�q�设计的一个重要方向就是消除重复代�?b>�Q�Duplicate Code�Q?/span>

2.2「重构」��软�g更易被理�?/h2>
　　你的源码�q�有其它读者：��C��月之后可能会有另一位程序员��试��L��你的代码�q�做一些修�?/b>。我们很�Ҏ(gu��)��忘记�q�第二位读者，但他才是最重要的。计��器是否多花了数个钟头进行编译，又有什么关�p�d��Q�如果一个程序员��p��一周时间来修改某段代码�Q�那才关�p�重�?mdash; 如果他理解你的代码，�q�个修改原本只需一��时

2.3「重构」助你找到臭�?�Q?bugs�Q?/h2>
　　Kent Beck �l�常形容自己的㆒句话�Q��?b>我不是个伟大的程序员�Q�我只是个有着�?/b>些优�U��?f��n)惯的好�E�序员而已。』重构能够帮助我更有效地写出强固�E�_��Q�robust�Q�的代码�?b>

2.4「重构」助你提高编�E�速度

　　�l�于�Q�前面的一切都归结��C��q�最后一点：重构帮助你更快速地开发程序。听��h��有违反直觉。当我谈到重构，��Z��很容易看出它能够提高质量�?b>改善设计、提升可��L��、减��错�?/b>�Q�这些都是提高质量。但�q�难道不会降低开发速度吗？我强烈相信：良好设计是快速��Y件开发的�Ҏ(gu��)��。事实上拥有良好设计才可能达成快速的开发�?b>如果没有良好设计�Q�或许某一�D�|��间内你的�q�展�q�速，但恶劣的设计很快��p��你的速度�?/b>�?/b>来。你会把旉��花在调试�?/b>面，无法��d��新功�?/b>。修�Ҏ(gu��)��间愈来愈长，因�ؓ你必��花愈来愈多的时间去理解�pȝ��、寻��N��复代码。随着你给最初程序打上一个又一个的补丁�Q�patch�Q�，新特性需要更多代码才能实现。真是个恶性��@环�?

3.何时重构�Q?/h1>
　　重构本来��׃��是一件「特别拨出时间做」的事情�Q�重构应该随旉��地进�?/span>。你不应该�ؓ重构而重构，你之所以重构，是因��Z��惛_��别的什么事�Q�而重构可以帮助你把那些事做好

3.1三次法则�Q�The Rule of Three�Q?/h2>
　　Don Roberts �l�了我一条准则：�W�一�ơ做某�g事时只管��d��Q�第二次做类似的事会产生反感�Q�但无论如何�q�是做了�Q�第三次再做�c�M��的事�Q�你��应该重构�?

　　�?nbsp;事不�q?/b>�?/b>�Q?/b>�?/b>则重构。（Three strikes and you refactor.�Q?/b>

3.2重构时机

　　��d��功能时一�q��?/span>

　　修补错误时一�q��?/span>

　　复审代码时一�q��?

-以上章节摘抄自《重�?改善既有代码的设�?b>�?/b>

4.�q�_��重构案例

4.1重构动机

　　1. 实例模块为View�Q�重构元素�ؓViewAction、ViewProcessBean、View�Q�以下�ؓ关系图�?/span>

　　

　　2. �׃��View存在多种editMode�Q�编辑模式）�Q�而每个调用的地方都需要进行type code�Q�类型码�Q�判�?/b>�Q�然后再�q�行相应的业务逻辑处理�Q�最�l�在每个调用的地斚w��形成了大量的if-else代码�Q�大大减�׃��代码的可��L��，和逻辑清晰度�?/span>

　　3. 调用的地方：

　　

4.2重构作法

　　

如上图所�C�，��每�U�type code重构成subclass�Q�加��Z��每种�c�d��处理业务逻辑的能力�?/span>

View-版本1566代码片段�Q?/span>

public EditMode getEditModeType() {
if (EDIT_MODE_CODE_DQL.equals(getEditMode())) {
return new DQLEditMode(this);
} else if (EDIT_MODE_CODE_SQL.equals(getEditMode())) {
return new SQLEditMode(this);
} else if (EDIT_MODE_DESIGN.equals(getEditMode())) {
return new DesignEditMode(this);
}

return new NullEditMode(this);
}

说明�Q�调用者无需了解具体的类型，由View自��n作判断，�q�回EditMode接口�Q�从而实现多态调用�?/span>

ViewProcessBean代码片段�Q?/span>

重构�?版本1503�Q?/span>

public String expDocToExcel(String viewid, WebUser user, ParamsTable params) throws Exception {
if (view.getEditMode().equals(View.EDIT_MODE_DESIGN)) {
datas = dp.queryBySQLPage(sql, params, tempPage, LINES, user.getDomainid());
} else if (view.getEditMode().equals(View.EDIT_MODE_CODE_DQL)) {
datas = dp.queryByDQLPage(dql, params, tempPage, LINES, user.getDomainid());
} else if (view.getEditMode().endsWith(View.EDIT_MODE_CODE_SQL)) {
datas = dp.queryBySQLPage(sql, params, tempPage, LINES, user.getDomainid());
}
}

重构�?版本1566�Q?/span>

public String expDocToExcel(String viewid, WebUser user, ParamsTable params) throws Exception {
datas = view.getEditModeType().getDataPackage(params, tempPage, LINES, user, currdoc);
//其他业务逻辑
}

5.�l�语

　　�׃��q�案例可看到�Q�引入subclass代替type code可以大大减少if-else判断�Q�而且可以把责��d��聚到每种type中，使代码结构更清晰易懂�?/span>

6.其他

在本案例中引入了�I�类型概念，�?/span>NullEditMode�Q�代码如下：

　　

/**
*
* @author nicholas zhen
*
*/
public class NullEditMode extends AbstractEditMode implements EditMode {

public NullEditMode(View view) {
super(view);
}

public String getQueryString(ParamsTable params, WebUser user, Document sDoc) {
return "";
}

public DataPackage getDataPackage(ParamsTable params, WebUser user, Document doc) throws Exception {
return new DataPackage();
}

public DataPackage getDataPackage(ParamsTable params, int page, int lines, WebUser user, Document doc) throws Exception {
return new DataPackage();
}

public long count(ParamsTable params, WebUser user, Document doc) throws Exception {
return 0;
}
}

说明�Q�空�c�d��保证了调用每个方法都有默认��D��回，而不需要进行非�I�判断，当View没有�c�d��Ӟ��卌��回默认的�I�类�?/span>

原创人员�Q�Nicholas

文章来源:http://www.cnblogs.com/obpm/archive/2010/07/13/1776856.html

obpm 2010-07-13 23:22 发表评论

Hibernate的乐观锁与�?zh��n)�观�?转蝲)

obpm — Sun, 11 Jul 2010 01:58:00 GMT

锁（ locking �Q?
业务逻辑的实现过�E�中�Q�往往需要保证数据访问的排他性。如在金融系�l�的日终�l�算处理中，我们希望针对某个 cut-off 旉��点的数据�q�行处理�Q�而不希望在结��进行过�E�中�Q�可能是几秒�U�，也可能是几个��时�Q�，数据再发生变化。此�Ӟ��我们��需要通过一些机制来保证�q�些数据在某个操作过�E�中不会被外界修改，�q�样的机�Ӟ��在这里，也就是所谓的 “�?rdquo; �Q�即�l�我们选定的目标数据上锁，使其无法被其他程序修攏V��Hibernate 支持两种锁机�Ӟ��即通常所说的 “�(zh��n)�观锁（ Pessimistic Locking �Q?rdquo;�?“乐观锁（ Optimistic Locking �Q?rdquo; �?br />
�(zh��n)�观锁（ Pessimistic Locking �Q?
�(zh��n)�观锁，正如其名�Q�它指的是对数据被外界（包括本系�l�当前的其他事务�Q�以及来自外部系�l�的事务处理�Q�修�Ҏ(gu��)��保守态度�Q�因此，在整个数据处理过�E�中�Q�将数据处于锁定状态。�?zh��n)�观锁的实玎ͼ�往往依靠数据库提供的锁机�Ӟ��也只有数据库层提供的锁机制才能真正保证数据访问的排他性，否则�Q�即使在本系�l�中实现了加锁机�Ӟ��也无法保证外部系�l�不会修�Ҏ(gu��)��据）�?
一个典型的倚赖数据库的�(zh��n)�观锁调用：
select * from account where name=”Erica” for update
�q�条 sql 语句锁定�?account 表中所有符合检索条�Ӟ��name=”Erica”�Q�的记录。本�ơ事务提交之前（事务提交时会释放事务�q�程中的锁）�Q�外界无法修改这些记录。Hibernate 的�?zh��n)�观锁�Q�也是基于数据库的锁机制实现�?br />下面的代码实��C��Ҏ(gu��)��询记录的加锁�Q?
String hqlStr ="from TUser as user where user.name='Erica'";
Query query = session.createQuery(hqlStr);
query.setLockMode("user",LockMode.UPGRADE); // 加锁
List userList = query.list();// 执行查询�Q�获取数�?/span>
query.setLockMode �Ҏ(gu��)��询语句中�Q�特定别名所对应的记录进行加锁（我们为TUser �c�L��定了一个别�?“user” �Q�，�q�里也就是对�q�回的所�?user 记录�q�行加锁�?br />观察�q�行�?Hibernate 生成�?SQL 语句�Q?br />select tuser0_.id as id, tuser0_.name as name, tuser0_.group_id
as group_id, tuser0_.user_type as user_type, tuser0_.sex as sex
from t_user tuser0_ where (tuser0_.name='Erica' ) for update
�q�里 Hibernate 通过使用数据库的 for update 子句实现了�?zh��n)�观锁机制�?
Hibernate 的加锁模式有�Q?
LockMode.NONE �Q?/strong> 无锁机制�?
LockMode.WRITE �Q?/strong> Hibernate �?Insert �?Update 记录的时候会自动获取�?
LockMode.READ �Q?/strong> Hibernate 在读取记录的时候会自动获取�?br />以上�q�三�U�锁机制一般由 Hibernate 内部使用�Q�如 Hibernate ��Z��保证 Update�q�程中对象不会被外界修改�Q�会�?save �Ҏ(gu��)��实现中自动�ؓ目标对象加上 WRITE 锁�?br />LockMode.UPGRADE �Q?/strong>利用数据库的 for update 子句加锁�?
LockMode. UPGRADE_NOWAIT �Q?/strong> Oracle 的特定实玎ͼ�利用 Oracle �?for update nowait 子句实现加锁�?
上面�q�两�U�锁机制是我们在应用层较为常用的�Q�加锁一般通过以下�Ҏ(gu��)��实现�Q?
Criteria.setLockMode
Query.setLockMode
Session.lock
注意�Q�只有在查询开始之前（也就�?Hiberate 生成 SQL 之前�Q�设定加锁，才会真正通过数据库的锁机制进行加锁处理，否则�Q�数据已�l�通过不包�?for update 子句�?Select SQL 加蝲�q�来�Q�所谓数据库加锁也就无从谈�v�?br />
乐观锁（ Optimistic Locking �Q?
相对�(zh��n)�观锁而言�Q�乐观锁机制采取了更加宽杄��加锁机制。�?zh��n)�观锁大多数情况下依靠数据库的锁机制实玎ͼ�以保证操作最大程度的独占性。但随之而来的就是数据库性能的大量开销�Q�特别是寚w��事务而言�Q�这��L(f��ng)��开销往往无法承受�?
如一个金融系�l�，当某个操作员��d��用户的数据，�q�在��d��的用��h��据的基础上进行修�Ҏ(gu��)��如更改用户帐户余额）�Q�如果采用�?zh��n)�观锁机制�Q�也��意味着整个操作�q�程中（从操作员��d��数、开始修改直��x��交修改结果的全过�E�，甚至�q�包括操作员中途去煮咖啡的旉��Q�，数据库记录始�l�处于加锁状态，可以惌��Q�如果面对几百上千个�q�发�Q�这��L(f��ng)��情况��导致怎样的后果。乐观锁机制在一定程度上解决了这个问题。乐观锁�Q�大多是��Z��数据版本�Q?Version �Q�记录机制实现。何谓数据版本？即�ؓ数据增加一个版本标识，在基于数据库表的版本解决�Ҏ(gu��)��中，一般是通过为数据库表增加一�?“version” 字段来实现�?
��d��出数据时�Q�将此版本号一同读出，之后更新�Ӟ��Ҏ(gu��)��版本号加一。此�Ӟ��提交数据的版本数据与数据库表对应记录的当前版本信息�q�行比对�Q�如果提交的数据版本号大于数据库表当前版本号�Q�则予以更新�Q�否则认为是�q�期数据�?
对于上面修改用户帐户信息的例子而言�Q�假设数据库中帐户信息表中有一个version 字段�Q�当前��gؓ 1 �Q�而当前帐户余额字�D�（balance�Q��ؓ $100 �?
1 操作�?A 此时��其��d��Q�version=1�Q�，�q�从其帐户余额中扣除 $50�Q?100-$50�Q��?
2 在操作员 A 操作的过�E�中�Q�操作员 B 也读入此用户信息�Q�version=1�Q�，�q�从其帐户余额中扣除 $20 �Q?100-$20�Q��?
3 操作�?A 完成了修改工作，��数据版本号加一�Q�version=2�Q�，�q�同帐户扣除后余额（balance=$50�Q�，提交��x��据库更新�Q�此时由于提交数据版本大于数据库记录当前版本�Q�数据被更新�Q�数据库记录 version 更新�?2 �?
4 操作�?B 完成了操作，也将版本号加一�Q�version=2�Q�试囑֐�数据库提交数据（balance=$80�Q�，但此时比�Ҏ(gu��)��据库记录版本时发玎ͼ�操作�?B 提交的数据版本号�?2 �Q�数据库记录当前版本也�ؓ 2 �Q�不满��“ 提交版本必须大于记录当前版本才能执行更新“ 的乐观锁�{�略�Q�因此，操作�?B 的提交被驛_��。这��P��避免了操作�?B 用基�?version=1 的旧数据修改的结果覆盖操作员 A 的操作结果的可能�?
从上面的例子可以看出�Q�乐观锁机制避免了长事务中的数据库加锁开销�Q�操作员 A 和操作员 B 操作�q�程中，都没有对数据库数据加锁）�Q�大大提升了大�ƈ发量下的�pȝ��整体性能表现。需要注意的是，乐观锁机制往往��Z��pȝ��中的数据存储逻辑�Q�因此也具备一定的局限性，如在上例中，�׃��乐观锁机制是在我们的�pȝ��中实玎ͼ�来自外部�pȝ��的用户余额更新操作不受我们系�l�的控制�Q�因此可能会造成脏数据被更新到数据库中。在�pȝ��设计阶段�Q�我们应该充分考虑到这些情况出现的可能性，�q�进行相应调��_��如将乐观锁策略在数据库存储过�E�中实现�Q�对外只开攑֟�于此存储�q�程的数据更新途径�Q�而不是将数据库表直接对外公开�Q��?
Hibernate 在其数据讉K��引擎中内�|�了乐观锁实现。如果不用考虑外部�pȝ��Ҏ(gu��)��据库的更新操作，利用 Hibernate 提供的透明化乐观锁实现�Q�将大大提升我们的生产力�?
Hibernate 中可以通过 class 描述�W�的 optimistic-lock 属性结�?version描述�W�指定�?br />
现在�Q�我们�ؓ之前�C�Z��中的 TUser 加上乐观锁机制�?br />1 �Q?首先�?TUser �?class 描述�W�添�?optimistic-lock 属性：

dynamic-insert="true" optimistic-lock="version">
……

optimistic-lock 属性有如下可选取��|��
none�Q?/strong>无乐观锁
version�Q?/strong>通过版本机制实现乐观�?
dirty�Q?/strong>通过��查发生变动过的属性实��C��观锁
all�Q?/strong>通过��查所有属性实��C��观锁
其中通过 version 实现的乐观锁机制�?Hibernate 官方推荐的乐观锁实现�Q�同时也�?Hibernate 中，目前唯一在数据对象脱��?Session 发生修改的情况下依然有效的锁机制。因此，一般情况下�Q�我们都选择 version 方式作�ؓ Hibernate 乐观锁实现机制�?
2 �Q?��d��一�?Version 属性描�q�符

optimistic-lock="version">

……

注意 version 节点必须出现�?ID 节点之后。这里我们声明了一�?version 属性，用于存放用户的版本信息，保存�?TUser 表的version 字段中�?
此时如果我们��试�~�写一�D�代码，更新 TUser 表中记录数据�Q�如�Q?
Criteria criteria = session.createCriteria(TUser.class);
criteria.add(Expression.eq("name","Erica"));
List userList = criteria.list();
TUser user =(TUser)userList.get(0);
Transaction tx = session.beginTransaction();
user.setUserType(1); // 更新 UserType 字段
tx.commit();
每次�?TUser �q�行更新的时候，我们可以发现�Q�数据库中的 version 都在递增。而如果我们尝试在 tx.commit 之前�Q�启动另外一�?Session �Q�对名�ؓ Erica 的用戯��行操作，以模拟�ƈ发更新时的情形：
Session session= getSession();
Criteria criteria = session.createCriteria(TUser.class);
criteria.add(Expression.eq("name","Erica"));
Session session2 = getSession();
Criteria criteria2 = session2.createCriteria(TUser.class);
criteria2.add(Expression.eq("name","Erica"));
List userList = criteria.list();
List userList2 = criteria2.list();TUser user =(TUser)userList.get(0);
TUser user2 =(TUser)userList2.get(0);
Transaction tx = session.beginTransaction();
Transaction tx2 = session2.beginTransaction();
user2.setUserType(99);
tx2.commit();
user.setUserType(1);
tx.commit();
执行以上代码�Q�代码将�?tx.commit() 处抛�?StaleObjectStateException 异常�Q��ƈ指出版本��查失败，当前事务正在试图提交一个过期数据。通过捕捉�q�个异常�Q�我们就可以在乐观锁校验��p�|时进行相应处理�?/p>

转蝲人员�Q�Nicholas

文章来源:http://www.cnblogs.com/obpm/archive/2010/07/11/1775120.html

obpm 2010-07-11 09:58 发表评论

亚洲精品字幕在线观看,久久精品亚洲中文字幕无码麻豆,亚洲狠狠久久综合一区77777

重构实战案例一�Q�以子类取代�c�d���~�码(原创)

1. 何谓重构

1.1名词解释

1.2动词解释

2. ��Z��重构

2.4「重构」助你提高编�E�速度

3.何时重构�Q?/h1> 重构本来��׃��是一件「特别拨出时间做」的事情�Q�重构应该随旉���地进�?/span>。你不应该�ؓ重构而重构，你之所以重构，是因��Z��惛_��别的什么事�Q�而重构可以帮助你把那些事做好

3.2重构时机

4.�q�_��重构案例

4.1重构动机

4.2重构作法

5.�l�语

6.其他

Hibernate的乐观锁与�?zh��n)�观�?转蝲)

重构实战案例一�Q�以子类取代�c�d��~�码(原创)