BlogJava-zhb8015-文章分类-soahttp://www.blogjava.net/zhb8015/category/51178.htmlzh-cnTue, 05 Jun 2012 07:24:35 GMTTue, 05 Jun 2012 07:24:35 GMT60REST架构下的接口规范和使用准则（ 转）http://www.blogjava.net/zhb8015/articles/379943.htmlzhb8015zhb8015Mon, 04 Jun 2012 08:38:00 GMThttp://www.blogjava.net/zhb8015/articles/379943.htmlhttp://www.blogjava.net/zhb8015/comments/379943.htmlhttp://www.blogjava.net/zhb8015/articles/379943.html#Feedback0http://www.blogjava.net/zhb8015/comments/commentRss/379943.htmlhttp://www.blogjava.net/zhb8015/services/trackbacks/379943.html来自: http://hi.baidu.com/yaobodi/blog/item/f655da333ff3974fac4b5f01.html
REST架构下的接口规范和使用准则
2010-04-08 15:14

REST架构风格是全新的针对Web应用的开发风格，是当今世界最成功的互联网超媒体分布式系统架构，它使得人们真正理解了Http协议本来面貌。随着 REST架构成为主流技术，一种全新的互联网网络应用开发的思维方式开始流行。

目前，51，校内，海内，阿里软件等都通过REST架构来实现平台数据的开放，与第三方的数据交换。REST已然成为sns开放平台的首要开放标准。下面简单介绍一下REST的原理和使用准则。

wiki介绍见此：http://en.wikipedia.org/wiki/Representational_State_Transfer

REST是什么

REST是英文Representational State Transfer的缩写，中文翻译为“表述性状态转移”，他是由Roy Thomas Fielding博士在他的论文 《Architectural Styles and the Design of Network-based Software Architectures》中提出的一个术语。REST本身只是为分布式超媒体系统设计的一种架构风格，而不是标准。

基于Web的架构，实际上就是各种规范的集合，这些规范共同组成了Web架构。比如Http协议，比如客户端服务器模 式，这些都是规范。每当我们在原有规 范的基础上增加新的规范，就会形成新的架构。而REST正是这样一种架构，他结合了一系列的规范，而形成了一种新的基于Web的架构风格。

传统的Web应用大都是B/S架构，它包括了如下一些规范 。

客户－服务器

  • 这种规范的提出，改善了用户接口跨多个平台的可移植性，并且通过简化服务器组件，改善了系统的可伸缩性。最为关键的是通过分离用户接口和数据存储这两个关注点，使得不同用户终端享受相同数据成为了可能。

无状态性

  • 无 状态性是在客户－服务器约束的基础上添加的又一层规范。他要求通信必须在本质上是无状态的，即从客户到服务器的每个request都必须包含理解该 request所必须的所有信息。这个规范改善了系统的可见性（无状态性使得客户端和服务器端不必保存对方的详细信息，服务器只需要处理当前 request，而不必了解所有的request历史），可靠性（无状态性减少了服务器从局部错误中恢复的任务量），可伸缩性（无状态性使得服务器端可以 很容易的释放资源，因为服务器端不必在多个request中保存状态）。同时，这种规范的缺点也是显而易见得，由于不能将状态数据保存在服务器上的共享上 下文中，因此增加了在一系列request中发送重复数据的开销,严重的降低了效率。

缓存

  • 为 了改善无状态性带来的网络的低效性，我们填加了缓存约束。缓存约束允许隐式或显式地标记一个response中的数据，这样就赋予了客户端缓存 response数据的功能，这样就可以为以后的request共用缓存的数据，部分或全部的消除一部分交互，增加了网络的效率。但是用于客户端缓存了信 息，也就同时增加了客户端与服务器数据不一致的可能，从而降低了可靠性。

B/S架构的优点是其部署非常方便，但在用户体验方面却不是很理想。为了改善这种情况，我们引入了REST。

REST在原有的架构上增加了三个新规范：统一接口，分层系统和按需代码。

统一接口

  • REST 架构风格的核心特征就是强调组件之间有一个统一的接口，这表现在REST世界里，网络上所有的事物都被抽象为资源，而REST就是通过通用的链接器接口对 资源进行操作。这样设计的好处是保证系统提供的服务都是解耦的，极大的简化了系统，从而改善了系统的交互性和可重用性。并且REST针对Web的常见情况 做了优化，使得REST接口被设计为可以高效的转移大粒度的超媒体数据，这也就导致了REST接口对其它的架构并不是最优的。

分层系统

  • 分层系统规则的加入提高了各种层次之间的独立性，为整个系统的复杂性设置了边界，通过封装遗留的服务，使新的服务器免受遗留客户端的影响，这也就提高了系统的可伸缩性。

按需代码

  • REST允许对客户端功能进行扩展。比如，通过下载并执行applet或脚本形式的代码，来扩展客户端功能。但这在改善系统可扩展性的同时，也降低了可见性。所以它只是REST的一个可选的约束。

REST的设计准则

REST架构是针对Web应用而设计的，其目的是为了降低开发的复杂性，提高系统的可伸缩性。REST提出了如下设计准则：

    1. 网络上的所有事物都被抽象为资源（resource）；
    2. 每个资源对应一个唯一的资源标识符（resource identifier）；
    3. 通过通用的连接器接口（generic connector interface）对资源进行操作；
    4. 对资源的各种操作不会改变资源标识符；
    5. 所有的操作都是无状态的（stateless）。

REST中的资源所指的不是数据，而是数据和表现形式的组合，比如“最新访问的10位会员”和“最活跃的10为会员”在 数据上可能有重叠或者完全相同，而 由于他们的表现形式不同，所以被归为不同的资源，这也就是为什么REST的全名是Representational State Transfer的原因。资源标识符就是URI(Uniform Resource Identifier)，不管是图片，Word还是视频文件，甚至只是一种虚拟的服务，也不管你是xml格式,txt文件格式还是其它文件格式，全部通过 URI对资源进行唯一的标识。

REST是基于Http协议的，任何对资源的操作行为都是通过Http协议来实现。以往的Web开发大多数用的都是 Http协议中的GET和POST方 法，对其他方法很少使用，这实际上是因为对Http协议认识片面的理解造成的。Http不仅仅是一个简单的运载数据的协议，而是一个具有丰富内涵的网络软 件的协议。他不仅仅能对互联网资源进行唯一定位，而且还能告诉我们如何对该资源进行操作。Http把对一个资源的操作限制在4个方法以内：GET, POST,PUT和DELETE，这正是对资源CRUD操作的实现。由于资源和URI是一一对应的，执行这些操作的时候URI是没有变化的，这和以往的 Web开发有很大的区别。正由于这一点，极大的简化了Web开发，也使得URI可以被设计成更为直观的反映资源的结构，这种URI的设计被称作 RESTful的URI。这位开发人员引入了一种新的思维方式：通过URL来设计系统结构。当然了，这种设计方式对一些特定情况也是不适用的，也就是说不 是所有的URI都可以RESTful的。

REST 之所以可以提高系统的可伸缩性，就是因为它要求所有的操作都是无状态的。由于没有了上下文(Context)的约束，做分布式和集群的时候就更为简单，也 可以让系统更为有效的利用缓冲池(Pool）。并且由于服务器端不需要记录客户端的一系列访问，也减少了服务器端的性能。

使用REST架构

对于开发人员来 说，关心的是如何使用REST架构，这里我们来简单谈谈这个问题。REST不仅仅是一种崭新的架构，它带来的更是一种全新的Web开发过程中的思维方式： 通过URL来设计系统结构。在REST中，所有的URL都对应着资源，只要URL的设计是良好的，那么其呈现的系统结构也就是良好的。这点和TDD (Test Driven Development)很相似，他是通过测试用例来设计系统的接口，每一个测试用例都表示一系列用户的需求。开发人员不需要一开始就编写功能，而只需要 把需要实现的功能通过测试用例的形式表现出来即可。这个和REST中通过URL设计系统结构的方式类似，我们只需要根据需求设计出合理地URL，这些 URL不一定非要链接到指定的页面或者完成一些行为，只要它们能够直观的表现出系统的用户接口。根据这些URL，我们就可以方便的设计系统结构。从 REST架构的概念上来看，所有能够被抽象成资源的东西都可以被指定为一个URL，而开发人员所需要做的工作就是如何能把用户需求抽象为资源，以及如何抽 象的精确。因为对资源抽象的越为精确，对REST的应用来说就越好。这个和传统MVC开发模式中基于Action的思想差别就非常大。设计良好的URL， 不但对于开发人员来说可以更明确的认识系统结构，对使用者来说也方便记忆和识别资源，因为URL足够简单和有意义。按照以往的设计模式，很多URL后面都 是一堆参数，对于使用者来说也是很不方便的。

既然REST这 么好用，那么是不是所有的Web应用都能采取此种架构呢？答案是否定的。我们知道，直到现在为止，MVC(Model-View-Controller) 模式依然是Web开发最普遍的模式，绝大多数的公司和开发人员都采取此种架构来开发Web应用，并且其思维方式也停留于此。MVC模式由数据，视图和控制 器构成，通过事件(Event)触发Controller来改变Model和View。加上Webwork,Struts等开源框架的加入，MVC开发模 式已经相当成熟，其思想根本就是基于Action来驱动。从开发人员角度上来说，贸然接受一个新的架构会带来风险，其中的不确定因素太多。并且REST新 的思维方式是把所有用户需求抽象为资源，这在实际开发中是比较难做到的，因为并不是所有的用户需求都能被抽象为资源，这样也就是说不是整个系统的结构都能 通过REST的来表现。所以在开发中，我们需要根据以上2点来在REST和MVC中做出选择。我们认为比较好的办法是混用REST和MVC，因为这适合绝 大多数的Web应用开发，开发人员只需要对比较容易能够抽象为资源的用户需求采取REST的开发模式，而对其它需求采取MVC开发即可。这里需要提到的就 是ROR(Ruby on Rails)框架，这是一个基于Ruby语言的越来越流行的Web开发框架，它极大的提高了Web开发的速度。更为重要的是，ROR(从1.2版本起)框 架是第一个引入REST做为核心思想的Web开发框架，它提供了对REST最好的支持，也是当今最成功的应用REST的Web开发框架。实际上，ROR的 REST实现就是REST和MVC混用，开发人员采用ROR框架，可以更快更好的构建Web应用。

对开发人员来说，REST不仅仅在Web开发上贡献了自己的力量，同时也让我们学到了如何把软件工程原则系统地应用于对一个真实软件的设计和评估上



zhb8015 2012-06-04 16:38 发表评论
]]>xfire 与spring完整集成实例(转)http://www.blogjava.net/zhb8015/articles/378208.htmlzhb8015zhb8015Tue, 15 May 2012 09:42:00 GMThttp://www.blogjava.net/zhb8015/articles/378208.htmlhttp://www.blogjava.net/zhb8015/comments/378208.htmlhttp://www.blogjava.net/zhb8015/articles/378208.html#Feedback0http://www.blogjava.net/zhb8015/comments/commentRss/378208.htmlhttp://www.blogjava.net/zhb8015/services/trackbacks/378208.html
首先打开Myeclipse8.x以上版本..因为我这里共享那些xfire 项目所需要的jar都是Myeclipse自带添加的，所以要求大家伙准备好myeclipse8.x或者更高版本的..这里是spring2.0与xfire1.2整合..废话少说..转正正传..

 

1.打开Myeclipse--->new project-->项目名随便吧..最好是有意义的名称..看起来比较舒服..


2--配置web.xml

 

<?xml version="1.0" encoding="UTF-8"?>

<web-app xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="2.5" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee   http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">


  <context-param>

   <param-name>contextConfigLocation</param-name>

   <param-value>classpath:applicationContext.xml,classpath:org/codehaus/xfire/spring/xfire.xml</param-value>

  </context-param>


<listener>

<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>

</listener>


   <listener>

<listener-class>org.springframework.web.util.IntrospectorCleanupListener</listener-class>

</listener>

  <servlet>

    <servlet-name>XFireServlet</servlet-name>

    <servlet-class>org.codehaus.xfire.transport.http.XFireConfigurableServlet</servlet-class>

    <load-on-startup>0</load-on-startup>

  </servlet>

  <servlet-mapping>

    <servlet-name>XFireServlet</servlet-name>

    <url-pattern>/services/*</url-pattern>

  </servlet-mapping>

  <welcome-file-list>

    <welcome-file>index.jsp</welcome-file>

  </welcome-file-list>

</web-app>

 


3.配置applicationContext.xml

 

<?xml version="1.0" encoding="UTF-8"?>

<beans

xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns:p="http://www.springframework.org/schema/p"

xmlns:jee="http://www.springframework.org/schema/jee"

xmlns:aop="http://www.springframework.org/schema/aop"

xmlns:tx="http://www.springframework.org/schema/tx"

xsi:schemaLocation="http://www.springframework.org/schema/beans

 http://www.springframework.org/schema/beans/spring-beans-2.0.xsd

 http://www.springframework.org/schema/aop

 http://www.springframework.org/schema/aop/spring-aop-2.0.xsd

 http://www.springframework.org/schema/tx

 http://www.springframework.org/schema/tx/spring-tx-2.0.xsd

 http://www.springframework.org/schema/jee

 http://www.springframework.org/schema/jee/spring-jee-2.0.xsd"

 default-autowire="byName" default-lazy-init="true"

 >

 <import resource="classpath:org/codehaus/xfire/spring/xfire.xml"/>

 <import resource="xfire-servlet.xml"/>

</beans>

 

 

 

 

4.配置xfire-servlet.xml

 

为了不给大家伙困扰.所以我这里用那个就打开那个配置..

 

 

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN"

"http://www.springframework.org/dtd/spring-beans-2.0.dtd">

<beans>

<!-- 

<bean id="HellWorldSimple" class="org.codehaus.xfire.spring.ServiceBean">

<property name="name">

<value>HelloWorldSimple</value>

</property>

<property name="namespace">

<value>http://service.core.xfire.com</value>

</property>

<property name="serviceClass">

<value>com.xfire.core.service.IHelloWorld</value>

</property>

<property name="serviceBean">

<ref bean="HellWorldSimple"/>

</property>

</bean>

-->

<!-- 

  <bean id="MyHandle" class="org.codehaus.xfire.spring.ServiceBean">

<property name="name">

<value>MyHandle</value>

</property>

<property name="namespace">

<value>http://service.core.xfire.com</value>

</property>

<property name="serviceClass">

<value>com.xfire.core.handler.MyHandlerImpl</value>

</property>

<property name="serviceBean">

<ref bean="MyHandle"/>

</property>

</bean>

 -->



<bean id="UserInfoService" class="org.codehaus.xfire.spring.ServiceBean">

<property name="name">

<value>UserInfo</value>

</property>

<property name="namespace">

<value>http://service.core.xfire.com/UserInfoService</value>

</property>

<property name="serviceClass">

<value>com.xfire.core.service.IUserInfoService</value>

</property>

<property name="serviceBean">

<ref bean="UserInfoService"/>

</property>

</bean>

<!--  

   <bean id="ApplictionException" class="org.codehaus.xfire.spring.ServiceBean">

<property name="name">

<value>ApplictionException</value>

</property>


<property name="namespace">

<value>http://service.core.xfire.com/IMyExceptionSevice</value>

</property>

<property name="serviceClass">

<value>com.xfire.core.service.IMyExceptionSevice</value>

</property>

<property name="serviceBean">

<ref bean="ApplictionException"/>

</property>

</bean>

-->

 

 

 

 <!--  

   <bean id="IServiceMap" class="org.codehaus.xfire.spring.ServiceBean">

<property name="name">

<value>AddressService</value>

</property>


<property name="namespace">

<value>http://service.core.xfire.com/IServiceMap</value>

</property>

<property name="serviceClass">

<value>com.xfire.core.service.IServiceMap</value>

</property>

<property name="serviceBean">

<ref bean="IServiceMap"/>

</property>

</bean>

-->

 

</beans>


 

 

5.xfire-servlet.xml配置

 

 

<?xml version="1.0" encoding="UTF-8"?>

<beans>

<!--

    在没整合spring之前的xfire是这样的配置

  当要整合spring之后的这句代码复制到service 节点

  xmlns="http://xfire.codehaus.org/config/1.0"

  <beans xmlns="http://xfire.codehaus.org/config/1.0">

 -->

<service xmlns="http://xfire.codehaus.org/config/1.0">


 

 <name>UserInfo</name>

 <namespace>http://service.core.xfire.com</namespace>

 <serviceClass>com.xfire.core.service.IUserInfoService</serviceClass>

 <implementationClass>com.xfire.core.service.impl.UserInfoServiceImpl

 </implementationClass>

 <scope>request</scope>

 

 

<!-- 

<name>HelloWorldSimple</name>

<namespace>http://service.core.xfire.com</namespace>

<serviceClass>com.xfire.core.service.IHelloWorld</serviceClass>

<implementationClass>com.xfire.core.service.impl.HelloWorldImpl</implementationClass>

<style>wrapped</style>

<use>literal</use>

<scope>request</scope>

-->

<!--  

<name>MyHandle</name>

<namespace>http://service.core.xfire.com</namespace>

<serviceClass>com.xfire.core.handler.IMyHandler</serviceClass>

<implementationClass>com.xfire.core.handler.MyHandlerImpl</implementationClass>

<scope>application</scope>

 -->

 <!-- 

<name>ServiceMap</name>

<namespace>http://service.core.xfire.com</namespace>

<serviceClass>com.xfire.core.service.IServiceMap</serviceClass>

<implementationClass>com.xfire.core.service.impl.ServiceMapImpl

</implementationClass>

<scope>request</scope>

 -->

 

 

<!-- 

<name>ApplictionException</name>

<namespace>http://service.core.xfire.com</namespace>

<serviceClass>com.xfire.core.service.IMyExceptionSevice</serviceClass>

<implementationClass>com.xfire.core.service.impl.MyExceptionSeviceImpl</implementationClass>

<scope>request</scope>

-->

 

</service>

</beans>

 

 


实现代码..

首先新建一个实体类UseInfor

package com.xfire.core.entity;

 

import java.io.Serializable;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

 

/**

 *@author jilongliang

 *@Date 2012-2-29

 */

@SuppressWarnings("all")

public class UserInfo implements Serializable {

 

private Integer identifier;

 

private String address;

private String city;

private String proivice;

 

public Integer getIdentifier() {

return identifier;

}

 

public void setIdentifier(Integer identifier) {

this.identifier = identifier;

}

 

public String getAddress() {

return address;

}

 

public void setAddress(String address) {

this.address = address;

}

 

public String getCity() {

return city;

}

 

public void setCity(String city) {

this.city = city;

}

 

public String getProivice() {

return proivice;

}

 

public void setProivice(String proivice) {

this.proivice = proivice;

}

 

public String getCountry() {

return country;

}

 

public void setCountry(String country) {

this.country = country;

}

 

public String getPostCode() {

return postCode;

}

 

public void setPostCode(String postCode) {

this.postCode = postCode;

}

 

public String[] getArrary() {

return arrary;

}

 

public void setArrary(String[] arrary) {

this.arrary = arrary;

}

 

public List<Integer> getList() {

return list;

}

 

public void setList(List<Integer> list) {

this.list = list;

}

 

public Map<Integer, InnerClass> getMap() {

return map;

}

 

public void setMap(Map<Integer, InnerClass> map) {

this.map = map;

}

 

public boolean isExist() {

return isExist;

}

 

public void setExist(boolean isExist) {

this.isExist = isExist;

}

 

public InnerClass getInner() {

return inner;

}

 

public void setInner(InnerClass inner) {

this.inner = inner;

}

 

private String country;

private String postCode;

private String[] arrary;

private List<Integer> list;

 

private Map<Integer, InnerClass> map;

 

private boolean isExist;

private InnerClass inner;

 

public UserInfo() {

 

list = new ArrayList<Integer>();

list.add(1);

list.add(2);

list.add(3);

 

map = new HashMap<Integer, InnerClass>();

map.put(1, new InnerClass("a"));

map.put(2, new InnerClass("b"));

map.put(3, new InnerClass("c"));

 

inner = new InnerClass();

inner.setInnerName("服务器地址: Address InnerClass");

 

}

 

@Override

public String toString() {

return "Address [address=" + address + ", arrary="

+ Arrays.toString(arrary) + ", city=" + city + ", country="

+ country + ", identifier=" + identifier + ", inner=" + inner

+ ", isExist=" + isExist + ", list=" + list + ", map=" + map

+ ", postCode=" + postCode + ", proivice=" + proivice + "]";

}

 

}



----内置实体类
package com.xfire.core.entity;

import java.io.Serializable;

/**
 *@Project xfire
 *@author jilongliang
 *@Date 2012-2-29
 *@Class InnerClass.java
 */
@SuppressWarnings("all")
public class InnerClass implements Serializable {

private String innerName = "static InnerClass";

public String getInnerName() {
return innerName;
}

public void setInnerName(String innerName) {
this.innerName = innerName;
}

public InnerClass() {
}

public InnerClass(String innerName) {
super();
this.innerName = innerName;

}
}



其次一个接口类:
package com.xfire.core.service;

import java.util.List;

import com.xfire.core.entity.UserInfo;

/**
 *@author jilongliang
 *@Date 2012-2-29
 */
public interface IUserInfoService {
public List<UserInfo> getAddressList();

public List<UserInfo> setAddresses(List<UserInfo> list);
}



然后新建一个实现类去实现接口

package com.xfire.core.service.impl;

import java.util.ArrayList;
import java.util.List;

import com.xfire.core.entity.UserInfo;
import com.xfire.core.service.IUserInfoService;

/**
 *@author jilongliang
 *@Date 2012-2-29
 */
public class UserInfoServiceImpl implements IUserInfoService {

private int requestCount = 0;

public List<UserInfo> getAddressList() {
requestCount++;
System.out.println("requestCount" + requestCount);
List<UserInfo> listAdd = new ArrayList<UserInfo>();
UserInfo address = new UserInfo();
address.setIdentifier(1);
address.setCountry("中國");
address.setProivice("廣東省");
address.setCity("陽江");
address.setAddress("廣東陽春");
address.setPostCode("1111111");
address.setExist(false);
address.setArrary(new String[] { "22", "23", "24" });
listAdd.add(address);

address.setIdentifier(2);
address.setCountry("中國");
address.setProivice("廣東省");
address.setCity("陽江");
address.setAddress("廣東陽春");
address.setPostCode("1111111");
address.setExist(false);
address.setArrary(new String[] { "a", "b", "c" });
listAdd.add(address);

return listAdd;
}

/**
 * 
 * @param list
 * @return
 */
public List<UserInfo> setAddresses(List<UserInfo> list) {
requestCount++;
System.out.println("requestCount" + requestCount);
return list;
}

}



-----客户端

package com.xfire.core.client;

import java.net.MalformedURLException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.codehaus.xfire.client.XFireProxyFactory;
import org.codehaus.xfire.service.Service;
import org.codehaus.xfire.service.binding.ObjectServiceFactory;

import com.xfire.core.entity.UserInfo;
import com.xfire.core.service.IUserInfoService;

/**
 *@author jilongliang
 *@Date 2012-3-5
 * 
 */
public class UserInfoClient {

public static void main(String[] args) {
getServiceList();
setServiceList();
}

static String url = "http://localhost:8081/xfire/services/UserInfo";

/**
 * 
 */
public static void getServiceList() {
Service service = new ObjectServiceFactory()
.create(IUserInfoService.class);

try {
IUserInfoService iAddressService = (IUserInfoService) new XFireProxyFactory()
.create(service, url);
List<UserInfo> list = (ArrayList<UserInfo>) iAddressService
.getAddressList();

System.out.println("一共多少条数据：" + list.size());

for (Iterator<UserInfo> iter = list.iterator(); iter.hasNext();) {

UserInfo a = iter.next();

System.out.println(a);
}

} catch (MalformedURLException e) {
e.printStackTrace();
}
}

public static void setServiceList() {
Service service = new ObjectServiceFactory()
.create(IUserInfoService.class);

try {
IUserInfoService iAddressService = (IUserInfoService) new XFireProxyFactory()
.create(service, url);

List<UserInfo> listAdd = new ArrayList<UserInfo>();
UserInfo address = new UserInfo();
address.setIdentifier(1);
address.setCountry("中國");
address.setProivice("廣東省");
address.setCity("陽江");
address.setAddress("廣東陽春");
address.setPostCode("1111111");
address.setExist(false);
address.setArrary(new String[] { "22", "23", "24" });
listAdd.add(address);

address.setIdentifier(2);
address.setCountry("中國");
address.setProivice("廣東省");
address.setCity("陽江");
address.setAddress("廣東陽春");
address.setPostCode("1111111");
address.setExist(false);
address.setArrary(new String[] { "a", "b", "c" });
listAdd.add(address);

List<UserInfo> returnAdd = iAddressService.setAddresses(listAdd);

System.out.println("总数:" + returnAdd);

for (Iterator<UserInfo> it = returnAdd.iterator(); it.hasNext();) {
UserInfo address2 = it.next();

System.out.println(address2);
}

} catch (MalformedURLException e) {
e.printStackTrace();
}

}
}


图解----

 




 

 

 

 

 

 

 

 

 

 

 

 

子书下载http://download.csdn.net/detail/l_ji_l/4116804

源代码下载：http://download.csdn.net/detail/l_ji_l/4116788



zhb8015 2012-05-15 17:42 发表评论
]]>java.lang.IllegalStateException: Could not find valid implementation for: 2.0http://www.blogjava.net/zhb8015/articles/377905.htmlzhb8015zhb8015Fri, 11 May 2012 06:42:00 GMThttp://www.blogjava.net/zhb8015/articles/377905.htmlhttp://www.blogjava.net/zhb8015/comments/377905.htmlhttp://www.blogjava.net/zhb8015/articles/377905.html#Feedback0http://www.blogjava.net/zhb8015/comments/commentRss/377905.htmlhttp://www.blogjava.net/zhb8015/services/trackbacks/377905.htmlmyeclipse6.5,xfire1.2.6开发webservice报错，
报错原因：xfire自带spring-1.2.6.jar 与spring.jar版本冲突，删除一个即可 
 
 
java.lang.IllegalStateException: Could not find valid implementation for: 2.0
	org.apache.xbean.spring.context.impl.XBeanHelper.createBeanDefinitionReader(XBeanHelper.java:48)
	org.codehaus.xfire.spring.XFireConfigLoader.getXFireApplicationContext(XFireConfigLoader.java:74)
	org.codehaus.xfire.spring.XFireConfigLoader.loadContext(XFireConfigLoader.java:41)
	org.codehaus.xfire.transport.http.XFireConfigurableServlet.loadConfig(XFireConfigurableServlet.java:86)
	org.codehaus.xfire.transport.http.XFireConfigurableServlet.createXFire(XFireConfigurableServlet.java:54)
	org.codehaus.xfire.transport.http.XFireServlet.init(XFireServlet.java:45)
	javax.servlet.GenericServlet.init(GenericServlet.java:212)
	org.apache.catalina.valves.ErrorReportValve.invoke(ErrorReportValve.java:102)
	org.apache.catalina.connector.CoyoteAdapter.service(CoyoteAdapter.java:298)
	org.apache.coyote.http11.Http11Processor.process(Http11Processor.java:859)
	org.apache.coyote.http11.Http11Protocol$Http11ConnectionHandler.process(Http11Protocol.java:588)
	org.apache.tomcat.util.net.JIoEndpoint$Worker.run(JIoEndpoint.java:489)
	java.lang.Thread.run(Thread.java:662)

 

root cause 

java.lang.reflect.InvocationTargetException
	sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
	sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:39)
	sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:27)
	java.lang.reflect.Constructor.newInstance(Constructor.java:513)
	org.apache.xbean.spring.context.impl.XBeanHelper.createBeanDefinitionReader(XBeanHelper.java:46)
	org.codehaus.xfire.spring.XFireConfigLoader.getXFireApplicationContext(XFireConfigLoader.java:74)
	org.codehaus.xfire.spring.XFireConfigLoader.loadContext(XFireConfigLoader.java:41)
	org.codehaus.xfire.transport.http.XFireConfigurableServlet.loadConfig(XFireConfigurableServlet.java:86)
	org.codehaus.xfire.transport.http.XFireConfigurableServlet.createXFire(XFireConfigurableServlet.java:54)
	org.codehaus.xfire.transport.http.XFireServlet.init(XFireServlet.java:45)
	javax.servlet.GenericServlet.init(GenericServlet.java:212)
	org.apache.catalina.valves.ErrorReportValve.invoke(ErrorReportValve.java:102)
	org.apache.catalina.connector.CoyoteAdapter.service(CoyoteAdapter.java:298)
	org.apache.coyote.http11.Http11Processor.process(Http11Processor.java:859)
	org.apache.coyote.http11.Http11Protocol$Http11ConnectionHandler.process(Http11Protocol.java:588)
	org.apache.tomcat.util.net.JIoEndpoint$Worker.run(JIoEndpoint.java:489)
	java.lang.Thread.run(Thread.java:662)

 

root cause 

java.lang.NoSuchMethodError: org.springframework.beans.factory.xml.XmlBeanDefinitionReader.setValidationMode(I)V
	org.apache.xbean.spring.context.v2.XBeanXmlBeanDefinitionReader.<init>(XBeanXmlBeanDefinitionReader.java:58)
	sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
	sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:39)
	sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:27)
	java.lang.reflect.Constructor.newInstance(Constructor.java:513)
	org.apache.xbean.spring.context.impl.XBeanHelper.createBeanDefinitionReader(XBeanHelper.java:46)
	org.codehaus.xfire.spring.XFireConfigLoader.getXFireApplicationContext(XFireConfigLoader.java:74)
	org.codehaus.xfire.spring.XFireConfigLoader.loadContext(XFireConfigLoader.java:41)
	org.codehaus.xfire.transport.http.XFireConfigurableServlet.loadConfig(XFireConfigurableServlet.java:86)
	org.codehaus.xfire.transport.http.XFireConfigurableServlet.createXFire(XFireConfigurableServlet.java:54)
	org.codehaus.xfire.transport.http.XFireServlet.init(XFireServlet.java:45)
	javax.servlet.GenericServlet.init(GenericServlet.java:212)
	org.apache.catalina.valves.ErrorReportValve.invoke(ErrorReportValve.java:102)
	org.apache.catalina.connector.CoyoteAdapter.service(CoyoteAdapter.java:298)
	org.apache.coyote.http11.Http11Processor.process(Http11Processor.java:859)
	org.apache.coyote.http11.Http11Protocol$Http11ConnectionHandler.process(Http11Protocol.java:588)
	org.apache.tomcat.util.net.JIoEndpoint$Worker.run(JIoEndpoint.java:489)
	java.lang.Thread.run(Thread.java:662)


zhb8015 2012-05-11 14:42 发表评论
]]>理解AXIOMhttp://www.blogjava.net/zhb8015/articles/377311.htmlzhb8015zhb8015Thu, 03 May 2012 10:16:00 GMThttp://www.blogjava.net/zhb8015/articles/377311.htmlhttp://www.blogjava.net/zhb8015/comments/377311.htmlhttp://www.blogjava.net/zhb8015/articles/377311.html#Feedback0http://www.blogjava.net/zhb8015/comments/commentRss/377311.htmlhttp://www.blogjava.net/zhb8015/services/trackbacks/377311.html　　AXIOM 还不是另一种对象模型。它有着明确的设计目标：大幅提升 Apache 下一代 SOAP 协议栈 Axis 2 的性能。结果造就了不同于其他对象模型的 AXIOM（也称为 OM），因为它突出了构造的轻型，并且 仅当需要的时候才建立。由于是轻型的，它尽可能地减轻对系统资源的压力，特别是 CPU 和内存。同时，延迟构造又允许在其他部分还没有完成的时候使用树的一部分。AXIOM 强大的延迟构建能力源于底层的 Streaming API for XML (StAX) 解析器。AXIOM 提供了所有这些特性，同时幕后的复杂性对用户是透明的。
　　使用 XMLBench Document Model Benchmark 测试的结果表明，AXIOM 的性能和现有的高性能对象模型相当。但是 AXIOM 的内存占用要好于现有多数依靠 SAX 和/或 DOM 输入输出的对象模型。因此对于 Web 服务引擎或内存受限制设备这样的 XML 处理器，AXIOM 是一种理想的选择，它可用于
　　一般的 XML 处理，但是有一个对 SOAP 优化了的可选层。

zhb8015 2012-05-03 18:16 发表评论
]]>axis2教程（转）http://www.blogjava.net/zhb8015/articles/377301.htmlzhb8015zhb8015Thu, 03 May 2012 09:07:00 GMThttp://www.blogjava.net/zhb8015/articles/377301.htmlhttp://www.blogjava.net/zhb8015/comments/377301.htmlhttp://www.blogjava.net/zhb8015/articles/377301.html#Feedback0http://www.blogjava.net/zhb8015/comments/commentRss/377301.htmlhttp://www.blogjava.net/zhb8015/services/trackbacks/377301.html

Axis2 教程

(http://zxs19861202.iteye.com/blog/630359

http://zxs19861202.iteye.com/blog/635903   手工打包)

WebServiceTomcatApache浏览器Web

  Axis2是一套崭新的WebService引擎，该版本是对Axis1.x重新设计的产物。Axis2不仅支持SOAP1.1和SOAP1.2，还集成了非常流行的REST WebService，同时还支持Spring、JSON等技术。这些都将在后面的系列教程中讲解。在本文中主要介绍了如何使用Axis2开发一个不需要任何配置文件的WebService，并在客户端使用Java和C#调用这个WebService。

一、Axis2的下载和安装

    读者可以从如下的网址下载Axis2的最新版本：

    http://ws.apache.org/axis2/

    在本文使用了目前Axis2的最新版本1.4.1。读者可以下载如下两个zip包：

    axis2-1.4.1-bin.zip

    axis2-1.4.1-war.zip

    其中axis2-1.4.1-bin.zip文件中包含了Axis2中所有的jar文件, axis2-1.4.1-war.zip文件用于将WebService发布到Web容器中。

    将axis2-1.4.1-war.zip文件解压到相应的目录，将目录中的axis2.war文件放到<Tomcat安装目录>\webapps目录中（本文使用的Tomcat的版本是6.x），并启动Tomcat。

    在浏览器地址栏中输入如下的URL：

    http://localhost:8080/axis2/

    如果在浏览器中显示出如图1所示的页面，则表示Axis2安装成功。



图1


 

二、编写和发布WebService

  对于用Java实现的服务程序给人的印象就是需要进行大量的配置，不过这一点在Axis2中将被终结。在Axis2中不需要进行任何的配置，就可以直接将一个简单的POJO发布成WebService。其中POJO中所有的public方法将被发布成WebService方法。

    下面我们来实现一个简单的POJO，代码如下：

public class SimpleService
{
    public String getGreeting(String name)
    {
        return "你好 " + name;
    }    
    public int getPrice()
    {
        return new java.util.Random().nextInt(1000);
    }    
}

 

    在SimpleService类中有两个方法，由于这两个方法都是public方法，因此，它们都将作为WebService方法被发布。

    编译SimpleService类后，将SimpleService.class文件放到<Tomcat安装目录>\webapps\axis2\WEB-INF\pojo目录中（如果没有pojo目录，则建立该目录）。现在我们已经成功将SimpleService类发布成了WebService。在浏览器地址栏中输入如下的URL：

http://localhost:8080/axis2/services/listServices

    这时当前页面将显示所有在Axis2中发布的WebService，如图2所示。

 

    在浏览器地址栏中输入如下的两个URL来分别测试getGreeting和getPrice方法：

http://localhost:8080/axis2/services/SimpleService/getGreeting?name=bill

http://localhost:8080/axis2/services/SimpleService/getPrice

    图3和图4分别显示了getGreeting和getPrice方法的测试结果。

 

图3  getGreeting方法的测试结果



 

 

 

图4  getPrice方法的测试结果



 

 

    在编写、发布和测试0配置的WebService时应注意如下几点：

    1. POJO类不能使用package关键字声明包。

    2. Axis2在默认情况下可以热发布WebService，也就是说，将WebService的.class文件复制到pojo目录中时，Tomcat不需要重新启动就可以自动发布WebService。如果想取消Axis2的热发布功能，可以打开<Tomcat安装目录>\webapps\axis2\WEB-INF\conf\axis2.xml，找到如下的配置代码：

<parameter name="hotdeployment">true</parameter>

 

 

 

    将true改为false即可。要注意的是，Axis2在默认情况下虽然是热发布，但并不是热更新，也就是说，一旦成功发布了WebService，再想更新该WebService，就必须重启Tomcat。这对于开发人员调试WebService非常不方便，因此，在开发WebService时，可以将Axis2设为热更新。在axis2.xml文件中找到<parameter name="hotupdate">false</parameter>，将false改为true即可。

    3. 在浏览器中测试WebService时，如果WebService方法有参数，需要使用URL的请求参数来指定该WebService方法参数的值，请求参数名与方法参数名要一致，例如，要测试getGreeting方法，请求参数名应为name，如上面的URL所示。

    4. 发布WebService的pojo目录只是默认的，如果读者想在其他的目录发布WebService，可以打开axis2.xml文件，并在<axisconfig>元素中添加如下的子元素：

 <deployer extension=".class" directory="my" class="org.apache.axis2.deployment.POJODeployer"/>

 

 

 

    上面的配置允许在<Tomcat安装目录>\webapps\axis2\WEB-INF\my目录中发布WebService。例如，将本例中的SimpleService.class复制到my目录中也可以成功发布（但要删除pojo目录中的SimpleService.class，否则WebService会重名）。

 

三、 用Java实现调用WebService的客户端程序

    WebService是为程序服务的，只在浏览器中访问WebService是没有意义的。因此，在本节使用Java实现了一个控制台程序来调用上一节发布的WebService。调用WebService的客户端代码如下：

package client;

import javax.xml.namespace.QName;
import org.apache.axis2.addressing.EndpointReference;
import org.apache.axis2.client.Options;
import org.apache.axis2.rpc.client.RPCServiceClient;

public class RPCClient
{
    public static void main(String[] args) throws Exception  
    {
        //  使用RPC方式调用WebService        
        RPCServiceClient serviceClient = new RPCServiceClient();
        Options options = serviceClient.getOptions();
        //  指定调用WebService的URL
        EndpointReference targetEPR = new EndpointReference(
                "http://localhost:8080/axis2/services/SimpleService");
        options.setTo(targetEPR);
        //  指定getGreeting方法的参数值
        Object[] opAddEntryArgs = new Object[] {"超人"};
        //  指定getGreeting方法返回值的数据类型的Class对象
        Class[] classes = new Class[] {String.class};
        //  指定要调用的getGreeting方法及WSDL文件的命名空间
        QName opAddEntry = new QName("http://ws.apache.org/axis2", "getGreeting");
        //  调用getGreeting方法并输出该方法的返回值
        System.out.println(serviceClient.invokeBlocking(opAddEntry, opAddEntryArgs, classes)[0]);
        //  下面是调用getPrice方法的代码，这些代码与调用getGreeting方法的代码类似
        classes = new Class[] {int.class};
        opAddEntry = new QName("http://ws.apache.org/axis2", "getPrice");
        System.out.println(serviceClient.invokeBlocking(opAddEntry, new Object[]{}, classes)[0]);
    } 
}

 

 

 

 

运行上面的程序后，将在控制台输出如下的信息：

 

你好 超人
443

    在编写客户端代码时应注意如下几点：

    1. 客户端代码需要引用很多Axis2的jar包，如果读者不太清楚要引用哪个jar包，可以在Eclipse的工程中引用Axis2发行包的lib目录中的所有jar包。

    2. 在本例中使用了RPCServiceClient类的invokeBlocking方法调用了WebService中的方法。invokeBlocking方法有三个参数，其中第一个参数的类型是QName对象，表示要调用的方法名；第二个参数表示要调用的WebService方法的参数值，参数类型为Object[]；第三个参数表示WebService方法的返回值类型的Class对象，参数类型为Class[]。当方法没有参数时，invokeBlocking方法的第二个参数值不能是null，而要使用new Object[]{}。

    3. 如果被调用的WebService方法没有返回值，应使用RPCServiceClient类的invokeRobust方法，该方法只有两个参数，它们的含义与invokeBlocking方法的前两个参数的含义相同。

    4. 在创建QName对象时，QName类的构造方法的第一个参数表示WSDL文件的命名空间名，也就是<wsdl:definitions>元素的targetNamespace属性值，下面是SimpleService类生成的WSDL文件的代码片段：

<?xml version="1.0" encoding="UTF-8"?>
<wsdl:definitions xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/" xmlns:ns1="http://org.apache.axis2/xsd"
xmlns:ns="http://ws.apache.org/axis2" xmlns:wsaw="http://www.w3.org/2006/05/addressing/wsdl"
xmlns:http="http://schemas.xmlsoap.org/wsdl/http/" xmlns:xs="http://www.w3.org/2001/XMLSchema"
xmlns:mime="http://schemas.xmlsoap.org/wsdl/mime/" xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
xmlns:soap12="http://schemas.xmlsoap.org/wsdl/soap12/"
targetNamespace="http://ws.apache.org/axis2">
    <wsdl:types>
         
    </wsdl:types>
     
</wsdl:definitions>

 

四、用wsdl2java简化客户端的编写

    也许有很多读者会说“有没有搞错啊，只调用两个WebService方法用要写这么多代码，太麻烦了”。

    不过幸好Axis2提供了一个wsdl2java.bat命令可以根据WSDL文件自动产生调用WebService的代码。wsdl2java.bat命令可以在<Axis2安装目录>"bin目录中找到。在使用wsdl2java.bat命令之前需要设置AXIS2_HOME环境变量，该变量值是<Axis2安装目录>。

    在Windows控制台输出如下的命令行来生成调用WebService的代码：

%AXIS2_HOME%\bin\wsdl2java -uri http://localhost:8080/axis2/services/SimpleService?wsdl -p client -s -o stub

    其中-url参数指定了wsdl文件的路径，可以是本地路径，也可以是网络路径。-p参数指定了生成的Java类的包名，-o参数指定了生成的一系列文件保存的根目录。在执行完上面的命令后，读者就会发现在当前目录下多了个stub目录，在."stub"src"client目录可以找到一个SimpleServiceStub.java文件，该文件复杂调用WebService，读者可以在程序中直接使用这个类，代码如下：

package client;

import javax.xml.namespace.QName;
import org.apache.axis2.addressing.EndpointReference;
import org.apache.axis2.client.Options;
import org.apache.axis2.rpc.client.RPCServiceClient;

public class StubClient
{
    public static void main(String[] args) throws Exception  
    {
        SimpleServiceStub stub = new SimpleServiceStub();
        SimpleServiceStub.GetGreeting gg = new SimpleServiceStub.GetGreeting();
        gg.setName("比尔");
        System.out.println( stub.getGreeting(gg).get_return());
        System.out.println(stub.getPrice().get_return());
    } 
}

 

 

    上面的代码大大简化了调用WebService的步骤，并使代码更加简洁。但要注意的是，wsdl2java.bat命令生成的Stub类将WebService方法的参数都封装在了相应的类中，类名为方法名，例如，getGreeting方法的参数都封装在了GetGreeting类中，要想调用getGreeting方法，必须先创建GetGreeting类的对象实例。

五、使用C#调用WebService

    从理论上说，WebService可以被任何支持SOAP协议的语言调用。在Visual Studio中使用C#调用WebService是在所有语言中最容易实现的（VB.net的调用方法类似，也同样很简单）。

    新建一个Visual Studio工程，并在引用Web服务的对话框中输入如下的URL，并输入Web引用名为“WebService”：

    http://localhost:8080/axis2/services/SimpleService?wsdl

    然后引用Web服务的对话框就会显示该WebService中的所有的方法，如图5所示。

 

 

    在完成上面的工作后，只需要如下三行C#代码就可以调用getGreeting和getPrice方法，并显示这两个方法的返回值：

WebService.SimpleService simpleService = new WSC.WebService.SimpleService();
MessageBox.Show( simpleService.getGreeting("比尔"));
MessageBox.Show(simpleService.getPrice().@return.ToString());

 

 

 

    在.net解析WSDL文件时直接将getGreeting方法的参数映射为String类型，因此，可以直接进行传值。
    从上面的调用过程可以看出，添加Web引用的过程就相当于在Java中调用wsdl2java.bat自动生成stub类的过程。只是在调用stub类时与C#有一定的区别，但从总体上来说，都大大简化了调用WebService的过程。



图5


 


图2


 


zhb8015 2012-05-03 17:07 发表评论
]]>axis2插件安装http://www.blogjava.net/zhb8015/articles/377280.htmlzhb8015zhb8015Thu, 03 May 2012 07:25:00 GMThttp://www.blogjava.net/zhb8015/articles/377280.htmlhttp://www.blogjava.net/zhb8015/comments/377280.htmlhttp://www.blogjava.net/zhb8015/articles/377280.html#Feedback0http://www.blogjava.net/zhb8015/comments/commentRss/377280.htmlhttp://www.blogjava.net/zhb8015/services/trackbacks/377280.html
Axis2_Codegen_Wizard_1.3.0
Axis2_Service_Archiver_1.3.0

zhb8015 2012-05-03 15:25 发表评论
]]>XFire 学习http://www.blogjava.net/zhb8015/articles/373409.htmlzhb8015zhb8015Thu, 05 Apr 2012 14:10:00 GMThttp://www.blogjava.net/zhb8015/articles/373409.htmlhttp://www.blogjava.net/zhb8015/comments/373409.htmlhttp://www.blogjava.net/zhb8015/articles/373409.html#Feedback0http://www.blogjava.net/zhb8015/comments/commentRss/373409.htmlhttp://www.blogjava.net/zhb8015/services/trackbacks/373409.html
http://www.blogjava.net/fastzch/archive/2008/08/28/225439.html
http://www.blogjava.net/waterye/archive/2005/12/05/22643.html
http://xfire.codehaus.org/JSR+181+Annotations
http://blog.csdn.net/hlf48641715/article/details/3220542
http://www.ibm.com/developerworks/cn/java/j-ws/#JAVAZA45

http://blog.csdn.net/shazhenhua/article/details/3186726
<interface_name>.aegis.xml-->
<mappings>
    <mapping>
        <method name="test">
            <parameter index="0" componentType="java.lang.String" />
            <return-type componentType="org.vivianj.xfire.pojo.Course" />
        </method>
    </mapping>
</mappings>

problem:
http://yuyuqian521.iteye.com/blog/939047

PS：
1、IHelloService.aegis.xml 应与interface放在同一包下，否则报错：
1 Cannot create mapping for java.util.List, unspecified component type for parameter 0 of method test in interface org.vivianj.xfire.service.IHelloService
2     org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:370)
2、services.xml应放在classes 中，目录结构META-INF-xfire-services.xml

zhb8015 2012-04-05 22:10 发表评论
]]>