Gxt2.1中使用Gwt2.0开发模式.初探.java.lang.VerifyError问题解决

    前两天看见Gwt2.0发布的消息，新的特性让人相当兴奋，尤其是开发者模式，大大提高了调试效率。随即就将项目升级到了Gwt2.0+Gxt2.1， 并且eclipse也更新到最新的1.2..  

    安装插件，运行代码，一路基本都没有问题。。  在开发者模式下访问host page...  碰到如下错误:

    错误信息 写道

     经过一番google也没查出什么原因， 用一段很简单的代码调试追踪(代码如下:)，发现是devMode反射的时候出的问题，虽然知道问题的大致原因，但是还是没办法解决。

     package st.lv.web.im.client;

import com.google.gwt.core.client.EntryPoint;

/**
 * Entry point classes define <code>onModuleLoad()</code>.
 */
public class WebIM implements EntryPoint {

	
	/**
	 * This is the entry point method.
	 */
	public void onModuleLoad() {
		
//		com.google.gwt.user.client.Window.alert("ok..");//this line is ok..
		com.extjs.gxt.ui.client.widget.MessageBox.alert("gxt", "gxt", null);
	}
}

    最后只得求助ext的官方论坛, 最终将这段代码跑通解决了。。

http://www.extjs.com/forum/showthread.php?p=420100#post420100post420100

    经tortexy解释: 该原因是由Class Loader产生的，当com.extjs.gxt.ui.client.widget.Layout加载太晚，classloader将停止执行。

   最终代码如下所示:

package st.lv.demo.overview.client;

import com.extjs.gxt.ui.client.widget.Layout;
import com.extjs.gxt.ui.client.widget.MessageBox;
import com.extjs.gxt.ui.client.widget.layout.AnchorLayout;
import com.google.gwt.core.client.EntryPoint;

/**
 * Entry point classes define <code>onModuleLoad()</code>.
 */
public class Gwt2Gxt implements EntryPoint {

	/**
	 * This is the entry point method.
	 */
	public void onModuleLoad() {		
		
		@SuppressWarnings("unused")
		Layout junk = new AnchorLayout();//提前初始化Layout对象
		MessageBox.alert("Msg", "gxt MessageBox", null);	
	}
}

    虽然这个问题解决了，但是项目在Gxt2.1+Gwt2.0的Develop Mode下还是会报很多错误，依然没有升级到Gwt2.0...  不过在Gxt的论坛上并没有太多设计关于Gxt2.1中使用Gwt2.0新特性的问题，看来这些东西又得自己开始慢慢摸索了。。。

import java.io.IOException;

import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

import org.springframework.web.context.WebApplicationContext;

import cn.com.dayang.common.user.domain.RemoteUser;
import cn.com.dayang.common.user.domain.User;
import cn.com.dayang.common.user.webwork.interceptor.LoginInterceptor;

import com.google.gwt.user.client.rpc.IncompatibleRemoteServiceException;
import com.google.gwt.user.client.rpc.RemoteService;
import com.google.gwt.user.client.rpc.SerializationException;
import com.google.gwt.user.server.rpc.RPC;
import com.google.gwt.user.server.rpc.RPCRequest;
import com.google.gwt.user.server.rpc.RPCServletUtils;
import com.google.gwt.user.server.rpc.RemoteServiceServlet;
import com.google.gwt.user.server.rpc.SerializationPolicy;

/**
 * @author Zwf
 * 
 */
public class MyGWTServer extends RemoteServiceServlet {
	

	private final ThreadLocal<HttpServletRequest> perThreadRequest = new ThreadLocal<HttpServletRequest>();
	private final ThreadLocal<HttpServletResponse> perThreadResponse = new ThreadLocal<HttpServletResponse>();

	private WebApplicationContext springContext;

	@Override
	public void init(ServletConfig Config) throws ServletException {
		super.init(Config);
		springContext = (WebApplicationContext) Config.getServletContext().getAttribute(
				WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE);

		if (springContext == null) {
			throw new RuntimeException("Check Your Web.Xml Setting, No Spring Context Configured");
		}

	}

	@Override
	protected SerializationPolicy doGetSerializationPolicy(HttpServletRequest request, String moduleBaseURL,
			String strongName) {
		return super.doGetSerializationPolicy((HttpServletRequest) perThreadRequest.get(), moduleBaseURL, strongName);
	}

	@Override
	protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
		try {
			
			perThreadRequest.set(req);
			perThreadResponse.set(resp);
	
			String requestURI = req.getRequestURI();
			String beanname = requestURI.substring(requestURI.lastIndexOf("/") + 1,requestURI.lastIndexOf(".gwt"));
			RemoteService service = (RemoteService) springContext.getBean(beanname);

			String requestPayload = readPayloadAsUtf8(req);
			
			// Let subclasses see the serialized request.
			//    
			onBeforeRequestDeserialized(requestPayload);

			// Invoke the core dispatching logic, which returns the serialized
			// result.
			//    
			 HttpSession session=req.getSession(true);
			 if(session.getAttribute(LoginInterceptor.USER_LOGIN)==null)
			{
			System.out.println("no user login!!!!!");
				throw new Exception("please login");
			}
			 User user = (User)session.getAttribute(LoginInterceptor.USER_LOGIN);
			 RemoteUser.set(user);
			String responsePayload = processCall(service, requestPayload);

			// Let subclasses see the serialized response.
			//    
			onAfterResponseSerialized(responsePayload);

			// Write the response.
			//    
			writeResponse(req, resp, responsePayload);
		} catch (Throwable e) {
			// Give a subclass a chance to either handle the exception or
			// rethrow it
			//    
			doUnexpectedFailure(e);
		} finally {
			// HttpRequestContext.ThreadLocalHttpRequestContext.remove();
			perThreadRequest.set(null);
			perThreadResponse.set(null);
		}
	}

	/**
	 * rewrite processCall
	 * 
	 * @param bean
	 * @param payload
	 * @return
	 * @throws SerializationException
	 */
	public String processCall(RemoteService bean, String payload) throws SerializationException {
		try {			
			RPCRequest rpcRequest = RPC.decodeRequest(payload, bean.getClass(), this);
			return RPC.invokeAndEncodeResponse(bean, rpcRequest.getMethod(), rpcRequest.getParameters(), rpcRequest
					.getSerializationPolicy());
		} catch (IncompatibleRemoteServiceException ex) {
			getServletContext().log("An IncompatibleRemoteServiceException was thrown while processing this call.", ex);
			return RPC.encodeResponseForFailure(null, ex);
		}
	}

	private String readPayloadAsUtf8(HttpServletRequest request) throws IOException, ServletException {
		return RPCServletUtils.readContentAsUtf8(request, true);
	}

	private void writeResponse(HttpServletRequest request, HttpServletResponse response, String responsePayload)
			throws IOException {
		boolean gzipEncode = RPCServletUtils.acceptsGzipEncoding(request)
				&& shouldCompressResponse(request, response, responsePayload);
		RPCServletUtils.writeResponse(getServletContext(), response, responsePayload, gzipEncode);
	}
}