RPC远程调用（RMI的方式实现RPC、HttpClient实现RPC远程调用）

落日映苍穹つ 2023-06-13 13:30 18阅读 0赞

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）

项目本来是单体架构：只需要创建一个工程，将所有的代码放在一个工程中进行开发、管理、测试、打包，代码与代码之间在同一个项目中相互调用。

**      单体项目：**

![20191117182832669.png][]

**项目的分布式架构:**在一个由n个服务器构成的集群环境中，不同的服务器提供不同的业务功能。不同服务之间相互协作(调用)完成一个完成的业务流程。

将一个单体架构进行拆分，拆分为n个不同的系统开发(n个服务),而**n个服务之间存在项目调用的问题，不同的服务器之间相互访问—需要使用RPC技术实现（完成方法的远程调用）**

--------------------

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTgxMTU0_size_16_color_FFFFFF_t_70][]

--------------------

## 2.3RPC实现的技术： ##

**RMI**

**HttpClient**

**Dubbo**

**Zookeeper**

# 3：RMI实现RPC远程调用： #

## 3.1RMI介绍 ##

RMI(Remote Method Invocation，远程方法调用)是用Java在JDK1.2中实现的，它大大增强了Java开发分布式应用的能力。

java RMI 则支持存储于不同地址空间的程序级对象之间彼此进行通信，实现远程对象之间的无缝远程调用。

![20191117183247439.png][]

## **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方法

![20191117184911735.png][]

## **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>
    		
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-webmvc</artifactId>
    			<version>4.3.18.RELEASE</version>
    		</dependency>
    		
    		<dependency>
    			<groupId>com.fasterxml.jackson.core</groupId>
    			<artifactId>jackson-databind</artifactId>
    			<version>2.9.9.3</version>
    		</dependency>
    		
    		<dependency>
    			<groupId>javax.servlet</groupId>
    			<artifactId>jstl</artifactId>
    			<version>1.2</version>
    		</dependency>
    
    		
    		<dependency>
    			<groupId>javax.servlet.jsp</groupId>
    			<artifactId>jsp-api</artifactId>
    			<version>2.2</version>
    			<scope>provided</scope>
    		</dependency>
    		
    		<dependency>
    			<groupId>javax.servlet</groupId>
    			<artifactId>servlet-api</artifactId>
    			<version>2.5</version>
    			<scope>provided</scope>
    		</dependency>
    	</dependencies>
    
    	
    	<build>
    		<plugins>
    			
    			<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实体类** ###

### **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测试查询会员订单列表** ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTgxMTU0_size_16_color_FFFFFF_t_70 1][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTgxMTU0_size_16_color_FFFFFF_t_70 2][]

## **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请求** ###

/***
    	 * 使用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();
    		}
    
    	}
    
    }

[20191117182832669.png]: https://img-blog.csdnimg.cn/20191117182832669.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTgxMTU0_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20191117182932371.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTgxMTU0,size_16,color_FFFFFF,t_70
[20191117183247439.png]: https://img-blog.csdnimg.cn/20191117183247439.png
[20191117184911735.png]: https://img-blog.csdnimg.cn/20191117184911735.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTgxMTU0_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20191117185329687.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTgxMTU0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTgxMTU0_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20191117185428530.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTgxMTU0,size_16,color_FFFFFF,t_70