RPC是什么？
2.3RPC实现的技术：
3：RMI实现RPC远程调用：
3.1RMI介绍
3.2RMI实现vip访问orders
3.2.1开发服务生产者(provider)
3.2.1.1创建orders-provider项目
3.2.1.2创建Orders实体类
3.2.1.3创建OrdersService接口（继承Remote类，抛出该类特有的异常）
3.2.1.4创建OrdersServiceImpl实现类
3.2.1.5发远程RMI服务
3.2.2开发服务消费者(consumer)
3.2.2.1创建vip-consumer项目
3.2.2.2拷贝Orders实体类
3.2.2.3拷贝OrdersService接口
3.2.2.4创建消费者启动类
3.3RMI调用结构优化
3.3.1provider提供sdk
3.3.2使用maven项目的依赖关系
3.3.2.1将公共的资源单独开发
4:HttpClient实现RPC调用
4.1HttpClient介绍
4.2需求
4.3开发orders-sys服务提供者(provider)
4.3.1创建orders-sys(war)
4.3.2添加依赖
4.3.3创建Orders实体类
4.3.4创建OrdersService接口
4.3.5创建OrdersServiceImpl实现类
4.3.6创建OrdersController
4.3.7使用postMan测试
4.3.7.1测试查询会员订单列表
4.4开发vip-sys服务消费者(consumer)
4.4.1创建vip-sys(jar)
4.4.2添加依赖
4.4.3拷贝Orders实体类
4.4.5创建测试类
4.4.5.1测试发送Post请求
4.4.5.2测试发送Get请求
4.4.5.3测试post请求提交json字符串
4.5HttpClient总结
RPC是什么？
RPC就是远程过程调用（Remote Procedure Call）
项目本来是单体架构：只需要创建一个工程，将所有的代码放在一个工程中进行开发、管理、测试、打包，代码与代码之间在同一个项目中相互调用。
单体项目：
项目的分布式架构:在一个由n个服务器构成的集群环境中，不同的服务器提供不同的业务功能。不同服务之间相互协作(调用)完成一个完成的业务流程。
将一个单体架构进行拆分，拆分为n个不同的系统开发(n个服务),而n个服务之间存在项目调用的问题，不同的服务器之间相互访问—需要使用RPC技术实现（完成方法的远程调用）
2.3RPC实现的技术：
RMI
HttpClient
Dubbo
Zookeeper
3：RMI实现RPC远程调用：
3.1RMI介绍
RMI(Remote Method Invocation，远程方法调用)是用Java在JDK1.2中实现的，它大大增强了Java开发分布式应用的能力。
java RMI 则支持存储于不同地址空间的程序级对象之间彼此进行通信，实现远程对象之间的无缝远程调用。
3.2RMI实现vip访问orders
Orders:服务端(生产者)，开发服务端的过程，叫暴露服务
Vip客户端(消费者)，开发消费者的过程，叫调用服务
3.2.1开发服务生产者(provider)
3.2.1.1创建orders-provider项目
3.2.1.2创建Orders实体类
package com.bjsxt.pojo;
import java.io.Serializable;
/***
* 描述订单信息
* @author EDZ
*
*/
public class Orders implements Serializable{
private Integer id;
private String remark;
private String odate;
private Integer vip;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getRemark() {
return remark;
}
public void setRemark(String remark) {
this.remark = remark;
}
public String getOdate() {
return odate;
}
public void setOdate(String odate) {
this.odate = odate;
}
public Integer getVip() {
return vip;
}
public void setVip(Integer vip) {
this.vip = vip;
}
}3.2.1.3创建OrdersService接口（继承Remote类，抛出该类特有的异常）
package com.bjsxt.service;
import java.rmi.Remote;
import java.rmi.RemoteException;
import java.util.List;
import com.bjsxt.pojo.Orders;
/****
* Remote 标识接口，该接口的子接口中的方法可以被远程调用
* @author EDZ
*
*/
public interface OrdersService extends Remote{
/****
* 查询会员的订单列表
*/
public List<Orders> loadOrdersList(Integer vid) throws RemoteException;
/***
* 查询会员的某个订单
*/
public Orders loadOrders(Integer id) throws RemoteException;
}3.2.1.4创建OrdersServiceImpl实现类
package com.bjsxt.service.impl;
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
import java.util.ArrayList;
import java.util.List;
import com.bjsxt.pojo.Orders;
import com.bjsxt.service.OrdersService;
public class OrdersServiceImpl extends UnicastRemoteObject implements OrdersService {
/***
* 生成五参数构造方法，调用父类中受保护的五参数狗子方法
* @throws RemoteException
*/
public OrdersServiceImpl() throws RemoteException {
super();
// TODO Auto-generated constructor stub
}
@Override
public List<Orders> loadOrdersList(Integer vid) throws RemoteException {
// TODO Auto-generated method stub
List<Orders> results=new ArrayList<Orders>();
Orders o1=new Orders();
o1.setId(10000);
o1.setRemark("美女配送.....");
o1.setOdate("2010-10-10");
o1.setVip(vid);
Orders o2=new Orders();
o2.setId(555555);
o2.setRemark("美帅哥配送.....");
o2.setOdate("2010-11-11");
o2.setVip(vid);
results.add(o1);
results.add(o2);
return results;
}
@Override
public Orders loadOrders(Integer id) throws RemoteException {
// TODO Auto-generated method stub
Orders o1=new Orders();
o1.setId(id);
o1.setRemark("美女配送.....");
o1.setOdate("2010-10-10");
o1.setVip(888888);
return o1;
}
}3.2.1.5发远程RMI服务
package com.bjsxt.app;
import java.rmi.Naming;
import java.rmi.registry.LocateRegistry;
import com.bjsxt.service.OrdersService;
import com.bjsxt.service.impl.OrdersServiceImpl;
public class OrdersApp {
/****
* 使用main方法启动生产者，发布服务
* @param args
*/
public static void main(String[] args) {
/***
* 远程访问三要素:
* 1 协议
* 2 主机
* 3 端口
* url=1+2+3
*/
try {
Integer port=7777;
//指定暴露的远程服务的访问端口
LocateRegistry.createRegistry(port);
//创建OrdersServiceImpl实现类
OrdersService remote=new OrdersServiceImpl();
//定义远程访问的url
String name="rmi://localhost:"+port+"/sxt";
//进行给remote对象绑定一个远程访问的地址
Naming.bind(name, remote);
System.out.println("==========发布远程服务===========");
}catch(Exception ex) {
ex.printStackTrace();
}
}
}3.2.2开发服务消费者(consumer)
3.2.2.1创建vip-consumer项目
3.2.2.2拷贝Orders实体类
3.2.2.3拷贝OrdersService接口
3.2.2.4创建消费者启动类
package com.bjsxt.app;
import java.rmi.Naming;
import java.util.List;
import com.bjsxt.pojo.Orders;
import com.bjsxt.service.OrdersService;
public class VipApp {
public static void main(String[] args) {
/***
* 启动消费端完成远程服务的调用
*/
try {
//远程服务的访问地址
String name="rmi://localhost:7777/sxt";
//获得远程服务的代理对象
OrdersService remote=(OrdersService) Naming.lookup(name);
System.out.println(remote.getClass().getName());
//获得会员某个订单信息
//Orders orders=remote.loadOrders(99999);
//获得会员订单的集合
List<Orders> list = remote.loadOrdersList(111111);
for(Orders orders:list) {
System.out.println(orders.getId()+"\t"+orders.getVip()
+"\t"+orders.getOdate()+"\t"+orders.getRemark());
}
}catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}
}
}3.3RMI调用结构优化
3.3.1provider提供sdk
将消费者需要的公共的资源，上传到特定服务器，让消费者下载，加入到消费者的项目
3.3.2使用maven项目的依赖关系
生产者提供公共资源的项目的坐标，给消费者
3.3.2.1将公共的资源单独开发
公共资源:生产者和消费都需要的
4:HttpClient实现RPC调用
4.1HttpClient介绍
Httpclient是Apache提供的用来在java程序中发送标准的http请求的工具包。实现RPC调用。访问远程服务的Controller，使用http请求远程服务，需要远程服务（provider）暴露http服务。
4.2需求
Vip会员系统访问远程的订单系统，使用httpclient方法
4.3开发orders-sys服务提供者(provider)
4.3.1创建orders-sys(war)
4.3.2添加依赖
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.bjsxt.orders</groupId>
<artifactId>orders-sys</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>war</packaging>
<dependencies>
<!-- 添加springmvc的依赖 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>4.3.18.RELEASE</version>
</dependency>
<!-- 添加jackson依赖 -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.9.9.3</version>
</dependency>
<!-- jstl -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>
<!-- jsp -->
<dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>jsp-api</artifactId>
<version>2.2</version>
<scope>provided</scope>
</dependency>
<!-- servlet -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>2.5</version>
<scope>provided</scope>
</dependency>
</dependencies>
<!-- 声明需要的插件 -->
<build>
<plugins>
<!-- 添加tomcat插件 -->
<plugin>
<artifactId>tomcat7-maven-plugin</artifactId>
<groupId>org.apache.tomcat.maven</groupId>
<version>2.2</version>
<configuration>
<port>8081</port>
<path>/</path>
</configuration>
</plugin>
</plugins>
</build>
</project>4.3.3创建Orders实体类
package com.bjsxt.pojo;
import java.io.Serializable;
/***
* 描述订单信息
* @author EDZ
*
*/
public class Orders implements Serializable{
private Integer id;
private String remark;
private String odate;
private Integer vip;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getRemark() {
return remark;
}
public void setRemark(String remark) {
this.remark = remark;
}
public String getOdate() {
return odate;
}
public void setOdate(String odate) {
this.odate = odate;
}
public Integer getVip() {
return vip;
}
public void setVip(Integer vip) {
this.vip = vip;
}
}4.3.4创建OrdersService接口
package com.bjsxt.service;
import java.util.List;
import java.util.Map;
import com.bjsxt.pojo.Orders;
public interface OrdersService {
/****
* 查询会员的订单列表
*/
public List<Orders> loadOrdersList(Integer vid);
/***
* 查询会员的某个订单
*/
public Orders loadOrders(Integer id);
/***
* 实现会员下订单
*/
public Map<String,String> saveOrders(Orders orders);
}4.3.5创建OrdersServiceImpl实现类
package com.bjsxt.service.impl;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.springframework.stereotype.Service;
import com.bjsxt.pojo.Orders;
import com.bjsxt.service.OrdersService;
@Service
public class OrdersServiceImpl implements OrdersService {
@Override
public List<Orders> loadOrdersList(Integer vid) {
// TODO Auto-generated method stub
// TODO Auto-generated method stub
List<Orders> results=new ArrayList<Orders>();
Orders o1=new Orders();
o1.setId(10000);
o1.setRemark("美女配送.....");
o1.setOdate("2010-10-10");
o1.setVip(vid);
Orders o2=new Orders();
o2.setId(555555);
o2.setRemark("美帅哥配送.....");
o2.setOdate("2010-11-11");
o2.setVip(vid);
results.add(o1);
results.add(o2);
return results;
}
@Override
public Orders loadOrders(Integer id) {
// TODO Auto-generated method stub
Orders o1=new Orders();
o1.setId(id);
o1.setRemark("美女配送.....");
o1.setOdate("2010-10-10");
o1.setVip(888888);
return o1;
}
@Override
public Map<String, String> saveOrders(Orders orders) {
// TODO Auto-generated method stub
System.out.println(orders.getId()+"\t"+orders.getRemark()
+"\t"+orders.getRemark()+"\t"+orders.getVip());
Map<String, String> result=new HashMap<String, String>();
result.put("success", "成功");
return result;
}
}4.3.6创建OrdersController
远程的http服务对消费者的响应是异步响应，响应给消费的是json字符串
package com.bjsxt.controller;
import java.util.List;
import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import com.bjsxt.pojo.Orders;
import com.bjsxt.service.OrdersService;
@Controller
public class OrdersController {
@Autowired
private OrdersService ordersService;
/***
* 处理加载会员订单集合的请求
*/
@RequestMapping("/loadOrdersList")
@ResponseBody
public List<Orders> loadOrdersList(Integer vid,Model model) {
List<Orders> list = ordersService.loadOrdersList(vid);
model.addAttribute("results", list);
return list;
}
/***
* 处理加载会员某个订单详细信息的请求
*/
@RequestMapping("/loadOrders")
@ResponseBody
public Orders loadOrders(Integer id,Model model) {
Orders orders = ordersService.loadOrders(id);
model.addAttribute("orders", orders);
return orders;
}
/***
* 处理会员下订单的请求
* @ResponseBody 将javabean对象，javabean对象集合，Map集合转化为json字符串
* @RequestBody 将json串转化为javabean对象
*/
@RequestMapping("/saveOrders")
@ResponseBody
public Map<String,String> saveOrders(@RequestBody Orders orders){
return ordersService.saveOrders(orders);
}
}4.3.7使用postMan测试
4.3.7.1测试查询会员订单列表
4.4开发vip-sys服务消费者(consumer)
4.4.1创建vip-sys(jar)
4.4.2添加依赖
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.bjsxt.vip</groupId>
<artifactId>vip-sys</artifactId>
<version>0.0.1-SNAPSHOT</version>
<dependencies>
<!-- 添加httpclient的依赖 -->
<dependency>
<groupId>org.apache.httpcomponents</groupId>
<version>4.5.6</version>
<artifactId>httpclient</artifactId>
</dependency>
<!-- 添加发送json的依赖 -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.47</version>
</dependency>
</dependencies>
</project>4.4.3拷贝Orders实体类
4.4.5创建测试类
4.4.5.1测试发送Post请求
/***
* 使用httpclient发送post
*/
public static void sendPost() {
try {
//创建HttpClient对象
HttpClient client=HttpClients.createDefault();
//定义发送远程请求的url
String url="http://localhost:8081/loadOrdersList";
//创建HttpPost对象
HttpPost post=new HttpPost(url);
//创建BasicNameValuePair对象,封装参数的键值对
BasicNameValuePair vid=new BasicNameValuePair("vid","909090");
//创建List<BasicNameValuePair>对象，封装发送到provider多个参数
List<BasicNameValuePair> params=new ArrayList<>();
params.add(vid);
//创建UrlEncodedFormEntity对象，封装请求体，给发送的数据进行编码
UrlEncodedFormEntity entity=new UrlEncodedFormEntity(params,"UTF-8");
/****
* HttpEntity 用来封装请求体
*/
post.setEntity(entity);
//发送http请求
HttpResponse response = client.execute(post);
//处理响应回来的响应头信息
/*Header[] headers = response.getAllHeaders();
for(Header header:headers) {
System.out.println(header);
}*/
//获得响应体对应的输入流对象
InputStream content = response.getEntity().getContent();
//将content字节输入流，转为字符输入流
InputStreamReader reader=new InputStreamReader(content);
char[] buf=new char[1024];
int len=0;
String jsonStr="";
while((len=reader.read(buf))!=-1) {
//将buf字符数组转化为字符串输出
jsonStr=String.valueOf(buf);
System.out.println(jsonStr);
}
//将json字符串转化为javabean对象的集合
List<Orders> list = JSON.parseArray(jsonStr, Orders.class);
for(Orders orders:list) {
System.out.println(orders.getId()+"\t"+orders.getRemark()
+"\t"+orders.getVip()+"\t"+orders.getOdate());
}
reader.close();
content.close();
} catch (Exception e) {
// TODO: handle exception
}
}4.4.5.2测试发送Get请求
/****
* 发送get请求
*/
public static void sendGet() {
try {
//创建HttpClient对象
HttpClient client=HttpClients.createDefault();
//定义http请求的url
String url="http://localhost:8081/loadOrders?id=9999";
//创建HttpGet对象，用来发送get请求
HttpGet get=new HttpGet(url);
//发送http请求
HttpResponse response = client.execute(get);
//处理响应回来的响应头信息
/* Header[] headers = response.getAllHeaders();
for(Header header:headers) {
System.out.println(header);
}*/
//获得响应体对应的输入流对象
InputStream content = response.getEntity().getContent();
//将content字节输入流，转为字符输入流
InputStreamReader reader=new InputStreamReader(content);
char[] buf=new char[1024];
int len=0;
String jsonStr="";
while((len=reader.read(buf))!=-1) {
//将buf字符数组转化为字符串输出
jsonStr=String.valueOf(buf);
System.out.println(jsonStr);
}
Orders orders = JSON.parseObject(jsonStr, Orders.class);
System.out.println(orders.getId()+"\t"+orders.getRemark()
+"\t"+orders.getVip()+"\t"+orders.getOdate());
}catch(Exception ex) {
ex.printStackTrace();
}
}4.4.5.3测试post请求提交json字符串
将一个对象从消费者传递给生产者，需要将对象转化为json字符串传递
/***
* 发送post请求实现会员下订单,通过表单的方式提交json字符串
*/
public static void sendVipPost2() {
try {
//创建HttpClient对象
HttpClient client=HttpClients.createDefault();
//定义发送远程请求的url
String url="http://localhost:8081/saveOrders";
//创建HttpPost对象
HttpPost post=new HttpPost(url);
/***
* 创建Orders对象，封装订单数据
* 该对象的值是通过浏览器提交给vip-sys的
*/
Orders orders=new Orders();
orders.setId(120110);
orders.setRemark("美女配送.....");
orders.setOdate("2010-10-10");
orders.setVip(888888);
//将orders对象转化为json字符串
String jsonStr=JSON.toJSONString(orders);
/****
* HttpEntity 用来封装请求体,对象发送的json字符串进行编码
*/
StringEntity entity=new StringEntity(jsonStr,"UTF-8");
post.setEntity(entity);
//修改请求头信息
post.setHeader("Content-Type", "application/json");
//发送http请求
HttpResponse response = client.execute(post);
//获得响应体对应的输入流对象
InputStream content = response.getEntity().getContent();
//将content字节输入流，转为字符输入流
InputStreamReader reader=new InputStreamReader(content);
char[] buf=new char[1024];
int len=0;
String json="";
while((len=reader.read(buf))!=-1) {
//将buf字符数组转化为字符串输出
json=String.valueOf(buf);
System.out.println(json);
}
}catch(Exception ex) {
ex.printStackTrace();
}
}4.5HttpClient总结
httpClient=http+json
package com.bjsxt.app;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import org.apache.http.Header;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpUriRequest;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.bjsxt.pojo.Orders;
public class App {
/**
* 调用其他项目的controller
*
* @param args
*/
public static void main(String[] args) {
addObject2();
}
/**
* 发送Post表单请求 http://localhost:8081/selectOrder 调用方法查询集合
*/
public static void sendPost() {
try {
// 1：创建一个HttpClient实例
HttpClient httpClient = HttpClients.createDefault();
// 4：提供一个访问路径
String url = "http://localhost:8081/selectOrdersList";
// 3：创建一个HttpPost对象,需要传一个访问路径
HttpPost request = new HttpPost(url);
// 8：BasicNameValuePair创建
// 这个参数是查询条件
BasicNameValuePair bnvp = new BasicNameValuePair("vip", "20000");
// 7：实现参数List<NameValuePair>params,泛型是接口类型
// 所以添加实现类对象BasicNameValuePair
List<NameValuePair> params = new ArrayList<NameValuePair>();
String charset = "utf-8";
// 9：往集合里添加对象（这个集合是添加查询的参数）
params.add(bnvp);
// 6:创建请求体需要两个参数
// 第一个参数:List <? extends NameValuePair> parameters
// 第二个参数：final String charset
UrlEncodedFormEntity entity = new UrlEncodedFormEntity(params, charset);
// 5:post里需要防止一个请求体 HttpEntity，所以要创建一个请求体(HttpEntity实现类UrlEncodedFormEntity)
request.setEntity(entity);
// 2：需要发送http请求，里面需要一个参数（HttpUriRequest）
// 这是一个接口所以需要实现类，HttpPost就是实现类
HttpResponse response = httpClient.execute(request);
// 10.响应的结果获得响应头
Header[] allHeaders = response.getAllHeaders();
for (Header header : allHeaders) {
System.out.println(header);
}
// 11:获得响应体输入流对象(因为在网络中传输，接收到的是字节输入流)
InputStream content = response.getEntity().getContent();
// 12：我们需要输入流的内容，所以要将其转换为字符输入流
InputStreamReader isp = new InputStreamReader(content);
// 13:用jsonStr接受响应回来的字符输入流的内容
char[] buf = new char[1024];
int len = 0;
String jsonStr = "";
while ((len = isp.read(buf)) != -1) {
// 将buf数组转换为json字符串输入
jsonStr = String.valueOf(buf);
System.out.println(jsonStr);
}
// 14:JsonStr就是传输过来的list集合但是是字符串，
// 所以我们需要将其转化为javaBean对象
// json字符串转化集合 需要添加依赖 并且使用JSON.parseArray()
List<Orders> list = JSON.parseArray(jsonStr, Orders.class);
for (Orders orders : list) {
System.out.println(
orders.getId() + "\t" + orders.getRemark() + "\t" + orders.getVip() + "\t" + orders.getOdate());
}
// 15:关闭流
isp.close();
content.close();
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 发送Get请求 http://localhost:8081/selectOrder 调用get请求查对象
*/
public static void sendGet() {
try {
// 1：创建一个httpClient对象
HttpClient httpClient = HttpClients.createDefault();
// 4:设置传输的url
String url = "http://localhost:8081/selectOrder?id=9999";
// 3:创建get的对象准备放进去发送一个get请求（get请求里要放点数据）
HttpGet request = new HttpGet(url);
// 2：发送一个Http请求（HttpUriRequest）
HttpResponse response = httpClient.execute(request);
// 获得响应体的输入流对象
InputStream inputStream = response.getEntity().getContent();
// 响应体输入流对象转化为字符输入流
InputStreamReader isReader = new InputStreamReader(inputStream);
char[] buf = new char[1024];
int len = 0;
String jsonStr = "";
while ((len = isReader.read(buf)) != -1) {
// 将字符数组转化为json字符串
jsonStr = String.valueOf(buf);
System.out.println(jsonStr);
}
Orders orders = JSON.parseObject(jsonStr, Orders.class);
System.out.println(orders);
isReader.close();
inputStream.close();
} catch (Exception e) {
// TODO: handle exception
}
}
/**
* 发送一个对象（控制层接受的是一个对象）表单提交 控制层的方法是接受对象，添加该对象
*/
public static void addObject() {
try {
// 1:创建HttpClient对象
HttpClient httpClient = HttpClients.createDefault();
// 4：创建url地址
String url = "http://localhost:8081/addOrders";
// 3:创建一个post请求对象里面放url请求地址
HttpPost request = new HttpPost(url);
// 7：存放的请求体，NameValuePair是一个接口，也是需要实现类的
// 实现类：BasicNameValuePair
List<NameValuePair> parameters = new ArrayList<>();
// 8：创建实现类BasicNameValuePair对象，实现类是键值，键是pojo实体类，值是数据
BasicNameValuePair b = new BasicNameValuePair("id", "123");
BasicNameValuePair b1 = new BasicNameValuePair("remark", "remark");
BasicNameValuePair b2 = new BasicNameValuePair("odate", "odate");
BasicNameValuePair b3 = new BasicNameValuePair("vip", "11111");
parameters.add(b);
parameters.add(b1);
parameters.add(b2);
parameters.add(b3);
// 9:设置请求格式
String charset = "utf-8";
// 6:HttpEntity是一个接口，需要实现类，这个实现类是表单数据
// 参数一：List<NameValuePair> 存放的请求体
// 参数二：编码格式
UrlEncodedFormEntity entity = new UrlEncodedFormEntity(parameters, charset);
// 5:往请求里放数据HttpEntity
request.setEntity(entity);
// 2:发送Http请求（HttpUriRequest）
HttpResponse response = httpClient.execute(request);
// 获得响应的字节流
InputStream content = response.getEntity().getContent();
// 将字节输入流转化为字符输入流
InputStreamReader iReader = new InputStreamReader(content);
char[] buf = new char[1024];
String jsonStr = "";
int len = 0;
while ((len = iReader.read(buf)) != -1) {
jsonStr = String.valueOf(buf);
System.out.println(jsonStr);
}
} catch (Exception e) {
// TODO: handle exception
}
}
/**
* 发送添加对象请求，使用json字符串发送过去，然后控制层用json字符串接收
*
*/
public static void addObject2() {
try {
// 1:创建HttpClient请求
HttpClient httpClient = HttpClients.createDefault();
// 3：创建post连接
String url = "http://localhost:8081/addOrders";
HttpPost request = new HttpPost(url);
/***
* 4：创建Orders对象，封装订单数据 该对象的值是通过浏览器提交给vip-sys的
*/
Orders orders = new Orders();
orders.setId(120110);
orders.setRemark("美女配送.....");
orders.setOdate("2010-10-10");
orders.setVip(888888);
// 5：将对象转化为json字符串
String jsonString = JSON.toJSONString(orders);
// 7:封装实体类
StringEntity entity = new StringEntity(jsonString, "utf-8");
// 8：修改请求头信息
request.setHeader("Content-Type", "application/json");
// 6：post把对象装起来
request.setEntity(entity);
// 2:发送http请求
HttpResponse response = httpClient.execute(request);
// 获得响应体对应的输入流对象
InputStream content = response.getEntity().getContent();
// 将content字节输入流，转为字符输入流
InputStreamReader reader = new InputStreamReader(content);
char[] buf = new char[1024];
int len = 0;
String json = "";
while ((len = reader.read(buf)) != -1) {
// 将buf字符数组转化为字符串输出
json = String.valueOf(buf);
System.out.println(json);
}
} catch (Exception ex) {
ex.printStackTrace();
}
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
