top

2.使用以下命令

ps p 14766 -L -o pcpu,pid,tid,time,tname,stat,psr | sort -n -k1 -r

其中14766是刚才1中cpu占用率高的进程pid

3.2.4 32525 32537 01:58:41 ?        Sl     6
0.8 32525  1771 00:43:12 ?        Sl     0
0.8 32525  1769 00:39:46 ?        Sl     0
0.7 32525 12324 00:33:36 ?        Sl     0
0.5 32525  1772 00:27:50 ?        Sl     0
0.5 32525  1768 00:25:45 ?        Sl     0
0.4 32525 30760 00:19:13 ?        Sl     0
0.4 32525  1773 00:22:36 ?        Sl     0
0.4 32525  1770 00:20:25 ?        Sl     0
0.3 32525 32385 00:00:10 ?        Sl     0
0.1 32525 31668 00:00:03 ?        Sl     0
0.1 32525 31667 00:00:03 ?        Sl     0
0.1 32525  1790 00:07:10 ?        Sl     1

其中第3个结果就是此进程中有问题的线程nid

4.通过jstack命令dump出堆栈

"AppController_ThreadPool_L2_Pool Thread" daemon prio=10 tid=0x0000000051c2b000 nid=0x7bb3 in Object.wait() [0x000000005e3c5000]
   java.lang.Thread.State: TIMED_WAITING (on object monitor)
        at java.lang.Object.wait(Native Method)
        at org.company.threadpool.ThreadPoolImpl$PoolThread.run(ThreadPoolImpl.java:142)
        - locked <0x00002aaca30341a8> (a org.company.threadpool.ThreadPoolImpl$PoolThread)

其中的nid就是线程的编码，只不过是经过了16进制的转换。

即十进制的31776对应的十六进制)0x7bb3，定位到线程后一切好办。 

@XmlRootElement(name = "ReturnInfo")
@XmlType()
public class ReturnInfo<T> {

private List<T> resultList;

 public List<T> getResultList() {

  return resultList;
 }

 public void setResultList(List<T> resultList) {

  this.resultList = resultList;
 }

}

2.在最初测试的时候jaxbMarshaller报异常，无法找到处理泛型的办法。

3.在使用jaxb时需要在java bean打上@XmlSeeAlso(MultiQueryInfo.class)注释，作用就是是在jaxb绑定一个class时候可以使用

其他的class，在jaxb使用多态的时候都需要用到此标签；其中括号中可以添加多个class,如@XmlSeeAlso(A.class,B.class)

4.在客户端的bean中也需要用到此注释，否则同样报转换错误：

Exception in thread "main" java.lang.ClassCastException: com.sun.org.apache.xerces.internal.dom.ElementNSImpl cannot be cast to com.jd.fms.adsettlement.client.domain.MultiQueryInfo

2.导致此错误是m2eclipse插件0.12及之前的版本在Eclipse 内执行了一系列的生命周期引起冲突导致的，如果你的maven报此类错误，而又用到了maven-resources-plugin这个插件，那么请按你的项目pom.xml中加上

<plugin>
      <groupId>org.eclipse.m2e</groupId>
      <artifactId>lifecycle-mapping</artifactId>
      <version>1.0.0</version>
      <configuration>
        <lifecycleMappingMetadata>
          <pluginExecutions>
            <pluginExecution>
              <pluginExecutionFilter>
                <groupId>org.apache.maven.plugins</groupId>
       <artifactId>maven-resources-plugin</artifactId>
                <versionRange>[1.2,)</versionRange>
                <goals>
                <goal>resources</goal>
                 <goal>testResources</goal>
                </goals>
              </pluginExecutionFilter>
              <action>
                <ignore />
              </action>
            </pluginExecution>
          </pluginExecutions>
        </lifecycleMappingMetadata>
      </configuration>
    </plugin>

解决冲突，具体原因参看http://wiki.eclipse.org/M2E_plugin_execution_not_covered

2.通过以下方式配置spring使用groovy，和采用java编程没有太大区别，groovy提供较平顺的从java过来的学习曲线，下面的例子中的groovy类活生生就是一个java类，只不过是写在xml文件中的java类罢了；

3.spring通过org.springframework.scripting.groovy.GroovyScriptFactory类反射生成groovy类，由于使用到jdk的动态代理，所以所有用groovy定义的类必须实现java定义的接口，这是可以运行的关键；

4.配置spring.xml

<beans xmlns="http://www.springframework.org/schema/beans"
  xmlns:lang="http://www.springframework.org/schema/lang"
 xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/lang
        http://www.springframework.org/schema/lang/spring-lang-2.5.xsd
  "
 default-autowire="byName">

此文件头必不可少，否则无法识别lang标签；

<lang:groovy id="groovyHello" >
  <lang:inline-script>
        <![CDATA[
        package com.jd.fms;
            import com.jd.fms.netty.GroovyHelloWorld;
            public class TestGroovyHelloWorld implements GroovyHelloWorld{
    public void doit(){
    System.out.println("hello world");
    }
   }
        ]]>
    </lang:inline-script>
 </lang:groovy>

采用lang:groovy定义groovy片段，当然也可以采用

<lang:groovy id=" script-source="....">的方式引入文件。

不要忘记的是在工程中定义GroovyHelloWorld的接口，该接口需要实现一个doit方法。

5.项目中直接通过

@Autowired
 GroovyHelloWorld groovyHelloWorld;

调用即可；

6.groovy为java提供了很好的动态语言能力，如果项目没有必要使用太重量级的规则引擎，

那么使用动态语言让业务人员直接配置也不失为一个好方法。

RESTful Web 服务使用标准的 HTTP 方法 (GET/PUT/POST/DELETE) 来抽象所有 Web 系统的服务能力，而不同的是，SOAP 应用都通过定义自己个性化的接口方法来抽象 Web 服务，这更像我们经常谈到的 RPC。例如本例中的 getUserList 与 getUserByName 方法。

RESTful Web 服务使用标准的 HTTP 方法优势，从大的方面来讲：标准化的 HTTP 操作方法，结合其他的标准化技术，如 URI，HTML，XML 等，将会极大提高系统与系统之间整合的互操作能力。尤其在 Web 应用领域，RESTful Web 服务所表达的这种抽象能力更加贴近 Web 本身的工作方式，也更加自然。

同时，使用标准 HTTP 方法实现的 RRESTful Web 服务也带来了 HTTP 方法本身的一些优势：

• 无状态性（Stateless）

HTTP 协议从本质上说是一种无状态的协议，客户端发出的 HTTP 请求之间可以相互隔离，不存在相互的状态依赖。基于 HTTP 的 ROA，以非常自然的方式来实现无状态服务请求处理逻辑。对于分布式的应用而言，任意给定的两个服务请求 Request 1 与 Request 2, 由于它们之间并没有相互之间的状态依赖，就不需要对它们进行相互协作处理，其结果是：Request 1 与 Request 2 可以在任何的服务器上执行，这样的应用很容易在服务器端支持负载平衡 (load-balance)。

• 安全操作与幂指相等特性（Safety /Idempotence）

HTTP 的 GET、HEAD 请求本质上应该是安全的调用，即：GET、HEAD 调用不会有任何的副作用，不会造成服务器端状态的改变。对于服务器来说，客户端对某一 URI 做 n 次的 GET、HAED 调用，其状态与没有做调用是一样的，不会发生任何的改变。

HTTP 的 PUT、DELTE 调用，具有幂指相等特性 , 即：客户端对某一 URI 做 n 次的 PUT、DELTE 调用，其效果与做一次的调用是一样的。HTTP 的 GET、HEAD 方法也具有幂指相等特性。

HTTP 这些标准方法在原则上保证你的分布式系统具有这些特性，以帮助构建更加健壮的分布式系统。

安全控制

为了说明问题，基于上面的在线用户管理系统，我们给定以下场景：

参考一开始我们给出的用例图，对于客户端 Client2，我们只希望它能以只读的方式访问 User 和 User List 资源，而 Client1 具有访问所有资源的所有权限。

如何做这样的安全控制？

通行的做法是：所有从客户端 Client2 发出的 HTTP 请求都经过代理服务器 (Proxy Server)。代理服务器制定安全策略：所有经过该代理的访问 User 和 User List 资源的请求只具有读取权限，即：允许 GET/HEAD 操作，而像具有写权限的 PUT/DELTE 是不被允许的。

如果对于 REST，我们看看这样的安全策略是如何部署的。如下图所示：

一般代理服务器的实现根据 (URI, HTTP Method) 两元组来决定 HTTP 请求的安全合法性。

当发现类似于（http://localhost:8182/v1/users/{username}，DELETE）这样的请求时，予以拒绝。

对于 SOAP，如果我们想借助于既有的代理服务器进行安全控制，会比较尴尬，如下图：

所有的 SOAP 消息经过代理服务器，只能看到（http://localhost:8182/v1/soap/servlet/messagerouter, HTTP POST）这样的信息，如果代理服务器想知道当前的 HTTP 请求具体做的是什么，必须对 SOAP 的消息体解码，这样的话，意味着要求第三方的代理服务器需要理解当前的 SOAP 消息语义，而这种 SOAP 应用与代理服务器之间的紧耦合关系是不合理的。

关于缓存

众所周知，对于基于网络的分布式应用，网络传输是一个影响应用性能的重要因素。如何使用缓存来节省网络传输带来的开销，这是每一个构建分布式网络应用的开发人员必须考虑的问题。

HTTP 协议带条件的 HTTP GET 请求 (Conditional GET) 被设计用来节省客户端与服务器之间网络传输带来的开销，这也给客户端实现 Cache 机制 ( 包括在客户端与服务器之间的任何代理 ) 提供了可能。HTTP 协议通过 HTTP HEADER 域：If-Modified-Since/Last- Modified，If-None-Match/ETag 实现带条件的 GET 请求。

REST 的应用可以充分地挖掘 HTTP 协议对缓存支持的能力。当客户端第一次发送 HTTP GET 请求给服务器获得内容后，该内容可能被缓存服务器 (Cache Server) 缓存。当下一次客户端请求同样的资源时，缓存可以直接给出响应，而不需要请求远程的服务器获得。而这一切对客户端来说都是透明的。

而对于 SOAP，情况又是怎样的呢？

使用 HTTP 协议的 SOAP，由于其设计原则上并不像 REST 那样强调与 Web 的工作方式相一致，所以，基于 SOAP 应用很难充分发挥 HTTP 本身的缓存能力。

两个因素决定了基于 SOAP 应用的缓存机制要远比 REST 复杂：

其一、所有经过缓存服务器的 SOAP 消息总是 HTTP POST，缓存服务器如果不解码 SOAP 消息体，没法知道该 HTTP 请求是否是想从服务器获得数据。

其二、SOAP 消息所使用的 URI 总是指向 SOAP 的服务器，如本文例子中的 http://localhost:8182/v1/soap/servlet/messagerouter，这并没有表达真实的资源 URI，其结果是缓存服务器根本不知道那个资源正在被请求，更不用谈进行缓存处理。

关于连接性

在一个纯的 SOAP 应用中，URI 本质上除了用来指示 SOAP 服务器外，本身没有任何意义。与 REST 的不同的是，无法通过 URI 驱动 SOAP 方法调用。例如在我们的例子中，当我们通过

getUserList SOAP 消息获得所有的用户列表后，仍然无法通过既有的信息得到某个具体的用户信息。唯一的方法只有通过 WSDL 的指示，通过调用 getUserByName 获得，getUserList 与 getUserByName 是彼此孤立的。

而对于 REST，情况是完全不同的：通过 http://localhost:8182/v1/users URI 获得用户列表，然后再通过用户列表中所提供的 LINK 属性，例如 <link>http://localhost:8182/v1/users/tester</link>获得 tester 用户的用户信息。这样的工作方式，非常类似于你在浏览器的某个页面上点击某个 hyperlink, 浏览器帮你自动定向到你想访问的页面，并不依赖任何第三方的信息。

总结

典型的基于 SOAP 的 Web 服务以操作为中心，每个操作接受 XML 文档作为输入，提供 XML 文档作为输出。在本质上讲，它们是 RPC 风格的。而在遵循 REST 原则的 ROA 应用中，服务是以资源为中心的，对每个资源的操作都是标准化的 HTTP 方法。

本文主要集中在以上的几个方面，对 SOAP 与 REST 进行了对比，可以看到，基于 REST 构建的系统其系统的扩展能力要强于 SOAP，这可以体现在它的统一接口抽象、代理服务器支持、缓存服务器支持等诸多方面。并且，伴随着 Web Site as Web Services 演进的趋势，基于 REST 设计和实现的简单性和强扩展性，有理由相信，REST 将会成为 Web 服务的一个重要架构实践领域。