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

• 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++工程师

package com.chenzhq.ejb;

import javax.ejb.Remote;

@Remote ({HelloWorldRemote.class})
public interface HelloWorldRemote {

	   public String say(String name);
}

package com.chenzhq.ejb;

import javax.ejb.Local;
import javax.ejb.Remote;
import javax.ejb.Stateless;

@Stateless//注意这里啊
@Remote ({HelloWorldRemote.class})//注意这里啊

public class HelloWorld implements HelloWorldRemote {

	   public String say(String name){
		   System.out.println(HelloWorld.class.getCanonicalName());
		   return name;
	   }
}

<?xml version="1.0" encoding="UTF-8"?>
<project name="ejb" default="jar">
  
  <target name="jar">
      <jar destfile="D:\work\lib\helloworld.jar">
          <fileset dir="./classes">
             <include name="**/*.class"/>
             <include name="**/*.xml"/>
          </fileset>
      </jar>
  
  </target>

</project>

package com.chenzhq;

import java.util.Properties;

import javax.naming.InitialContext;
import javax.naming.NamingException;

import com.chenzhq.ejb.HelloWorldRemote;

public class Test {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Properties props = new Properties();
		props.setProperty("java.naming.factory.initial", "org.jnp.interfaces.NamingContextFactory");
		props.setProperty("java.naming.provider.url", "jnp://192.168.0.2:1099");//这里是我部署ejb的主机地址。
		props.setProperty("java.naming.factory.url.pkgs", "org.jboss.naming"); 
		
		try {
			InitialContext ic = new InitialContext(props);
			HelloWorldRemote hwr = ((HelloWorldRemote)ic.lookup("HelloWorld/remote"));
			System.out.println(hwr.say("chenzhq"));
			
		} catch (NamingException e) {
			// TODO Auto-generated catch block
			System.out.print(e);
			e.printStackTrace();
		}
		
		// 

	}

}

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

private void saveNote(Note note) {
	Vector notes = new Vector();
	notes.addElement(note);
	try {
		storage.save(notes, "notes");
	} catch (IOException e) {
		e.printStackTrace();
	}
}

Note note = new Note("xxxx", "yyyy");
saveNote(note);

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

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

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

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

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

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

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

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

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

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

hibernate-memcached（http://code.google.com/p/hibernate-memcached/）是允许hibernate使用MemCached作为二级缓存的项目，它用到了spymemcached（http://code.google.com/p/spymemcached/）这个MemCached的Java客户端。花了一点时间做了个补丁，让它也支持Whalin的Java客户端（http://whalin.com/memcached/）。

所有的代码（包括原hibernate-memcached的所有源码）、javadoc及重新制作的发布包请见附件，限于篇幅就不具体说明了。以下是我更新过的hibernate-memcached的配置说明，原配置说明请参见http://code.google.com/p/hibernate-memcached/wiki/Configuration

Adding hibernate-memcached to your application

If you are using Maven2 for your application build you can follow the instructions on the MavenRepository page. For those that aren't using Maven2 you'll need to collect a few simple jars for yourself. I am going to assume you already have hibenrnate3 setup before you came here.

You'll need...

• hibernate-memcached-<version>.jar
• commons-codec 1.3
• slf4j-1.5.0.jar
• An slf4j implementation for your preferred logging framework. For log4j you can use slf4j-log4j12-1.5.0.jar.

If you are using spymemcached as the MemCached client, you also need

• memcached-2.1.jar
• spy-2.4.jar

or if you prefer Whalin's memcached client for java, you need to download java_memcached-release_2.0.1.jar from the download page according to your Java VM version.

Configuring Hibernate

The first thing to do is to tell hibernate which cache provider you'd like to use, and to enable the second level cache.

Using just the property above you get basic entity caching by default. The hibernate-memcached library supports query caching, but you have to enable query caching separately.

!Now you can start setting up the hibernate-memcached specific properties. The hibernate-memcached properties are divided into two categories; cache-wide settings and cache-region settings.

Cache Wide Settings

The cache wide settings all have defaults can mostly be overwritten at a cache-region level. For both spymemcached and Whalin's client, you can set:

For spymemcached, you can set:

For Whalin's client, you can set:

Cache Region Settings

Cache regon properties are set by giving your cached data a "region name" in hibernate. You can tune the MemcachedCache instance for your region using the following properties. These properties essentially override the cache-wide properties above.

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

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

资源的引用

在Android开发中对资源的引用是很重要的内容，看一个Android工程结构的好与坏，其实看看工程结构的资源文件的相互关系就大概可以看出来了，个人觉得学习好Android，资源文件是很重要的部分，这里讲的都是些入门级别的知识点，耐下心思看哦，呵呵。

1，  三种资源文件形式。资源文件之间的相互引用自然是基础的基础，三种形式(android:xxx/yyy,@xxxx/yyy,?xxx)的区别要彻底地弄明白。

2，  资源文件的属性命名。资源文件属性的命名(其实大部分是id名字，也有其它的，这里不再累赘)对于初学者可能不太会在意，其实是很重要的部分，它其实也就是一些我们预先定义好的变量，能不在乎吗，这些变量会在自动生成映射类R.java中生成一些静态索引值，帮助Android快速定位，命名说白了，也是要求我们做到望名知意(最好包括类型)。

3，  每个工程都会有对应的一个AndroidManifest.xml文件，这个文件要注意的是一些权限的表示属性，如：

<uses-permission android:name="android.permission.INTERNET" />

    <uses-permission android:name="android.permission.READ_CONTACTS" />

    <uses-permission android:name="android.permission.WRITE_CONTACTS" />

    <uses-permission android:name="android.permission.INSTALL_PACKAGES" />

    <uses-permission android:name="android.permission.DELETE_PACKAGES" />

看命名就知道是针对什么做权限限制，所以初学者要注意了，在你的程序运行的时候报SecurityException的时候要看看你的程序是否涉及到限制操作，呵呵。这些在android.Manifest.permission里面，大家自己看可能会更好，自己学习的能力很重要哦，要不然你做的不可能是前沿的东西啦。

4，  自己定义类的引用。怎么定义、怎么使用，可以参考ApiDemo里面的经典实例：com.example.android.apis.view.LableView.java 。这也是很重哦，因为在我们开发的过程中,Android提供的UI肯定不能满足我们的要求，这样你就得自己写新的UI类，我在开发中就遇到很多这样的问题。如，Android现有的TabHost，在TabSpec多的时候你就感觉出TabHost英雄无用武之地啦，这样就得自己写了。

写自己的Android Components

上面的第四点已经提到了一下，学会写自己的控件的重要性。在Android里面，提供了丰富的类库，如何使用好也是值得探讨的问题。当然这里说的也是api里面说的，这里说的主要是我在学习的过程中认为很重要的方面.

主要把界面布局类：LinearLayout和FrameLayout弄懂简单的开发就够了，再深入一点就要把ViewManager及其子类弄清楚了。

其中，LinearLayout垂直和水平两种，他们之间可以相互嵌套，嵌套时候要注意高和宽的属性，如。

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"

    xmlns:app="http://schemas.android.com/apk/res/com.srk.study"

    android:id="@+id/screen" android:layout_width="fill_parent"

    android:layout_height="fill_parent"

    android:background="@drawable/background" android:focusable="true"

    android:orientation="vertical">

    <LinearLayout  android:layout_width="fill_parent"

       android:layout_height="65dip"

       android:background="@drawable/background"

       android:orientation="horizontal">

       <com.srk.study.model.TitleView android:id="@+id/titleView"

           android:layout_width="280dip" android:layout_height="65dip"

           android:paddingLeft="5dip" android:paddingTop="10dip"

           app:focusBgColor=@drawable/whiteColor app:titleColor=@drawable/blackColor

           app:titleSize="15dip" />

       <com.srk.study.model.ConnectView android:id="@+id/connectView"

       android:layout_height="65dip"

           android:layout_width="40dip" app.startX="280dip" />

    </LinearLayout>

    <!-- ############# Body ############ -->

    <ListView android:id="@+id/bodyListView" android:layout_width="fill_parent"

       android:paddingTop="3dip" android:layout_height="wrap_content"

       android:layout_weight="1.0"

       android:persistentDrawingCache="animation|scrolling"

       android:scrollbars="vertical" android:focusable="true"

       android:scrollbarSize="12dip" />

</LinearLayout>

以上的配置文件是我学习过程的小练习，在这里秀一下，哈哈，记得在去年刚毕业的时候，特别爱学习，什么都想弄弄，在去年一年的时光中，每天都过得很充实，也许那就是年轻的标志吧，扯远了。今天就说这么多，有空分享点源代码出来。。。

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

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

现在将常见的乱码问题分为JSP页面显示中文乱码、表单提交乱码两类。

     1）JSP页面中显示中文乱码

     在JSP文件中使用page命令指定响应结果的MIME类型，如<%@ page language="java" contentType="text/html;charset=gb2312" %>

     2）表单提交乱码   

     表单提交时（post和Get方法），使用request.getParameter方法得到乱码，这是因为tomcat处理提交的参数时默认的是iso-8859-1，表单提交get和post处理乱码问题不同，下面分别说明。
    (1)POST处理
    对post提交的表单通过编写一个过滤器的方法来解决，过滤器在用户提交的数据被处理之前被调用，可以在这里改变参数的编码方式，过滤器的代码如下：

package example.util;
    
    import java.io.IOException;
    
    import javax.servlet.Filter;
    import javax.servlet.FilterChain;
    import javax.servlet.FilterConfig;
    import javax.servlet.ServletException;
    import javax.servlet.ServletRequest;
    import javax.servlet.ServletResponse;
    
    public class SetCharacterEncodingFilter implements Filter {
    
       protected String encoding = null;
    
       protected FilterConfig filterConfig = null;
    
       protected boolean ignore = true;
    
  
     public void destroy() {
    
      this.encoding = null;
      this.filterConfig = null