Spring整合CXF，发布RSETful 风格WebService

最新推荐文章于 2024-08-20 18:23:39 发布
最新推荐文章于 2024-08-20 18:23:39 发布
阅读量757 收藏
点赞数
分类专栏： restful WebService CXF java 文章标签： rest cxf webservice spring
java 同时被 3 个专栏收录
19 篇文章 0 订阅
订阅专栏
WebService
2 篇文章 0 订阅
订阅专栏
restful
1 篇文章 0 订阅
订阅专栏

Spring整合CXF，发布RSETful 风格WebService

这篇文章是承接之前CXF整合Spring的这个项目示例的延伸，所以有很大一部分都是一样的。关于发布CXF WebServer和Spring整合CXF这里就不再多加赘述了。如果你对Spring整合CXF WebService不了解，具体你可以参看这两篇文章：

http://www.cnblogs.com/hoojo/archive/2011/03/30/1999563.html

http://www.cnblogs.com/hoojo/archive/2012/07/13/2590593.html

如果你不了解restful风格的WebService，你可以参考：

http://www.oracle.com/technetwork/articles/javase/index-137171.html

SpringMVC对RESTful的支持：

http://www.cnblogs.com/hoojo/archive/2011/06/10/2077422.html

使用 Jersey框架，搭建RESTful WebService（这个也比较简单）

http://www.ibm.com/developerworks/cn/web/wa-aj-tomcat/

官方文档：http://jersey.java.net/nonav/documentation/latest/user-guide.html#d4e8

其中，比较常用的RESTful框架就有Jersey、Spring REST、CXF RESTful，这些都可以很好的整合Spring框架，发布也相当的简单。且简单、易用、易上手，文档也比较丰富。

 

开发环境：

System：Windows

JavaEE Server：tomcat6

JavaSDK： jdk6+

IDE：eclipse、MyEclipse 6.6

 

开发依赖库：

JDK6、 JavaEE5、CXF-2.3.3、Spring 3.0.4

Email：hoojo_@126.com

Blog：http://blog.csdn.net/IBM_hoojo

http://hoojo.cnblogs.com/

http://hoojo.blogjava.net

 

下面我们就接着http://www.cnblogs.com/hoojo/archive/2011/03/30/1999563.html这篇文章，开始我们CXF RESTful WebService的旅程，enjoy~！^_*

 

准备工作

首先，你需要添加相关的jar包

image

其中，jsr331-api-1.1.1.jar是必须的，利用CXF发布REST服务得用到它，在cxf的lib库中可以找到这个jar。

下载地址：http://www.apache.org/dyn/closer.cgi?path=/cxf/2.3.11/apache-cxf-2.3.11.zip

其它的jar包都是非必须的！

JavaEntity

package com.hoo.entity;
 
import java.util.Map;
import javax.xml.bind.annotation.XmlRootElement;
 
/**
 * <b>function:</b> MapBean 封装Map集合元素
 * @author hoojo
 * @createDate 2012-7-20 下午01:22:31
 * @file MapBean.java
 * @package com.hoo.entity
 * @project CXFWebService
 * @blog http://blog.csdn.net/IBM_hoojo
 * @email hoojo_@126.com
 * @version 1.0
 */
@XmlRootElement
public class MapBean {
    private Map<String, User> map;
    
    //@XmlElement(type = User.class)
    public Map<String, User> getMap() {
        return map;
    }
    public void setMap(Map<String, User> map) {
        this.map = map;
    }
}

 

package com.hoo.entity;
 
import java.util.HashMap;
import java.util.List;
import javax.xml.bind.annotation.XmlRootElement;
 
/**
 * <b>function:</b> Users Entity
 * @author hoojo
 * @createDate 2011-3-18 上午09:27:31
 * @file Users.java
 * @package com.hoo.entity
 * @project CXFWebService
 * @blog http://blog.csdn.net/IBM_hoojo
 * @email hoojo_@126.com
 * @version 1.0
 */
@XmlRootElement(name = "UserInfos")
public class Users {
    private List<User> users;
    
    private User[] userArr;
    
    private HashMap<String, User> maps;
    
    
   // getter/setter
}
package com.hoo.entity;
 
import java.io.Serializable;
import javax.xml.bind.annotation.XmlRootElement;
 
/**
 * <b>function:</b>User Entity
 * @author hoojo
 * @createDate Dec 16, 2010 10:20:02 PM
 * @file User.java
 * @package com.hoo.entity
 * @project AxisWebService
 * @blog http://blog.csdn.net/IBM_hoojo
 * @email hoojo_@126.com
 * @version 1.0
 */
@XmlRootElement(name = "UserInfo")
public class User implements Serializable {
    private static final long serialVersionUID = 677484458789332877L;
    private int id;
    private String name;
    private String email;
    private String address;
    
    //getter/setter
    
    @Override
    public String toString() {
        return this.id + "#" + this.name + "#" + this.email + "#" + this.address;
    }
}

一、定义你的WebService的接口RESTSample.java，代码如下

package com.hoo.service;
 
import java.io.IOException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.Context;
import javax.ws.rs.core.MediaType;
 
import com.hoo.entity.MapBean;
import com.hoo.entity.User;
import com.hoo.entity.Users;
 
 
/*
     注释（Annotation）：在 javax.ws.rs.* 中定义，是 JAX-RS (JSR 311) 规范的一部分。 
    @Path：定义资源基 URI。由上下文根和主机名组成，资源标识符类似于 http://localhost:8080/RESTful/rest/hello。 
    @GET：这意味着以下方法可以响应 HTTP GET 方法。 
    @Produces：以纯文本方式定义响应内容 MIME 类型。
    
    @Context： 使用该注释注入上下文对象，比如 Request、Response、UriInfo、ServletContext 等。 
    @Path("{contact}")：这是 @Path 注释，与根路径 “/contacts” 结合形成子资源的 URI。 
    @PathParam("contact")：该注释将参数注入方法参数的路径，在本例中就是联系人 id。其他可用的注释有 @FormParam、@QueryParam 等。 
    @Produces：响应支持多个 MIME 类型。在本例和上一个示例中，APPLICATION/XML 将是默认的 MIME 类型。
 */
/**
 * <b>function:</b> CXF RESTful风格WebService
 * @author hoojo
 * @createDate 2012-7-20 下午01:23:04
 * @file RESTSampleSource.java
 * @package com.hoo.service
 * @project CXFWebService
 * @blog http://blog.csdn.net/IBM_hoojo
 * @email hoojo_@126.com
 * @version 1.0
 */
@Path(value = "/sample")
public interface RESTSample {
    
    @GET
    @Produces(MediaType.TEXT_PLAIN)
    public String doGet();
    
    @GET
    @Produces(MediaType.TEXT_PLAIN)
    @Path("/request/{param}")
    public String doRequest(@PathParam("param") String param, 
            @Context HttpServletRequest servletRequest, @Context HttpServletResponse servletResponse);
    
    @GET
    @Path("/bean/{id}")
    @Produces({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
    public User getBean(@PathParam("id") int id);
    
    @GET
    @Path("/list")
    @Produces({ MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML })
    public Users getList();
    
    @GET
    @Path("/map")
    @Produces({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
    public MapBean getMap();
    
    /*
        @Consumes：声明该方法使用 HTML FORM。 
        @FormParam：注入该方法的 HTML 属性确定的表单输入。 
        @Response.created(uri).build()： 构建新的 URI 用于新创建的联系人（/contacts/{id}）并设置响应代码（201/created）。
        您可以使用 http://localhost:8080/Jersey/rest/contacts/<id> 访问新联系人
     */
    @POST
    @Path("/postData")
    public User postData(User user) throws IOException;
    
    @PUT
    @Path("/putData/{id}")
    @Consumes(MediaType.APPLICATION_XML)
    public User putData(@PathParam("id") int id, User user);
    
    @DELETE
    @Path("/removeData/{id}")
    public void deleteData(@PathParam("id") int id);
}

 

二、RESTSample接口的实现，这里我们只是简单的实现下，并不是涉及实际的具体业务

package com.hoo.service;
 
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.Context;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Request;
import javax.ws.rs.core.UriInfo;
import com.hoo.entity.MapBean;
import com.hoo.entity.User;
import com.hoo.entity.Users;
 
 
/*
     注释（Annotation）：在 javax.ws.rs.* 中定义，是 JAX-RS (JSR 311) 规范的一部分。 
    @Path：定义资源基 URI。由上下文根和主机名组成，资源标识符类似于 http://localhost:8080/RESTful/rest/hello。 
    @GET：这意味着以下方法可以响应 HTTP GET 方法。 
    @Produces：以纯文本方式定义响应内容 MIME 类型。
    
    @Context： 使用该注释注入上下文对象，比如 Request、Response、UriInfo、ServletContext 等。 
    @Path("{contact}")：这是 @Path 注释，与根路径 “/contacts” 结合形成子资源的 URI。 
    @PathParam("contact")：该注释将参数注入方法参数的路径，在本例中就是联系人 id。其他可用的注释有 @FormParam、@QueryParam 等。 
    @Produces：响应支持多个 MIME 类型。在本例和上一个示例中，APPLICATION/XML 将是默认的 MIME 类型。
 */
/**
 * <b>function:</b> CXF RESTful风格WebService
 * @author hoojo
 * @createDate 2012-7-20 下午01:23:04
 * @file RESTSampleSource.java
 * @package com.hoo.service
 * @project CXFWebService
 * @blog http://blog.csdn.net/IBM_hoojo
 * @email hoojo_@126.com
 * @version 1.0
 */
@Path(value = "/sample")
public class RESTSampleSource implements RESTSample {
    
    @Context
    private UriInfo uriInfo;
    
    @Context
    private Request request;
 
    
    @GET
    @Produces(MediaType.TEXT_PLAIN)
    public String doGet() {
        return "this is get rest request";
    }
    
    @GET
    @Produces(MediaType.TEXT_PLAIN)
    @Path("/request/{param}")
    public String doRequest(@PathParam("param") String param, 
            @Context HttpServletRequest servletRequest, @Context HttpServletResponse servletResponse) {
        System.out.println(servletRequest);
        System.out.println(servletResponse);
        System.out.println(servletRequest.getParameter("param"));
        System.out.println(servletRequest.getContentType());
        System.out.println(servletResponse.getCharacterEncoding());
        System.out.println(servletResponse.getContentType());
        return "success";
    }
    
    @GET
    @Path("/bean/{id}")
    @Produces({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
    public User getBean(@PathParam("id") int id) {
        System.out.println("####getBean#####");
        System.out.println("id:" + id);
        System.out.println("Method:" + request.getMethod());
        System.out.println("uri:" + uriInfo.getPath());
        System.out.println(uriInfo.getPathParameters());
        
        User user = new User();
        user.setId(id);
        user.setName("JojO");
        return user;
    }
    
    @GET
    @Path("/list")
    @Produces({ MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML })
    public Users getList() {
        System.out.println("####getList#####");
        System.out.println("Method:" + request.getMethod());
        System.out.println("uri:" + uriInfo.getPath());
        System.out.println(uriInfo.getPathParameters());
        
        List<User> list = new ArrayList<User>();
        User user = null;
        for (int i = 0; i < 4;i ++) {
            user = new User();
            user.setId(i);
            user.setName("JojO-" + i);
            list.add(user);
        }
        Users users = new Users();
        users.setUsers(list);
        return users;
    }
    
    @GET
    @Path("/map")
    @Produces({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
    public MapBean getMap() {
        System.out.println("####getMap#####");
        System.out.println("Method:" + request.getMethod());
        System.out.println("uri:" + uriInfo.getPath());
        System.out.println(uriInfo.getPathParameters());
        
        Map<String, User> map = new HashMap<String, User>();
        User user = null;
        for (int i = 0; i < 4;i ++) {
            user = new User();
            user.setId(i);
            user.setName("JojO-" + i);
            map.put("key-" + i, user);
        }
        MapBean bean = new MapBean();
        bean.setMap(map);
        return bean;
    }    
    
    /*
        @Consumes：声明该方法使用 HTML FORM。 
        @FormParam：注入该方法的 HTML 属性确定的表单输入。 
        @Response.created(uri).build()： 构建新的 URI 用于新创建的联系人（/contacts/{id}）并设置响应代码（201/created）。
        您可以使用 http://localhost:8080/Jersey/rest/contacts/<id> 访问新联系人
     */
    @POST
    @Path("/postData")
    @Produces({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
    public User postData(User user) throws IOException {
        System.out.println(user);
        user.setName("jojo##12321321");
        return user;
    } 
    
    @PUT
    @Path("/putData/{id}")
    @Produces({ MediaType.APPLICATION_XML })
    public User putData(@PathParam("id") int id, User user) {
        System.out.println("#####putData#####");
        System.out.println(user);
        user.setId(id);
        user.setAddress("hoojo#gz");
        user.setEmail("hoojo_@126.com");
        user.setName("hoojo");
        System.out.println(user);
        return user;
    }
    
    @DELETE
    @Path("/removeData/{id}")
    public void deleteData(@PathParam("id") int id) {
        System.out.println("#######deleteData#######" + id);
    }
}
三、配置我们的WebService，修改applicationContext-server.xml。这里主要是添加jaxrs标签的支持，修改头部文件如下： 
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:jaxws="http://cxf.apache.org/jaxws"
    xmlns:jaxrs="http://cxf.apache.org/jaxrs"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-3.0.xsd
    http://cxf.apache.org/jaxws 
    http://cxf.apache.org/schemas/jaxws.xsd
    http://cxf.apache.org/jaxrs
    http://cxf.apache.org/schemas/jaxrs.xsd">
特别注意上面加粗带下划线的部分，这是新增加的配置。我们发布restful WebService需要用到它。
然后在配置文件中添加如下配置 
<import resource="classpath:META-INF/cxf/cxf.xml"/>
<import resource="classpath:META-INF/cxf/cxf-extension-soap.xml"/>
<import resource="classpath:META-INF/cxf/cxf-servlet.xml"/>
<bean id="restSample" class="com.hoo.service.RESTSampleSource"/>
<!-- 这里的地址很重要，客户端需要通过这个地址来访问WebService -->
<jaxrs:server id="restServiceContainer" address="/rest">
    <jaxrs:serviceBeans>
        <ref bean="restSample" />
    </jaxrs:serviceBeans>
    <jaxrs:extensionMappings>
        <entry key="json" value="application/json" />
        <entry key="xml" value="application/xml" />
    </jaxrs:extensionMappings>
    <jaxrs:languageMappings>
           <entry key="en" value="en-gb"/>  
    </jaxrs:languageMappings>
</jaxrs:server>

这样服务器端就完成了CXF RESTful WebService的发布，启动你的tomcat。然后在浏览器中服务地址：http://localhost:8000/CXFWebService/ （其实这里请求的是CXFServlet，你可以看看上一篇Spring整合CXF文章的web.xml的配置）

你就可以看到我们这里刚刚发布的RESTSample rest的WebService

image 

你也可以看看里面的xml，也就是WebService的wsdl文件内容。我们找一个GET方式的WebService的方法，在浏览器中调用一下试试

http://localhost:8000/CXFWebService/rest/sample/bean/123

这个url对应到下面这个方法 

@GET
@Path("/bean/{id}")
@Produces({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
public User getBean(@PathParam("id") int id)

结果如下

image

一篇xml文档内容。

 

四、编写客户端代码，调用RESTful WebService 

package com.hoo.client;
 
import java.io.IOException;
import javax.ws.rs.core.MediaType;
import org.apache.cxf.jaxrs.client.WebClient;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.hoo.entity.MapBean;
import com.hoo.entity.User;
import com.hoo.entity.Users;
import com.hoo.service.RESTSample;
 
/**
 * <b>function:</b> RESTful风格WebService
 * @author hoojo
 * @createDate 2012-7-20 下午03:31:03
 * @file RSETServiceClient.java
 * @package com.hoo.client
 * @project CXFWebService
 * @blog http://blog.csdn.net/IBM_hoojo
 * @email hoojo_@126.com
 * @version 1.0
 */
public class RSETServiceClient {
 
    private static WebClient client;
    
    @Before
    public void init() {
        // 手动创建webClient对象，注意这里的地址是发布的那个/rest地址
        //String url = "http://localhost:8000/CXFWebService/rest/";
        //client = WebClient.create(url);
 
        // 从Spring Ioc容器中拿webClient对象
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext-client.xml");
        client = ctx.getBean("webClient", WebClient.class);
    }
    
    @After
    public void destory(){
    }
    
    @Test
    public void testGet() {
        System.out.println(client.path("sample").accept(MediaType.TEXT_PLAIN).get(String.class));
    }
    
    @Test
    public void testRequest() {
        System.out.println(client.path("sample/request/234234").accept(MediaType.TEXT_PLAIN).get(String.class));
    }
    
    @Test
    public void testBean() {
        User user = client.path("sample/bean/{id}", 25).accept(MediaType.APPLICATION_XML).get(User.class);
        System.out.println(user);
    }
    
    @Test
    public void testList() {
        System.out.println(client.path("sample/list").accept(MediaType.APPLICATION_XML).get(Users.class).getUsers());
    }
    
    @Test
    public void testMap() {
        System.out.println(client.path("sample/map").accept(MediaType.APPLICATION_XML).get(MapBean.class).getMap());
    }
    
    @Test
    public void testDeleteData() {
        client.path("sample/removeData/23").delete();
    }
    
    @Test
    public void testPostData() {
        User user = new User();
        user.setId(21432134);
        user.setAddress("hoojo#gz");
        user.setEmail("hoojo_@126.com");
        user.setName("hoojo");
        System.out.println(client.path("sample/postData").accept(MediaType.APPLICATION_XML).post(user, User.class));
    }
    
    @Test
    public void testPutData() {
        User user = new User();
        user.setId(21432134);
        System.out.println(client.path("sample/putData/1").accept(MediaType.APPLICATION_XML).put(user).getEntity());
    }
}
如果你喜欢用Spring的方式，还需要在applicationContext-client.xml中增加如下配置 
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:jaxws="http://cxf.apache.org/jaxws"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-3.0.xsd
    http://cxf.apache.org/jaxws 
    http://cxf.apache.org/schemas/jaxws.xsd">
    
    <bean id="webClient" class="org.apache.cxf.jaxrs.client.WebClient" factory-method="create">
        <constructor-arg type="java.lang.String" value="http://localhost:8000/CXFWebService/rest/" />
    </bean>
    
</beans>

这种是利用WebClient对象来调用WebService，还有一种方法也可以调用WebService，代码如下：

// 手动创建
//RESTSample sample = JAXRSClientFactory.create("http://localhost:8000/CXFWebService/rest", RESTSample.class);
 
// 从Spring Ioc容器中拿webClient对象
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext-client.xml");
RESTSample sample = ctx.getBean("restSampleBean", RESTSample.class);
 
System.out.println(sample);
 
System.out.println(sample.doGet());
//System.out.println(sample.doRequest("haha", null, null));
System.out.println(sample.getBean(22));
System.out.println(sample.getList());
System.out.println(sample.getMap().getMap());
User user = new User();
user.setId(21432134);
user.setAddress("hoojo#gz");
user.setEmail("hoojo_@126.com");
user.setName("hoojo");
System.out.println(sample.postData(user));
System.out.println(sample.putData(111, user));
sample.deleteData(2);

这种方式相对比WebClient要简单，直接使用接口中的方法即可。同样如果你要整合到Spring可以在applicationContext-client.xml中增加配置如下：

<bean id="restSampleBean" class="org.apache.cxf.jaxrs.client.JAXRSClientFactory" factory-method="create">
    <constructor-arg type="java.lang.String" value="http://localhost:8000/CXFWebService/rest/" />
    <constructor-arg type="java.lang.Class" value="com.hoo.service.RESTSample" />
</bean>

 

执行以上方法可以看到控制台打印结果如下：

client console
org.apache.cxf.jaxrs.client.ClientProxyImpl@1cf7491
this is get rest request
22#JojO#null#null
com.hoo.entity.Users@16eb6bc
{key-0=0#JojO-0#null#null, key-1=1#JojO-1#null#null, key-2=2#JojO-2#null#null, key-3=3#JojO-3#null#null}
21432134#jojo##12321321#hoojo_@126.com#hoojo#gz
111#hoojo#hoojo_@126.com#hoojo#gz
 
server console
####getBean#####
id:22
Method:GET
uri:sample/bean/22
{id=[22]}
####getList#####
Method:GET
uri:sample/list
{}
####getMap#####
Method:GET
uri:sample/map
{}
21432134#hoojo#hoojo_@126.com#hoojo#gz
#####putData#####
21432134#hoojo#hoojo_@126.com#hoojo#gz
111#hoojo#hoojo_@126.com#hoojo#gz
#######deleteData#######2

就这样，整合restful WebService成功。


本文转自：http://www.cnblogs.com/hoojo/archive/2012/07/23/2605219.html

chenjunan888
关注
专栏目录
Spring REST 配置CSRF防护
laojiaqi的专栏
09-23 6433
Spring REST 配置CSRF防护内容从以下几个方面展开 什么是CSRF防护 如何运用CSRF进行防御（WEB） 如何将CSRF防御，运用到REST中 1.什么是CSRFCSRF 攻击简单来说，是多Tab页面浏览器的一个安全漏洞，比如你正在访问A网站，此时如果浏览器有你的cookie，并且session没有过期，此时你去访问B网站，那么B网站可以直接调用A网站的接口，而A网站则认为是你本人进行
Spring REST
weixin_34306676的博客
07-02 100
REST风格 　　/user/1    get请求　　  获取用户 　　/user/1　 post请求　   新增用户 　　/user/1　 put请求　     更新用户 　　/user/1　 delete请求　 删除用户   在Spring MVC中如何提交put和delete请求呢？ 　　需要在web.xml文件中配置一个HiddenHttpMethodFilter过滤器。该过...
REST是什么（转）
tornado886的专栏
05-25 2015
REST是什么（转）概述     REST是英文Representational State Transfer的缩写，中文翻译：表述性状态转移。     他是由Roy Thomas Fielding博士在他的论文 《Architectural Styles and the Design of Network-based Software Architectures》中提出的一个术语。    
spring rest
weixin_34138255的博客
02-27 127
幂等 PUT 初始状态：0 修改状态：1 * N 最终状态：1 DELETE 初始状态：1 修改状态：0 * N 最终状态：0 非幂等 POST 初始状态：1 修改状态：1 + 1 =2 N次修改： 1+ N = N+1 最终状态：N+1 幂等/非幂等 依赖于服务端实现，这种方式是一种契约 #自描述消息 > Accept:...
Spring整合CXF发布服务
04-02
当我们需要在Spring环境中发布Web服务时，Spring与CXF的整合就显得尤为重要。本篇文章将深入探讨如何实现Spring与CXF的整合，以便发布服务。 1. **Spring与CXF整合的基础** 在整合Spring和CXF之前，我们需要确保...
Spring和CXF整合发布WebService(服务端、客户端)
热门推荐
yhahaha_的博客
08-06 4万+
目录 一、服务端 1、依赖 1.1 第一种方式 1.2 第二种方式 2、测试代码 3、配置文件 3.1 第一种配置方式 3.2 第二种配置方式 4、运行 二、生成客户端 第一种方式wsdl2java 第二种方式 wsimport 三、测试 工作上遇到了，所以自己琢磨了一下，也是第一次想到用博客来记录，平时也有用word文档记录，怕忘了。所以在这里来一个详细总结，那些关于...
Spring整合CXF步骤，Spring实现webService，spring整合WebService
04-23
总的来说，Spring整合CXF的步骤主要包括配置CXF，定义服务接口和实现，然后在Spring中发布这些服务。通过这样的整合，你可以享受到Spring带来的便利，同时利用CXF的强大功能来构建高质量的Web服务。在实际开发中，还...
Spring rest
GeoJava的专栏
02-21 758
1.Rest的基本原理 Rest与RPC几乎没有任何关系。RPC是面向服务的，并关注行为和动作，而REST是面向资源的，强调描述应用程序的事物和名词。 为了理解REST是什么，我们将它的首字母缩写拆分成不同的组成部分 简单说，rest就是将资源的状态以合适的形式从服务器转移到客户端（或者反之） 2.Spring是如何支持REST的 3.编写面向资源的Control
Spring REST
李思苇
09-15 271
转自：https://www.cnblogs.com/forerver-elf/p/6610901.html RPC是面向服务的，并关注与行为和动作；而REST是面向资源的，强调描述应用程序的事务的名词。REST将资源的状态以最适合客户端或服务端的形式从服务器端转移到客户端。 　　REST 　　Representational(表述性)：REST资源实际上可以用各种形式来进行表述，包括XML...
Spring REST 教程（一）
龙哥盟
08-20 1330
在本章中，我们将学习以下内容:休止符基础REST 资源及其表示HTTP 方法和状态代码理查森的成熟度模型今天，网络已经成为我们生活中不可或缺的一部分——从在脸书上查看状态到在线订购产品，再到通过电子邮件交流。Web 的成功和无处不在导致组织将 Web 的架构原则应用于构建分布式应用。在这一章中，我们将深入 REST，一种形式化这些原则的架构风格。REST 代表表述性状态转移，是一种用于设计分布式网络应用的架构风格。罗伊·菲尔丁在他的博士论文1。
Spring REST 教程（二）
最新发布
龙哥盟
08-20 787
在这一章中，我们为基于 Spring MVC 的 REST 应用设计并实现了一个错误响应格式。我们还研究了验证用户输入和返回对 API 消费者有意义的错误消息。在下一章，我们将看看使用 Swagger 框架记录 REST 服务的策略。文档在理解和使用 REST API 的过程中扮演着重要的角色。在这一章中，我们回顾了 Swagger 的基础知识，并将其与 QuickPoll 应用集成，以生成交互式文档。我们还研究了如何定制 Swagger 来满足我们特定应用的需求。
[转]REST是什么
weixin_34409822的博客
07-28 119
REST架构风格是全新的针对Web应用的开发风格，是当今世界最成功的互联网超媒体分布式系统架构，它使得人们真正理解了Http协议本来面貌。随着 REST架构成为主流技术，一种全新的互联网网络应用开发的思维方式开始流行。 REST是什么      REST是英文Representational State Transfer的缩写，中文翻译为“表述性状态转移”，他是由Roy Thomas Fie...
Spring REST简介
书香水墨
08-25 4225
一、REST 1.1 REST特性 REST具有如下特性： 表述性（Representational）：REST资源实际上可以用各种形式来进行表述，包括XML、JSON（JavaScript Object Notation）甚至HTML——最适合资源使用者的任意形式； 状态（State）：当使用REST的时候，我们更关注资源的状态而不是对资源采取的行为； 转移（Transfer）：REST涉及...
Spring RestTemplate
昝昝的博客
12-29 633
简单说就是：简化了发起HTTP请求以及处理响应的过程，并且支持REST。为什么说简化了呢？ 来看两种实现方式 （1）使用java.net包下的URLConnection建立连接 String result= ""; BufferedReaderin = null; try { String urlNameString= u...
Spring的REST简单使用
Dana_i的博客
03-06 367
1、在Spring-MVC中使用REST时，首先我们需要导入相应的依赖 <dependencies> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</a...
java spring rest_使用Spring 4 restTemplate(Java Client和RestControlle...
weixin_32683881的博客
02-21 155
我试图使用spring restTemplate将MultipartFile列表发布到我的RestController,尽管我对确切的语法和放大器有点困惑.我的客户使用的类型和控制器.基于我所做的研究,到目前为止我所拥有的……FileUploadClient.javapublic void uploadFiles(List multiPartFileList) throws IOException...
Spring+CXF整合：发布RESTful WebService教程
本文档主要介绍了如何在SSH环境中集成Spring框架与CXF，以实现RESTful风格的WebService。首先，对于Spring整合CXF的基础设置，文章假设读者已经熟悉了《Spring整合CXFWebService详解》...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值