restful不是一个框架,称为一种编码更烦更贴切吧,其核心类位于spring-web.jar中,即RestTemplate.class
restful是rpc通过http协议的一种实现方式,和webservice一样,请参阅我的其他文章
今天我将在springmvc环境中进行演示,首先请看我其他博客文章下载整理好的源码,整理好的源码可以直接用于商业项目开发
整理好的代码项目结构如下:
本次讲的restful大致如下
文采不好,开始贴代码:
① 常量工具类,用于保存http、:、?、=、&这些的
package xiaochangwei.zicp.net.restful.tools;
import java.io.IOException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;
public class CommonUtils
{
private static Logger logger = LoggerFactory.getLogger(HttpClientUtils.class);
private static ObjectMapper objectMapper = new ObjectMapper();
public static String HTTP_SLASH = "/";
public static String HTTP_COLON = ":";
public static String HTTP_QUESTION_MARK = "?";
public static String HTTP_EQUAL_MARK = "=";
public static String HTTP_AMPERSAND = "&";
public static int INIT_VALUE = -1;
public static String changeObjectToJsonStr(Object object) throws JsonProcessingException
{
String content = objectMapper.writeValueAsString(object);
logger.debug("content = [{}].", content);
return content;
}
public static <T> T changeJsonStrToObject(String content, Class<T> valueType)
throws JsonParseException, JsonMappingException, IOException
{
return objectMapper.readValue(content, valueType);
}
}
② 模块枚举定义类
package xiaochangwei.zicp.net.restful.tools;
public enum ModuleEnum {
MODULE_SERVICE("services", 1),
MODULE_ACCESS("icp/url", 2),
MODULE_SMSSend("sms/Api/Send.do", 3),
MODULE_TEST("project-web/restful/restfulService", 4),;
private String name;
private int index;
private ModuleEnum(String name, int index) {
this.name = name;
this.index = index;
}
public static String getName(int index) {
for (ModuleEnum m : ModuleEnum.values()) {
if (m.getIndex() == index) {
return m.name;
}
}
return null;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getIndex() {
return index;
}
public void setIndex(int index) {
this.index = index;
}
}
③ 参数封装类
package xiaochangwei.zicp.net.restful.tools;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import org.springframework.http.HttpMethod;
public class ParamEntity
{
// IP地址。
private String ipaddr;
// IP端口。
private String port;
④ 核心调用类
package xiaochangwei.zicp.net.restful.tools;
import java.io.IOException;
import java.net.Socket;
import java.net.UnknownHostException;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.UnrecoverableKeyException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
import org.apache.http.client.HttpClient;
import org.apache.http.conn.ClientConnectionManager;
import org.apache.http.conn.scheme.PlainSocketFactory;
import org.apache.http.conn.scheme.Scheme;
import org.apache.http.conn.scheme.SchemeRegistry;
import org.apache.http.conn.ssl.SSLSocketFactory;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.impl.conn.tsccm.ThreadSafeClientConnManager;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
import org.springframework.util.StringUtils;
import org.springframework.web.client.RestTemplate;
@SuppressWarnings("deprecation")
public class HttpClientUtils
{
private static Logger logger = LoggerFactory.getLogger(HttpClientUtils.class);
private static String HTTP_PROTOCOL = "http://";
public static ResponseEntity<String> Execute(ParamEntity paramEntity)
{
HttpClient httpClient = null;
try {
KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
trustStore.load(null, null);
SSLSocketFactory sf = new MySSLSocketFactory(trustStore);
sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
SchemeRegistry registry = new SchemeRegistry();
registry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), Integer.valueOf(paramEntity.getPort())));
registry.register(new Scheme("https", sf, Integer.valueOf(paramEntity.getPort())));
ClientConnectionManager ccm = new ThreadSafeClientConnManager(registry);
httpClient = new DefaultHttpClient(ccm);
} catch (Exception e) {
logger.info("httpclient创建错误.");
}
HttpComponentsClientHttpRequestFactory httpComponentsClientHttpRequestFactory = new HttpComponentsClientHttpRequestFactory(httpClient);
httpComponentsClientHttpRequestFactory.setConnectTimeout(120*1000);
httpComponentsClientHttpRequestFactory.setReadTimeout(120*1000);
RestTemplate rt = new RestTemplate(httpComponentsClientHttpRequestFactory);
String url = HttpClientUtils.generateUrl(paramEntity);
HttpEntity<String> requestEntity = HttpClientUtils.generateHttpEntity(paramEntity);
try
{
System.out.println("httpMethod = " + paramEntity.getHttpMethod());
System.out.println("url = " + url);
System.out.println("requestEntity = " + requestEntity);
ResponseEntity<String> responseEntity =
rt.exchange(url, paramEntity.getHttpMethod(), requestEntity, String.class);
logger.debug("responseEntity = [{}].", responseEntity);
System.out.println("responseEntity = " + responseEntity);
return responseEntity;
}
catch (Exception e)
{
System.out.println("info: " + e.getMessage());
logger.debug("error info: = [{}].", e.getMessage());
return generateRespWhenException(e);
}
}
private static ResponseEntity<String> generateRespWhenException(Exception e)
{
String msg = e.getMessage();
String[] strs = msg.split(" ");
HttpStatus retCode;
try
{
retCode = HttpStatus.valueOf(Integer.valueOf(strs[0]));
}
catch (NumberFormatException ex)
{
retCode = HttpStatus.SERVICE_UNAVAILABLE;
}
return new ResponseEntity<String>(retCode);
}
private static String generateUrl(ParamEntity paramEntity)
{
StringBuilder url = new StringBuilder();
url.append(HTTP_PROTOCOL)
.append(paramEntity.getIpaddr())
.append(CommonUtils.HTTP_COLON)
.append(paramEntity.getPort())
.append(CommonUtils.HTTP_SLASH);
if (!StringUtils.isEmpty(paramEntity.getVersion()))
{
url.append(paramEntity.getVersion()).append(CommonUtils.HTTP_SLASH);
}
ModuleEnum module = paramEntity.getModule();
switch (module)
{
case MODULE_SERVICE:
addServiceUri(url);
break;
case MODULE_SMSSend:
addSMSSendUri(url, paramEntity);
break;
case MODULE_TEST:
addUserUri(url, paramEntity);
break;
default:
logger.error("module [{}] does not exist.", module.getName());
break;
}
logger.debug("url = [{}].", url.toString());
return url.toString();
}
private static HttpEntity<String> generateHttpEntity(ParamEntity frontInfo)
{
String data = frontInfo.getData();
HttpHeaders headers = new HttpHeaders();
for (String headerKey : frontInfo.getHeadersMap().keySet())
{
String headerValue = frontInfo.getHeadersMap().get(headerKey);
if (!StringUtils.isEmpty(headerValue))
{
headers.add(headerKey, headerValue);
}
}
HttpEntity<String> requestEntity = new HttpEntity<String>(data, headers);
logger.debug("requestEntity = [{}].", requestEntity);
return requestEntity;
}
private static void addServiceUri(StringBuilder url)
{
url.append(ModuleEnum.MODULE_SERVICE.getName());
}
private static void addUserUri(StringBuilder url, ParamEntity frontInfo)
{
url.append(ModuleEnum.MODULE_TEST.getName());
if (!StringUtils.isEmpty(frontInfo.getUser_id()))
{
url.append(CommonUtils.HTTP_SLASH).append(frontInfo.getUser_id());
}
}
private static void addSMSSendUri(StringBuilder url, ParamEntity frontInfo)
{
url.append(ModuleEnum.MODULE_SMSSend.getName());
boolean hasParam = false;
hasParam = addParamsToUri(hasParam, "SpCode", frontInfo.getSmsSpCode(), url);
hasParam = addParamsToUri(hasParam, "LoginName", frontInfo.getSmsLoginName(), url);
hasParam = addParamsToUri(hasParam, "Password", frontInfo.getSmsPassword(), url);
hasParam = addParamsToUri(hasParam, "MessageContent", frontInfo.getSmsMessageContent(), url);
hasParam = addParamsToUri(hasParam, "UserNumber", frontInfo.getSmsUserNumber(), url);
hasParam = addParamsToUri(hasParam, "SerialNumber", frontInfo.getSmsSerialNumber(), url);
hasParam = addParamsToUri(hasParam, "ScheduleTime", frontInfo.getSmsScheduleTime(), url);
hasParam = addParamsToUri(hasParam, "f", frontInfo.getSmsf(), url);
}
private static boolean addParamsToUri(boolean hasParam, String descripition, String param, StringBuilder url)
{
if (!StringUtils.isEmpty(param) && !param.equals("null"))
{
if (hasParam)
{
url.append(CommonUtils.HTTP_AMPERSAND);
}
else
{
url.append(CommonUtils.HTTP_QUESTION_MARK);
}
url.append(descripition).append(CommonUtils.HTTP_EQUAL_MARK).append(param);
return true;
}
return false;
}
private static class MySSLSocketFactory extends SSLSocketFactory {
SSLContext sslContext = SSLContext.getInstance("TLS");
public MySSLSocketFactory(KeyStore truststore)
throws NoSuchAlgorithmException, KeyManagementException,
KeyStoreException, UnrecoverableKeyException {
super(truststore);
TrustManager tm = new X509TrustManager() {
public void checkClientTrusted(X509Certificate[] chain, String authType)
throws CertificateException {
}
public void checkServerTrusted(X509Certificate[] chain, String authType)
throws CertificateException {
}
public X509Certificate[] getAcceptedIssuers() {
return null;
}
};
sslContext.init(null, new TrustManager[] { tm }, null);
}
@Override
public Socket createSocket(Socket socket, String host, int port, boolean autoClose)
throws IOException, UnknownHostException {
return sslContext.getSocketFactory().createSocket(socket, host, port, autoClose);
}
@Override
public Socket createSocket() throws IOException {
return sslContext.getSocketFactory().createSocket();
}
}
}
⑤ 调用入口
package xiaochangwei.zicp.net.restful.operation.impl;
import org.springframework.http.HttpMethod;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Component;
import xiaochangwei.zicp.net.restful.operation.RestfulTestOperation;
import xiaochangwei.zicp.net.restful.tools.ParamEntity;
import xiaochangwei.zicp.net.restful.tools.HttpClientUtils;
import xiaochangwei.zicp.net.restful.tools.ModuleEnum;
/**
* @author http://www.cnblogs.com/xiaochangwei
* @date 2016年4月20日
*
*/
@Component
public class RestfulTestOperationImpl implements RestfulTestOperation {
public ResponseEntity<String> restfulTestMethod(ParamEntity paramEntity) {
paramEntity.setModule(ModuleEnum.MODULE_TEST);
paramEntity.setHttpMethod(HttpMethod.POST);
ResponseEntity<String> responseEntity = HttpClientUtils.Execute(paramEntity);
return responseEntity;
}
}
⑥ service层参数封装、调用、返回结果处理类
package xiaochangwei.zicp.net.service.restful;
import java.util.HashMap;
import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import xiaochangwei.zicp.net.restful.operation.RestfulTestOperation;
import xiaochangwei.zicp.net.restful.tools.ParamEntity;
/**
* @author http://www.cnblogs.com/xiaochangwei
* @date 2016年4月20日
*
*/
@Service
public class RestfulTestServiceImpl implements RestfulTestService {
@Autowired
private RestfulTestOperation restfulTestOperation;
public String restfulTestMethod() {
ParamEntity info = new ParamEntity();
Map<String, Map<String, Object>> dataMap = new HashMap<String, Map<String, Object>>();
Map<String, Object> userEntity = new HashMap<String, Object>();
userEntity.put("default_project_id", "pid");
userEntity.put("description", "user.getDescription()");
userEntity.put("domain_id", "default");
userEntity.put("email", "user.getEmail()");
userEntity.put("enabled", true);
userEntity.put("name", "user.getUsername()");
userEntity.put("password", "user.getStrPassword()");
dataMap.put("user", userEntity);
String data = JSON.toJSONString(dataMap);
info.setData(data);
info.setIpaddr("127.0.0.1");
info.setPort("808");
ResponseEntity<String> response = restfulTestOperation.restfulTestMethod(info);
// 当创建某个用户失败时
if (response == null || !response.getStatusCode().equals(HttpStatus.CREATED)) {
throw new RuntimeException("调用接口创建用户失败!");
} else {
JSONObject object = JSONObject.parseObject(response.getBody().toString());
JSONObject userJson = JSONObject.parseObject(object.getString("user"));
System.out.println("解析body为json后的用户id为:"+userJson.getString("id"));
//return userJson.getString("id");
return response.getBody().toString();
}
}
}
⑦ controller层测试类,包含调用入口和服务方法,此处为静态返回,可以根据具体业务书写,和常见代码一样
package xiaochangwei.zicp.net.web.controller;
import java.util.HashMap;
import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestHeader;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import com.alibaba.fastjson.JSON;
import xiaochangwei.zicp.net.entity.TestEntity;
import xiaochangwei.zicp.net.service.restful.RestfulTestService;
/**
* @author http://www.cnblogs.com/xiaochangwei
* @date 2016年4月20日
*
*/
@Controller
@RequestMapping("restful")
public class RestfulTestController {
@Autowired
private RestfulTestService restfulTestService;
/**
* 处理restClient请求的的方法体
*/
@RequestMapping("restfulService")
public ResponseEntity<String> testRestClientAdd(
@RequestHeader("Accept") String Accept, @RequestBody String userStr) {
System.out.println("接收到的请求信息-Accept:" + Accept);
System.out.println("接收到的请求信息-body:" + userStr);
// 可以根据请请进行业务处理,这里略了 只是打印出来确定消息传递过来没
// 返回处理结果给调用者
TestEntity en = new TestEntity();
en.setId(1);
en.setName("name1");
Map<String, Object> map = new HashMap<String, Object>();
map.put("user", en);
String body = JSON.toJSONString(map);
System.out.println("准备返回给调用者的body content:" + body);
ResponseEntity<String> responseEntity = new ResponseEntity<String>(
body, HttpStatus.CREATED);
return responseEntity;
}
/**
* 调用rest接口方法进行rpc调用
*/
@RequestMapping("restfulClientCall")
public @ResponseBody String t() {
return restfulTestService.restfulTestMethod();
}
}
⑧ 见证奇迹的时候又到了
输入 http://www.xiaochangwei.com:808/project-web/restful/restfulClientCall 进行调用,restful会访问我们这个controller中的restfulService
同时控制台也看到如下信息,证明我们的调用成功
至此,restful使用讲解完毕,不过需要提醒的时,restful是通过http协议进行传输的,同等条件下速度比tcp慢,所以实时性较高请使用tcp实现的rpc或者采用jms
相关技术均可以通过我的博客了解学习到,请锁定关注。