• 搜狐网站诚聘Java、PHP和C++工程师
• Windows7在微软WinHEC 2008上揭开神秘面纱

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• Windows7在微软WinHEC 2008上揭开神秘面纱

找了几个javascript的框架，都没有找到我想要的：
提供函数，把某个表单的所有域封装成json数据格式的对象，唯有自己实现一个。

包括对象中有集合属性、对象中引用其他对象属性： 

/**
**json对象数据设置到表单域中
*/
function jsonObjectToForm(form, jsonObject){
	for(i = 0, max = form.elements.length; i < max; i++) {
		e = form.elements[i];
		eName = e.name;
		if(eName.indexOf('.') > 0){
			dotIndex = eName.indexOf('.');
			parentName = eName.substring(0, dotIndex);
			childName = eName.substring(dotIndex+1);
			//迭代判断eName，组装成json数据结构
			eValue = iterValueFromJsonObject(jsonObject, parentName, childName);
		}else{
			eValue = jsonObject[eName];
		}
		if(eValue && eValue != "undefined" && eValue != "null"){
			switch(e.type){
				case 'checkbox': 
				case 'radio': 
					if(e.value == eValue){
						e.checked = true;
					}
					break;
				case 'hidden': 
				case 'password': 
				case 'textarea':
				case 'text': 
					e.value = eValue;
					break;
				case 'select-one':
				case 'select-multiple':
					for(j = 0; j < e.options.length; j++){
						op = e.options[j];
						//alert("eName : " + eName + "; op value : " + op.value + "; eValue : " + eValue);
						if(op.value == eValue){
							op.selected = true;
						}
					}
					break;
				case 'button': 
				case 'file': 
				case 'image': 
				case 'reset': 
				case 'submit': 
				default:  
			}
		}
	}
}

/**
* json数组读写有两种方式
* 1: a.bs[0].id
* 2: a["bs"][0]["id"]
* 把表单转换成json数据格式
*/
function formToJsonObject(form){
	var jsonObject = {};
	for(i = 0, max = form.elements.length; i < max; i++) {
		e = form.elements[i];
		em = new Array();
		if(e.type == 'select-multiple'){
			for(j = 0; j < e.options.length; j++){
				op = e.options[j];
				if(op.selected){
					em[em.length] = op.value;
				}
			}
		}
		switch(e.type){
			case 'checkbox': 
			case 'radio': 
				if (!e.checked) { break; } 
			case 'hidden': 
			case 'password': 
			case 'select-one':
			case 'select-multiple':
			case 'textarea':
			case 'text': 
				eName = e.name;
				if(e.type == 'select-multiple'){
					eValue = em;
				}else{
					eValue = e.value.replace(new RegExp('(["\\\\])', 'g'), '\\$1');
				}
				//判断是否是对象类型数据
				if(eName.indexOf('.') > 0){
					dotIndex = eName.indexOf('.');
					parentName = eName.substring(0, dotIndex);
					childName = eName.substring(dotIndex+1);
					//迭代判断eName，组装成json数据结构
					iterJsonObject(jsonObject, parentName, childName, eValue);
				}else{
					jsonObject[eName] = eValue;
				}
				break; 
			case 'button': 
			case 'file': 
			case 'image': 
			case 'reset': 
			case 'submit': 
			default:  
		}
	}
	return jsonObject;
}

/**
* 把表单元素迭代转换成json数据
*/
function iterJsonObject(jsonObject, parentName, childName, eValue){
	//pArrayIndex用于判断元素是否是数组标示
	pArrayIndex = parentName.indexOf('[');
	//判断是否集合数据，不是则只是对象属性
	if(pArrayIndex < 0){
		var child = jsonObject[parentName];
		if(!child){
			jsonObject[parentName] = {};
		}
		dotIndex = childName.indexOf('.');
		if(dotIndex > 0){
			iterJsonObject(jsonObject[parentName], childName.substring(0, dotIndex), childName.substring(dotIndex+1), eValue);
		}else{
			jsonObject[parentName][childName] = eValue;
		}
	}else{
		pArray = jsonObject[parentName.substring(0, pArrayIndex)];
		//若不存在js数组，则初始化一个数组类型
		if(!pArray){
			jsonObject[parentName.substring(0, pArrayIndex)] = new Array();
		}
		//取得集合下标，并判断对应下标是否存在js对象
		arrayIndex = parentName.substring(pArrayIndex+1, parentName.length-1);
		var c = jsonObject[parentName.substring(0, pArrayIndex)][arrayIndex];
		if(!c){
			jsonObject[parentName.substring(0, pArrayIndex)][arrayIndex] = {};
		}
		dotIndex = childName.indexOf('.');
		if(dotIndex > 0){
			iterJsonObject(jsonObject[parentName.substring(0, pArrayIndex)][arrayIndex], childName.substring(0, dotIndex), childName.substring(dotIndex+1), eValue);
		}else{
			jsonObject[parentName.substring(0, pArrayIndex)][arrayIndex][childName] = eValue;
		}
	}
}

/**
* 迭代json数据对象设置到表单域中
*/
function iterValueFromJsonObject(jsonObject, parentName, childName){
	//pArrayIndex用于判断元素是否是数组标示
	pArrayIndex = parentName.indexOf('[');
	//判断是否集合数据，不是则只是对象属性
	if(pArrayIndex < 0){
		dotIndex = childName.indexOf('.');
		if(dotIndex > 0){
			return iterValueFromJsonObject(jsonObject[parentName], childName.substring(0, dotIndex), childName.substring(dotIndex+1));
		}else{
			return jsonObject[parentName][childName]
		}
	}else{
		pArray = jsonObject[parentName.substring(0, pArrayIndex)];
		//取得集合下标，并判断对应下标是否存在js对象
		arrayIndex = parentName.substring(pArrayIndex+1, parentName.length-1);
		var c = jsonObject[parentName.substring(0, pArrayIndex)][arrayIndex];
		dotIndex = childName.indexOf('.');
		if(dotIndex > 0){
			return iterValueFromJsonObject(jsonObject[parentName.substring(0, pArrayIndex)][arrayIndex], childName.substring(0, dotIndex), childName.substring(dotIndex+1));
		}else{
			return jsonObject[parentName.substring(0, pArrayIndex)][arrayIndex][childName]
		}
	}
}

欢迎大家讨论，最近在研究jsp页面纯净，只与js有关，但这将导致rich client

so bad  不知道有什么好的建议没 

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• Windows7在微软WinHEC 2008上揭开神秘面纱

ClassA a = (ClassA) beanFactory.getBean("A");

public class ClassA {
  private ClassB b;
  public void setB(ClassB b) {
    this.b = b;
  }
}

public class StandardConfiguration {

	private static Logger logger = Logger.getLogger(StandardConfiguration.class);
	
	private ImportBusiness importBusiness;
	
	public StandardConfiguration(BeanFactory beanFactory) {
		
		Method[] methods = getClass().getMethods();
		
		for(Method method : methods) {
			
			String methodName = method.getName();
			Class returnType = method.getReturnType();
			if(methodName.startsWith("get")) {
				
				String fieldName = getFieldName(methodName);
				
				Object bean = null;
				try {
					bean = beanFactory.getBean(fieldName);
					
				} catch (NoSuchBeanDefinitionException e) {
					
					logger.debug("StandardConfiguration - " + fieldName + " NoSuchBeanDefinitionException, ignore.");
					continue;
				}
				
				String setMethodName = "set" + createFieldMethodVar(fieldName);
				
				Method setMethod = null;
				try {
					setMethod = getClass().getMethod(setMethodName, new Class[]{returnType});
					setMethod.invoke(this, bean);
					
				} catch (NoSuchMethodException e) {
					
					logger.debug("StandardConfiguration - " + fieldName + " has no set method.");
					
				} catch (InvocationTargetException e) {
					
					logger.error("StandardConfiguration - " + fieldName + " invoke failed.");
				} catch (IllegalAccessException e) {
					
					logger.error("StandardConfiguration - " + fieldName + " IllegalAccessException.");
				}
			}
		}
		
	}
	
	private String getFieldName(String methodName) {
		
		String fieldName = methodName.substring(3, methodName.length());
		fieldName = fieldName.substring(0, 1).toLowerCase() +
						fieldName.substring(1, fieldName.length());
		
		return fieldName;
	}
	
	private String createFieldMethodVar(String fieldName) {
		
		return fieldName.substring(0, 1).toUpperCase() +
				fieldName.substring(1, fieldName.length());
	}

	public ImportBusiness getImportBusiness() {
		return importBusiness;
	}

	public void setImportBusiness(ImportBusiness business) {
		this.importBusiness = business;
	}
}

StandardConfiguration config = new StandardConfiguration(beanFactory)
ImportBusiness importBusiness = config.getImportBusiness();

public class StandardConfiguration extends BeanFactory {
  private ImportBusiness importBusiness;
  public ImportBusiness getImportBusiness() {
    return importBusiness;
  }

  public void setImportBusiness(ImportBusiness business) {
     this.importBusiness = business;
  }
}

• 搜狐网站诚聘Java、PHP和C++工程师
• Windows7在微软WinHEC 2008上揭开神秘面纱

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

还是通过一些步骤例子说明
首先建立Struts工程的时候要启动验证框架。
它称为Validator验证框架
主要依赖与两个.jar文件

 
Jakarta-oro.jar
Commons-validator.jar 

这个是在struts-config.xml文件中如下加入配置之后即代表该工程已经使用验证框架的插件了 

<plug-in className="org.apache.struts.validator.ValidatorPlugIn"> 
        <set-property property="pathnames" value="/WEB-INF/validator-rules.xml, 
                                                  /WEB-INF/validation.xml"/> 
</plug-in>

 
完成好了之后以注册的例子说明它的主要使用方法
1.建立一个注册的页面；包含用户名: 密码: 年龄: 邮箱:都不能为空。密码长度必须大于或等于8位，邮箱格式验证等
显示方式一：使用错误消息显示在相应的控件后面。
2.建立注册页相对应的表单Bean(ActionForm),重点在这里，因为要使用验证框架的话该表单类需要修改
1)修改该类的继承 

  import org.apache.struts.validator.ValidatorForm;// 导入要继承的类 
  public class 表单类 extends ValidatorForm //修改继承类

 
2) //修改该类且不包含validate()方法.
3、在validation.xml 中配置验证规则
  这个验证规则依赖与validator-rules.xml此文件已经配置好的验证类
  大概介绍几种规则吧{}中的为参数
   errors.required={0} is required.      必须的，或者不能为空的
   errors.minlength={0} can not be less than {1} characters. {某某}不能小于{多少}位
   errors.maxlength={0} can not be greater than {1} characters.{ 某某}不能大于{多少}位
  errors.range={0} is not in the range {1} through {2}.{0}是不能在{1}与{2}之间

<form-validation>   <!--以下是配置一些常用的验证规则 -->
  <formset> 
<form name="regActionForm">  
<!--表单名，为验证哪个表单而配置，这里的name指定struts中form-bean的别名 -->
    <field property="username" depends="required"> 
      <arg0 key="tip.username"/> 
    </field>         arg0指要为该规则传入的第一个参数 
<!--property为表单中的属性，depends为要验证的规则key为消息资料文件中的配置键 -->
<!-- 验证密码最小长度不小于8位 要一个控件属性验证两个规则的话真正以逗号分开, --> 

<field property="userpass" depends="required,minlength"> 
      <arg0 key="tip.userpass"/> 
      <arg1 key="${var:minlength}" name="minlength" resource="false"/> 
      <var> 
        <var-name>minlength</var-name> 
        <var-value>8</var-value> 
      </var> 
    </field> 
 
    <!--绿色的为变量名,好像定义也有规则，必须是那样而resource 则是配置是否从资源文件中查找key -->
    

<field property="email" depends="required,email"> 
      <arg0 key="tip.email"/> 
    </field> 
 
<!-- 验证年龄在一定范围之内 -->
    <field property="age" depends="required,intRange"> 
      <arg0 key="tip.age"/> 
      <arg1 key="${var:min}" name="intRange" resource="false"/> 
      <arg2 key="${var:max}" name="intRange" resource="false"/> 
       <var> 
         <var-name>min</var-name> 
         <var-value>1</var-value> 
       </var> 
       <var> 
         <var-name>max</var-name> 
         <var-value>100</var-value> 
       </var> 
    </field> 
    </form> 
  </formset> 
</form-validation> 

4、编写消息资源文件

验证规则的配置文件中所用key的名字为该资源文件所配置

# errors.required={0}不能为空. 
# tip.username=用户名 
# tip.userpass=密码 
# errors.minlength={0}不能少于{1}个字符. 
# errors.email={0} 格式不合法. 
# tip.email=邮箱 
# tip.age=年龄 
# errors.range={0} 必须在 {1} - {2} 之间. 

errors.required={0}\u4e0d\u80fd\u4e3a\u7a7a. 
tip.username=\u7528\u6237\u540d 
tip.userpass=\u5bc6\u7801 
errors.minlength={0}\u4e0d\u80fd\u5c11\u4e8e{1}\u4e2a\u5b57\u7b26. 
errors.email={0} \u683c\u5f0f\u4e0d\u5408\u6cd5. 
tip.email=\u90ae\u7bb1 
tip.age=\u5e74\u9f84 
errors.range={0} \u5fc5\u987b\u5728 {1} - {2} \u4e4b\u95f4. 

5.在struts-config.xml中配置Action验证失败跳转页面，属性为input指向的地方

二、手工验证；
1、用户名、密码不能为空；
2、密码长度不能小于8位；

（1）验证代码写在哪儿？
ActionForm的validate()方法中，如果该方法返回的ActionErrors中没有包含错误消息，认为验证通过。

（2）错误集合存在哪儿？
由 RequestProcessor 将错误集合存储在 Request 中，键名为
Globas.ERROR_KEY；

（3）如何显示错误消息？ 

<html:errors/> <!--显示所有消息 -->
<html:errors property="xx"/> <!--显示指定的消息-->

 

三、生成JavaScript
（1）ActionForm继承 org.apache.struts.validator.ValidatorForm；
（2）ActionForm中无 validate() 方法；
（3）表单JSP页中加：
<html:form .... onsubmit="return validateRegForm(this);">颜色字体一致，首字母大写
<html:javascript formName="regForm"/>
（4）在validation.xml中配置验证规则；



另外再说一个不怎么常用的标签，它的作用一般就是方便表单Bean对象的重复代码

<%@ taglib uri="/WEB-INF/struts-nested.tld" prefix="nested" %> 
<h1>用户注册</h1> 
<html:form action="reg.do" method="post"> 
  <nested:nest property="user">   
    用户名:<nested:text property="username"/><br/> 
    密码:<nested:text property="userpass"/><br/> 
  </nested:nest> 
  <html:submit value="提交"/> 
</html:form> 

要使用该配置，在ActionForm中要实例化一个user对象才可以通过以上配置使用对象中username的属性

<hr> 
<h1>用户注册</h1> 
<html:form action="reg.do" method="post"> 
    用户名:<html:text property="user.username"/><br/> 
    密码:<html:text property="user.userpass"/><br/> 
  <html:submit value="提交"/> 
</html:form> 

 

上面的代码也可以实现刚才的功能，但是在验证框架中就不能那么使用了

Tiles标签

<tiles:insert page="header.jsp" flush="true"/><!--标头内容 -->

 
作用与嵌套网页，可以定制好一个模板，然后在模板中使用相应的可编辑内容

<h1>t1.jsp</h1> 
111111111111111 
<hr> 
<!--page表示所要插入的网页，flush是否及时更新 -->
<tiles:insert page="footer.jsp" flush="true"/><!--末尾内容 -->

 

第二种情况是以一个定制了的模板生成个新的网页

<tiles:insert attribute="header"/> 
<tiles:insert attribute="footer"/> 

<tiles:insert page="template1.jsp" flush="true">   <!--已经存在一个template1.jsp模板 -->
<tiles:put name="header" value="header.jsp"/>  <!--往属性header设置嵌入页面 -->
<tiles:put name="footer" value="footer.jsp"/>    <!--往属性footer设置嵌入页面 -->
</tiles:insert> 

 
（1）防止重复提交；  Action
原理是通过在请求里面加入一些身份标记，在请求的时候判断是否事先存放的标记，如果不是则是第二次非正常提交

this.saveToken(request);        //在第一次点击请求的时候存入然后存转发到另一个JSP页面 
//判断令牌是否有效； 
if(! this.isTokenValid(request) ){     //如果是刚才的页面转发过来的话则它返回真 
saveToken(request); 
return ( new ActionForward(mapping.getInput()) );  
//跳转到Action配置的input中的页面 
} 
//最后正常执行完业务逻辑就把先前存的Token删除 
request.removeAttribute(mapping.getAttribute()); 
this.resetToken(request); 

 

（2）动态ActionForm（对应的JAVA类是动态产生的，JAVA类中的属性在struts-config.xml文件中动态配置）
1.配置Struts-config.xml中的 <form-bean/>，在其中声明
表单中要包含的字段元素；
----------------------------------------
例如页面上有以下一个表单 ，分别有属性username userage

<form action="dynaReg.do" method="post"> 
username:<input size=10 name="username"><br> 
userage:<input size=10 name="userage"><br> 
<input type="submit" value=" OK "> 
</form> 

那么对应这个表单就要在Struts-config.xml中配置一个与其对应的form-bean

<form-bean name="dynaRegForm" dynamic="true" type="org.apache.struts.action.DynaActionForm"> <!--指定该bean为动态的，并类型是该类 
如果使用了动态FORMBEAN也想用验证框架的话这里的TYPE就要指定DynaValidatorActionForm -->
        <form-property name="username" type="java.lang.String"/> 
        <form-property name="userage" type="java.lang.Integer" initial="0"/> 
</form-bean> 
  

 ----------------------------------------------------
2.配置Struts-config.xml中的 <action/>，将动态ActionForm
与某个Action结合起来;
只要name属性名称一致就可以了
在Action中的业务方法有些改动，因为它自动生成表单bean,所以取值的时候要像这样取,get中填写xml配置中的属性名字,把form强转换成DynaActionForm类对象，使用.get方法，返回Object，所以相应的再强转成想要的类型
String username=(String)((DynaActionForm)form).get("username");
Integer userage=(Integer)((DynaActionForm)form).get("userage");
3.客户使用表单,表单中名称与<form-bean>中声明的相同；

最后在使用完表单bean之后要删除掉刚才生成的bean;方法如下
request.removeAttribute(mapping.getAttribute());//删除FormBean


(3)DispatchAction类，可以在一个Action中编写多个业务方法;
1、编写Action，要继承DispatchAction，且无execute()方法；
2、在Action类中提供多个业务方法；
3、在表单/超链接中生成请求时，用URL： xxxxx.do?method=XX
4、使用该类，可以节省Action的个数;

测试DispatchAction类(一个Action处理多种业务):
加math.do?method=add
减math.do?method=dec
乘math.do?method=mul

在Action类中要写入相应的方法。

public ActionForward add(ActionMapping mapping, 
                            ActionForm form, 
                            HttpServletRequest request, 
                            HttpServletResponse response) 
    throws Exception { 
    System.out.println("add...."); 
    request.setAttribute( "mathresult","add...." ); 
    return mapping.findForward( "success" ); 
    } 

 
其他几个以此类推。。。。。。。。。。。。

(4)一个表单实现多种业务（计算器）----LookupDispatchAction;
LookupDispatchAction(一个表单对应多个处理方法):

1、编写Action，继承LookupDispatchAction类；
2、重写LookupDispatchAction类的getKeyMethodMap()，在该方法内对提交按钮文字“键名”和“业务方法名”进行映射；

protected Map getKeyMethodMap(){ 
Map map=new HashMap(); 
map.put("页面显示的按钮","本类中的业务方法名"); 
map.put("button.add ","add"); 
return map; 
} 

 
3、编写业务方法；

//add 
    public ActionForward add(ActionMapping mapping, 
                                 ActionForm form, 
                                 HttpServletRequest request, 
                                 HttpServletResponse response) 
    throws Exception 
    { 

        int num1 = ((Math2Form) form).getNum1(); 
        int num2 = ((Math2Form) form).getNum2(); 
request.setAttribute( "math2Result", ""+(num1+num2) ); 
        request.removeAttribute(mapping.getAttribute()); 
        return (mapping.findForward("success")); 
    } 

 
4、表单中的提交按钮中，显示文字时使用

<bean:message key="xxx"/>

 
5、使用该类，可以出现许多避免重复性表单；(如下为前台表单显示的内容)

<html:submit property="action"> 
<bean:message key="button.add"/> 
</html:submit> 

 
(5)ForwardAction

<action    
path = "/jsp1" 
type = "org.apache.struts.actions.ForwardAction" 
parameter ="/jsp1.jsp" 
/> 

<action    
path = "/jsp1" 
forward="/jsp1.jsp" 
/> 

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• Windows7在微软WinHEC 2008上揭开神秘面纱

package org.jrest4guice.persistence.ibatis;
public class Account {
  private int id;
  private String firstName;
  private String lastName;
  private String emailAddress;

  public int getId() {
    return id;
  }

  public void setId(int id) {
    this.id = id;
  }

  public String getFirstName() {
    return firstName;
  }

  public void setFirstName(String firstName) {
    this.firstName = firstName;
  }

  public String getLastName() {
    return lastName;
  }

  public void setLastName(String lastName) {
    this.lastName = lastName;
  }

  public String getEmailAddress() {
    return emailAddress;
  }

  public void setEmailAddress(String emailAddress) {
    this.emailAddress = emailAddress;
  }

}

package org.jrest4guice.persistence.ibatis;

import java.sql.SQLException;
import java.util.List;

import org.jrest4guice.persistence.ibatis.annotations.Delete;
import org.jrest4guice.persistence.ibatis.annotations.IbatisDao;
import org.jrest4guice.persistence.ibatis.annotations.Insert;
import org.jrest4guice.persistence.ibatis.annotations.Result;
import org.jrest4guice.persistence.ibatis.annotations.ResultMap;
import org.jrest4guice.persistence.ibatis.annotations.Select;
import org.jrest4guice.persistence.ibatis.annotations.Update;
import org.jrest4guice.transaction.annotations.Transactional;
import org.jrest4guice.transaction.annotations.TransactionalType;

import com.google.inject.Inject;
import com.ibatis.sqlmap.client.SqlMapClient;

@IbatisDao
@SuppressWarnings("unchecked")
@Transactional
@ResultMap(id = "accountResultMap", result = {
		@Result(property = "id", column = "id"),
		@Result(property = "firstName", column = "firstName"),
		@Result(property = "lastName", column = "lastName"),
		@Result(property = "emailAddress", column = "emailAddress") }, resultClass = Account.class)
@Cachemodel(id = "account-cache", flushInterval = "24", flushOnExecute = {
		"insertAccount", "updateAccount", "deleteAccount" }, type = "LRU", 
		property = { @Property(name = "size", value = "100") })
public class AccountService {
	@Inject
	private SqlMapClient sqlMapper;

	@Select(id = "selectAllAccounts", sql = "select * from ACCOUNT", 
			resltMap = "accountResultMap", cacheModel = "account-cache")
	@Transactional(type = TransactionalType.READOLNY)
	public List<Account> findAll() throws SQLException {
		return sqlMapper.queryForList("selectAllAccounts");
	}

	@Select(sql = "select id ,firstName,lastName,emailAddress from "
			+ "ACCOUNT where id = #id#")
	@Transactional(type = TransactionalType.READOLNY)
	public Account getAccountById(int id) throws SQLException {
		return (Account) sqlMapper.queryForObject("getAccountById", id);
	}

	@Insert(id = "insertAccount", sql = "insert into ACCOUNT (id,firstName,"
			+ "lastName,emailAddress) values (#id#, #firstName#, #lastName#, "
			+ "#emailAddress#)")
	public void createAccount(Account account) throws SQLException {
		sqlMapper.insert("insertAccount", account);
	}

	@Update(sql = "update ACCOUNT set firstName = #firstName#,lastName = "
			+ "#lastName#,emailAddress = #emailAddress# where id = #id#")
	public void updateAccount(Account account) throws SQLException {
		sqlMapper.update("updateAccount", account);
	}

	@Delete(id = "deleteAccount", sql = "delete from ACCOUNT where id = #id#")
	public void deleteAccount(int id) throws SQLException {
		sqlMapper.delete("deleteAccount", id);
	}

	@Select(id = "queryAccounts", 
		sql = "select * from ACCOUNT "
			+ "<dynamic prepend=\"where\">"
			+ " <isNotNull prepend=\"and\" property=\"firstName\">"
			+ "    firstName = #firstName#" 
			+ " </isNotNull>"
			+ " <isNotNull prepend=\"and\" property=\"lastName\">"
			+ "    lastName = #lastName#" 
			+ " </isNotNull>"
			+ " <isNotNull prepend=\"and\" property=\"emailAddress\">"
			+ "    emailAddress = #emailAddress#" 
			+ " </isNotNull>"
			+ "</dynamic> " 
			+ "order by lastName", resltMap = "accountResultMap", 
			cacheModel = "account-cache")
	@Transactional(type = TransactionalType.READOLNY)
	/**
	 * 动态SQL查询
	 */
	public List<Account> queryAccounts(Account account) throws SQLException {
		return sqlMapper.queryForList("queryAccounts",account);
	}
}

package org.jrest4guice.persistence.ibatis;

import java.sql.SQLException;
import java.util.List;

import junit.framework.Assert;

import org.jrest4guice.guice.GuiceContext;
import org.jrest4guice.guice.PersistenceGuiceContext;
import org.junit.BeforeClass;
import org.junit.Test;

public class AccountServiceTest {
	private static AccountService service;

	@BeforeClass
	public static void setUp() throws Exception {
		// 初始化JRest4Guice
		PersistenceGuiceContext.getInstance().useIbatis(
				"org.jrest4guice.persistence.ibatis").init();
		// 获取服务
		service = GuiceContext.getInstance().getBean(AccountService.class);
	}

	@Test
	public void doTest() {
		List<Account> accounts;
		try {
			Account account = new Account();
			account.setFirstName("张");
			account.setLastName("学友");
			account.setEmailAddress("jackey@rest4g.org");
			// 添加
			service.createAccount(account);

			account = new Account();
			account.setFirstName("刘");
			account.setLastName("学友");
			account.setEmailAddress("test@rest4g.org");
			// 添加
			service.createAccount(account);
			
			//查询（按lastName）
			Account queryCondition = new Account();
			queryCondition.setLastName("学友");
			accounts = service.queryAccounts(queryCondition);
			Assert.assertEquals(2, accounts.size());
			
			//查询（按firstName和lastName）
			queryCondition.setFirstName("张");
			accounts = service.queryAccounts(queryCondition);
			Assert.assertEquals(1, accounts.size());

			// 修改
			account = accounts.get(0);
			account.setFirstName("何");
			service.updateAccount(account);
			account = service.getAccountById(account.getId());
			Assert.assertNotNull(account);
			Assert.assertEquals("何", account.getFirstName());

			//查询所有
			accounts = service.findAll();
			Assert.assertEquals(2, accounts.size());

			// 删除
			for (Account ac : accounts){
				service.deleteAccount(ac.getId());
			}
			
			//断言删除的结果
			accounts = service.findAll();
			Assert.assertEquals(0, accounts.size());
		} catch (SQLException e) {
			Assert.fail(e.getLocalizedMessage());
		}
	}
}

• 搜狐网站诚聘Java、PHP和C++工程师
• Windows7在微软WinHEC 2008上揭开神秘面纱

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

总结了一些新手面试经验，希望能有帮助

1：简历不能太实在，两个项目参考就可以了，但要对你在项目的做的什么工作很清楚

2：让你自我介绍时，就说说自己在大学是怎么学习编程的，自己做了哪些实践，实习时又干了些什么，当

然你可以编，但要有准备

3：在网上搜集一些Java面试题做做，背背是很有必要的

4：一定要会数据结构中的 选择和排序 算法，一定要在记事本中写出来，并在命令提示符下测试

5：J2SE的基本配置最好 了如指掌

6：进了公司后，实在，实在是呆不下去了，可以申请离职

7：面试回来后，感觉不错就给公司回个邮件

8：工资要求不要太高，不相信？那你试试吧

9：简单的数据库表设计要会，一定要会这两个查找

   A：找出一个表中重复的记录

   B：删除表中重复记录，只留一条即可(网上有好多答案，自己搜吧)

10：Struts一定要熟悉，什么配置了，处理流程了，等

11：Hibernate一定要熟悉，什么配置了，持久化类的设计了，ORMapping的配置了，如何提高Hb的性能

了，等，从零开始，如完成一个数据的CRUD功能

至于spring，对新手几呼没有考过，最多写一个类的注入配置文件

12：面试时不要迟到，实在是来晚了，见了人家要先说：“对不起，犯了个错误，来晚了”，什么原因就

不用说了，说了只会产生腹面影响

最后再次提醒一下：

工资不要太高，正常加班可以接受就行，离家不能太远(2小时??)，搞程序开发的，一定要是软件公司，专开发开发Web或桌面程序(针对中小公司而言)

我们也要选择公司(java web开发)

1：没有项目的不去

2：没有笔试的要考虑

3：只做本公司门户网站的不去

4：一线开发人员少的不去(至少得有几个真正懂得java 代码的老员工吧)

5：搞CMS维护的不去，要去也得去搞开发CMS(java版)的公司

6：工资太低的不去(低于2K)

7：疯狂加班的不去，如明确说朝9晚9，周一到周六，适当加班

8：只邮件通知不打电话的公司不去

9：如果你是编程的，面试你时，连几个有关编程技术的问题都不问(或者就根本不提)的公司不去

如果你要跳槽，不防看看以下几点

• 搜狐网站诚聘Java、PHP和C++工程师
• Windows7在微软WinHEC 2008上揭开神秘面纱

• 搜狐网站诚聘Java、PHP和C++工程师
• Windows7在微软WinHEC 2008上揭开神秘面纱

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

在Ext2.2的Ext.form.FormPanel中如果有RadioGroup或者CheckboxGroup，那么FormPanel.form.setValues方法对这2个东东内部的radio和checkbox无法动态赋值，需要对Ext.form.BasicForm的findField方法进行修正，代码如下：

Ext.override(Ext.form.BasicForm,{
    findField : function(id){        
        var field = this.items.get(id);        
        if(!field){
            this.items.each(function(f){
                if(f.isXType('radiogroup')||f.isXType('checkboxgroup')){
                    f.items.each(function(c){
                        if(c.isFormField && (c.dataIndex == id || c.id == id || c.getName() == id)){
                            field = c;
                            return false;
                        }
                    });
                }
                                
                if(f.isFormField && (f.dataIndex == id || f.id == id || f.getName() == id)){
                    field = f;
                    return false;
                }
            });
        }
        return field || null;
    } 
});

• 搜狐网站诚聘Java、PHP和C++工程师
• Windows7在微软WinHEC 2008上揭开神秘面纱

stats
stats reset
stats malloc
stats maps
stats sizes
stats slabs
stats items
stats cachedump slab_id limit_num
stats detail [on|off|dump]

Problem : 4564
GroupPost : 5643
User : 27133
Group : 144
...
Post : 44442
PostText : 255286
......
views : 36260
Forum : 27
Category : 15065

#!/usr/bin/env ruby
require 'socket'

# stats
# stats reset
# stats malloc
# stats maps
# stats sizes
# stats slabs
# stats items
# stats cachedump slab_id limit_num
# stats detail [on|off|dump]

class Memcache
  class << self
    def open(host, port)
      s = TCPSocket.open(host, port)
      yield s if block_given?
    ensure
      s.close if s
    end
  
    def command(command_string, s)
      s.send(command_string + "\r\n", 0)
      buff = []
      until ["END", "OK", "DELETE", "ERROR"].include?(line = s.gets.strip) do
        buff << line 
      end
      buff
    end
  
    def exec(command_string, host = "javaeye", port = 11211)
      open(host, port) { |socket| command(command_string, socket).each {|line| puts line } }
    end
    
    def cache_stats(host = "javaeye", port = 11211)
      cache_objects = {}
      open(host, port) do |socket|
        slabs = []
        command("stats items", socket).each do |line|
          slab_id = line.split[1].split(":")[1].to_i
          slabs << slab_id unless slabs.include?(slab_id)
        end
        slabs.each do |slab_id|
          puts "browse slab #{slab_id}..."
          command("stats cachedump #{slab_id} 0", socket).each do |item|
            key = item.split[1].split("/")[0].to_s
            cache_objects.include?(key) ? cache_objects[key] += 1 : cache_objects[key] = 1
          end
        end
      end
      cache_objects.each_pair {|key, value| puts "#{key} : #{value}"}
    end
  end
end

if ARGV.size == 0
  Memcache.cache_stats
else
  Memcache.exec(ARGV.join(" "))
end

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• Windows7在微软WinHEC 2008上揭开神秘面纱

• 搜狐网站诚聘Java、PHP和C++工程师
• Windows7在微软WinHEC 2008上揭开神秘面纱

• 搜狐网站诚聘Java、PHP和C++工程师
• Windows7在微软WinHEC 2008上揭开神秘面纱

     1）代码命名和书写规范，改掉一些坏习惯

     大家都比较清楚现在的开发框架越来越多，需要自己写的代码越来越少，不规范的情况也越来越少。但是仍然会存在不规范的写法。比如说，有的开发人员已经习惯了原来的调试方式，喜欢用System.out来输出调试信息，而不喜欢用log4j之类的日志框架来输出调试信息，有人则更喜欢在jsp写代码，即使已经有了新的开发框架一再的要求还是喜欢在jsp里面直接写java代码。看来习惯是很可怕的。  

     2）系统框架要足够清晰，容易进行维护

     现在一般都会写一个增/删/改/查的功能，java文件的命名都是有一定的规范的，这样就会层次清晰，任何人维护都会很容易修改其中的代码。现在一般的项目中都用到了事务和缓存，如何更高效率的添加事务处理和缓存功能，这是一个很值得考虑的问题。第一，可以对每个方法里面添加事务或者缓存的处理代码，但是这样成本会大大提高。第二，使用AOP处理，只需要给需要处理的类添加Spring的配置就可以了。第三，使用AOP给所有符合条件的类的方法添加事务或缓存处理。所以一般会将架构分为三层Action,Service,Dao，Service主要是处理业务逻辑，也是主要的事务和缓存处理的地方，Dao主要是负责数据库的操作，Action主要是负责前端显示的。

     3）配置管理规范

      配置管理只是一种代码管理的工具，正确使用才是关键。要养成好的习惯，如，每次修改文件之前要先更新代码，提交代码时要对修改的内容做一个明确的说明，以方便其他开发人员查看。

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• Windows7在微软WinHEC 2008上揭开神秘面纱