购物车模块
未登录购物车实现
实现的效果
我们需要完成的步骤及功能
方案一:
针对方案一的不足,我们在方案二进行了改进
方案二:
- 在方案二我们做了一些改进
- 存入CartItem的数据中,我们不再存放product商品本身,而选择存入productId
- 存入cookie的数据,我们选择了一个标识,uuid
- 加入redis缓存,通过uuid等信息查询redis中的CartItem信息
项目实现
技术运用:dubbo+spring boot+redis+cookie
创建工程,添加依赖:约定
- 创建shop_cart_api工程,并创建相应的方法,约定:方法的返回值都为RsoultBean
- 增
- 删
- 改
- 查
- 创建shop_cart_service工程
- 创建shop_cart工程
shop_cart_api工程实现
public interface CartService {
//增加购物车的方法
RsoultBean add(String key,Long productId,Integer count);
//修改购物车的方法
RsoultBean updataCart(String key,Long productId,Integer count);
//删除购物车的方法
RsoultBean del(String key,Long productId);
//查询购物车的方法
RsoultBean queryCart(String key);
}
shop_cart_service工程实现
-
导入依赖
<dependency> <groupId>com.qianfeng</groupId> <artifactId>shop_mapper</artifactId> <version>1.0-SNAPSHOT</version> </dependency> <dependency> <groupId>com.qianfeng</groupId> <artifactId>shop_cart_api</artifactId> <version>1.0-SNAPSHOT</version> </dependency> <dependency> <groupId>com.qianfeng</groupId> <artifactId>shop_entity</artifactId> <version>1.0-SNAPSHOT</version> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> <version>2.1.6.RELEASE</version> </dependency>
-
application.yml文件编写
//dubbo配置 dubbo: application: name: shop_cart_service protocol: port: 28807 registry: protocol: zookeeper address: 192.168.111.132:2181 spring: //数据库配置 datasource: driver-class-name: com.mysql.jdbc.Driver url: jdbc:mysql:///shop_2005?serverTimezone=Asia/Shanghai&characterEncoding=UTF-8 username: root password: root //redis配置 redis: host: 192.168.111.132 port: 6379 server: port: 8087
-
service编写
@Service
public class CartServiceImpl implements CartService {
@Autowired
private TProductMapper mapper;
@Autowired
private RedisTemplate redisTemplate;
@Override
public RsoultBean add(String key, Long productId, Integer count) {
//用key获取购物车信息
List<CartItem> cart = (List<CartItem>) redisTemplate.opsForValue().get(key);
//如果没有购物车
if(cart==null){
//创建购物车
cart = new ArrayList<>();
//添加商品到购物车
cart.add(new CartItem(productId,count,new Date()));
//把购物车存到redis中
redisTemplate.opsForValue().set(key,cart);
//设置生存时间,30天
redisTemplate.expire(key,30, TimeUnit.DAYS);
//返回购物车长度
return RsoultBean.success(String.valueOf(cart.size()));
}
//有购物车并有该商品的处理
for (CartItem cartItem : cart) {
//使用productId进行对比
if(cartItem.getProductId().longValue()==productId.longValue()){
//有该商品,修改商品数量
cartItem.setCount(cartItem.getCount()+count);
//修改时间
cartItem.setUpdateTime(new Date());
//存到redis中
redisTemplate.opsForValue().set(key, cart);
//设置生存时间,30天
redisTemplate.expire(key, 30, TimeUnit.DAYS);
//返回购物车长度
return RsoultBean.success(String.valueOf(cart.size()));
}
}
//有购物车但是没有商品,直接添加
cart.add(new CartItem(productId,count,new Date()));
//保存到redis中
redisTemplate.opsForValue().set(key,cart);
//设置生存时间
redisTemplate.expire(key,30,TimeUnit.DAYS);
return RsoultBean.success(String.valueOf(cart.size()));
}
@Override
public RsoultBean updataCart(String key, Long productId, Integer count) {
//获取购物车
List<CartItem> cart = (List<CartItem>) redisTemplate.opsForValue().get(key);
//如果没有购物车,直接返回
if(cart==null){
return RsoultBean.msg("暂无购物车信息");
}
//遍历购物车
for (CartItem cartItem : cart) {
//找到需要修改的商品
if(cartItem.getProductId().longValue()==productId.longValue()){
//修改商品数量跟修改时间
cartItem.setCount(count);
cartItem.setUpdateTime(new Date());
//存入redis
redisTemplate.opsForValue().set(key,cart);
//设置生存时间30天
redisTemplate.expire(key,30,TimeUnit.DAYS);
//返回购物车长度
return RsoultBean.success(String.valueOf(cart.size()));
}
}
return RsoultBean.msg("暂无购物车信息");
}
@Override
public RsoultBean del(String key, Long productId) {
//获取购物车
List<CartItem> cart = (List<CartItem>) redisTemplate.opsForValue().get(key);
//如果没有购物车,直接返回
if(cart==null){
return RsoultBean.msg("删除商品失败!");
}
//遍历购物车找到商品
for (CartItem cartItem : cart) {
if(cartItem.getProductId().longValue()==productId.longValue()){
//删除这条购物车
cart.remove(cartItem);
//存入redis并设置时间
redisTemplate.opsForValue().set(key,cart);
redisTemplate.expire(key,30,TimeUnit.DAYS);
return RsoultBean.success(String.valueOf(cart.size()));
}
}
//返回信息
return RsoultBean.msg("删除商品失败!");
}
@Override
public RsoultBean queryCart(String key) {
//查询购物车
List<CartItem> cart = (List<CartItem>) redisTemplate.opsForValue().get(key);
if(cart==null){
return RsoultBean.msg("暂无购物车信息");
}
//List<CartItem> -->List<CartItemVO>传到前端需要视图对象
List<CartItemVO> cartItemVOS = new ArrayList<>();
//遍历
for (CartItem cartItem : cart) {
//创建视图对象,填充数据
CartItemVO cartItemVO = new CartItemVO();
cartItemVO.setCount(cartItem.getCount());
cartItemVO.setUpdateTime(new Date());
//前提:缓存预热 2/8定律,把20%热闹商品信息放到 redis
//存商品信息: key:product:1001 value:product
//先去redis查询商品信息,如果没有情况再查询数据库
StringBuilder stringBuilder = new StringBuilder("product").append(cartItem.getProductId());
TProduct product = (TProduct) redisTemplate.opsForValue().get(stringBuilder.toString());
//说明这个商品redis中没有
if(product==null){
//往数据库查询商品信息
product=mapper.selectByPrimaryKey(cartItem.getProductId());
//获取后存入redis
redisTemplate.opsForValue().set(stringBuilder.toString(),product);
//设置生存时间,1小时
redisTemplate.expire(stringBuilder.toString(), 60, TimeUnit.MINUTES);
}
//存入视图对象
cartItemVO.setProduct(product);
//存入视图对象集合
cartItemVOS.add(cartItemVO);
}
//要实现排序的效果,后更新的操作应该排在集合的前面
Collections.sort(cartItemVOS, new Comparator<CartItemVO>() {
@Override
public int compare(CartItemVO o1, CartItemVO o2) {
return (int) (o2.getUpdateTime().getTime()-o1.getUpdateTime().getTime());
}
});
return new RsoultBean(200,cartItemVOS);
}
}
实现排序的两种方式:
方式一:Collections工具类
//要实现排序的效果,后更新的操作应该排在集合的前面
Collections.sort(cartItemVOS, new Comparator<CartItemVO>() {
@Override
public int compare(CartItemVO o1, CartItemVO o2) {
return (int) (o2.getUpdateTime().getTime()-o1.getUpdateTime().getTime());
}
});
方式二:实现Collection接口,重写接口的方法
- 在这里我们选择第一种方式进行排序
shop_cart工程的实现
导入依赖
<dependency>
<groupId>com.qianfeng</groupId>
<artifactId>shop_cart_api</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>com.qianfeng</groupId>
<artifactId>shop_common</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>com.qianfeng</groupId>
<artifactId>shop_user_api</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>com.alibaba.boot</groupId>
<artifactId>dubbo-spring-boot-starter</artifactId>
<version>0.2.0</version>
</dependency>
配置文件编写
dubbo:
application:
name: shop_cart
registry:
protocol: zookeeper
address: 192.168.111.132:2181
server:
port: 9097
controller实现
@Controller
@RequestMapping("/cart")
public class CartController {
@Reference
private CartService cartService;
@RequestMapping("/add/{productId}/{count}")
@ResponseBody
public RsoultBean add(@CookieValue(name = UserUtil.USER_CART_COOKIE, required = false) String uuid,
HttpServletResponse response,
@PathVariable Long productId,
@PathVariable Integer count) {
//如果没有这个uuid
if (uuid == null) {
uuid = UUID.randomUUID().toString();
}
//拼一个redis的key
StringBuilder builder = new StringBuilder(UserUtil.REDIS_CART_KEY).append(uuid);
//进行添加操作
RsoultBean rsoultBean = cartService.add(builder.toString(), productId, count);
//返回cookie给客户端
flushCookie(uuid, response);
//返回信息
return rsoultBean;
}
@RequestMapping("/list")
@ResponseBody
public RsoultBean list(@CookieValue(name = UserUtil.USER_CART_COOKIE, required = false) String uuid,
HttpServletResponse response, HttpServletRequest request) {
//判断uuid是否为空
if (uuid == null) {
return RsoultBean.msg("暂无购物车信息");
}
//拼一个redis的key
StringBuilder builder = new StringBuilder(UserUtil.REDIS_CART_KEY).append(uuid);
//进行查询
RsoultBean resultBean = cartService.queryCart(builder.toString());
//返回cookie给客户端
flushCookie(uuid, response);
return resultBean;
}
@RequestMapping("/updata/{productId}/{count}")
@ResponseBody
public RsoultBean updata(@CookieValue(name = UserUtil.USER_CART_COOKIE, required = false) String uuid,
HttpServletResponse response,
@PathVariable Long productId,
@PathVariable Integer count){
if(uuid==null){
return RsoultBean.msg("暂无商品信息");
}
//拼一个完整的key
StringBuilder builder = new StringBuilder(UserUtil.REDIS_CART_KEY).append(uuid);
//进行修改操作
RsoultBean rsoultBean = cartService.updataCart(builder.toString(), productId, count);
//设置cookie时间返回信息
flushCookie(uuid,response);
return rsoultBean;
}
@RequestMapping("/del/{productId}")
@ResponseBody
public RsoultBean delete(@CookieValue(name = UserUtil.USER_CART_COOKIE, required = false) String uuid,
HttpServletResponse response,
@PathVariable Long productId){
if(uuid==null){
return RsoultBean.msg("暂无商品信息");
}
//拼一个完整的key
StringBuilder builder = new StringBuilder(UserUtil.REDIS_CART_KEY).append(uuid);
//进行修改操作
RsoultBean rsoultBean = cartService.del(builder.toString(), productId);
//设置cookie时间返回信息
flushCookie(uuid,response);
return rsoultBean;
}
/*
* 因为多处方法都需要重新设置cookie的生存时间,故我们把这段代码提出,设成方法引用,减少冗余
* */
private void flushCookie(@CookieValue(name = UserUtil.USER_CART_COOKIE, required = false) String uuid, HttpServletResponse response) {
Cookie cookie = new Cookie(UserUtil.USER_CART_COOKIE, uuid);
cookie.setPath("/");
cookie.setHttpOnly(true);
cookie.setMaxAge(30 * 24 * 60 * 60);
response.addCookie(cookie);
}
}
登录购物车实现
与未登录的购物车相比,我们做出了许多改变
那么我们怎么判断用户是否登录呢?
- 通过拦截器实现监控用户是否登录功能
- 我们知道,用户登录后会在客户端保存一个cookie,我们可以设置一个拦截器,这个拦截器不进行拦截的操作
- 但是我们会在拦截器中获取用户客户端的所有cookie,进行对比,如果发现了用户登录的cookie,将其保存携带
如图所示
拦截器实现
/**
* @PACKAGE_NAME com.qianfeng.shop.cart.interceptor
* @Author
* @Description
* @date 2020/12/2
* 这个拦截器不进行拦截的作用,主要是判断用户状态的,如果是登录状态就将这个用户存入request
**/
@Component
public class Webinterceptor implements HandlerInterceptor {
@Reference
private UserService userService;
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
//通过request获取cookie
Cookie[] cookies = request.getCookies();
//判断是否存在cookie
if(cookies==null){
return true;
}
//遍历
for (Cookie cookie : cookies) {
//判断用户的cookie
if(UserUtil.USER_COOKIE.equals(cookie.getName())){
//取这个cookie的值
String uuid = cookie.getValue();
//已经登录,存着这个状态
RsoultBean rsoultBean = userService.checkIsLogin(uuid);
request.setAttribute("user",rsoultBean.getData());
return true;
}
}
return true;
}
}
拦截器在编写后并不能马上发挥作用,我们需要在注册中心将其进行注册才能使用
@Configuration
//这个config是用来注册拦截器的
public class WebConfig implements WebMvcConfigurer {
@Autowired
//这里不能使用new一个拦截器的方法,会报异常,只能使用注入的方式进行注册
private Webinterceptor webinterceptor;
@Override
public void addInterceptors(InterceptorRegistry registry) {
//registry就是拦截器的注册中心,需要在这里进行注册后才能正常使用
registry.addInterceptor(webinterceptor).addPathPatterns("/**");
}
}
注意:我们的拦截器在注册中心不能使用new的方式进行注册
controller判断登录
最后我们需要在controller中进行修改
判断用户是否登录决定我们需要展示一个什么类型的购物车
TUser user = (TUser) request.getAttribute("user");
//通过判断用户是否登录,展示不同的购物车
if(user!=null){
//拼一个redis的key,登录状态的话不再使用uuid作为key的一部分而选择使用用户id:uid
builder = new StringBuilder(UserUtil.REDIS_CART_USER_KEY).append(String.valueOf(user.getId()));
}else{
//拼一个redis的key
builder = new StringBuilder(UserUtil.REDIS_CART_KEY).append(uuid);
}
实现合并购物车功能
实现的步骤
-
在shop_cart_api工程中添加方法
//合并购物车的方法 RsoultBean mager(String noLoginKey,String LoginKey);
-
在shop_cart_service工程实现方法
注意:
在合并的时候选择map作为中间数据的载体,是因为两个list重复遍历的效率太差了,远比map的效率低
所以这里我们选择将数据存储在map中进行操作
@Override //合并购物车的方法 public RsoultBean mager(String noLoginKey, String LoginKey) { //获取未登录的购物车 List<CartItem> noLoginCart = (List<CartItem>) redisTemplate.opsForValue().get(noLoginKey); //1.判断未登录的购物车是否存在 if (noLoginCart == null) { return RsoultBean.msg("未登录的购物车不存在,不需合并"); } //获取登录的购物车 List<CartItem> LoginCart = (List<CartItem>) redisTemplate.opsForValue().get(LoginKey); //2.如果登录的购物车数据是空的,直接覆盖 if (LoginCart == null) { return getRsoultBean(LoginKey, noLoginCart); } //3.如果登录的购物车中有数据 //我们先将未登录的购物车的数据放入map中 Map<Long, CartItem> map = new HashMap<>(); for (CartItem cartItem : noLoginCart) { map.put(cartItem.getProductId(), cartItem); } //遍历登录的购物车 for (CartItem cartItem : LoginCart) { //查看是否有相同的商品,如果有就修改商品数量 CartItem item = map.get(cartItem.getProductId()); if (item != null) { //修改map中的商品的数量 item.setCount(cartItem.getCount() + item.getCount()); } else { //如果没有这个商品则直接添加 map.put(cartItem.getProductId(), cartItem); } } //现在map中包含了所有的商品数据,我们将它转成list然后保存到登录状态的购物车中放入redis Collection<CartItem> values = map.values(); //现在已经转成list了 List<CartItem> list = new ArrayList<>(values); //合并后要删除未登录购物车的数据 redisTemplate.delete(noLoginKey); //返回数据 RsoultBean rsoultBean = getRsoultBean(LoginKey, list); return rsoultBean; } //通用方法,保存数据到redis并设置redis的生存时间 private RsoultBean getRsoultBean(String LoginKey, List<CartItem> cart) { redisTemplate.opsForValue().set(LoginKey, cart); redisTemplate.expire(LoginKey, 30, TimeUnit.DAYS); return RsoultBean.success(String.valueOf(cart.size())); }
-
shop_cart工程实现
@RequestMapping("/mager")
@ResponseBody
//这是合并购物车的方法
public RsoultBean mager(HttpServletRequest request,@CookieValue(name = UserUtil.USER_CART_COOKIE,required = false) String uuid){
//获取登录信息
TUser user = (TUser) request.getAttribute("user");
//进行判断
if(uuid==null){
return RsoultBean.msg("没有未登录的购物车,不需要合并");
}
if(user==null){
return RsoultBean.msg("没有登录,不需要合并");
}
//构建两个key
String noLoginKey = new StringBuilder(UserUtil.REDIS_CART_KEY).append(uuid).toString();
//user:cart:userId
String loginKey = new StringBuilder(UserUtil.REDIS_CART_USER_KEY).append(user.getId()).toString();
//进行合并
RsoultBean rsoultBean = cartService.mager(noLoginKey, loginKey);
return rsoultBean;
}
实现登录自动合并购物车功能
使用HttpClient工具来实现自动合并购物车的功能
- 使用httpclient工具类
导入依赖
<dependency>
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpclient</artifactId>
<version>4.3.5</version>
</dependency>
将工具类封装在shop_common工程中,在shop_sso工程中引用
import org.apache.http.NameValuePair;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import java.io.IOException;
import java.net.URI;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
public class HttpClientUtils {
/**
* 携带请求参数的GET请求
*
* @param url
* @param param
* @return
*/
public static String doGet(String url, Map<String, String> param) {
//
String result = "";
// 1.创建Httpclient对象
CloseableHttpClient httpclient = HttpClients.createDefault();
CloseableHttpResponse response = null;
try {
// 2.创建uri对象
URIBuilder builder = new URIBuilder(url);
if (param != null) {
for (String key : param.keySet()) {
builder.addParameter(key, param.get(key));
}
}
URI uri = builder.build();
// 3.创建http GET请求
HttpGet httpGet = new HttpGet(uri);
// 4.执行请求
response = httpclient.execute(httpGet);
// 5.判断返回状态是否为200
if (response.getStatusLine().getStatusCode() == 200) {
// 6.进行UTF-8编码处理
result = EntityUtils.toString(response.getEntity(), "UTF-8");
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (response != null) {
response.close();
}
httpclient.close();
} catch (IOException e) {
e.printStackTrace();
}
}
return result;
}
/**
* 不需要携带参数的get请求
*
* @param url
* @return
*/
public static String doGet(String url) {
return doGet(url, null);
}
/**
* 携带请求参数的POST请求
*
* @param url
* @param param
* @return
*/
public static String doPost(String url, Map<String, String> param) {
//
String result = "";
// 1.创建Httpclient对象
CloseableHttpClient httpClient = HttpClients.createDefault();
CloseableHttpResponse response = null;
try {
// 2.创建Http Post请求
HttpPost httpPost = new HttpPost(url);
// 3.创建参数列表
if (param != null) {
List<NameValuePair> paramList = new ArrayList<>();
for (String key : param.keySet()) {
paramList.add(new BasicNameValuePair(key, param.get(key)));
}
// 4.模拟表单
UrlEncodedFormEntity entity = new UrlEncodedFormEntity(paramList);
httpPost.setEntity(entity);
}
// 5.执行http请求
response = httpClient.execute(httpPost);
// 6.获取响应的结果
result = EntityUtils.toString(response.getEntity(), "utf-8");
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
response.close();
} catch (IOException e) {
e.printStackTrace();
}
}
return result;
}
/**
* 发送无携带请求参数的POST请求
*
* @param url
* @return
*/
public static String doPost(String url) {
return doPost(url, null);
}
/**
* 以json的方式传递请求参数,发送POST请求
*
* @param url
* @param json
* @return
*/
public static String doPostJson(String url, String json) {//map json
//
String result = "";
// 1.创建Httpclient对象
CloseableHttpClient httpClient = HttpClients.createDefault();
CloseableHttpResponse response = null;
try {
// 2.创建Http Post请求
HttpPost httpPost = new HttpPost(url);
// 3.创建请求内容
StringEntity entity = new StringEntity(json, ContentType.APPLICATION_JSON);
httpPost.setEntity(entity);
// 4.执行http请求
response = httpClient.execute(httpPost);
// 5.获取响应结果
result = EntityUtils.toString(response.getEntity(), "utf-8");
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
response.close();
} catch (IOException e) {
e.printStackTrace();
}
}
return result;
}
/*
* 可以设置请求头的get方法
* */
public static String doGetWithHeader(String url, Map<String, String> paramMap) {
//
String result = "";
// 1.创建Httpclient对象
CloseableHttpClient httpclient = HttpClients.createDefault();
CloseableHttpResponse response = null;
try {
// 2.创建http GET请求
HttpGet httpGet = new HttpGet(url);
//3.给get请求的头部设置参数
Set<Map.Entry<String, String>> entries = paramMap.entrySet();
for (Map.Entry<String, String> entry : entries) {
httpGet.setHeader(entry!](https://img-blog.csdnimg.cn/20201204165150381.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80OTEzODM4NQ==,size_16,color_FFFFFF,t_70#pic_center)
.getKey(),entry.getValue());
}
// 4.执行请求
response = httpclient.execute(httpGet);
// 5.判断返回状态是否为200
if (response.getStatusLine().getStatusCode() == 200) {
// 6.进行UTF-8编码处理
result = EntityUtils.toString(response.getEntity(), "UTF-8");
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (response != null) {
response.close();
}
httpclient.close();
} catch (IOException e) {
e.printStackTrace();
}
}
return result;
}
}
在shop_sso工程的登录的方法中,用户在成功登录后需要通知购物车模块合并购物车
//登录成功,发送合并购物车的请求,自动合并购物车
//这种方式不是在浏览器直接发送,所以少了cookie
//Cookie: user_cart=7c61b8ce-f435-41b3-9469-ca2e8b1b3aba; user_cookie=ac7994b8-15cb-4ba1-8eaa-07f8791f4254
//所以我们要拼接一个请求头的参数传入请求中
StringBuilder cookieValue = new StringBuilder(UserUtil.USER_CART_COOKIE+"=");
cookieValue.append(userCartCookie);
cookieValue.append(";");
cookieValue.append(UserUtil.USER_COOKIE+"=");
cookieValue.append(uuid);
Map<String,String> paramMap = new HashMap<>();
paramMap.put("Cookie",cookieValue.toString());
//将请求放入doGetWithHeader方法中执行请求
HttpClientUtils.doGetWithHeader("http://localhost:9097/cart/mager",paramMap);
httpclient.close();
} catch (IOException e) {
e.printStackTrace();
}
}
return result;
}
}
> 在shop_sso工程的登录的方法中,用户在成功登录后需要通知购物车模块合并购物车
```java
//登录成功,发送合并购物车的请求,自动合并购物车
//这种方式不是在浏览器直接发送,所以少了cookie
//Cookie: user_cart=7c61b8ce-f435-41b3-9469-ca2e8b1b3aba; user_cookie=ac7994b8-15cb-4ba1-8eaa-07f8791f4254
//所以我们要拼接一个请求头的参数传入请求中
StringBuilder cookieValue = new StringBuilder(UserUtil.USER_CART_COOKIE+"=");
cookieValue.append(userCartCookie);
cookieValue.append(";");
cookieValue.append(UserUtil.USER_COOKIE+"=");
cookieValue.append(uuid);
Map<String,String> paramMap = new HashMap<>();
paramMap.put("Cookie",cookieValue.toString());
//将请求放入doGetWithHeader方法中执行请求
HttpClientUtils.doGetWithHeader("http://localhost:9097/cart/mager",paramMap);