jmut的博客

草榴社区

-草榴社区最新网址,caoliushequ,草榴,t66y,草榴论坛,草榴社区最新IP地址,免费草榴社区注册邀请码. 草榴社区是一个完全免费的成人资源发布站，即使不注册不登陆也能自由的浏览和下载草榴所有的资源！

- 作者： jmut 2010年02月4日, 星期四 00:30　回复（0） |　引用（0）加入博采

hibernate的各种保存方式的区别 (save,persist,update,saveOrUpdte,merge,flush,lock)等

fromhttp://www.blogjava.net/dreamstone/archive/2007/07/29/133071.html

hibernate的保存
hibernate对于对象的保存提供了太多的方法，他们之间有很多不同，这里细说一下，以便区别：
一、预备知识：
在所有之前，说明一下，对于hibernate，它的对象有三种状态，transient、persistent、detached
下边是常见的翻译办法：
transient：瞬态或者自由态
persistent：持久化状态
detached：脱管状态或者游离态

脱管状态的实例可以通过调用save()、persist()或者saveOrUpdate()方法进行持久化。
持久化实例可以通过调用 delete()变成脱管状态。通过get()或load()方法得到的实例都是持久化状态的。
脱管状态的实例可以通过调用 update()、0saveOrUpdate()、lock()或者replicate()进行持久化。

save()和persist()将会引发SQL的INSERT，delete()会引发SQLDELETE，
而update()或merge()会引发SQLUPDATE。对持久化（persistent）实例的修改在刷新提交的时候会被检测到，
它也会引起SQLUPDATE。saveOrUpdate()或者replicate()会引发SQLINSERT或者UPDATE

二、save 和update区别
把这一对放在第一位的原因是因为这一对是最常用的。
save的作用是把一个新的对象保存
update是把一个脱管状态的对象保存

三,update 和saveOrUpdate区别
这个是比较好理解的，顾名思义，saveOrUpdate基本上就是合成了save和update
引用hibernate reference中的一段话来解释他们的使用场合和区别
通常下面的场景会使用update()或saveOrUpdate()：
程序在第一个session中加载对象
该对象被传递到表现层
对象发生了一些改动
该对象被返回到业务逻辑层
程序调用第二个session的update()方法持久这些改动

saveOrUpdate()做下面的事:
如果对象已经在本session中持久化了，不做任何事
如果另一个与本session关联的对象拥有相同的持久化标识(identifier)，抛出一个异常
如果对象没有持久化标识(identifier)属性，对其调用save()
如果对象的持久标识(identifier)表明其是一个新实例化的对象，对其调用save()
如果对象是附带版本信息的（通过<version>或<timestamp>）并且版本属性的值表明其是一个新实例化的对象，save()它。
否则update() 这个对象

四,persist和save区别
这个是最迷离的一对，表面上看起来使用哪个都行，在hibernate reference文档中也没有明确的区分他们.
这里给出一个明确的区分。（可以跟进src看一下，虽然实现步骤类似，但是还是有细微的差别）
这里参考http://opensource.atlassian.com/projects/hibernate/browse/HHH-1682中的一个说明：
---------------------------------------------------------------------------------
I found that a lot of people have the same doubt. To help to solve this issue
I'm quoting Christian Bauer:
"In case anybody finds this thread...

persist() is well defined. It makes a transient instance persistent. However,
it doesn't guarantee that the identifier value will be assigned to the persistent
instance immediately, the assignment might happen at flush time. The spec doesn't say
that, which is the problem I have with persist().

persist() also guarantees that it will not execute an INSERT statement if it is
called outside of transaction boundaries. This is useful in long-running conversations
with an extended Session/persistence context.A method like persist() is required.

save() does not guarantee the same, it returns an identifier, and if an INSERT
has to be executed to get the identifier (e.g. "identity" generator, not "sequence"),
this INSERT happens immediately, no matter if you are inside or outside of a transaction. This is not good in a long-running conversation with an extended Session/persistence context."

---------------------------------------------------------------------------------
简单翻译一下上边的句子的主要内容：
1，persist把一个瞬态的实例持久化，但是并"不保证"标识符被立刻填入到持久化实例中，标识符的填入可能被推迟
到flush的时间。

2，persist"保证"，当它在一个transaction外部被调用的时候并不触发一个Sql Insert，这个功能是很有用的，
当我们通过继承Session/persistence context来封装一个长会话流程的时候，一个persist这样的函数是需要的。

3，save"不保证"第2条,它要返回标识符，所以它会立即执行Sql insert，不管是不是在transaction内部还是外部

五,saveOrUpdateCopy,merge和update区别
首先说明merge是用来代替saveOrUpdateCopy的，这个详细见这里
http://www.blogjava.net/dreamstone/archive/2007/07/28/133053.html
然后比较update和merge
update的作用上边说了，这里说一下merge的
如果session中存在相同持久化标识(identifier)的实例，用用户给出的对象的状态覆盖旧有的持久实例
如果session没有相应的持久实例，则尝试从数据库中加载，或创建新的持久化实例,最后返回该持久实例
用户给出的这个对象没有被关联到session上，它依旧是脱管的
重点是最后一句：
当我们使用update的时候，执行完成后，我们提供的对象A的状态变成持久化状态
但当我们使用merge的时候，执行完成，我们提供的对象A还是脱管状态，hibernate或者new了一个B，或者检索到
一个持久对象B，并把我们提供的对象A的所有的值拷贝到这个B，执行完成后B是持久状态，而我们提供的A还是托管状态

六,flush和update区别
这两个的区别好理解
update操作的是在脱管状态的对象
而flush是操作的在持久状态的对象。
默认情况下，一个持久状态的对象是不需要update的，只要你更改了对象的值，等待hibernate flush就自动
保存到数据库了。hibernate flush发生再几种情况下：
1，调用某些查询的时候
2，transaction commit的时候
3，手动调用flush的时候

七,lock和update区别
update是把一个已经更改过的脱管状态的对象变成持久状态
lock是把一个没有更改过的脱管状态的对象变成持久状态
对应更改一个记录的内容，两个的操作不同：
update的操作步骤是：
（1）更改脱管的对象->调用update
lock的操作步骤是：
(2)调用lock把对象从脱管状态变成持久状态-->更改持久状态的对象的内容-->等待flush或者手动flush

参考内容：
http://www.blogjava.net/iamtin/archive/2006/03/06/33910.aspx
http://opensource.atlassian.com/projects/hibernate/browse/HHH-1682
http://www.redsaga.com/hibernate-ref/3.x/zh-cn/html/objectstate.html

- 作者： jmut 2009年06月3日, 星期三 23:17　回复（0） |　引用（0）加入博采

Tomcat安全域设置大全

from:http://www.wangchao.net.cn/bbsdetail_60240.html

安全域是tomcat内置的功能，在org.apache.catalina.Realm接口中声明了把一组用户名，口令及所关联的角色集成到Tomcat的方法中，Tomcat5提供了4个实现这一接口的类，它们代表了4种安全域类型。
　　下面我一一介绍其相关配置，及其应用方法。
　　运行环境：windows2000，tomcat5.0.28，jdk1.5，jdbc3.0，sqlserver2000，
　　测试目录：%tomcat%\webapps\Area目录。
　　1. 内存域：类名，MemoryRealm；在初始化阶段，从xml文件中读取安全验证信息，并把它们以一组对象的形式放在内存中。
　　对于资源访问它有三种方式：BASIC、DIGEST、FORM。使用Basic Authentication通过被认为是不安全的，因为它没有强健的加密方法，除非在客户端和服务器端都使用HTTPS或者其他密码加密码方式（比如，在一个虚拟私人网络中）。
　　配置文件%tomcat%\conf\Catalina\localhost\Area.xml为：
　　<?xml version='1.0' encoding='utf-8'?>
　　<Context docBase="D:\jakarta-tomcat-5.0.28\webapps\Area" path="/Area" reloadable="true"
　　workDir="work\Catalina\localhost\Area">
　　 <Realm className="org.apache.catalina.realm.MemoryRealm"/>
　　</Context>
　　web应用所在的WEB-INF\web.xml为：
　　<?xml version="1.0" encoding="GB2312"?>
　　<!DOCTYPE web-app
　　 PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN" "http://java.sun.com/dtd/web-app_2_3.dtd">
　　<web-app>
　　 <security-constraint>
　　 <display-name>sessiontest secruity constraint</display-name>
　　 <web-resource-collection>
　　 <web-resource-name>Protected Area</web-resource-name>
　　 <url-pattern>/test/*</url-pattern>
　　 </web-resource-collection>
　　 <auth-constraint>
　　 <role-name>cool</role-name>
　　 </auth-constraint>
　　 </security-constraint>
　　 
　　<login-config>
　　 <auth-method>BASIC</auth-method>
　　 <realm-name>Sessiontest Realm</realm-name>
　　 </login-config>
　　 
　　
　　 
　　
　　<security-role>
　　 <description> session jdbctest </description>
　　 <role-name>cool</role-name>
　　 </security-role>
　　</web-app>
　　基中<url-pattern>/test/*</url-pattern>表示受保护的资源为：http://localhost:8080/Area/test/下的所有资源。role角色cool在%tomcat%conf中的tomcat-users.xml中添加：
　　 <role rolename="cool"/>
　　 <user username="zxj1" password="zxj2" roles="cool"/>
　　2. JDBC域：类名，JDBCRealm，通过jdbc驱动程序访问存在数据库中的安全验证。
　　3. 数据源域：类名，DataSourceRealm，通过JNDI数据源访问存在数据库中的安全验证信息。
　　4. JNDI域：类名，JNDIRealm，通过JNDIproveider访问存放在基于LDAP的目录服务器中的安全验证信息。
　　时间有限，待下回编辑进行修改。

- 作者： jmut 2009年05月6日, 星期三 23:03　回复（0） |　引用（0）加入博采

(转)数据公钥加密和认证中的私钥公钥

先前我曾经写了一篇“网站的安全登录认证设计”，可能是讲述的不够清楚，有一位读者就留言质疑到，“公钥顾名思义就是公开的啦，只要你愿意，谁都会有你的公钥，何来安全？应该是用网站的公钥加密，传到网站后，网站用自己的私钥解密吧”。

　　这些密码学的概念容易被搞混淆，的确也情有可原。因为公钥、私钥、加密、认证这些都是较为复杂的问题，其概念不太容易理解，理解不透就容易产生各种似是而非的概念，为了让大家对于密码学有进一步的了解，这里我就详细解说一下公钥和私钥的具体作用和使用方法。

　　加密和认证

　　首先我们需要区分加密和认证这两个基本概念。

　　加密是将数据资料加密，使得非法用户即使取得加密过的资料，也无法获取正确的资料内容，所以数据加密可以保护数据，防止监听攻击。其重点在于数据的安全性。身份认证是用来判断某个身份的真实性，确认身份后，系统才可以依不同的身份给予不同的权限。其重点在于用户的真实性。两者的侧重点是不同的。

　　公钥和私钥

　　其次我们还要了解公钥和私钥的概念和作用。

　　在现代密码体制中加密和解密是采用不同的密钥（公开密钥），也就是非对称密钥密码系统，每个通信方均需要两个密钥，即公钥和私钥，这两把密钥可以互为加解密。公钥是公开的，不需要保密，而私钥是由个人自己持有，并且必须妥善保管和注意保密。

　　公钥私钥的原则：

一个公钥对应一个私钥。
密钥对中，让大家都知道的是公钥，不告诉大家，只有自己知道的，是私钥。
如果用其中一个密钥加密数据，则只有对应的那个密钥才可以解密。
如果用其中一个密钥可以进行解密数据，则该数据必然是对应的那个密钥进行的加密。

　　非对称密钥密码的主要应用就是公钥加密和公钥认证，而公钥加密的过程和公钥认证的过程是不一样的，下面我就详细讲解一下两者的区别。

　　基于公开密钥的加密过程

　　比如有两个用户Alice和Bob，Alice想把一段明文通过双钥加密的技术发送给Bob，Bob有一对公钥和私钥，那么加密解密的过程如下：

Bob将他的公开密钥传送给Alice。
Alice用Bob的公开密钥加密她的消息，然后传送给Bob。
Bob用他的私人密钥解密Alice的消息。

　　上面的过程可以用下图表示，Alice使用Bob的公钥进行加密，Bob用自己的私钥进行解密。

　　基于公开密钥的认证过程

　　身份认证和加密就不同了，主要用户鉴别用户的真伪。这里我们只要能够鉴别一个用户的私钥是正确的，就可以鉴别这个用户的真伪。

　　还是Alice和Bob这两个用户，Alice想让Bob知道自己是真实的Alice，而不是假冒的，因此Alice只要使用公钥密码学对文件签名发送给Bob，Bob使用Alice的公钥对文件进行解密，如果可以解密成功，则证明Alice的私钥是正确的，因而就完成了对Alice的身份鉴别。整个身份认证的过程如下：

Alice用她的私人密钥对文件加密，从而对文件签名。
Alice将签名的文件传送给Bob。
Bob用Alice的公钥解密文件，从而验证签名。

　　上面的过程可以用下图表示，Alice使用自己的私钥加密，Bob用Alice的公钥进行解密。

　　总结

　　好了，上面就详细讲述了加密、认证、公钥、私钥这四个概念，明白这些概念后，你就应该对“网站的安全登录认证设计”一文所讲述的概念有了更清晰的了解了。

转载自月光博客 [ http://www.williamlong.info/ ]

- 作者： jmut 2009年05月6日, 星期三 21:37　回复（0） |　引用（0）加入博采

AST构建Hibernat动态查询2

Java代码

package com.ayufox.framework.core.dao.hqlx.ast;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.hql.antlr.SqlTokenTypes;
import antlr.collections.AST;
import com.ayufox.framework.core.Context;
import com.ayufox.framework.core.common.CommonUtils;
import com.ayufox.framework.core.dao.hql.Hql;
import com.ayufox.framework.core.dao.hql.Parameter;
/**
* @author ray
*
*/
public class HqlCompileExecutor implements SqlTokenTypes
{
private final static Log LOG = LogFactory.getLog(HqlCompileExecutor.class);
private final static Map NODE_TYPE_MAP = new HashMap();
static
{
Field[] fields = SqlTokenTypes.class.getFields();
for (int i = 0; i < fields.length; i++)
{
Field field = fields[i];
int modifiers = field.getModifiers();
if (Modifier.isPublic(modifiers) && Modifier.isStatic(modifiers)
&& Modifier.isFinal(modifiers))
{
String name = field.getName();
try
{
Object value = field.get(null);
NODE_TYPE_MAP.put(value, name);
}
catch (IllegalAccessException ex)
{
LOG.error("Imposible", ex);
}
}
}
}
protected Hql hql;
protected List<Parameter> parameters;
protected Context context;
private AST root;
public HqlCompileExecutor(AST root, Context context)
{
init(root, context);
}
protected HqlCompileExecutor()
{
}
protected void init(AST root, Context context)
{
this.context = context;
this.root = root;
this.parameters = new ArrayList<Parameter>();
}
public Hql build()
{
if (this.hql == null)
{
String hql = buildHql();
if (LOG.isDebugEnabled())
{
LOG.debug("hql:" + hql);
for (int i = 0; i < this.parameters.size(); i++)
{
LOG.debug(" parameter[" + i + "]:name=["
+ this.parameters.get(i).getName() + "],value=["
+ this.parameters.get(i).getValue() + "]");
}
}
this.hql = new Hql(hql, this.parameters
.toArray(new Parameter[this.parameters.size()]));
}
return this.hql;
}
protected String buildHql()
{
StringBuffer buffer = new StringBuffer();
print(buffer, this.root);
return buffer.toString();
}
protected void print(StringBuffer buffer, AST ast)
{
switch (ast.getType())
{
case QUERY: //查询根节点
printChildren(buffer, ast, " ");
break;
case RANGE: //FROM根节点
printRANGE(buffer, ast);
break;
case IDENT:
case ALIAS:
case ROW_STAR: //*
case DISTINCT:
case ALL:
case NUM_INT:
case NUM_DOUBLE:
case NUM_FLOAT:
case NUM_LONG:
printText(buffer, ast);
break;
case INNER:
case OUTER:
case FULL:
case LEFT:
case RIGHT:
printText(buffer, ast);
buffer.append(" join");
break;
case JOIN:
printJOIN(buffer, ast);
break;
case FROM:
printSelfAndChildren(buffer, ast, " ");
break;
case SELECT:
printSelfAndChildren(buffer, ast, ",");
break;
case SELECT_FROM:
printSELECT_FROM(buffer, ast);
break;
case COUNT:
case AGGREGATE: //聚合函数
printFunction(buffer, ast);
break;
case DOT: //.
printDOT(buffer, ast);
break;
case AND:
case OR:
printLinkWord(buffer, ast);
break;
case WHERE:
printWhere(buffer, ast);
break;
case CONSTRUCTOR:
printCONSTRUCTOR(buffer, ast);
break;
case LIKE:
case NOT_LIKE:
case EQ:
case GT:
case GE:
case LT:
case LE:
case IN:
case NOT_IN:
printCondition(buffer, ast);
break;
case BETWEEN:
case NOT_BETWEEN:
printBETWEEN(buffer, ast);
break;
case IN_LIST: //in
printInList(buffer, ast);
break;
case COLON: //:
printCOLON(buffer, ast);
break;
case ORDER:
printORDER(buffer, ast);
break;
case GROUP:
buffer.append("group by ");
printChildren(buffer, ast, ",");
break;
case ASCENDING:
case DESCENDING:
printText(buffer, ast);
break;
default:
LOG.warn("Incognizance node, type["
+ NODE_TYPE_MAP.get(ast.getType()) + "("
+ ast.getType() + ")] text[" + ast.getText() + "]");
}
}
protected void printCONSTRUCTOR(StringBuffer buffer, AST ast)
{
buffer.append("new ");
AST constructor = ast.getFirstChild();
print(buffer, constructor);
buffer.append('(');
AST next = constructor.getNextSibling();
while (next != null)
{
if (buffer.charAt(buffer.length()-1) != '(')
{
buffer.append(',');
}
print(buffer, next);
next = next.getNextSibling();
}
buffer.append(')');
}
protected void printORDER(StringBuffer buffer, AST ast)
{
buffer.append("order by ");
AST child = ast.getFirstChild();
AST next = null;
while (child != null)
{
print(buffer, child);
next = child.getNextSibling();
if (next != null)
{
if (next.getType() == DESCENDING || next.getType() == ASCENDING)
{
buffer.append(" ");
}
else
{
buffer.append(",");
}
}
child = next;
}
}
protected void printRANGE(StringBuffer buffer, AST ast)
{
printChildren(buffer, ast, " ");
AST next = ast.getNextSibling();
if (next != null && next.getType() == RANGE)
{
buffer.append(",");
}
}
protected void printInList(StringBuffer buffer, AST ast)
{
buffer.append("(");
printChildren(buffer, ast, "");
buffer.append(")");
}
protected void printWhere(StringBuffer buffer, AST ast)
{
//where节点下只有一个子节点
int length = buffer.length();
AST child = ast.getFirstChild();
print(buffer, child);
if (buffer.length() > length)
{
buffer.insert(length, ast.getText() + " ");
}
}
/*
* 连接词，即and和or
*/
protected void printLinkWord(StringBuffer buffer, AST ast)
{
int sourceLength = buffer.length();
AST left = ast.getFirstChild();
AST right = left.getNextSibling();
print(buffer, left);
int middleLength = buffer.length();
print(buffer, right);
int allLength = buffer.length();
//or/and的左表达式和右表达式都存在，需要加上括号和连接词
if ((allLength > middleLength) && (middleLength > sourceLength))
{
buffer.insert(sourceLength, "(");
buffer.insert(middleLength + 1, " " + ast.getText() + " ");
buffer.append(")");
}
}
/*
* :
*/
protected void printCOLON(StringBuffer buffer, AST ast)
{
int length = buffer.length();
printChildren(buffer, ast, "");
String name = buffer.substring(length, buffer.length()).replace('_',
'.');
Object value = context.get(name);
if (CommonUtils.isEmpty(value))
{
throw new ValueNotExistException(name);
}
buffer.insert(length, ast.getText());
this.parameters.add(new Parameter(name, value));
}
protected void printText(StringBuffer buffer, AST ast)
{
buffer.append(ast.getText());
}
/*
* 函数，如avg(..)、count(...)等
*/
protected void printFunction(StringBuffer buffer, AST ast)
{
buffer.append(ast.getText());
buffer.append("(");
printChildren(buffer, ast, " ");
buffer.append(")");
}
/*
* .
*/
protected void printDOT(StringBuffer buffer, AST ast)
{
AST left = ast.getFirstChild();
print(buffer, left);
buffer.append(ast.getText());
AST right = left.getNextSibling();
print(buffer, right);
}
/*
* 打印所有子节点
* @param buffer 结果输出为止
* @param ast AST树
* @param join 子节点间连接符
*/
protected void printChildren(StringBuffer buffer, AST ast, String join)
{
AST child = ast.getFirstChild();
while (child != null)
{
print(buffer, child);
child = child.getNextSibling();
if (child != null)
{
buffer.append(join);
}
}
}
/*
* 打印自身，然后再打印子节点
* @param buffer
* @param ast
* @param join
* @param selfJoin
*/
protected void printSelfAndChildren(StringBuffer buffer, AST ast,
String join)
{
buffer.append(ast.getText());
buffer.append(" ");
printChildren(buffer, ast, join);
}
/*
* join
*/
protected void printJOIN(StringBuffer buffer, AST ast)
{
int length = buffer.length();
printChildren(buffer, ast, " ");
if (!buffer.substring(length, buffer.length()).contains(ast.getText()))
{
buffer.insert(length, "join ");
}
}
protected void printSELECT_FROM(StringBuffer buffer, AST ast)
{
AST from = ast.getFirstChild();
AST select = from.getNextSibling();
if (select != null)
{
print(buffer, select);
buffer.append(" ");
}
print(buffer, from);
}
protected void printBETWEEN(StringBuffer buffer, AST ast)
{
int length = buffer.length();
AST property = ast.getFirstChild();
AST first = property.getNextSibling();
AST second = first.getNextSibling();
try
{
print(buffer, property);
buffer.append(" ");
printText(buffer, ast);
buffer.append(" ");
print(buffer, first);
buffer.append(" and ");
print(buffer, second);
}
catch (ValueNotExistException e)
{
if (buffer.lastIndexOf(":") > length)
{
this.parameters.remove(this.parameters.size() - 1);
}
//将已输出的部分截断
buffer.setLength(length);
}
}
/*
* 双操作数条件式，譬如like、=、in等等
*/
protected void printCondition(StringBuffer buffer, AST ast)
{
int length = buffer.length();
AST left = ast.getFirstChild();
print(buffer, left);
buffer.append(" ");
buffer.append(ast.getText());
buffer.append(" ");
AST right = left.getNextSibling();
try
{
print(buffer, right);
}
catch (ValueNotExistException e)
{
//将已输出的部分截断
buffer.setLength(length);
}
}
}

- 作者： jmut 2009年05月6日, 星期三 20:29　回复（0） |　引用（0）加入博采

AST构建Hibernat动态查询

关于Hibernate的动态查询，其实是所有sql的动态查询，或者说是动态条件查询，一直以来都没有什么好的方法。通常都是写一大段逻辑代码拼出正确的hql（sql），不仅实现很ugly，而且有安全隐患，容易产生注入。今天偶然看到这篇blog，通过对hql的AST的遍历改写出正确的hql，实在是一个妙方！哎，看来编译原理也抛向脑后了。

from:http://ayufox.javaeye.com/blog/82995

一、效果

java 代码

public class HqlCompilerImplTest extends TestCase
{
private IHqlCompiler compiler = new HqlCompilerImpl();
public void test1()
{
Hql hql = compiler.compile("from User u where u.username = :username and u.age = :age order by u.username,u.age",
new MapContext());
assertEquals("from User u order by u.username,u.age", hql.getHql());
assertEquals(0, hql.getParameters().length);
}
public void test2)
{
MapContext context = new MapContext();
context.add("username", "ray");
Hql hql = compiler
.compile(
"from User u where u.username = :username and u.age = :age order by u.username,u.age",
context);
assertEquals(
"from User u where u.username = :username order by u.username,u.age",
hql.getHql());
assertEquals(1, hql.getParameters().length);
assertEquals("username", hql.getParameters()[0].getName());
assertEquals("ray", hql.getParameters()[0].getValue());
}
public void test3()
{
MapContext context = new MapContext();
context.add("username", "ray");
context.add("age", new Integer(10));
Hql hql = compiler
.compile(
"from User u where u.username = :username and u.age = :age order by u.username,u.age",
context);
assertEquals(
"from User u where (u.username = :username and u.age = :age) order by u.username,u.age",
hql.getHql());
assertEquals(2, hql.getParameters().length);
assertEquals("username", hql.getParameters()[0].getName());
assertEquals("ray", hql.getParameters()[0].getValue());
assertEquals("age", hql.getParameters()[1].getName());
assertEquals(new Integer(10), hql.getParameters()[1].getValue());
}
}

二、基本接口

java 代码

package com.ayufox.framework.core;
/**
* @author ray
*
*/
public interface Context
{
Object get(String name);
}

java 代码

package com.ayufox.framework.core.dao.hqlx;
import com.ayufox.framework.core.Context;
import com.ayufox.framework.core.dao.hql.Hql;
/**
* @author ray
*
*/
public interface IHqlCompiler
{
Hql compile(String hql, Object ... values);
Hql compile(String hql, Context context);
}

三、实现

java 代码

package com.ayufox.framework.core.dao.hqlx.ast;
import java.io.ByteArrayOutputStream;
import java.io.PrintStream;
import java.util.Collections;
import java.util.HashMap;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.hql.ast.HqlParser;
import antlr.RecognitionException;
import antlr.TokenStreamException;
import antlr.collections.AST;
import com.ayufox.framework.core.Context;
import com.ayufox.framework.core.cache.Cache;
import com.ayufox.framework.core.cache.MapCache;
import com.ayufox.framework.core.dao.hql.Hql;
import com.ayufox.framework.core.dao.hqlx.DynamicMapContext;
import com.ayufox.framework.core.dao.hqlx.IHqlCompiler;
import com.ayufox.framework.core.dao.hqlx.IllegalSyntaxException;
/**
* @author ray
*
*/
public class HqlCompilerImpl implements IHqlCompiler
{
private final static Log LOG = LogFactory.getLog(HqlCompilerImpl.class);
private Cache astCache = new MapCache(Collections
.synchronizedMap(new HashMap()));
public void setAstCache(Cache astCache)
{
this.astCache = astCache;
}
/* (non-Javadoc)
* @see com.konceptusa.framework.core.dao.hqlx.IHqlCompiler#compile(java.lang.String, java.lang.Object[])
*/
public Hql compile(String hql, Object... values)
{
return compile(hql, new DynamicMapContext(values));
}
/* (non-Javadoc)
* @see com.konceptusa.framework.core.dao.hqlx.IHqlCompiler#compile(java.lang.String, com.konceptusa.framework.core.Context)
*/
public Hql compile(String hql, Context context)
{
if (hql == null || context == null)
{
throw new IllegalArgumentException("hql or context can't be null");
}
AST ast = getRootAST(hql);
HqlCompileExecutor compilerContext = new HqlCompileExecutor(ast,
context);
return compilerContext.build();
}
protected AST getRootAST(String hql)
{
AST ast = (AST) this.astCache.get(hql);
if (ast == null)
{
ast = createAST(hql);
this.astCache.put(hql, ast);
if (LOG.isDebugEnabled())
{
LOG.debug("get ast[" + ast + "] from cache for hql[" + hql
+ "]");
}
}
return ast;
}
private AST createAST(String hql)
{
HqlParser parser = HqlParser.getInstance(hql);
try
{
parser.statement();
}
catch (RecognitionException e)
{
throw new IllegalSyntaxException(e);
}
catch (TokenStreamException e)
{
throw new IllegalSyntaxException(e);
}
AST ast = parser.getAST();
parser.getParseErrorHandler().throwQueryException();
if (LOG.isDebugEnabled())
{
ByteArrayOutputStream baos = new ByteArrayOutputStream();
parser.showAst(ast, new PrintStream(baos));
LOG.debug("AST:" + new String(baos.toByteArray()));
}
return ast;
}
}

- 作者： jmut 2009年05月6日, 星期三 20:28　回复（0） |　引用（0）加入博采

what do web frameworks provide?

只是用，而从来没想过web framework到底为我们做了什么？Gavin King在讨论中回答了为个问题：validation, databinding and templating。

from http://www.javalobby.org/java/forums/t103190.html

- 作者： jmut 2009年04月25日, 星期六 19:54　回复（0） |　引用（0）加入博采

CE = DQ + A

CS = ∑CE(t)

SV = t ×CS

CE：Customer Experience

CS：Customer Satisfaction

SV：Service Value

DQ：Deliverable Quality

A：Attitude

t：time

BTW，Wayne说了他的梦想。说实说这何尝不是我的梦想，我不是也天天想如何快速开发，满足客户并提升价值么。我要继续走下去。

- 作者： jmut 2009年04月25日, 星期六 19:17　回复（0） |　引用（0）加入博采

jmut的博客

关于作者

日历　年月日

快速登录

搜索

快速浏览

最新文章

文章索引

在线留言

JAVA

最新评论

访问统计：
文章个数:85
评论个数:5
留言条数:1

jmut的博客

文章

草榴社区

hibernate的各种保存方式的区别 (save,persist,update,saveOrUpdte,merge,flush,lock)等

Tomcat安全域设置大全

(转)数据公钥加密和认证中的私钥公钥

加密和认证

公钥和私钥

基于公开密钥的加密过程

基于公开密钥的认证过程

总结

AST构建Hibernat动态查询2

AST构建Hibernat动态查询

what do web frameworks provide?

认识JBI

认识JBI

All heads meeting

+ 用户名：
+ 密　码：

jmut的博客

关于作者

日历 document.write(d.getFullYear());年document.write(d.getMonth()+1);月document.write(day)日

快速登录

搜索

快速浏览

最新文章

文章索引

在线留言

JAVA

最新评论

访问统计： 文章个数:85 评论个数:5 留言条数:1

jmut的博客

文章

加密和认证

公钥和私钥

基于公开密钥的加密过程

基于公开密钥的认证过程

总结

日历　年月日

访问统计：
文章个数:85
评论个数:5
留言条数:1

　　加密和认证

　　公钥和私钥

　　基于公开密钥的加密过程

　　基于公开密钥的认证过程

　　总结