2010年7月11日

 测试效果：

源码下载：TabbedPane.rar

发表人： Tom

在数据库层使用SQL分页可以很大程度增加平台系统程序运行速度与效率。本人只是初入手半数据库半程序的开发，所以对数据库研究不深。于是要收集下列代码以作参考，同时也Post出来可以让需要的人参考一下，高手就请见笑了。说转载说不上，说原创也... 国庆期间在家家里的机子跑DB比较困难，做不了过多测试。不过语句或函数方面本人都仔细看过抄回来的SQL的网页里示例，感觉基本上大同小异，如果有错误查下做相应的修改或百度Google一下应该没什么大问题，也请多多包涵。当然，有机会就会对下列SQL做测试，然后会进行修正。至于每个数据库分页在这就不进行深究，只是列出个可用的方法。

##########
# MySQL#
##########

select * from tlk_buginfo limit startPos, pageSize

startPos: 定义当前页起始位置(不包括startPos)
pageSize: 每页显示数据的条数

##########
# MSSQL#(2005的row_number，暂无2000)
##########

1、
--返回第20-40行数据
select top 20 * from (select row_number() over (order by EmployeeID) as RowNumber, * from HumanResources.Employee) TableNickname where RowNumber>=20

2、
--返回第20-40行数据
select * from (select row_number() over (order by EmployeeID) as RowNumber, * from HumanResources.Employee) TableNickname where RowNumber between 20 and 40

3、
--返回第20-40行数据
with OrderedResults as
(select *, ROW_NUMBER() OVER (order by EmployeeID) as RowNumber FROM HumanResources.Employee)
select * from OrderedResults where RowNumber between 20 and 40

##########
# Oracle#
##########

①采用rownum关键字(三层嵌套)
--返回第5-15行数据
select * from (select row_.*, rownum num from (select * from tlk_buginfo) row_ where rownum<=15) where num>=5

②采用row_number解析函数进行分页(效率更高)
--返回第5-15行数据
select tab.* from (select t.*, row_number() over (order by lastmodified) as num from tlk_buginfo t) tab where num between 5 and 15

##########
# DB2#
##########

select * from (select *, rownumber() over(order by 排序字段 asc ) as rowid  from 表名 )as a where a.rowid >= startPage AND a.rowid <endPage

##########
# Hsqldb#
##########

select LIMIT 0 10 表名

HTML5写的例子(IE9或google浏览器才有效果)：
 

Google Gravity
http://mrdoob.com/projects/chromeexperiments/google_gravity/

BallDropping
http://balldroppings.com/js/

Animated Harmonograph
http://hernan.amiune.com/labs/harmonograph/animated-harmonograph.html

Canopy
http://onecm.com/projects/canopy/

Ball Pool
http://mrdoob.com/projects/chromeexperiments/ball_pool/

Browser Ball
http://experiments.instrum3nt.com/markmahoney/ball/parent.html

Wavy Scrollbars
http://the389.com/experiment/

Twitch
http://reas.com/twitch/window0.html

Colorscube
http://www.canvasdemos.com/2009/04/03/colorscube/

InterNetris
http://internetris.net/

CanvasPaint
http://canvaspaint.org/

HTML5学习资料：

http://www.chinabyte.com/bang/html5/

收集资料:(denny)

权限分析文档

基于RBAC的权限设计模型：

1 RBAC 介绍

RBAC 模型作为目前最为广泛接受的权限模型。

NIST （The National Institute of Standards and Technology，美国国家标准与技术研究院）标准RBAC模型由4个部件模型组成，这4个部件模型分别是基本模型RBAC0（Core RBAC）、角色分级模型RBAC1（Hierarchal RBAC）、角色限制模型RBAC2（Constraint RBAC）和统一模型RBAC3（Combines RBAC）^[1]。RBAC0模型如图1所示。

图表 1 RBAC 0 模型

l RBAC0 定义了能构成一个RBAC控制系统的最小的元素集合

在RBAC之中,包含用户users(USERS)、角色roles(ROLES)、目标objects(OBS)、操作operations(OPS)、许可权permissions(PRMS)五个基本数据元素，权限被赋予角色,而不是用户，当一个角色被指定给一个用户时，此用户就拥有了该角色所包含的权限。会话sessions是用户与激活的角色集合之间的映射。RBAC0与传统访问控制的差别在于增加一层间接性带来了灵活性，RBAC1、RBAC2、RBAC3都是先后在RBAC0上的扩展。

l RBAC1 引入角色间的继承关系

角色间的继承关系可分为一般继承关系和受限继承关系。一般继承关系仅要求角色继承关系是一个绝对偏序关系，允许角色间的多继承。而受限继承关系则进一步要求角色继承关系是一个树结构。

l RBAC2 模型中添加了责任分离关系

RBAC2 的约束规定了权限被赋予角色时,或角色被赋予用户时,以及当用户在某一时刻激活一个角色时所应遵循的强制性规则。责任分离包括静态责任分离和动态责任分离。约束与用户-角色-权限关系一起决定了RBAC2模型中用户的访问许可。

l RBAC3 包含了RBAC1和RBAC2

既提供了角色间的继承关系，又提供了责任分离关系。

建立角色定义表。定出当前系统中角色。

因为有继承的问题，所以角色体现出的是一个树形结构。

2 权限设计：

配置资源以及资源的操作 ： 这里资源可以定义为一个通用的资源模型。提供通用的资源统一接口。

数据库 ER 图：

关系图：

3 分析：

根据以上的类关系图和ER图可以看出。整个权限可以抽象为五个对象组成。

OrgBean : 用于描述org模型。

Role ： 用于描述角色。

Permission ： 用于描述权限。

Resource ： 用于描述资源。

Operation ： 用于描述操作。

其中Permission中有Resource , Operation 的聚合，资源和操作组成权限。

Role 和 Permission 都有自包含。因为设计到权限的继承。

资源Resource 也可能出现一颗树形结构，那资源也要有自包含。

思想 :

权限系统的核心由以下三部分构成： 1. 创造权限， 2. 分配权限， 3. 使用权限，然后，系统各部分的主要参与者对照如下： 1. 创造权限 -Creator 创造， 2. 分配权限 - Administrator 分配， 3. 使用权限 - User ：

1. Creator 创造 Privilege ， Creator 在设计和实现系统时会划分，一个子系统或称为模块，应该有哪些权限。这里完成的是 Privilege 与Resource 的对象声明，并没有真正将 Privilege 与具体 Resource 实例联系在一起，形成 Operator 。

2. Administrator 指定 Privilege 与 Resource Instance 的关联 。在这一步， 权限真正与资源实例联系到了一起， 产生了 Operator （Privilege Instance ）。 Administrator 利用 Operator 这个基本元素，来创造他理想中的权限模型。如，创建角色，创建用户组，给用户组分配用户，将用户组与角色关联等等 ... 这些操作都是由 Administrator 来完成的。

3. User 使用 Administrator 分配给的权限去使用各个子系统。 Administrator 是用户，在他的心目中有一个比较适合他管理和维护的权限模型。于是，程序员只要回答一个问题，就是什么权限可以访问什么资源，也就是前面说的 Operator 。程序员提供 Operator 就意味着给系统穿上了盔甲。 Administrator 就可以按照他的意愿来建立他所希望的权限框架 可以自行增加，删除，管理 Resource 和 Privilege 之间关系。可以自行设定用户 User 和角色 Role 的对应关系。 ( 如果将 Creator 看作是 Basic 的发明者， Administrator 就是 Basic 的使用者，他可以做一些脚本式的编程 ) Operator 是这个系统中最关键的部分，它是一个纽带，一个系在 Programmer ， Administrator ， User 之间的纽带。

4 权限API

getPermissionByOrgGuid(String orgGuid )

通过传入一个org的Guid ， 拿到当前这个org对象都具有那些访问权限。

getSourcePermissionByOrgGuid(String orgGuid , String resouceGuid)

通过传入一个org的Guid 和 一个资源的Guid ， 返回改Org对当前这个资源的访问权限。

getPermissionByResourceGuid(String resource)

通过传入一个资源的Guid ， 得到当前资源下都有那些权限定义。

havingHeritPermission(String orgGuid , String resouceGuid) : Boolean

传入一个orgGuid， 资源GUID ，查看改OrgGuid下对资源是否有向下继承的权限。这里继承是资源的继承。即对父栏目有权限，可以继承下去对父栏目下的子栏目同样有权限。

havingPermission(String orgGuid , String resourceGuid) : Boolean

判断某Org对某一资源是否用权限。

以上是粗粒度的权限API 。 以下为细粒度的权限：

getOperationByPermission(String permissionGuid)

通过permission 的Guid 得到该permission 的所有有效操作。

getOperationByGuid(String permissionGuid , String resourceGuid)

通过permision的Guid ， 资源的Guid 得到该资源下所有的有效操作。

screeningOpreationByGuid (String permissionGuid , String resourceGuid , String orgGuid)

通过permission ， resource ， org的Guid 得到改Org对这一资源的有效操作。

hasOperation(String operationGuid) : boolean

通过传入的operationGuid 返回是否具有操作权限。

5 权限的实现：

1 ．表单式认证，这是常用的，但用户到达一个不被授权访问的资源时， Web 容器就发

出一个 html 页面，要求输入用户名和密码。

2 ．用 Filter 防止用户访问一些未被授权的资源， Filter 会截取所有 Request/Response ，

然后放置一个验证通过的标识在用户的 Session 中，然后 Filter 每次依靠这个标识来决定是否放行 Response 。

这个模式分为：

Gatekeeper ：采取 Filter 或统一 Servlet 的方式。

Authenticator ： 在 Web 中使用 JAAS 自己来实现。

Filter 拦截只是拦截该用户是否有访问这个页面，或这一资源的权限。真正做到显示后拦截是在应用程序内部去做。

做显示拦截提供API ， 标签这两种方式

转载人员：Happy

原文地址 http://blog.csdn.net/huanghanzzz2006/archive/2006/12/04/1429666.aspx

flex4帮助文档大小有34M(网页版)，上传不了。需要该文档的，请留下你的邮箱地址。
115共享地址：
http://u.115.com/file/f8c22d4e48
flex4api.zip   提取码：f8c22d4e48


原创人员：denny

java代码：

源码: flex图片剪切示例

原创人员：Denny

功能：在线拍照
简介：用flex与java结合实现在线拍照
需求：为了满足希望通过摄像头拍照的图片，然后通过服务器来展示需要
效果：
            后台： 

            前台：


实现代码：
flex:

java：

源码：/Files/obpm/onlinetakephoto.rar

 原创人员：Denny

LDAP快速入门

1. LDAP简介

　　LDAP（轻量级目录访问协议，Lightweight Directory Access Protocol)是实现提供被称为目录服务的信息服务。目录服务是一种特殊的数据库系统，其专门针对读取，浏览和搜索操作进行了特定的优化。目录一般用来包含描述性的，基于属性的信息并支持精细复杂的过滤能力。目录一般不支持通用数据库针对大量更新操作操作需要的复杂的事务管理或回卷策略。而目录服务的更新则一般都非常简单。这种目录可以存储包括个人信息、web链结、jpeg图像等各种信息。为了访问存储在目录中的信息，就需要使用运行在TCP/IP 之上的访问协议—LDAP。

　　LDAP目录中的信息是是按照树型结构组织，具体信息存储在条目(entry)的数据结构中。条目相当于关系数据库中表的记录；条目是具有区别名DN （Distinguished Name）的属性（Attribute），DN是用来引用条目的，DN相当于关系数据库表中的关键字（Primary Key）。属性由类型（Type）和一个或多个值（Values）组成，相当于关系数据库中的字段（Field）由字段名和数据类型组成，只是为了方便检索的需要，LDAP中的Type可以有多个Value，而不是关系数据库中为降低数据的冗余性要求实现的各个域必须是不相关的。LDAP中条目的组织一般按照地理位置和组织关系进行组织，非常的直观。LDAP把数据存放在文件中，为提高效率可以使用基于索引的文件数据库，而不是关系数据库。类型的一个例子就是mail，其值将是一个电子邮件地址。

LDAP的信息是以树型结构存储的，在树根一般定义国家(c=CN)或域名(dc=com)，在其下则往往定义一个或多个组织 (organization)(o=Acme)或组织单元(organizational units) (ou=People)。一个组织单元可能包含诸如所有雇员、大楼内的所有打印机等信息。此外，LDAP支持对条目能够和必须支持哪些属性进行控制，这是有一个特殊的称为对象类别(objectClass)的属性来实现的。该属性的值决定了该条目必须遵循的一些规则，其规定了该条目能够及至少应该包含哪些属性。例如：inetorgPerson对象类需要支持sn(surname)和cn(common name)属性，但也可以包含可选的如邮件，电话号码等属性。

2. LDAP简称对应

1. o– organization（组织-公司）
2. ou – organization unit（组织单元-部门）
3. c - countryName（国家）
4. dc - domainComponent（域名）
5. sn – suer name（真实名称）
6. cn - common name（常用名称）

3. 目录设计

设计目录结构是LDAP最重要的方面之一。下面我们将通过一个简单的例子来说明如何设计合理的目录结构。该例子将通过Netscape地址薄来访文。假设有一个位于美国US(c=US)而且跨越多个州的名为Acme(o=Acme)的公司。Acme希望为所有的雇员实现一个小型的地址薄服务器。

　　我们从一个简单的组织DN开始：　

　　　　dn: o=Acme, c=US

　　Acme所有的组织分类和属性将存储在该DN之下，这个DN在该存储在该服务器的目录是唯一的。Acme希望将其雇员的信息分为两类：管理者(ou= Managers)和普通雇员(ou=Employees),这种分类产生的相对区别名(RDN,relative distinguished names。表示相对于顶点DN)就shi ：

　　　　dn: ou=Managers, o=Acme, c=US

　　　　dn: ou=Employees, o=Acme, c=US

　　在下面我们将会看到分层结构的组成：顶点是US的Acme，下面是管理者组织单元和雇员组织单元。因此包括Managers和Employees的DN组成为：

　　　　dn: cn=Jason H. Smith, ou=Managers, o=Acme, c=US

　　　　dn: cn=Ray D. Jones, ou=Employees, o=Acme, c=US

　　　　dn: cn=Eric S. Woods, ou=Employees, o=Acme, c=US

　　为了引用Jason H. Smith的通用名(common name )条目，LDAP将采用cn=Jason H. Smith的RDN。然后将前面的父条目结合在一起就形成如下的树型结构：

　　　　cn=Jason H. Smith

　　　　　　　　+ ou=Managers

　　　　　　　　　　　　+ o=Acme

　　　　　　　　　　　　　　　　+ c=US

　                              -> dn: cn=Jason H. Smith,ou=Managers,o=Acme,c=US

　　现在已经定义好了目录结构，下一步就需要导入目录信息数据。目录信息数据将被存放在LDIF文件中，其是导入目录信息数据的默认存放文件。用户可以方便的编写Perl脚本来从例如/etc/passwd、NIS等系统文件中自动创建LDIF文件。

　　下面的实例保存目录信息数据为testdate.ldif文件，该文件的格式说明将可以在man ldif中得到。

　　在添加任何组织单元以前，必须首先定义Acme DN：　

　　　　dn: o=Acme, c=US

　　　　objectClass: organization

　　这里o属性是必须的

　　　　o: Acme

　　下面是管理组单元的DN，在添加任何管理者信息以前，必须先定义该条目。

　　　　dn: ou=Managers, o=Acme, c=US

　　　　objectClass: organizationalUnit

这里ou属性是必须的。

ou: Managers

　　第一个管理者DN：

　　　　dn: cn=Jason H. Smith, ou=Managers, o=Acme, c=US

　　　　objectClass: inetOrgPerson

　　cn和sn都是必须的属性：

　　　　cn: Jason H. Smith

　　　　sn: Smith

　　但是还可以定义一些可选的属性：

　　　　telephoneNumber: 111-222-9999

　　　　mail: headhauncho@acme.com

　　　　localityName: Houston

　　可以定义另外一个组织单元：

　　　　dn: ou=Employees, o=Acme, c=US

　　　　objectClass: organizationalUnit

　　　　ou: Employees

　　并添加雇员信息如下：

　　　　dn: cn=Ray D. Jones, ou=Employees, o=Acme, c=US

　　　　objectClass: inetOrgPerson

　　　　cn: Ray D. Jones

　　　　sn: Jones

　　　　telephoneNumber: 444-555-6767

　　　　mail: jonesrd@acme.com

　　　　localityName: Houston

　　　　dn: cn=Eric S. Woods, ou=Employees, o=Acme, c=US

　　　　objectClass: inetOrgPerson

　　　　cn: Eric S. Woods

　　　　sn: Woods

　　　　telephoneNumber: 444-555-6768

　　　　mail: woodses@acme.com

　　　　localityName: Houston

4. 配置OpenLDAP

本文实践了在 Windows 下安装配 openldap，并添加一个条目，LdapBrowser 浏览，及 Java 程序连接 openldap 的全过程。

1. 下载安装 openldap for windows，当前版本2.2.29下载地址：http://download.bergmans.us/openldap/openldap-2.2.29/openldap-2.2.29-db-4.3.29-openssl-0.9.8a-win32_Setup.exe

    相关链接：http://lucas.bergmans.us/hacks/openldap/

   安装很简单，一路 next 即可，假设我们安装在 c:\openldap

2. 配置 openldap，编辑 sldap.conf 文件

   1) 打开 c:\openldap\sldap.conf，找到

    include  C:/openldap/etc/schema/core.schema，在它后面添加

    include  C:/openldap/etc/schema/cosine.schema

    include  C:/openldap/etc/schema/inetorgperson.schema

    接下来的例子只需要用到以上三个 schema，当然，如果你觉得需要的话，你可以把其他的 schema 全部添加进来

    include  C:/openldap/etc/schema/corba.schema

    include  C:/openldap/etc/schema/dyngroup.schema

    include  C:/openldap/etc/schema/java.schema

    include  C:/openldap/etc/schema/misc.schema

    include  C:/openldap/etc/schema/nis.schema

    include  C:/openldap/etc/schema/openldap.schema

   2) 还是在 sldap.conf 文件中，找到

    suffix  "dc=my-domain,dc=com"

    rootdn  "cn=Manager,dc=my-domain,dc=com"

    把这两行改为

    suffix "o=teemlink,c=cn" 

    rootdn "cn=Manager,o=teemlink,dc=cn"

    suffix 就是看自己如何定义了，后面步骤的 ldif 文件就必须与它定义了。还要注意到这个配置文件中有一个 rootpw  secret，这个 secret 是 cn=Manager 的密码，以后会用到，不过这里是明文密码，你可以用命令： slappasswd -h {MD5} -s secret 算出加密的密码 {MD5}Xr4ilOzQ4PCOq3aQ0qbuaQ== 取代配置中的 secret。

3. 启动 openldap

    CMD 进入到 c:\openldap 下，运行命令 sldapd -d 1

    用可以看到控制台下打印一片信息，openldap 默认是用的 Berkeley DB 数据库存储目录数据的。

4. 建立条目,编辑导入 ldif 文件

   1) 新建一个 ldif(LDAP Data Interchanged Format) 文件(纯文本格式)，例如 test.ldif，文件内容如下：

dn: o=teemlink

objectclass: top

objectclass: organization

o: develop

   2) 执行命令：ldapadd -l test.ldif

5. 使用LDAP Browser进行访问

       5.1安装LDAP Browser2.6软件，进行如下操作：

5.2显示效果

5. Java操作LDAP

5.1 用JNDI进访问

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("认证失败");

} catch (Exception e) {

System.out.println("认证出错：");

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进访问

访问地址：http://www.openldap.org/jldap/ 并下载相关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进访问

访问地址：http://www.openldap.org/jdbcldap/ 并下载相关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();

}

}

原创人员：Nicholas

以子类取代类型编码

 Replace Type Code with Subclasses

1. 何谓重构

1.1名词解释

　　对软件内部结构的㆒种调整，目的是在不改变「软件之可察行为」前提下，提高其可理解性，降低其修改成本。

1.2动词解释

　　使用一系列重构准则（手法），在不改变「软件之可察行为」前提下，调整其结构。

2. 为何重构

2.1「重构」改进软件设计

　　同样完成一件事，设计不良的程序往往需要更多代码，这常常是因为代码在不同的地方使用完全相同的语句做同样的事。因此改进设计的一个重要方向就是消除重复代码（Duplicate Code）

2.2「重构」使软件更易被理解

　　你的源码还有其它读者：数个月之后可能会有另一位程序员尝试读懂你的代码并做一些修改。我们很容易忘记这第二位读者，但他才是最重要的。计算器是否多花了数个钟头进行编译，又有什么关系呢？如果一个程序员花费一周时间来修改某段代码，那才关系重大— 如果他理解你的代码，这个修改原本只需一小时

2.3「重构」助你找到臭虫 （ bugs）

　　Kent Beck 经常形容自己的㆒句话：『我不是个伟大的程序员；我只是个有着㆒些优秀习惯的好程序员而已。』重构能够帮助我更有效地写出强固稳健（robust）的代码。 

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

　　终于，前面的一切都归结到了这最后一点：重构帮助你更快速地开发程序。听起来有违反直觉。当我谈到重构，人们很容易看出它能够提高质量。改善设计、提升可读性、减少错误，这些都是提高质量。但这难道不会降低开发速度吗？我强烈相信：良好设计是快速软件开发的根本。事实上拥有良好设计才可能达成快速的开发。如果没有良好设计，或许某一段时间内你的进展迅速，但恶劣的设计很快就让你的速度慢下来。你会把时间花在调试上面，无法添加新功能。修改时间愈来愈长，因为你必须花愈来愈多的时间去理解系统、寻找重复代码。随着你给最初程序打上一个又一个的补丁（patch），新特性需要更多代码才能实现。真是个恶性循环。

3.何时重构？

　　重构本来就不是一件「特别拨出时间做」的事情，重构应该随时随地进行。你不应该为重构而重构，你之所以重构，是因为你想做别的什么事，而重构可以帮助你把那些事做好

3.1三次法则（The Rule of Three）

　　Don Roberts 给了我一条准则：第一次做某件事时只管去做；第二次做类似的事会产生反感，但无论如何还是做了；第三次再做类似的事，你就应该重构。

　　☆ 事不过三，三则重构。（Three strikes and you refactor.）

3.2重构时机

　　添加功能时一并重构

　　修补错误时一并重构

　　复审代码时一并重构

-以上章节摘抄自《重构-改善既有代码的设计》

4.平台重构案例

4.1重构动机

　　1. 实例模块为View，重构元素为ViewAction、ViewProcessBean、View，以下为关系图。

　　2. 由于View存在多种editMode（编辑模式），而每个调用的地方都需要进行type code（类型码）判断，然后再进行相应的业务逻辑处理，最终在每个调用的地方都形成了大量的if-else代码，大大减弱了代码的可读性，和逻辑清晰度。

　　3. 调用的地方：

4.2重构作法

如上图所示，将每种type code重构成subclass，加强了每种类型处理业务逻辑的能力。

View-版本1566代码片段：

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);
}

说明：调用者无需了解具体的类型，由View自身作判断，返回EditMode接口，从而实现多态调用。

ViewProcessBean代码片段：

重构前-版本1503：

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：

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

5.结语

　　由上述案例可看到，引入subclass代替type code可以大大减少if-else判断，而且可以把责任内聚到每种type中，使代码结构更清晰易懂。

6.其他

       在本案例中引入了空类型概念，即NullEditMode，代码如下：

/**
 * 
 * @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;
    }
}

说明：空类型保证了调用每个方法都有默认值返回，而不需要进行非空判断，当View没有类型时，即返回默认的空类型

原创人员：Nicholas

不会画流程图的，看了这个就懂了，绝对经典！

转载人员：Nicholas

obpm一键生成视图功能原理

在obpm系统后台表单右上角有一个“一键生成视图”功能。实现它的真正目的是为了后台管理人员方便从实现好的表单中快速生成所有带值的列的视图。这样管理人员就不需要手工新建视图，然后再添加视图中的带值的列。

实现原理图：

在实现原理图中，我们发现没有视图中并没有不带值Field4相应的Column4在视图中，这是因为在视图中是要根据不同Column显示不同的值的。如果Column是不带值的话，那么视图中就不应该要这个Column,即使是要了，在视图中没有意义了。

实现原理代码：

其中代码路径是：src-java-cn-myapps-core-dynaform-form-ejb-FormProcessBean.java

/**

     * 根据表单编号来生成视图

     * @param formid 表单编号

     * @throws Exception

     */

    public Form oneKeyCreateView(String formid) throws Exception {

           FormProcess formPross = (FormProcess) ProcessFactory.createProcess(FormProcess.class);

           ViewProcess viewPross = (ViewProcess) ProcessFactory.createProcess(ViewProcess.class);

           Form form = (Form) formPross.doView(formid);//获得form

           Collection formfield=form.getValueStoreFields();//获得form存储值的field

           //新建视图

           View view = new View();

           if (view.getId() == null || view.getId().trim().length() <= 0) {

              view.setId(Sequence.getSequence());//设置视图的ID

              view.setSortId(Sequence.getTimeSequence());//设置视图的排序ID     }

            view.setName(form.getName());//把表单的名字赋给视图

            view.setOpenType(view.OPEN_TYPE_NORMAL); //设置视图打开类型-普通类型

            view.setLastmodifytime(new Date());//最后修改日期

            view.setApplicationid(form.getApplicationid());//把表单应用程序Id赋给视图的应用程序Id

            view.setModule(form.getModule());//把表单模块Id赋给视图的模块ID

            view.setPagelines("10");//设置视图的分页每页显示10条数据

            view.setShowTotalRow(true); //是否显示总共条数数据

            view.setPagination(true); //是否分页显示

            view.setRelatedForm(form.getId());//把表单ID赋给视图的映射表单，从而映射了该表单

            //将表单中对应有值的列转换为视图的列

            int i=0;

           for(Iterator iterator=formfield.iterator();iterator.hasNext();){

              FormField field=(FormField)iterator.next();

              Column column = new Column();

              if (column.getId() == null || column.getId().trim().length() <= 0) {

              column.setId(Sequence.getSequence());

              column.setOrderno(i);

              }

              if(field.getDiscript()!=null && !field.getDiscript().equals("")){//如果该表单中带值Field有描述的话，就作为视图Column,否则的用Field名称

              column.setName(field.getDiscript());

                  }else{

              column.setName(field.getName());

                  }

              column.setFormid(form.getId());//把表单中的ID赋给Column的表单ID

              column.setApplicationid(form.getApplicationid());//把表单中应用程序的ID赋给Column的表单应用程序ID

              column.setFieldName(field.getName());  //把表单中的名称赋给Column的表单名称

              column.setParentView(view.getId());//将视图ID赋给Column的父视图

              view.getColumns().add(column); //将视图和Column关联

              i++;

           }

           //分别创建两个按钮  新建，删除

           Activity activityCreate = new Activity();

           if (activityCreate.getId() == null || activityCreate.getId().trim().length() <= 0) {

              activityCreate.setId(Sequence.getSequence());

              activityCreate.setOrderno(0);

           }

           activityCreate.setApplicationid(form.getApplicationid());

           activityCreate.setName("新建");

           activityCreate.setParentView(view.getId());

           activityCreate.setType(ActivityType.DOCUMENT_CREATE);

           activityCreate.setOnActionForm(form.getId());

           view.getActivitys().add(activityCreate); //将视图和新建按钮关联

           Activity activityDelete = new Activity();

           if (activityDelete.getId() == null || activityDelete.getId().trim().length() <= 0) {

              activityDelete.setId(Sequence.getSequence());

              activityDelete.setOrderno(1);

           }

           activityDelete.setApplicationid(form.getApplicationid());

           activityDelete.setName("删除");

           activityDelete.setParentView(view.getId());

           activityDelete.setType(ActivityType.DOCUMENT_DELETE);

           view.getActivitys().add(activityDelete); //将视图和删除按钮关联

           viewPross.doCreate(view); //创建视图

            return form;

    }

后台效果图：

表单：

视图：

视图列：

视图按钮：

前台效果：

视图：

表单：

原创人员：Denny

锁（ locking ）
业务逻辑的实现过程中，往往需要保证数据访问的排他性。如在金融系统的日终结算处理中，我们希望针对某个 cut-off 时间点的数据进行处理，而不希望在结算进行过程中（可能是几秒种，也可能是几个小时），数据再发生变化。此时，我们就需要通过一些机制来保证这些数据在某个操作过程中不会被外界修改，这样的机制，在这里，也就是所谓的 “锁” ，即给我们选定的目标数据上锁，使其无法被其他程序修改。Hibernate 支持两种锁机制：即通常所说的 “悲观锁（ Pessimistic Locking ）”和 “乐观锁（ Optimistic Locking ）” 。

悲观锁（ Pessimistic Locking ）
悲观锁，正如其名，它指的是对数据被外界（包括本系统当前的其他事务，以及来自外部系统的事务处理）修改持保守态度，因此，在整个数据处理过程中，将数据处于锁定状态。悲观锁的实现，往往依靠数据库提供的锁机制（也只有数据库层提供的锁机制才能真正保证数据访问的排他性，否则，即使在本系统中实现了加锁机制，也无法保证外部系统不会修改数据）。
一个典型的倚赖数据库的悲观锁调用：
select * from account where name=”Erica” for update
这条 sql 语句锁定了 account 表中所有符合检索条件（name=”Erica”）的记录。本次事务提交之前（事务提交时会释放事务过程中的锁），外界无法修改这些记录。Hibernate 的悲观锁，也是基于数据库的锁机制实现。
下面的代码实现了对查询记录的加锁：
String hqlStr ="from TUser as user where user.name='Erica'";
Query query = session.createQuery(hqlStr);
query.setLockMode("user",LockMode.UPGRADE); // 加锁
List userList = query.list();// 执行查询，获取数据
query.setLockMode 对查询语句中，特定别名所对应的记录进行加锁（我们为TUser 类指定了一个别名 “user” ），这里也就是对返回的所有 user 记录进行加锁。
观察运行期 Hibernate 生成的 SQL 语句：
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
这里 Hibernate 通过使用数据库的 for update 子句实现了悲观锁机制。
Hibernate 的加锁模式有：
LockMode.NONE ： 无锁机制。
LockMode.WRITE ： Hibernate 在 Insert 和 Update 记录的时候会自动获取。
LockMode.READ ： Hibernate 在读取记录的时候会自动获取。
以上这三种锁机制一般由 Hibernate 内部使用，如 Hibernate 为了保证 Update过程中对象不会被外界修改，会在 save 方法实现中自动为目标对象加上 WRITE 锁。
LockMode.UPGRADE ：利用数据库的 for update 子句加锁。
LockMode. UPGRADE_NOWAIT ： Oracle 的特定实现，利用 Oracle 的 for update nowait 子句实现加锁。
上面这两种锁机制是我们在应用层较为常用的，加锁一般通过以下方法实现：
Criteria.setLockMode
Query.setLockMode
Session.lock
注意，只有在查询开始之前（也就是 Hiberate 生成 SQL 之前）设定加锁，才会真正通过数据库的锁机制进行加锁处理，否则，数据已经通过不包含 for update 子句的 Select SQL 加载进来，所谓数据库加锁也就无从谈起。

乐观锁（ Optimistic Locking ）
相对悲观锁而言，乐观锁机制采取了更加宽松的加锁机制。悲观锁大多数情况下依靠数据库的锁机制实现，以保证操作最大程度的独占性。但随之而来的就是数据库性能的大量开销，特别是对长事务而言，这样的开销往往无法承受。
如一个金融系统，当某个操作员读取用户的数据，并在读出的用户数据的基础上进行修改时如更改用户帐户余额），如果采用悲观锁机制，也就意味着整个操作过程中（从操作员读出数、开始修改直至提交修改结果的全过程，甚至还包括操作员中途去煮咖啡的时间），数据库记录始终处于加锁状态，可以想见，如果面对几百上千个并发，这样的情况将导致怎样的后果。乐观锁机制在一定程度上解决了这个问题。乐观锁，大多是基于数据版本（ Version ）记录机制实现。何谓数据版本？即为数据增加一个版本标识，在基于数据库表的版本解决方案中，一般是通过为数据库表增加一个 “version” 字段来实现。
读取出数据时，将此版本号一同读出，之后更新时，对此版本号加一。此时，将提交数据的版本数据与数据库表对应记录的当前版本信息进行比对，如果提交的数据版本号大于数据库表当前版本号，则予以更新，否则认为是过期数据。
对于上面修改用户帐户信息的例子而言，假设数据库中帐户信息表中有一个version 字段，当前值为 1 ；而当前帐户余额字段（balance）为 $100 。
1 操作员 A 此时将其读出（version=1），并从其帐户余额中扣除 $50（$100-$50）。
2 在操作员 A 操作的过程中，操作员 B 也读入此用户信息（version=1），并从其帐户余额中扣除 $20 （$100-$20）。
3 操作员 A 完成了修改工作，将数据版本号加一（version=2），连同帐户扣除后余额（balance=$50），提交至数据库更新，此时由于提交数据版本大于数据库记录当前版本，数据被更新，数据库记录 version 更新为 2 。
4 操作员 B 完成了操作，也将版本号加一（version=2）试图向数据库提交数据（balance=$80），但此时比对数据库记录版本时发现，操作员 B 提交的数据版本号为 2 ，数据库记录当前版本也为 2 ，不满足“ 提交版本必须大于记录当前版本才能执行更新“ 的乐观锁策略，因此，操作员 B 的提交被驳回。这样，就避免了操作员 B 用基于 version=1 的旧数据修改的结果覆盖操作员 A 的操作结果的可能。
从上面的例子可以看出，乐观锁机制避免了长事务中的数据库加锁开销（操作员 A 和操作员 B 操作过程中，都没有对数据库数据加锁），大大提升了大并发量下的系统整体性能表现。需要注意的是，乐观锁机制往往基于系统中的数据存储逻辑，因此也具备一定的局限性，如在上例中，由于乐观锁机制是在我们的系统中实现，来自外部系统的用户余额更新操作不受我们系统的控制，因此可能会造成脏数据被更新到数据库中。在系统设计阶段，我们应该充分考虑到这些情况出现的可能性，并进行相应调整（如将乐观锁策略在数据库存储过程中实现，对外只开放基于此存储过程的数据更新途径，而不是将数据库表直接对外公开）。
Hibernate 在其数据访问引擎中内置了乐观锁实现。如果不用考虑外部系统对数据库的更新操作，利用 Hibernate 提供的透明化乐观锁实现，将大大提升我们的生产力。
Hibernate 中可以通过 class 描述符的 optimistic-lock 属性结合 version描述符指定。

现在，我们为之前示例中的 TUser 加上乐观锁机制。
1 ． 首先为 TUser 的 class 描述符添加 optimistic-lock 属性：
<hibernate-mapping>
<class name="org.hibernate.sample.TUser" table="t_user" dynamic-update="true"
dynamic-insert="true" optimistic-lock="version">
……
</class>
</hibernate-mapping>
optimistic-lock 属性有如下可选取值： 
none：无乐观锁 
version：通过版本机制实现乐观锁
dirty：通过检查发生变动过的属性实现乐观锁
all：通过检查所有属性实现乐观锁
其中通过 version 实现的乐观锁机制是 Hibernate 官方推荐的乐观锁实现，同时也是 Hibernate 中，目前唯一在数据对象脱离 Session 发生修改的情况下依然有效的锁机制。因此，一般情况下，我们都选择 version 方式作为 Hibernate 乐观锁实现机制。
2 ． 添加一个 Version 属性描述符
<hibernate-mapping>
<class name="org.hibernate.sample.TUser" table="t_user" dynamic-update="true" dynamic-insert="true"
optimistic-lock="version">
<id name="id" column="id" type="java.lang.Integer">
<generator class="native">
</generator>
</id>
<version column="version" name="version" type="java.lang.Integer"/>
……
</class>
</hibernate-mapping>
注意 version 节点必须出现在 ID 节点之后。这里我们声明了一个 version 属性，用于存放用户的版本信息，保存在 TUser 表的version 字段中。
此时如果我们尝试编写一段代码，更新 TUser 表中记录数据，如：
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 进行更新的时候，我们可以发现，数据库中的 version 都在递增。而如果我们尝试在 tx.commit 之前，启动另外一个 Session ，对名为 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();
执行以上代码，代码将在 tx.commit() 处抛出 StaleObjectStateException 异常，并指出版本检查失败，当前事务正在试图提交一个过期数据。通过捕捉这个异常，我们就可以在乐观锁校验失败时进行相应处理。

转载人员：Nicholas