dubbo项目之：购物车模块

购物车模块

未登录购物车实现

实现的效果

我们需要完成的步骤及功能

方案一：

针对方案一的不足，我们在方案二进行了改进

方案二：

• 在方案二我们做了一些改进
  1. 存入CartItem的数据中，我们不再存放product商品本身，而选择存入productId
  2. 存入cookie的数据，我们选择了一个标识，uuid
  3. 加入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);
        }

实现合并购物车功能

实现的步骤

1. 在shop_cart_api工程中添加方法

   //合并购物车的方法
       RsoultBean mager(String noLoginKey,String LoginKey);
   

2. 在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()));
       }
   

3. 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);