如果您对Golang建立RESTfulwebservice接收客户端POST请求发送wav语音文件感兴趣，那么本文将是一篇不错的选择，我们将为您详在本文中，您将会了解到关于Golang建立RESTfu
如果您对Golang 建立RESTful webservice 接收客户端POST请求发送wav语音文件感兴趣，那么本文将是一篇不错的选择，我们将为您详在本文中，您将会了解到关于Golang 建立RESTful webservice 接收客户端POST请求发送wav语音文件的详细内容，我们还将为您解答golang 发送http请求的相关问题，并且为您提供关于.net 从WebService的restful api接口以POST方式请求并获取返回值、android – Java jersey RESTful webservice请求、C++上传文件到Restful Web Service服务端——客户端篇、CXF 开发RESTful WebService服务(Spring+JPA服务端,JAXRS2.0+WebClient客户端)的有价值信息。
本文目录一览：- Golang 建立RESTful webservice 接收客户端POST请求发送wav语音文件（golang 发送http请求）
- .net 从WebService的restful api接口以POST方式请求并获取返回值
- android – Java jersey RESTful webservice请求
- C++上传文件到Restful Web Service服务端——客户端篇
- CXF 开发RESTful WebService服务(Spring+JPA服务端,JAXRS2.0+WebClient客户端)
Golang 建立RESTful webservice 接收客户端POST请求发送wav语音文件（golang 发送http请求）
首先看下服务器端，服务器端使用martini框架，仅建立一个简单的接收客户端post请求并保存客户端传过来的语音的后台服务：
原文地址：http://www.jb51.cc/article/p-tonyjcqq-hg.html
package main
//http://liuxp0827.blog.51cto.com/5013343/1412977
import (
"bufio"
"github.com/go-martini/martini"
"io/IoUtil"
"log"
"net/http"
"os"
)
func main() {
m := martini.Classic()
m.Post("/wave",func(req *http.Request) {
file,_,err := req.FormFile("file")
if err != nil {
log.Fatal("FormFile: ",err.Error())
os.Exit(2)
}
defer func() {
if err := file.Close(); err != nil {
log.Fatal("Close: ",err.Error())
os.Exit(2)
}
}()
localFile,_ := os.Create("1.wav")
defer localFile.Close()
writer := bufio.NewWriter(localFile)
bytes,err := IoUtil.ReadAll(file)
if err != nil {
log.Fatal("ReadAll: ",err.Error())
os.Exit(2)
}
writer.Write(bytes)
writer.Flush()
})
http.ListenAndServe(":8080",m)
}
再来看下客户端的java代码，首先调用readWavform函数从本地读取语音文件到byte[],然后设置相应的POST头信息，最终发送数据：
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
//http://liuxp0827.blog.51cto.com/5013343/1412977
public final class upload {
public static void main(String[] args) {
Map<String,String> parameters = new HashMap<String,String>();
byte[] data = readWavform("C:\\Users\\PONPON\\Desktop\\test.wav");
doUploadFile("http://localhost:8080/wave",parameters,Constants.FILEParaM,"11.wav","multipart/form-data;",data);
}
public static byte[] readWavform(String filename) {
int regLen = 0;
byte[] regbuffer = null;
try {
FileInputStream inputsteam = new FileInputStream(new File(filename));
regLen = inputsteam.available();
regbuffer = new byte[regLen];
if ((regLen = inputsteam.read(regbuffer,regLen)) < 0) {
System.out.println("error when read pcm file.");
}
} catch (FileNotFoundException e) {
// Todo Auto-generated catch block
e.printstacktrace();
} catch (IOException e) {
// Todo Auto-generated catch block
e.printstacktrace();
}
return regbuffer;
}
public static String doUploadFile(String reqUrl,Map<String,String> parameters,String fileParamName,String filename,String contentType,byte[] data) {
HttpURLConnection urlConn = null;
try {
urlConn = sendFormdata(reqUrl,fileParamName,filename,contentType,data);
String responseContent = new String(getBytes(urlConn));
return responseContent.trim();
} catch (Exception e) {
throw new RuntimeException(e.getMessage(),e);
} finally {
if (urlConn != null) {
urlConn.disconnect();
}
}
}
private static HttpURLConnection sendFormdata(String reqUrl,byte[] data) {
HttpURLConnection urlConn = null;
try {
URL url = new URL(reqUrl);
urlConn = (HttpURLConnection) url.openConnection();
urlConn.setRequestMethod("POST");
urlConn.setConnectTimeout(10000);// （单位：毫秒）jdk
urlConn.setReadTimeout(10000);// （单位：毫秒）jdk 1.5换成这个,读操作超时
urlConn.setDoOutput(true);
urlConn.setRequestProperty("connection","keep-alive");
String boundary = "-----------------------------114975832116442893661388290519"; // 分隔符
urlConn.setRequestProperty("Content-Type","multipart/form-data; boundary=" + boundary);
boundary = "--" + boundary;
StringBuffer params = new StringBuffer();
if (parameters != null) {
for (Iterator<String> iter = parameters.keySet().iterator(); iter
.hasNext();) {
String name = iter.next();
String value = parameters.get(name);
params.append(boundary + "\r\n");
params.append("Content-disposition: form-data; name=\""
+ name + "\"\r\n\r\n");
params.append(value);
params.append("\r\n");
}
}
StringBuilder sb = new StringBuilder();
sb.append(boundary);
sb.append("\r\n");
sb.append("Content-disposition: form-data; name=\"" + fileParamName
+ "\"; filename=\"" + filename + "\"\r\n");
sb.append("Content-Type: " + contentType + "\r\n\r\n");
byte[] fileDiv = sb.toString().getBytes("UTF-8");
byte[] endData = ("\r\n" + boundary + "--\r\n").getBytes("UTF-8");
byte[] ps = params.toString().getBytes("UTF-8");
OutputStream os = urlConn.getoutputStream();
os.write(ps);
os.write(fileDiv);
os.write(data);
os.write(endData);
os.flush();
os.close();
} catch (Exception e) {
throw new RuntimeException(e.getMessage(),e);
}
return urlConn;
}
private static byte[] getBytes(HttpURLConnection urlConn) {
try {
InputStream in = urlConn.getInputStream();
ByteArrayOutputStream os = new ByteArrayOutputStream();
byte[] buf = new byte[1024];
for (int i = 0; (i = in.read(buf)) > 0;)
os.write(buf,i);
in.close();
return os.toByteArray();
} catch (Exception e) {
throw new RuntimeException(e.getMessage(),e);
}
}
}
这只是简单的功能实现，后面可以用martini拓展，写一个简单的web语音识别服务,用android录音后发送POST请求，把语音数据发送到服务器处理识别，再返回json格式的识别结果。
.net 从WebService的restful api接口以POST方式请求并获取返回值
- 最有效的：
- post位置
private void Logintest()
{
string resultState = string.Empty;
try
{
var request = new Request();
string jdata = "imei=1"+
"&contactid=1001"+
"&password=e10adc3949ba59abbe56e057f20f883e";
var response = request.Execute("http://dumXXXXXX.com.cn/dum/app_login.action",jdata,"POST");
JObject jo = (JObject)JsonConvert.DeserializeObject(response.ToString());
resultState = jo["result"].ToString();
}
catch (Exception ex)
{
errorList.Add(ex.Message);
}
finally
{
switch (resultState)
{
case "200":
resultStateDic["200(成功)"]++;
break;
case "401":
resultStateDic["401(失败)"]++;
break;
case "402":
resultStateDic["402(IMEI不匹配)"]++;
break;
case "403":
resultStateDic["403(没有权限)"]++;
break;
case "404":
resultStateDic["404(用户不存在)"]++;
break;
case "601":
resultStateDic["601(用户存在，但没有登记)"]++;
break;
default:
resultStateDic["other"]++;
break;
}
}
}
Request类
/// <summary>
/// Create Http Request,using json,and read Http Response.
/// </summary>
public class Request
{
/// <summary>
/// Url of http server wich request will be created to.
/// </summary>
public String URL { get; set; }
/// <summary>
/// HTTP Verb wich will be used. Eg. GET,POST,PUT,DELETE.
/// </summary>
public String Verb { get; set; }
/// <summary>
/// Request content,Json by default.
/// </summary>
public String Content
{
//get { return "text/json"; }
get { return "application/x-www-form-urlencoded"; }
}
/// <summary>
/// User and Password for Basic Authentication
/// </summary>
public Credentials Credentials { get; set; }
public HttpWebRequest HttpRequest { get; internal set; }
public HttpWebResponse HttpResponse { get; internal set; }
public CookieContainer CookieContainer = new CookieContainer();
public object Execute(string url,object obj,string verb)
{
if (url != null)
URL = url;
if (verb != null)
Verb = verb;
HttpRequest = CreateRequest();
WriteStream(obj);
try
{
HttpResponse = (HttpWebResponse)HttpRequest.GetResponse();
}
catch (WebException error)
{
HttpResponse = (HttpWebResponse)error.Response;
return ReadResponseFromError(error);
}
return ReadResponse();
}
internal HttpWebRequest CreateRequest()
{
var basicRequest = (HttpWebRequest)WebRequest.Create(URL);
basicRequest.ContentType = Content;
basicRequest.Method = Verb;
basicRequest.CookieContainer = CookieContainer;
if (Credentials != null)
basicRequest.Headers.Add("Authorization","Basic" + " " + EncodeCredentials(Credentials));
return basicRequest;
}
internal void WriteStream(object obj)
{
if (obj != null)
{
using (var streamWriter = new StreamWriter(HttpRequest.GetRequestStream()))
{
if (obj is string)
streamWriter.Write(obj);
else
streamWriter.Write(JsonConvert.SerializeObject(obj));
}
}
}
internal String ReadResponse()
{
if (HttpResponse != null)
using (var streamReader = new StreamReader(HttpResponse.GetResponseStream()))
return streamReader.ReadToEnd();
return string.Empty;
}
internal String ReadResponseFromError(WebException error)
{
using (var streamReader = new StreamReader(error.Response.GetResponseStream()))
return streamReader.ReadToEnd();
}
internal static string EncodeCredentials(Credentials credentials)
{
var strCredentials = string.Format("{0}:{1}",credentials.UserName,credentials.Password);
var encodedCredentials = Convert.ToBase64String(Encoding.UTF8.GetBytes(strCredentials));
return encodedCredentials;
}
}
Credentials
/// <summary>
/// This class support JsonRequest on sending credentials for Basic Authentication on HTTP server
/// </summary>
public class Credentials
{
public string UserName { get; set; }
public string Password { get; set; }
}
第三方dll
android – Java jersey RESTful webservice请求
我一直在关注一个关于宁静服务的教程,它运行正常.然而,有一些我还不太了解的东西.这是它的样子：
@Path("/hello")
public class Hello {
// This method is called if TEXT_PLAIN is request
@GET
@Produces( MediaType.TEXT_PLAIN )
public String sayPlainTextHello()
{
return "Plain hello!";
}
@GET
@Produces( MediaType.APPLICATION_JSON )
public String sayJsonTextHello()
{
return "Json hello!";
}
// This method is called if XML is request
@GET
@Produces(MediaType.TEXT_XML)
public String sayXMLHello() {
return "<?xml version=\"1.0\"?>" + "<hello> Hello Jersey" + "</hello>";
}
// This method is called if HTML is request
@GET
@Produces(MediaType.TEXT_HTML)
public String sayHtmlHello()
{
return "<html> " + "<title>" + "Hello fittemil" + "</title>"
+ "<body><h1>" + "Hello!" + "</body></h1>" + "</html> ";
}
}
困扰我的是我无法利用正确的操作.当我从浏览器请求服务时,会调用相应的sayHtmlHello()方法.但是现在我正在开发一个Android应用程序,我希望在Json中得到结果.但是当我从应用程序调用该服务时,将调用MediaType.TEXT_PLAIN方法.我的android代码看起来与此类似：
Make an HTTP request with android
如何从我的Android应用程序中调用使用MediaType.APPLICATION_JSON的方法？
此外,我想使该特定方法返回一个对象,如果我在那里得到一些指导,那将是很好的.
解决方法:
我个人有使用Jersey在Java(JAX-RS)中实现REST的经验.然后我通过Android应用程序连接到这个RESTful Web服务.
在Android应用程序中,您可以使用HTTP Client库.它支持HTTP命令,如POST,PUT,DELETE,GET.例如,使用GET命令并以JSON格式或TextPlain传输数据：
public class Client {
private String server;
public Client(String server) {
this.server = server;
}
private String getBase() {
return server;
}
public String getBaseURI(String str) {
String result = "";
try {
HttpParams httpParameters = new BasicHttpParams();
int timeoutConnection = 3000;
httpconnectionParams.setConnectionTimeout(httpParameters, timeoutConnection);
int timeoutSocket = 5000;
httpconnectionParams.setSoTimeout(httpParameters, timeoutSocket);
DefaultHttpClient httpClient = new DefaultHttpClient(httpParameters);
HttpGet getRequest = new HttpGet(getBase() + str);
getRequest.addHeader("accept", "application/json");
HttpResponse response = httpClient.execute(getRequest);
result = getResult(response).toString();
httpClient.getConnectionManager().shutdown();
} catch (Exception e) {
System.out.println(e.getMessage());
}
return result;
}
public String getBaseURIText(String str) {
String result = "";
try {
HttpParams httpParameters = new BasicHttpParams();
int timeoutConnection = 3000;
httpconnectionParams.setConnectionTimeout(httpParameters, timeoutConnection);
int timeoutSocket = 5000;
httpconnectionParams.setSoTimeout(httpParameters, timeoutSocket);
DefaultHttpClient httpClient = new DefaultHttpClient(httpParameters);
HttpGet getRequest = new HttpGet(getBase() + str);
getRequest.addHeader("accept", "text/plain");
HttpResponse response = httpClient.execute(getRequest);
result = getResult(response).toString();
httpClient.getConnectionManager().shutdown();
} catch (Exception e) {
System.out.println(e.getMessage());
}
return result;
}
private StringBuilder getResult(HttpResponse response) throws IllegalStateException, IOException {
StringBuilder result = new StringBuilder();
BufferedReader br = new BufferedReader(new InputStreamReader((response.getEntity().getContent())), 1024);
String output;
while ((output = br.readLine()) != null)
result.append(output);
return result;
}
}
然后在Android类中,您可以：
Client client = new Client("http://localhost:6577/Example/rest/");
String str = client.getBaseURI("Example"); // Json format
解析JSON字符串(或者可能是xml)并在ListView,GridView和…中使用它
我简要介绍了你提供的链接.那里有一个好点.您需要在API级别11或更高级别的单独线程上实现网络连接.看看这个链接：HTTP Client API level 11 or greater in Android.
这是我在Client类中使用HTTP发布对象的方式：
public String postBaseURI(String str, String strUrl) {
String result = "";
try {
HttpParams httpParameters = new BasicHttpParams();
int timeoutConnection = 3000;
httpconnectionParams.setConnectionTimeout(httpParameters, timeoutConnection);
int timeoutSocket = 5000;
httpconnectionParams.setSoTimeout(httpParameters, timeoutSocket);
DefaultHttpClient httpClient = new DefaultHttpClient(httpParameters);
HttpPost postRequest = new HttpPost(getBase() + strUrl);
StringEntity input = new StringEntity(str);
input.setContentType("application/json");
postRequest.setEntity(input);
HttpResponse response = httpClient.execute(postRequest);
result = getResult(response).toString();
httpClient.getConnectionManager().shutdown();
} catch (Exception e) {
System.out.println(e.getMessage());
}
return result;
}
在REST WS中,我将对象发布到数据库：
@POST
@Path("/post")
@Consumes(MediaType.APPLICATION_JSON)
@Produces(MediaType.TEXT_PLAIN)
public Response addTask(Task task) {
Session session = HibernateUtil.getSessionFactory().getCurrentSession();
session.beginTransaction();
session.save(task);
session.getTransaction().commit();
return Response.status(Response.Status.CREATED).build();
}
C++上传文件到Restful Web Service服务端——客户端篇
由于项目的需要，要做一个C++的http请求客户端实现上传数据到服务端的功能，服务端用的是Spring MVC实现的Restful Web Service，起初设计时在服务端以byte[]的形式接受数据，毕竟服务端用java写的，把接收到的数据流解析成相应的文件这是完全可行的。
如果写过Java或者其他语言的Http请求的人都知道，请求方式可以分GET和POST两种，不过GET传递的数据充其量只是简单类型的参数而已，在请求时的数据格式如代码，这是请求http://www.ip138.com:8080/search.asp?mobile=1565888&action=mobile站点的请求参数：
GET /search.asp?mobile=1565888&action=mobile HTTP/1.1
Host: www.ip138.com:8080
User-Agent: Mozilla/5.0 (Windows NT 6.1; rv:14.0) Gecko/20100101 Firefox/14.0.1
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: zh-cn,zh;q=0.8,en-us;q=0.5,en;q=0.3
Accept-Encoding: gzip, deflate
Connection: keep-alive以上是用FireFox的插件Live Http Headers获取的数据，而且这个插件可以自行编辑参数定制HTTP请求，方便编程的测试工作，具体使用可以查阅资料。这里面好多参数并不是必须的，但是为了模拟浏览器的效果最好设置一下。另外对于GET请求不需要设置Content-Type和Content-Length参数，通常这两个也是成对出现的。User-Agent表示请求客户端的浏览器和OS信息，这里模拟浏览器访问可以自己定制。
POST请求的数据是放在请求体里的，具体信息可参考http://blog.csdn.net/yc0188/article/details/4741871，严格按照要求组织请求数据即可。注意请求头和请求数据之间的空行。这是一个Web系统的POST请求数据：
POST /myproject/infoUpdate HTTP/1.1
Host: 192.168.52.250:8088
User-Agent: Mozilla/5.0 (Windows NT 6.1; rv:14.0) Gecko/20100101 Firefox/14.0.1
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: zh-cn,zh;q=0.8,en-us;q=0.5,en;q=0.3
Accept-Encoding: gzip, deflate
Connection: keep-alive
Referer: http://192.168.52.250:8088/myproject/infoUpdate.action
Content-Type: application/x-www-form-urlencoded
Content-Length: 24
infoId=3¤tPage=1另外在具体组织请求信息时，Windows下是用\r\n作为换行符的，但是在linux下这样用也不错，虽然linux的换行符是\n。
strcat(requestStr, "POST ");
strcat(requestStr, api);
strcat(requestStr, " HTTP/1.1\r\n");
strcat(requestStr, "Accept: application/x-ms-application, image/gif, "
"application/xaml+xml, image/pjpeg, application/x-ms-xbap, application/x-shockwave-flash, "
"application/vnd.ms-excel, application/vnd.ms-powerpoint, application/msword, */*\r\n");
strcat(requestStr, "User-Agent: Mozilla/5.0 (X11; Ubuntu; Linux i686; rv:17.0) Gecko/17.0 Firefox/17.0\r\n");
strcat(requestStr, "Accept-Language: zh-CN,en-US;q=0.5\r\n");
strcat(requestStr, "Accept-Encoding: gzip, deflate\r\n");
strcat(requestStr, "Host: ");
strcat(requestStr, hostname);
strcat(requestStr, "\r\n");POST简单的数据以上就可以做到，但是对于上传文件呢。文件通常是二进制形式的，也就是要传输流。不过我们对struts2或者Spring MVC的上传文件表单不陌生，于是我监测了一个上传文件操作的请求数据：
POST /myproject/infoUpdate HTTP/1.1
Host: 192.168.52.250:8088
User-Agent: Mozilla/5.0 (Windows NT 6.1; rv:14.0) Gecko/20100101 Firefox/14.0.1
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: zh-cn,zh;q=0.8,en-us;q=0.5,en;q=0.3
Accept-Encoding: gzip, deflate
Connection: keep-alive
Content-Type: multipart/form-data; boundary=---------------------------41184676334
Content-Length: 95254
-----------------------------41184676334\r\n
Content-Disposition: form-data; name="id"\r\n
\r\n
6\r\n
-----------------------------41184676334\r\n
Content-Disposition: form-data; name="doc"; filename="faq_info.jpg"\r\n
Content-Type: image/jpeg\r\n
\r\n
……请求的数据流……
\r\n-----------------------------41184676334--\r\n这里用到了boundary（分隔符），用来间隔不同的请求数据，这是Content-Type类型为multipart/form-data（Spring MVC Restful Web Service也支持multipart/mixed的类型用于上传文件）时所要求的数据格式，和Content-Type为application/x-www-form-urlencoded时用&间隔参数是一样的。但是要注意使用的规则，可参见http://blog.csdn.net/mspinyin/article/details/6141638。Java版本的HttpURLConnection请求可参考：http://lapulande.iteye.com/blog/719581。C++版的可以用Windows下的winsock，代码可参考：http://www.cnblogs.com/evlon/archive/2007/08/13/853145.html和http://www.oschina.net/code/snippet_176076_5908分别是windows下的和linux的范例，上述链接代码只是使用socket完成了请求操作，并没有做上传数据的部分。我建议用到的朋友可以先用Java版的客户端进行上传文件测试，如果测试通过了，可以比照着写C++的代码，在请求头部分C++老老实实地组织对应的参数就可以，请求数据部分要严格注意换行的地方，以及上传文件的长度加入Content-Length（包括上传数据长度和分隔符等其他字符的长度）。
文件流的长度可以这样获得：
ifstream fin(filePath ,ios::in|ios::binary);
if(!fin){
cout<<"File open error!\n";
return -1;
}
//---get the length of the file
int temp = fin.tellg();
fin.seekg(0,ios_base::end);
int len = fin.tellg();
fin.seekg(temp);获得长度后重新定位到文件开始处。
上传文件流时要读取多少send多少，否则服务端得到的是错误的流，且在send时不要用strlen(c)来指定发送的长度，因为char* c中可能包含‘\0’这样的空字符，从而使用了错误的长度。
char c[1024];
memset(c, 0,1024);
int tmpLen=0;
int i=0;
while(!fin.eof())
{
if(tmpLen<(len/1024)*1024) //首先按照1024的单位传
{
fin.read(c, 1024);
send(sock,c,1024,0);
Sleep(1); //休息，为了降低CPU使用率以及照顾带宽
tmpLen+=1024;
}else //如果剩余的小于等于1024了，单独send剩余的字节
{
fin.read(c,len-(len/1024)*1024);
send(sock,c,len-(len/1024)*1024,0);
break;
}
}
fin.close();在C++里用socket建立的请求，没有使用HTTP协议，可以选择TCP或者UDP协议，默认用TCP。我在测试中使用WireShark监测传输的数据时，在HTTP相关协议中没有看到数据，原因就在于此，Java版请求的就可以检测到。
CXF 开发RESTful WebService服务(Spring+JPA服务端,JAXRS2.0+WebClient客户端)
上次介绍了使用CXF框架开发SOAP WebService服务,接下来介绍如何使用CXF框架开发RESTful风格的WebService服务.
这里就不罗嗦介绍restful是什么云云的话了(因为我也不理解..),或者说官方的话读起来觉得隐晦难懂,REST -- REpresentational State Transfer 直接翻译：表现层状态转移(这偷猫的谁能懂???),所以呢,我觉得就是一句话:用URL定位资源,用HTTP来描述CRUD操作.
所以必须知道一下几点:
1.服务端每一个对象,每一个资源都可以通过唯一的URL来进行寻址.
2.基于HTTP协议来进行资源请求{GET(查),POST(增),PUT(改),DELETE(删)}.或许这就是REST的奥妙所在吧.
3.访问的每一个资源都可以使用不同的形式加以表示(XML/JSON).
CXF框架支持RESTful风格的编程,发布了JAX-RS规范(http://cxf.apache.org/docs/jax-rs.html).
======================================================================================================================================好了,如何发布一个REST服务并调用呢?
服务端(Spring继承JPA与数据库交互):
1.实体类(加上@XmlRootElement注解,方便对象与XML之间转换)
@XmlRootElement
@Entity
public class User {
private Integer uno;
private String uname;
}
2.定义一个REST服务接口
public interface IUserService {
@GET//请求的方法
@Path("sayHi")//方法的路径名(独一无二)
String sayHi(@QueryParam("name") String name);
@GET
@Path("queryById")
@Produces(MediaType.APPLICATION_JSON)//输出数据的格式
@Consumes(MediaType.APPLICATION_JSON)//接受数据的格式
User queryById(@QueryParam("uno") Integer uno);//方法中的查询参数,注意与@PathParam的区别,前者是键值对的形式出现的,本人喜欢用前者.
@GET
@Path("queryAll")
@Produces(MediaType.APPLICATION_JSON)
List<User> queryAll();
@POST
@Path("addUser")
@Consumes(MediaType.APPLICATION_JSON)
void addUser(User user);
@PUT
@Path("updUser")
@Consumes(MediaType.APPLICATION_JSON)
void updUser(User user);
@DELETE
@Path("delUser")
@Consumes(MediaType.APPLICATION_JSON)
void delUser(@QueryParam("uno") Integer uno);
}3.实现接口(其实rest不要求一定要有接口,所以可以直接实现方法)的部分省略,我是利用jpaRepository提供的方法实现的,有兴趣可以参照之前的博客.
@Component
public class UserServiceImpl implements IUserService{
......
}
4.发布REST服务(与Spring结合)
spring-cxf.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:jaxrs="http://cxf.apache.org/jaxrs"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://cxf.apache.org/jaxrs
http://cxf.apache.org/schemas/jaxrs.xsd">
<jaxrs:server address="/user">
<jaxrs:serviceBeans>
<ref bean="userServiceImpl"/>
</jaxrs:serviceBeans>
<jaxrs:providers>
<beanhttps://www.jb51.cc/tag/njs/" target="_blank">njsonProvider"/>
</jaxrs:providers>
</jaxrs:server>
</beans>
web.xml:
<!-- Spring -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:spring.xml</param-value>
</context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!-- CXF -->
<servlet>
<servlet-name>cxf</servlet-name>
<servlet-class>org.apache.cxf.transport.servlet.CXFServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>cxf</servlet-name>
<url-pattern>/ws/*</url-pattern>
</servlet-mapping>
客户端(JAXRS2.0+WebClient两种方式实现CRUD):
1.JAXRS2.0(推荐使用)
//使用JAXRS2.0发布REST服务
public class JAXRSClientTest {
private static final String url = "http://localhost:8080/restfulServer/ws/user";
private static final JacksonjsonProvider jsonProvider = new JacksonjsonProvider();
@Test
public void sayHitest() {
String result = ClientBuilder.newClient()
.target(url).path("/sayHi").queryParam("name","呢喃北上")
.request().get(String.class);
System.out.println(result);
}
@Test
public void queryByIdtest() {
System.out.println("根据id查询用户");
Client client = ClientBuilder.newClient().register(jsonProvider);// 注册json 支持
WebTarget target = client.target(url + "/queryById").queryParam("uno",2);
Invocation.Builder builder = target.request();
Response response = builder.get();
User user = response.readEntity(User.class);
System.out.println(user.getUname());
response.close();
System.out.println("over");
}
@Test
public void queryAlltest(){
System.out.println("查询所有的用户");
List<User> users = ClientBuilder.newClient().register(jsonProvider)
.target(url).path("/queryAll")
.request().get(new GenericType<List<User>>() {});
for (User user : users) {
System.out.println(user);
}
System.out.println("over");
}
@Test
public void addUsertest(){
System.out.println("增加一位用户");
User user = new User(0,"mokeychan");
Client client = ClientBuilder.newClient().register(jsonProvider);
WebTarget target = client.target(url+"/addUser");
Response response = target.request().buildPost(Entity.entity(user,MediaType.APPLICATION_JSON)).invoke();
response.close();
System.out.println("over");
}
@Test
public void updUsertest(){
System.out.println("更新一名用户");
User user = new User(21,"雷蒙磨咯");
Client client = ClientBuilder.newClient().register(jsonProvider);
WebTarget target = client.target(url+"/updUser");
Response response = target.request().buildPut(Entity.entity(user,MediaType.APPLICATION_JSON)).invoke();
response.close();
queryAlltest();
System.out.println("over");;
}
@Test
public void delUser(){
System.out.println("删除一名用户");
Client client = ClientBuilder.newClient().register(jsonProvider);
WebTarget target = client.target(url+"/delUser?uno=18");
Response response = target.request().delete();
response.close();
System.out.println("over");
}
}
2.WebClient实现
//通用的WebClient方式发布
public class WebClientTest {
private static final String url = "http://localhost:8080/restfulServer/ws/user";
public static void main(String[] args) {
List<Object> providerList = new ArrayList<Object>();
providerList.add(new JacksonjsonProvider());
WebClient client = WebClient.create(url,providerList);
User user = client.path("/queryById").query("uno",2).accept(MediaType.APPLICATION_JSON).get(User.class);
System.out.println(user.toString());
/*List users = client.path("/queryAll").accept(MediaType.APPLICATION_JSON).get(List.class);
for (Object user : users) {
System.out.println(user.toString());
}*/
}
}好了,发布与调用RESTful风格的WebService服务就实现了,不得不说利用URL来访问资源真的是妙啊.
感谢黄勇大神的启发博文,链接:https://my.oschina.net/huangyong/blog/294324
项目参考地址:http://download.csdn.net/download/qq_33764491/10180087
今天关于Golang 建立RESTful webservice 接收客户端POST请求发送wav语音文件和golang 发送http请求的讲解已经结束，谢谢您的阅读，如果想了解更多关于.net 从WebService的restful api接口以POST方式请求并获取返回值、android – Java jersey RESTful webservice请求、C++上传文件到Restful Web Service服务端——客户端篇、CXF 开发RESTful WebService服务(Spring+JPA服务端,JAXRS2.0+WebClient客户端)的相关知识，请在本站搜索。
本文标签：
![[转帖]Ubuntu 安装 Wine方法（ubuntu如何安装wine）](https://www.gvkun.com/zb_users/cache/thumbs/4c83df0e2303284d68480d1b1378581d-180-120-1.jpg)
