Enviar e aceito duas sub-projectos para ilustrar
arquitetura send
classe TestSend
/ **
* interface de chamada de teste backend
*
*
* /
@RequestMapping (value = "/ Enviar")
@RestController
classe pública TestSend {
Logger Logger = LoggerFactory.getLogger (this.getClass ());
/ **
* é transmitido Mapa envolto Lista de corda Josn (disponível)
* Pós maneira
* /
@RequestMapping (value = "/ send01")
público send01 void () {
logger.info ( "send01 incoming");
o de dados nova novo o Data = dados ( " HLH "23 é);
List <dados> = new new List ArrayList <> ();
List.add (Data);
string URL =" http: // interface IP: 8091 / aceitação / accept01 ";
o Map <string, Object> map = new HashMap <> () ;
map.put ( "list", lista);
JSON.toJSONString String = String (Mapa);
o enviar a enviar novas new = Send ();
String = send.sendPost o resultado (url, String);
logger.info ( "O resultado:" + o resultado); // retorna a interface de chamada retornou informações
}
/ **
* Mapa é enviado para o formato do pacote da classe entidade string JSON (disponível)
* Mensagem
* /
@RequestMapping (value = "/ send02")
público send02 void () {
logger.info ( "incoming send02 ");
Data = dados new new dados (" HLH "23 é);
string URL =" http: // interface IP: 8091 / Aceitar / accept02 ";
o Map <string, Object> = new novo Mapa do HashMap <> ();
map.put ( "Data", dados);
logger.info ( "Map:" + Mapa); // Mapa: Data = {dados (name = HLH, Idade = 23 é)}
String string = JSON.toJSONString (dados); logger.info ( "string:" + string);
Enviar a Enviar novo new = Send ();
string de resultado = send.sendPost (URL, String);
logger.info ( "Resultado:" Resultado +); // informações de retorno é retornado para a interface de chamada
}
/ **
*
* classe de entidade direto passar (isto é diretamente dado, não trabalho) (não disponível)
*
*
* /
@RequestMapping (value = "/ send04")
público send04 void () {
logger.info ( "send04 incoming");
o de dados nova novo o Data = dados ( " HLH "23 é);
string URL =" http: // interface IP: 8091 / Aceitar / accept04 ";
logger.info (" dados: "dados +);
a enviar novas novas = Enviar o Send ();
string de resultado = send.sendPost02 (URL, dados);
logger.info ( "Resultado:" Resultado +);// informações de retorno sobre a interface de chamada é retornada
}
/ **
*传的是Lista转成的字符串(可用)
* /
@RequestMapping ( "/ send05")
público send05 void () {
logger.info ( "进来send05");
Dados dados = new dados ( "hLH", 23);
Lista <Data> list = new ArrayList <> ();
list.add (dados);
String url = "http: //接口ip: 8091 / aceitação / accept05";
logger.info ( "lista:" + lista);
String String = JSON.toJSONString (lista);
Enviar Enviar = new Enviar ();
String result = send.sendPost (url, string);
logger.info ( "Resultado:" + resultado);
* Obter pedido
* 1 sem argumentos
* argumentos 2.
* solicitação POST
* /
@RequestMapping (value = "/ send06")
send06 public void () lança um URISyntaxException para {
/ **
* obter pedido sem parâmetros, e pode retornar algumas informações
* /
logger.info ( "venha send06");
rs RestTemplate = new new RestTemplate ();
string url = "http: // interface IP: 8091 / Aceitar / accept06";
logger.info ( "URL");
Cordas = rs.getForObject STR (novos novos da URI (URL), String.class);
logger.info ( "aviso:" + STR); // STR: Sucesso
}
/ **
* parâmetros do modo de pedidos GET
* @throws um URISyntaxException para
* /
@RequestMapping (value = "/ send07")
send07 public void () lança um URISyntaxException para {
/ **
* obter parâmetros de solicitação, e pode retornar algumas informações
* /
logger.info ( "send07 incoming");
RestTemplate nova nova RestTemplate RS = ( );
string URL = "http: / Aceitar / accept07 nome nome // interface IP :? 8091 = {} = {& Idade}";
o Map <string, Object> = new novo Mapa do HashMap <> ();
map.put ( "nome", "HLH");
map.put ( "Idade", 23 é);
string = rs.getForObject STR (URL, String.class, Mapa);
logger.info ( "Aviso:" + STR); // STR: Sucesso
}
/ **
* O modo POST
* 1.Com entidade parâmetro solicitando
parâmetros * Tenha a entidade receptora devem ser configurados, para ser capaz de desserializar dados recebidos
* Teste aqui está a receber classe de entidade
* /
@RequestMapping ( "/ send08")
público send08 void () {
logger.info ( "进来send08");
Rs = RestTemplate novo RestTemplate ();
String url = "http: //接口ip: 8091 / aceitação / accept08";
RequestEntity requestEntity = new RequestEntity ( "hLH", 23178);
RequestEntity requestEntity1 = rs.postForObject (URL, requestEntity, RequestEntity.class);
logger.info ( "name:" + requestEntity1.getName () + "a idade:" + requestEntity1.getAge ()); // nome: hLH, idade: 23
}
/ **
* pós方式
* 1.
* /
@RequestMapping ( "/ send09")
público send09 void () {
logger.info ( "send09 incoming");
RestTemplate novas nova RestTemplate RS = ();
string URL = "http: // interface IP: 8091 / aceitação / accept09 ";
RequestEntity nova nova RequestEntity RequestEntity = (" HLH "23178);
RequestEntity requestEntity1 = rs.postForObject (URL, RequestEntity, RequestEntity.class);
logger.info (" name: "+ requestEntity1.getName () +", Idade: "+ requestEntity1.getAge ()); // nome: HLH, Idade: 23 é
}
/ **
* O modo POST
* esta é uma classe de entidade teste envolveu tipos básicos, tipo de entidade, Lista de transferência de tipo de dados
*
* /
@ RequestMapping ( "/ send10")
Send010 public void () {
logger.info ( "进来send10"); //进来send10
RestTemplate rs = new RestTemplate ();
String url = "http: //接口ip: 8091 / aceitação / accept10";
RequestEntity RE1 = new RequestEntity ( "hLH", 10.120);
RequestEntity RE2 = new RequestEntity ( "hlh2", 11.130);
List <RequestEntity> list = new ArrayList <> ();
list.add (RE1);
list.add (RE2);
Dados de dados = novos dados ( "hlh3", 140);
SendModel sendModel = novo SendModel ();
sendModel.setCode ( "500");
sendModel.setStatus ( "ok");
sendModel.setData (dados);
sendModel.setListEntity (lista);
Corda str = rs.
logger.info ( "str:" + str); // str: sucesso
}
}
classe de dados
classe RequestEntity
classe SendModel
classe Enviar
/ **
* envio de pós pedido
* /
Cordas sendPost public static (URL String, String param) {
o PrintWriter OUT = null;
o BufferedReader in = null;
Resultado String = "";
o try {
a URL = new new realUrl o URL (URL);
o URLConnection Conn realUrl.openConnection = ();
conn.setRequestProperty ( "Aceitar", "* / *");
conn.setRequestProperty ( "Connection", "Keep-Alive");
conn.setRequestProperty ( "Content-Type", "arquivo application / json "); // Eu adicionei uma cabeça, é passado no formato JSON, tem que adicionar isso, você tem que usar o back-end receber @RequestBody
conn.setRequestProperty (" User-Agent "
" Mozilla / 4.0 (compatível; MSIE 6.0; Windows NT 5.1; SV1 ) ");
conn.setDoOutput (true);
conn.setDoInput (a verdade);
OUT = new new PrintWriter (conn.getOutputStream ());
out.print (param); // já passou a informação a ser chamado de Interface
out.flush ();
in = new new BufferedReader (
new new InputStreamReader (conn.getInputStream ())); // esta é a interface lê as informações retornadas pela chamada
linha string;
! o while ((linha = in.readLine ()) = null) {// declaração de informações
resultado + = linha;
}
} o catch (Exception e) {
System.out.println ( "informações de exceção:" + E);
e.printStackTrace ();
}
o finally {
try {
IF {(OUT! = null)
a out.close ();
}
IF (in! = null) {
cercar();
}
}
Catch (IOException ex) {
ex.printStackTrace ();
}
}
System.out.printlnl ( "Resultado:" + resultado);
retornar resultado;
}
aceitar Arquitetura
classe TestAccept
/ **
* classe Receba
* Mapa e recepção não muito diferentes classes de entidade, você pode receber, mas a classe entidade receptora deve ser sem argumento construtor para o trabalho
* /
@ RequestMapping ( "/ Accept")
@RestController
classe pública TestAccept {
Logger = LoggerFactory.getLogger Logger (this.getClass ());
/ **
* Lista
* @param STR
* @return
* /
@RequestMapping (value = "/ accept01", Method = RequestMethod.POST)
public string accept01 (string @RequestBody STR) {
logger.info ( "STR:" + STR); // STR: { "Lista": [{ "Age": 23 é, "nome": "HLH"}]}
// analisado
mapa mapa = ( Map <string, Object>) o JSON.parse (STR);
logger.info ( "Map:" + Mapa); // Mapa: { "Lista":[{ "Name": "hLH", "idade": 23}]}
List <Map <String, Object >> list = (List <Map <String, Object >>) map.get ( "list");
logger.info ( "lista:" + lista); // lista: [{ "name": "hLH", "idade": 23}]
for (int i = 0; i <list.size (); i ++) {
logger.info ( "map2" + i + ":" + list.get (i)); // map20: { "name": "hLH", "idade": 23}
logger.info ( "name:" + list.get (i) .get ( "nome") + "a idade: "+ list.get (i) .get (" age")); // nome: hLH, idade: 23
}
/ **
*这种有问题,实体类转换不了
* /
// List <dados> list1 = (List <dados>) map.get ( "list");
// for (ls dados: Lista1) {
// logger. info ( "name:" + ls.getName () + "a idade" + ls.getAge ());
//}
return "sucesso";
}
/ **
*实体类用Mapa包着的Josn字符串
* @param str
* @return
* /
@RequestMapping (value = "/ accept02")
public String accept02 (@RequestBody Cordas str) {
logger.info ( "str:" + str ); // str: { "dados": { "idade": 23, "nome": "hLH"}}
map <string, Object> map = (mapa) JSON.parse (str);
logger.info ( "mapa:" + mapa); // mapa: { "dados": { "nome": "hLH", "idade": 23}}
Map <String, Object> map1 = (Mapa) mapa. Obter dados");
logger.info ( "map1:" + map1); // map1: { "name": "hLH", "idade": 23}
logger.info ( "name:" + map1.get ( "nome") +" , idade: "+ map1.
* @Return
* /
@RequestMapping (value = "/ accept03")
public String accept03 (str @RequestBody String) {
logger.info ( "str:" + str); // string: { "idade": 23 ", nome ":" hLH "}
map <string, Object> map = (mapa) JSON.parse (str);
logger.info ( "mapa:" + mapa); // mapa: { "name": "hLH", "idade": 23}
logger.info ( "name:" + map.get ( "nome") +" , idade: "+ map.get (" age ")); // nome: hLH, idade: 23
de retorno "sucesso";
}
/ **
*实体类直接传,传报错了
* @ param de dados
* @return
* /
@RequestMapping (value = "/ accept04"
retornar "sucesso";
}
/ **
* Lista转成JSON字符串传过来
* @param str
* @return
* /
@RequestMapping (value = "/ accept05")
accept05 public String (@RequestBody Cordas str) {
logger.info ( "str:" + str); // str: [{ "idade": 23, "nome": "hLH"}]
List <Map <string, Object >> list = (List) JSON.parse (str);
logger.info ( "lista:" + lista); // lista: [{ "name": "hLH", "idade": 23}]
for (int i = 0; i <list.size (); i ++) {
logger.info ( "name:" + list.get (i) .get ( "nome") + "a idade "+ list.get (i) .get (" age")); // nome: hLH,
* /
@RequestMapping (value = "/ accept06")
accept06 public String () {
logger.info ( "进来accept06");
retornar "sucesso";
}
/ **
* obter请求带参数
* nome @ param
* idade @ param
* @ return
* /
@RequestMapping (value = "/ accept07")
accept07 public String (String nome, Integer idade) {
logger.info ( "进来accept07 "); //进来accept07
logger.info (" name: "+ nome); // nome: hLH
logger.info (" age: "+ idade); // idade: 23
de retorno "sucesso";
Em seguida, a resposta é a mesma *
* @ param de Dados
* @return
* /
@RequestMapping (value = "/ accept08", Method = RequestMethod.POST)
accept08 pública Dados (@RequestBody Dados Data) {
logger.info ( "Dados:" + dados); // dados: name = {HLH, Idade = 23 é, height = 178}
retornar dados;
}
/ **
* acima para receber classe de entidade, as regiões de classe entidade e cabelo Map nenhuma diferença pode ser usado para receber dados
* @param Mapa
* @return
* /
@RequestMapping (value = "/ accept09", Method = RequestMethod.POST)
pública do Map <string, Object> accept09 (@RequestBody o Map <string, Object> Mapa) {
logger.info ( "dados:" + Mapa); // dados: name = {HLH, Idade = 23 é, height = 178}
retornar Mapa;
}
@RequestMapping (value = "/ accept10", method = RequestMethod.POST)
accept10 public String (@RequestBody AcceptModelDTO acceptModelDTO) {
logger.info ( "进来");
logger.info ( "código:" + acceptModelDTO.getCode ()); // código: 500
logger.info ( "status:" + acceptModelDTO.getStatus ()); // status: ok
logger.info ( "name:" . + acceptModelDTO.getData () getName (+) "idade:" + acceptModelDTO.getData () getAge ()); // nome:. hlh3, idade: 140
List <AcceptEntity> list = acceptModelDTO.getListEntity ();
para (AcceptEntity AE: lista) {
/ **
*结果
* nome: hLH, idade: 10, altura: 120
* nome: hlh2, idade: 11, altura:
logger.info ( "nome:" + ae.getName () + "idade: "+ ae.getAge () +", altura:" + ae.getHeight ());
}
Retornar "sucesso";
}
}
classe de dados
classe AcceptData
classe AcceptEntity
classe AcceptModelDTO
completo