rest 应用demo

web.xml

<servlet>
<servlet-name>RESTEntrance</servlet-name>
<servlet-class>org.glassfish.jersey.servlet.ServletContainer</servlet-class>
<init-param>
<param-name>javax.ws.rs.Application</param-name>
<param-value>com.certusnet.nfv.mano.vnfm.RestApplication</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>

<servlet-mapping>
<servlet-name>RESTEntrance</servlet-name>
<url-pattern>/rest/*</url-pattern>
</servlet-mapping>

////新增的接口

package com.certusnet.nfv.mano.vim.vm.rest;

import java.awt.List;
import java.util.Iterator;

import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.HeaderParam;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.QueryParam;
import javax.ws.rs.core.MediaType;

import net.sf.json.JSONArray;
import net.sf.json.JSONObject;

import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.ResponseBody;

import com.certusnet.nfv.mano.exception.ManoException;
import com.certusnet.nfv.mano.rest.ContentType;
import com.certusnet.nfv.mano.vim.ExceptionCode;
import com.certusnet.nfv.mano.vim.HttpsUtil;
import com.certusnet.nfv.mano.vim.network.rest.NetworkRest;
import com.certusnet.nfv.mano.vim.network.service.INetworkService;
import com.certusnet.nfv.mano.vim.vm.rsclient.IVmRsClient;
import com.certusnet.nfv.mano.vim.vm.rsclient.impl.VmRsClient;

import javax.ws.rs.FormParam;

@Component
@Path("/")
public class VmRest {
private static Logger logger = Logger.getLogger(VmRest.class);

@Autowired
// private IVmRsClient vmRsClient = new VmRsClient();
private IVmRsClient vmRsClient;


//访问的时候用url建立客户端，之后，直接通过get标注获取标注中写接收response的类即可



@GET
@Path("vdus")
@Produces(ContentType.APPLICATION_JSON_UTF_8)
@Consumes(MediaType.TEXT_PLAIN)
public JSONArray findVmList(@HeaderParam("X-Auth-Token") String token) {

logger.info("findVmList-X-Auth-Token=" + token);

try {
String returnStr = vmRsClient.findVmList(token);
logger.debug("find-vm-list-returnstr=" + returnStr);

returnStr = returnStr.replace("null", "\"\"");
JSONObject jsonObj = JSONObject.fromObject(returnStr);

if (!"200".equalsIgnoreCase(jsonObj.getString("retCode")))
throw new ManoException(ExceptionCode.FIND_VDU_LIST_FAILED);

JSONArray vmJsonObj = jsonObj.getJSONArray("vms");
logger.info("find-vm-list-returnobj=" + vmJsonObj);
return vmJsonObj;
} catch (ManoException ex) {
throw ex;
}  catch (Exception ex) {
throw new ManoException(ExceptionCode.FIND_VDU_LIST_FAILED, ex);
}
}

@GET
@Path("vdus/{vdu_uuid}/detail")
@Produces(ContentType.APPLICATION_JSON_UTF_8)
@Consumes(MediaType.TEXT_PLAIN)
public JSONObject findVmById(@PathParam("vdu_uuid") String vm_id,@HeaderParam("X-Auth-Token") String token) {

logger.info("findVmById-X-Auth-Token=" + token);

if ((null == vm_id) || (vm_id.trim().equalsIgnoreCase(""))) {
throw new ManoException(ExceptionCode.PARAM_NEEDED_IS_NULL);
}

try {
   
String returnStr = vmRsClient.findVmById(vm_id,token);
logger.debug("findVmById-returnstr=" + returnStr);

returnStr = returnStr.replace("null", "\"\"");
JSONObject jsonObj = JSONObject.fromObject(returnStr);
if (!"200".equalsIgnoreCase(jsonObj.getString("retCode")) && !"404".equalsIgnoreCase(jsonObj.getString("retCode")))
throw new ManoException(ExceptionCode.FIND_VDU_FAILED);
if ("404".equalsIgnoreCase(jsonObj.getString("retCode")))
throw new ManoException(ExceptionCode.ITEM_NOT_FOUND);
logger.debug("findVmById-jsonObj = " + jsonObj);

JSONObject vmJsonObj = jsonObj.getJSONObject("vm").getJSONObject(
"server");

String flavor_id = vmJsonObj.getJSONObject("flavor")
.getString("id");

JSONObject addresses = vmJsonObj.getJSONObject("addresses");
logger.debug("findVmById-addresses = " + addresses);
String ip_addr = "";
for (Iterator iter = addresses.keys(); iter.hasNext();) {
    String key = (String)iter.next(); 
    String ip_addr_temp = addresses.getJSONArray(key).getJSONObject(0).getString("addr").trim();
   
    if (!ip_addr_temp.equals("")) {
    if (ip_addr.equals("")) {
    ip_addr += ip_addr_temp;
    } else {
    ip_addr += "," + ip_addr_temp;
    }
    }
}

String returnFlavorStr = vmRsClient.findFlavorById(flavor_id);
logger.debug("findVmById-returnFlavorStr=" + returnFlavorStr);

JSONObject returnFlvorJsonObj = JSONObject
.fromObject(returnFlavorStr);
logger.debug("findVmById-flavor-returnJsonObj=" + returnFlvorJsonObj);

JSONObject flavorJsonObj = returnFlvorJsonObj
.getJSONObject("flavor");

int cpu_number = flavorJsonObj.getInt("vcpus");

Double memory_size = ((Double) (flavorJsonObj.getInt("ram") * 1.0)) / 1024;

int disk_size = flavorJsonObj.getInt("disk");

JSONObject returnJsonObj = new JSONObject();
returnJsonObj.put("status", vmJsonObj.getString("status"));
returnJsonObj.put("vm_image", vmJsonObj.getJSONObject("image").getString("id"));
returnJsonObj.put("cpu_number", cpu_number);
returnJsonObj.put("memory_size", memory_size);
returnJsonObj.put("disk_size", disk_size);
returnJsonObj.put("path", "");
returnJsonObj.put("uuid",vm_id);
returnJsonObj.put("ip_addr",ip_addr);
returnJsonObj.put("name",vmJsonObj.getString("name"));
logger.info("findVmById-returnJsonObj=" + returnJsonObj);

return returnJsonObj;
} catch (ManoException ex) {
throw ex;
}  catch (Exception ex) {
throw new ManoException(ExceptionCode.FIND_VDU_FAILED, ex);
}
}

@POST
@Path("vdus")
@Produces(ContentType.APPLICATION_JSON_UTF_8)
// @Consumes(MediaType.TEXT_PLAIN)
@Consumes(MediaType.APPLICATION_FORM_URLENCODED)
// "application/json"
// @Consumes("application/json")
// public String createVm(@QueryParam("vdu_params") String vdu_params)
public Object createVm(@FormParam("vdu_params") String vdu_params,
@HeaderParam("X-Auth-Token") String token) throws ManoException {

logger.info("createVm-X-Auth-Token=" + token);

if ((null == token) || (token.trim().equalsIgnoreCase(""))) {
throw new ManoException(ExceptionCode.AUTH_TOKEN_IS_EMPTY);
}

logger.info("createVm-vdu_params:" + vdu_params);

if ((null == vdu_params) || (vdu_params.trim().equalsIgnoreCase(""))) {
throw new ManoException(ExceptionCode.PARAM_NEEDED_IS_NULL);
}



try {
logger.info("createVm-vdu_params:" + vdu_params);
JSONObject jsonObj = JSONObject.fromObject(vdu_params);
logger.info("tangjing-createVm-vdu_params-json:" + jsonObj.toString());

String image_id = "";
String cpu_number = "";
String mem_size = "";
String disk = "";
String network_list = "";
String user_param = "";
String seq_id = "";
String id = "";
String parent_id = "";
JSONArray networklist = new JSONArray();
JSONObject network_json = new JSONObject();

String vm_image = jsonObj.getString("vm_image");

image_id = vm_image;

int cpu_number_int = jsonObj.getInt("cpu_number");

cpu_number = "" + cpu_number_int;

double memory_size_int = jsonObj.getDouble("memory_size");

mem_size = "" + memory_size_int * 1024;

int disk_size_int = jsonObj.getInt("disk_size");

disk = "" + disk_size_int;

String user_param_from_json = jsonObj.getString("user_param");

user_param = user_param_from_json;

int seq_id_from_json = jsonObj.getInt("seq_id");

seq_id = "" + seq_id_from_json;

String id_from_json = jsonObj.getString("id");

id = id_from_json;

String parent_id_from_json = jsonObj.getString("parent_id");

parent_id = parent_id_from_json;


// String path = jsonObj.getString("vm_image");
//
// String file_content = jsonObj.getString("file_content");

JSONArray vlink_uuid_list = jsonObj.getJSONArray("vlink_uuid_list");

if ((null == vlink_uuid_list) || (vlink_uuid_list.isEmpty())) {

throw new ManoException(ExceptionCode.CREATE_VDU_FAILED);
} else {
int vlink_length = vlink_uuid_list.size();
logger.info("create-vm-vlink_length=" + vlink_length);
// System.Text.StringBuilder stringBuilder = new
// System.Text.StringBuilder();
for (int i = 0; i < vlink_length; i++) {
JSONObject tempJsonObj = vlink_uuid_list.getJSONObject(i);
JSONObject oneNetwork = new JSONObject();
String tmpStr = "";
tmpStr = tmpStr + tempJsonObj.getString("vlink_uuid");
oneNetwork.put("network_uuid", tempJsonObj.getString("vlink_uuid"));

String tempStrNetworkType = tempJsonObj
.getString("network_type");
tmpStr = tmpStr + "," + tempStrNetworkType;
oneNetwork.put("network_type", tempStrNetworkType);

tmpStr = tmpStr + ","
+ tempJsonObj.getString("service_type");
;
oneNetwork.put("service_type", tempJsonObj.getString("service_type"));

if ("E-LAN-L3".equalsIgnoreCase(tempStrNetworkType)) {
tmpStr = tmpStr + ","
+ tempJsonObj.getString("gateway_ip");
;
oneNetwork.put("gateway_ip", tempJsonObj.getString("gateway_ip"));
}
network_list = network_list + tmpStr;
if (i < vlink_length - 1) {
network_list = network_list + "/";
}

oneNetwork.put("seq_id", "" + tempJsonObj.getInt("seq_id"));
oneNetwork.put("vif_model", tempJsonObj.getString("vif_model"));

networklist.add(oneNetwork);
logger.info("create-vm-oneNetwork:" + oneNetwork);
}

}

            network_json.put("network_list", networklist);
            logger.info("create-vm-network_json:" + network_json);
logger.info("create-vm-network_list:" + network_list);

String scapeRestReturnStr = vmRsClient.createVm(image_id,
cpu_number, mem_size, disk,id,parent_id,seq_id,user_param, network_json.toString(),token);
JSONObject scapeJsonObj = JSONObject.fromObject(scapeRestReturnStr);
logger.info("createVm-scapeJsonObj=" + scapeJsonObj.toString());
logger.info("createVm-retCode=" + scapeJsonObj.getString("retCode"));

if (!"200".equalsIgnoreCase(scapeJsonObj.getString("retCode")))
throw new ManoException(ExceptionCode.CREATE_VDU_FAILED);

JSONObject returnJsonObj = new JSONObject();
returnJsonObj.put("uuid", scapeJsonObj.getString("id"));

return returnJsonObj;
} catch (ManoException ex) {
throw ex;
}  catch (Exception ex) {

logger.error("createVm-ex:" + ex);

throw new ManoException(ExceptionCode.CREATE_VDU_FAILED, ex);
}
}

@DELETE
@Path("vdus/{vdu_uuid}")
@Produces(ContentType.APPLICATION_JSON_UTF_8)
@Consumes(MediaType.TEXT_PLAIN)
public String deleteVm(@PathParam("vdu_uuid") String vm_id,
@HeaderParam("X-Auth-Token") String token) throws ManoException {

logger.info("deleteVm-X-Auth-Token=" + token);

if ((null == token) || (token.trim().equalsIgnoreCase(""))) {
throw new ManoException(ExceptionCode.AUTH_TOKEN_IS_EMPTY);
}
logger.info("deleteVm-vdu_uuid:" + vm_id);

if ((null == vm_id) || (vm_id.trim().equalsIgnoreCase(""))) {
throw new ManoException(ExceptionCode.PARAM_NEEDED_IS_NULL);
}

try {
String returnStr = vmRsClient.deleteVm(vm_id,token);
JSONObject jsonObj = JSONObject.fromObject(returnStr);
logger.info("deleteVm-find-host-list-returnStrJsonObj=" + jsonObj);

if (!"200".equalsIgnoreCase(jsonObj.getString("retCode")) && !"404".equalsIgnoreCase(jsonObj.getString("retCode")))
throw new ManoException(ExceptionCode.DELETE_VDU_FAILED);

if ("404".equalsIgnoreCase(jsonObj.getString("retCode")))
throw new ManoException(ExceptionCode.ITEM_NOT_FOUND);

return "";
} catch (ManoException ex) {
throw ex;
} catch (Exception ex) {
throw new ManoException(ExceptionCode.DELETE_VDU_FAILED, ex);
}
}
//不能放在main方法中，否则没有实例可以创建，这个可以用单元测试@junite

public static void main(String[] args) {
VmRest vm = new VmRest();
// String image_id = "307e56ea-f500-4c1f-a5b8-8a43cb8d1e83";
// String cpu_number = "1";
// String mem_size = "512";
// String disk = "1";
// String network_list= "71d9ca38-bb8e-4384-873b-82985bcfb7f0,L2,data";

//vm.findVmList();
vm.findVmById("b5a74a90-011c-43f9-87a1-c33c1901f386", "123");
// vm.findVmById("15afdb66-e607-43c4-b7c4-589fe0218c6a");
// vm.createVm(image_id, cpu_number, mem_size, disk, network_list);
// vm.deleteVm("cd171a62-ce10-47be-9dad-ddebbc27908c");

}
}



////注册新增的接口


package com.certusnet.nfv.mano.vim;

import org.glassfish.jersey.server.ResourceConfig;
import org.springframework.web.filter.RequestContextFilter;

import com.certusnet.nfv.mano.rest.ManoExceptionMapper;
import com.certusnet.nfv.mano.rest.RestResponseFilter;
import com.certusnet.nfv.mano.vim.host.rest.HostRest;
import com.certusnet.nfv.mano.vim.alarm.rest.AlarmRest;
import com.certusnet.nfv.mano.vim.cpu_utilization_history.rest.Cpu_utilization_historyRest;
import com.certusnet.nfv.mano.vim.network.rest.NetworkRest;
import com.certusnet.nfv.mano.vim.port.rest.PortRest;
import com.certusnet.nfv.mano.vim.providernet.rest.ProvidernetRest;
import com.certusnet.nfv.mano.vim.usage_history.rest.Usage_historyRest;
import com.certusnet.nfv.mano.vim.vm.rest.VmRest;
import com.certusnet.nfv.mano.vim.vnf.rest.HelloNfvRest;


public class RestApplication extends ResourceConfig {

    /**
     * Register JAX-RS application components.
     */
    public RestApplication () {
        register(RequestContextFilter.class);
        register(HelloNfvRest.class);
        register(VmRest.class);
        register(Usage_historyRest.class);
        register(Cpu_utilization_historyRest.class);
        register(ProvidernetRest.class);
        register(ManoExceptionMapper.class);
        register(RestResponseFilter.class);
        register(NetworkRest.class);
        register(HostRest.class);
        register(AlarmRest.class);
        register(PortRest.class);
    }
   
}



//客户端





package com.certusnet.nfv.mano.nfvo.vnfr.rsclient.impl;

import org.apache.log4j.Logger;

import javax.ws.rs.client.Client;
import javax.ws.rs.client.Invocation;
import javax.ws.rs.client.WebTarget;

import org.springframework.util.StringUtils;

import com.certusnet.nfv.mano.common.pojo.VDUDetailResp;
import com.certusnet.nfv.mano.common.pojo.VDUDetailResult;
import com.certusnet.nfv.mano.common.pojo.VduVm;
import com.certusnet.nfv.mano.exception.ManoException;
import com.certusnet.nfv.mano.nfvo.vnfr.pojo.VduQueryResp;
import com.certusnet.nfv.mano.nfvo.vnfr.rsclient.IVduRsClient;
import com.certusnet.nfv.mano.rest.ContentType;
import com.certusnet.nfv.mano.rest.RestResultCode;
import com.certusnet.nfv.mano.rsclient.RsClient;
//用注入的方式获取vimRestRootUrl

//<bean id="vimRsClient"
//class="com.certusnet.nfv.mano.vnfm.vnfr.vimrestclient.VimRestClient">
// <property name="vimRestRootUrl" value="${VIM_REST_ROOT_URL}" />
//</bean>

public class VduRsClient extends RsClient implements IVduRsClient {

private static final String VDU_URL = "vdus";

private static Logger logger = Logger.getLogger(VduRsClient.class);

@Override
public VDUDetailResult queryVDUDetail(String uuid) {

if(StringUtils.isEmpty(uuid))
{
return null;
}

Client client = getClient();
WebTarget webTarget = client.target(vimRestRootUrl).path(VDU_URL)
.path(uuid).path("detail");
Invocation.Builder invocationBuilder = webTarget
.request(ContentType.APPLICATION_JSON_UTF_8);

VDUDetailResp resp = invocationBuilder.get(VDUDetailResp.class);
if (!"ok".equals(resp.getRetCode().trim())) {
if(RestResultCode.ITEM_NOT_FOUND.equals(resp.getRetCode()))
{
logger.error(resp.getRetCode() + ":" + resp.getMsg());
return null;
}
else
{
throw new ManoException(resp.getRetCode(), resp.getMsg());
}
}
return resp.getResult();
}

@Override
public VduVm findVduVm(String vduUUID) {

if(StringUtils.isEmpty(vduUUID))
{
return null;
}

Client client = getClient();

WebTarget webTarget = client.target(vimRestRootUrl).path(VDU_URL)
.path(vduUUID).path("detail");
Invocation.Builder invocationBuilder = webTarget
.request(ContentType.APPLICATION_JSON_UTF_8);

VduQueryResp resp = invocationBuilder.get(VduQueryResp.class);
if (!resp.getRetCode().equals("ok")) {
if(RestResultCode.ITEM_NOT_FOUND.equals(resp.getRetCode()))
{
logger.error(resp.getRetCode() + ":" + resp.getMsg());
return null;
}
else
{
throw new ManoException(resp.getRetCode(), resp.getMsg());
}
}

return resp.getResult();
}
}


//客户端2（框架本身）

package com.certusnet.nfv.mano.nfvo.vnfr.rsclient.impl;

import javax.annotation.Resource;
import javax.ws.rs.client.Client;
import javax.ws.rs.client.Invocation;
import javax.ws.rs.client.WebTarget;

import org.apache.log4j.Logger;
import org.springframework.stereotype.Component;

import com.certusnet.nfv.mano.common.pojo.RestResultResp;
import com.certusnet.nfv.mano.exception.ManoException;
import com.certusnet.nfv.mano.rest.ContentType;
import com.certusnet.nfv.mano.rest.RestResultCode;
import com.certusnet.nfv.mano.rsclient.RsClient;
import com.certusnet.nfv.mano.vnfm.token.RestToken;

//访问的时候用url建立客户端，之后，直接通过get标注获取标注中写接收response的类即可

@Component
public class VnfmRsClient extends RsClient {
private Logger logger = Logger.getLogger(VnfmRsClient.class);

private static final String VNFM_URL = "vnfrs";

@Resource
private RestToken restToken;

public void deleteVNFR(Long vnfrId) {
Client client = getClient();
WebTarget webTarget = client.target(vnfmRestRootUrl).path(VNFM_URL)
.path(String.valueOf(vnfrId));
Invocation.Builder invocationBuilder = webTarget.request(
ContentType.APPLICATION_JSON_UTF_8).header(RestToken.key,
restToken.getToken());

RestResultResp resp = invocationBuilder.delete(RestResultResp.class);
if (!RestResultCode.OK.equals(resp.getRetCode().trim())
&& !RestResultCode.ITEM_NOT_FOUND.equals(resp.getRetCode()
.trim())) {
logger.error("Request VNFM RESTful for deleteVNFR, the response msg is : "
+ resp.getMsg());
throw new ManoException(resp.getRetCode(), resp.getMsg());
}

}

public void deleteVLByVNFRId(Long vnfrId) {
Client client = getClient();
WebTarget webTarget = client.target(vnfmRestRootUrl).path(VNFM_URL)
.path(String.valueOf(vnfrId)).path("vlrs");
Invocation.Builder invocationBuilder = webTarget.request(
ContentType.APPLICATION_JSON_UTF_8).header(RestToken.key,
restToken.getToken());

RestResultResp resp = invocationBuilder.delete(RestResultResp.class);////与结果集对应字段的类
if (!RestResultCode.OK.equals(resp.getRetCode().trim())
&& !RestResultCode.ITEM_NOT_FOUND.equals(resp.getRetCode()
.trim())) {
logger.error("Request VNFM RESTful for deleteVLByVNFRId, the response msg is : "
+ resp.getMsg());
throw new ManoException(resp.getRetCode(), resp.getMsg());
}
}

}


//客户端 3 （要用到工具类）

public SummeryOfResourcesVO getSummeryOfResource() {
        logger.info("查询一组资源使用情况(云主机、虚拟内核、虚拟内存、安全组)信息");
        final SummeryOfResourcesVO vo = new SummeryOfResourcesVO();
        final JSONObject[] provider = new JSONObject[1];
        final String[] reslt= new String[1];


       
        /**取资源使用情况*/
        HttpClientRequest request = new HttpClientGetRequest(ConfigFileLoad.getConfContent("API_IP") + "/rest/resource_used");
        try {
            request.process(new HttpClientResponseHandler() {
                @Override
                public void handle(String response, String retCode, String msg) throws HttpClientException,ManoException {
                    logger.debug("查询一组资源使用情况信息,返回状态：" + retCode + ",返回信息：" + msg);
                    JSONObject obj = JSONObject.parseObject(response);
                    if(obj.get("result")!=null){
                    System.out.println(obj.get("result").toString());
                    JSONObject jsonObj = JSONObject.parseObject(obj.get("result").toString());
                    if (jsonObj == null){
                    //&&!reslt[0].equals("0")
                    return;
                    }
                   
                       
                    // 一 、请求并计算 云主机信息
                    Integer vms = jsonObj.getInteger(Constants.OverView.VMS);
                    Integer used_vms = jsonObj.getInteger(Constants.OverView.USED_VMS);
                    Integer unused_vms = 0;
                    if (vms == null || vms.equals("")) {
                        vms = 0;
                    } else if (used_vms == null || used_vms.equals("")) {
                        used_vms = 0;
                    } else {
                        unused_vms = vms - used_vms;
                    }
                    vo.setCloudPlatformAll(String.valueOf(vms));
                    vo.setCloudPlatformUsed(String.valueOf(used_vms));
                    vo.setCloudPlatformUnUsed(String.valueOf(unused_vms));
                    // 二 、请求 虚拟内核
                    Integer cpus = jsonObj.getInteger(Constants.OverView.CPUS);
                    Integer used_cpus = jsonObj.getInteger(Constants.OverView.USED_CPUS);
                    Integer unused_cpus = 0;
                    if (cpus == null || cpus.equals("")) {
                        cpus = 0;
                    } else if (used_cpus == null || used_cpus.equals("")) {
                        used_cpus = 0;
                    } else {
                        unused_cpus = cpus - used_cpus;
                    }
                    vo.setVirtualKernelAll(String.valueOf(cpus));
                    vo.setVirtualKernelUsed(String.valueOf(used_cpus));
                    vo.setVirtualKernelUnUsed(String.valueOf(unused_cpus));
                    // 三、请求 虚拟内存
                    Integer mems = jsonObj.getInteger(Constants.OverView.MEMS);
                    Integer used_mem = jsonObj.getInteger(Constants.OverView.USED_MEM);
                    Integer unused_mem = 0;
                    if (mems == null || mems.equals("")) {
                        mems = 0;
                    } else if (used_mem == null || used_mem.equals("")) {
                        used_mem = 0;
                    } else {
                        unused_mem = mems - used_mem;
                    }
                    vo.setVirtualMemoryAll(String.valueOf(mems));
                    vo.setVirtualMemoryUsed(String.valueOf(used_mem));
                    vo.setVirtualMemoryUnUsed(String.valueOf(unused_mem));
                    // 四、请求 安全组
                    Integer security_group = jsonObj.getInteger(Constants.OverView.SECURITY_GROUP);
                    Integer used_security_group = jsonObj.getInteger(Constants.OverView.USED_SECURITY_GROUP);
                    Integer unused_security_group = 0;
                    if (security_group == null || security_group.equals("")) {
                        security_group = 0;
                    } else if (used_security_group == null || used_security_group.equals("")) {
                        used_security_group = 0;
                    } else {
                        unused_security_group = security_group - used_security_group;
                    }
                    vo.setSecurityGroupAll(String.valueOf(security_group));
                    vo.setSecurityGroupUsed(String.valueOf(used_security_group));
                    vo.setSecurityGroupUnUsed(String.valueOf(unused_security_group));
                }else{
               
                    /**provider连接数*/
                  HttpClientRequest requestProvider = new HttpClientGetRequest(ConfigFileLoad.getConfContent("API_IP") + "/rest/provider_network_cn");
                  try {
                 
                  requestProvider.process(new HttpClientResponseHandler() {
                          @Override
                          public void handle(String response, String retCode, String msg) throws HttpClientException {
                              logger.debug("查询一组资源使用情况信息,返回状态：" + retCode + ",返回信息：" + msg);
                              provider[0] = JSONObject.parseObject(response);
                              System.out.println(provider[0].get("result").toString()+"rrrrrrrrrrrrr");
                              String jsonObj = provider[0].get("result").toString();
                              reslt[0] =jsonObj;
                              if (jsonObj == null)
                                  return;
                          
                          }
                      });
                  } catch (HttpClientException e) {
                      e.printStackTrace();
                  }
                if(reslt[0].equals("0")){
                throw new ManoException("0","没建立与openstack的连接，请检查openstack资源中openstack提供者是否已添加");
                }else{
                throw new ManoException("1","没有数据");
                }
                //throw new HttpClientException("没建立连接");
                }
            }});
        } catch (HttpClientException e) {
        throw new ManoException("1","没建立连接");
        }

        logger.info("SummeryOfResourcesVO is " + vo.toString());
        return vo;
    }


客户端 4：

@Override
public String saveEventNameId(String id, String name) {
        String ret = "";
        try {
            logger.info("开始记录日志");
            String url = ConfigFileLoad.getConfContent("NFVO_IP") + "/rest/logs/EventId";
            // url = "http://172.16.25.138:9090/nfvo/rest/logs/generation";
            HttpRestClientRequest hr = new HttpRestClientRequest(url);
            hr.addParam("Event-Id", id);
            hr.addParam("Event-Name", formatStr(name));
            ret = hr.postRequest();
        } catch (Exception e) {
            logger.info("记录日志失败" + ret);
            e.printStackTrace();
        }
        return ret;
    }


客户端4对应的工具类：


package com.certus.util.httpClient;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import javax.ws.rs.client.Client;
import javax.ws.rs.client.ClientBuilder;
import javax.ws.rs.client.Entity;
import javax.ws.rs.client.WebTarget;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;

import com.certus.util.CommonUtil;

/**
* @ClassName   类  名   称： HttpRestClientRequest.java
* @Description 功能描述：   调用rest接口的客户端
* @author      创  建   者： <A HREF="[email protected]">wanglz</A>
* @date        创建日期： 2015年4月2日下午4:28:04
*/
public class HttpRestClientRequest {
    private String url;
    private Map<String, Object> paramMap = new HashMap<String, Object>();
    public static final String APPLICATION_JSON_UTF_8 = MediaType.APPLICATION_JSON + "; " + MediaType.CHARSET_PARAMETER + "=UTF-8";
    public HttpRestClientRequest(String url) {
        this.url = url;
    }

    public void addParam(String key, Object value) {
        this.paramMap.put(key, value);
    }

    public String postRequest() {
        String token = CommonUtil.getAuthToken();
        String message = "";
        try {
            Client client = ClientBuilder.newClient();
            WebTarget target = client.target(url);
  
            if (!paramMap.isEmpty()) {
                paramMap.keySet().iterator();
                for (Iterator<String> iter = paramMap.keySet().iterator(); iter.hasNext();) {
                    String key = iter.next();
                    target = target.queryParam(key, paramMap.get(key));
                }
            }
            Entity<String> entity = Entity.entity("Test", MediaType.APPLICATION_JSON_TYPE);
            Response response = target.request().header("X-Auth-Token", token).buildPost(entity).invoke();
            int code = response.getStatus();
            message = response.readEntity(String.class);
            response.close();
            /*  System.out.println(code);
              System.out.println(message);*/
        } catch (Exception e) {
            e.printStackTrace();
        }
        return message;
    }
}








////////////////用的jar包
javax.ws.rs-api-2.0.1.jar