在两个不同的项目之间使用SpringTemplate发布

我正在开发一个管理教授预约的应用程序，它应该在其他使用Web服务的项目中使用不同的功能。 我有一个RestController，它是我在项目中制作的，名为WSSpring和 这是它的代码

package org.icda.entry;
import java.util.List;
import org.icda.entry.entities.Professor;
import org.icda.entry.professor.metier.IProfessorMetier;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/Profs")
public class ProfessorController {

@Autowired
private IProfessorMetier professorMetier;

@RequestMapping(value = "/sortProfs", method = RequestMethod.GET)
public List<Professor> sortPorfessors() {
    return professorMetier.sortPorfessors();
}

@RequestMapping(value = "/allProfs", method = RequestMethod.GET)
public List<Professor> listAllProfessors() {
    return professorMetier.listAllProfessors();
}

@RequestMapping(value = "/findProf/{id}", method = RequestMethod.GET)
public Professor findOne(@PathVariable Long id) {
    return professorMetier.findOne(id);
}

 @RequestMapping(value = "/saveProf", method = RequestMethod.POST)
 public Professor save(@RequestBody Professor p) {
    return professorMetier.save(p);
 }
}

package org.icda.entry；
导入java.util.List；
导入org.icda.entry.entities.Professor；
导入org.icda.entry.professor.metier.IProfessorMetier；
导入org.springframework.beans.factory.annotation.Autowired；
导入org.springframework.web.bind.annotation.PathVariable；
导入org.springframework.web.bind.annotation.RequestBody；
导入org.springframework.web.bind.annotation.RequestMapping；
导入org.springframework.web.bind.annotation.RequestMethod；
导入org.springframework.web.bind.annotation.RestController；
@RestController
@请求映射（“/Profs”）
公开课教授兼主任{
@自动连线
私人知识产权教授；
@RequestMapping（value=“/sortProfs”，method=RequestMethod.GET）
公共列表排序器（）{
return professorMetier.sortPorfessors（）；
}
@RequestMapping（value=“/allProfs”，method=RequestMethod.GET）
公共列表listAllProfessors（）{
返回professorMetier.listAllProfessors（）；
}
@RequestMapping（value=“/findProf/{id}”，method=RequestMethod.GET）
public Professor findOne（@PathVariable Long id）{
返回findOne教授（id）；
}
@RequestMapping（value=“/saveProf”，method=RequestMethod.POST）
公共教授保存（@RequestBody Professor p）{
返回梅蒂埃教授。保存（p）；
}
}

现在，我必须使另一个名为WSSpringClient的项目中存在的客户端应用程序与RestController通信。 我开发了一个基于RestTemplate的解决方案。 这就是我的客户机类的外观

package org.icda.client.metier;

import java.net.URI;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.springframework.web.client.RestTemplate;

public class ProfessorClient implements IProfessorClient {

public static final String REST_SERVICE_URI = "http://localhost:8080 /entry/Profs";

public static void main(String[] args) {
  ProfessorClient professor = new ProfessorClient();
  professor.listAllProfessors();
  System.out.println("Sorting .....");
  professor.sortPorfessors();
  Object object = professor.findOne(2L);
  System.out.println(object.toString());
}

@SuppressWarnings("unchecked")
@Override
public List<Object> listAllProfessors() {
    RestTemplate restTemplate = new RestTemplate();
    List<Object> objects = restTemplate.getForObject(REST_SERVICE_URI
            + "/allProfs", List.class);
    for (Object o : objects) {
        System.out.println(o.toString());
    }
    return objects;
}

@SuppressWarnings({ "unchecked" })
@Override
public List<Object> sortPorfessors() {
    RestTemplate restTemplate = new RestTemplate();
    List<Object> objects = restTemplate.getForObject(REST_SERVICE_URI
            + "/sortProfs", List.class);
    for (Object o : objects) {
        System.out.println(o.toString());
    }
    return objects;
}

@Override
public Object findOne(Long id) {
    Map<String, Long> profsMap = new HashMap<String, Long>();
    profsMap.put("id", id);
    RestTemplate restTemplate = new RestTemplate();
    Object object = restTemplate.getForObject(REST_SERVICE_URI
            + "/findProf/{id}", Object.class, profsMap);
    System.out.println("Searching for user number....."+id);
    return object;
}

@SuppressWarnings("unused")
@Override
public Object save(Object p) {
    RestTemplate restTemplate = new RestTemplate();
    URI uri = restTemplate.postForLocation(REST_SERVICE_URI + "/saveProf",p, Object.class);
    return p;
}
} 

package org.icda.client.metier；
导入java.net.URI；
导入java.util.HashMap；
导入java.util.List；
导入java.util.Map；
导入org.springframework.web.client.rest模板；
公共类ProfessorClient实现IProfessorClient{
公共静态最终字符串REST\u服务\u URI=”http://localhost:8080 /进入/专业”；
公共静态void main（字符串[]args）{
ProfessorClient professor=新ProfessorClient（）；
professor.listAllProfessors（）；
System.out.println（“排序…”）；
sortPorfessors教授（）；
Object=professor.findOne（2L）；
System.out.println（object.toString（））；
}
@抑制警告（“未选中”）
@凌驾
公共列表listAllProfessors（）{
RestTemplate RestTemplate=新RestTemplate（）；
List objects=restTemplate.getForObject（REST\u服务\u URI
+“/allProfs”，List.class）；
用于（对象o:对象）{
System.out.println（o.toString（））；
}
归还物品；
}
@SuppressWarnings（{“unchecked”}）
@凌驾
公共列表排序器（）{
RestTemplate RestTemplate=新RestTemplate（）；
List objects=restTemplate.getForObject（REST\u服务\u URI
+“/sortProfs”，List.class）；
用于（对象o:对象）{
System.out.println（o.toString（））；
}
归还物品；
}
@凌驾
公共对象findOne（长id）{
Map profsMap=new HashMap（）；
profsMap.put（“id”，id）；
RestTemplate RestTemplate=新RestTemplate（）；
Object Object=restTemplate.getForObject（REST\u服务\u URI
+“/findProf/{id}”，Object.class，profsMap）；
System.out.println（“搜索用户号…”+id）；
返回对象；
}
@抑制警告（“未使用”）
@凌驾
公共对象保存（对象p）{
RestTemplate RestTemplate=新RestTemplate（）；
uriuri=restemplate.postForLocation（REST\u SERVICE\u URI+“/saveProf”，p，Object.class）；
返回p；
}
} 

我的问题是，我不知道如何发布教授对象 您可以在上一个方法中看到的RestTemplate

---

如果您有任何建议，伙计们，谢谢分享。

我想您的

/saveProf

端点可以接受

JSON

或

XML

表示

Professor

。因此，您将在

POST

调用中发送一个表示

Professor

的

JSON

，然后

save

处理程序方法将使用其注册的

HttpMessageConverter

读取HTTP消息正文，并填充

Professor

对象

假设您要发送此

JSON

：

{
    "name": "someone",
    "degree": "PhD"
}

你应该在你的客户机上写下这样的内容：

// Prepare professor representation
Map<String, Object> professor = new HashMap<>();
professor.put("name", "someone");
professor.put("degree", "PhD");

// Prepare request
HttpHeaders headers = new HttpHeaders();
headers.add(HttpHeaders.CONTENT_TYPE, "application/json");
HttpEntity<Map<String, Object>> request = new HttpEntity<>(professor, headers);

// Send prepared request
ResponseEntity<String> response = template.postForEntity(REST_SERVICE_URI + "/saveProf", request, String.class);

//准备教授陈述
Map professor=newhashmap（）；
教授。把（“姓名”、“某人”）；
普特教授（“学位”、“博士”）；
//准备请求
HttpHeaders=新的HttpHeaders（）；
headers.add（HttpHeaders.CONTENT_TYPE，“application/json”）；
HttpEntity请求=新的HttpEntity（professor，headers）；
//发送准备好的请求
ResponseEntity response=template.postForEntity（REST\u SERVICE\u URI+“/saveProf”，request，String.class）；