泛型方法的封装

本文已参与「新人创作礼」活动，一起开启掘金创作之路。

泛型方法的封装

展示尚硅谷大神的封装方法：

package com.atguigu.common.utils;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;
import org.apache.http.HttpStatus;

import java.util.HashMap;
import java.util.Map;

/**
 * 返回数据
 *
 * @author Mark sunlightcs@gmail.com
 */
public class R  extends HashMap<String, Object> {
	private static final long serialVersionUID = 1L;

	//利用fastJson
	public <T> T getData(TypeReference<T> typeReference){
		Object data = get("data");
		String s = JSON.toJSONString(data);
		T t = JSON.parseObject(s, typeReference);
		return t;
	}
	public R setData(Object data){
		put("data",data);
		return this;
	}

	public R() {
		put("code", 0);
		put("msg", "success");
	}

	public static R error() {
		return error(HttpStatus.SC_INTERNAL_SERVER_ERROR, "未知异常，请联系管理员");
	}

	public static R error(String msg) {
		return error(HttpStatus.SC_INTERNAL_SERVER_ERROR, msg);
	}

	public static R error(int code, String msg) {
		R r = new R();
		r.put("code", code);
		r.put("msg", msg);
		return r;
	}

	public static R ok(String msg) {
		R r = new R();
		r.put("msg", msg);
		return r;
	}

	public static R ok(Map<String, Object> map) {
		R r = new R();
		r.putAll(map);
		return r;
	}

	public static R ok() {
		return new R();
	}

	public R put(String key, Object value) {
		super.put(key, value);
		return this;
	}
	public  Integer getCode() {

		return (Integer) this.get("code");
	}

}

重点：

	//调用这个类 把存储存入data 默认是HashMap的保存
	public R setData(Object data){
		put("data",data);
		return this;
	}

调用的解析转化
    接参数时接收需要转换成的对象
   public <T> T getData(TypeReference<T> typeReference){
		Object data = get("data");//内容先取出map
		String s = JSON.toJSONString(data);//JSON转换
		T t = JSON.parseObject(s, typeReference);//转换成需要的结构
		return t;
	}

实例调用：

置入数据

    public R getSkusHasStock(@RequestBody List<Long> skuIds){
        //sku_id stock
        List<SkuHasStockVo> vos = wareSkuService.getSkusHasStock(skuIds);
        return R.ok().setData(vos);
    }

取出数据

 R r = wareFeignService.getSkusHasStock(skuIdList);
TypeReference<List<SkuHasStockTo>> typeReference = new TypeReference<List<SkuHasStockTo>>() {};
List<SkuHasStockTo> stockMap = r.getData(typeReference);

小笔记本解释一段stream()代码：

解释1：
List<SkuHasStockTo> listSku 

Map<key, value> map =listSku.stream().collect(Collectors.toMap(SkuHasStockTo::getSkuId, item -> item.getHasStock()));

//遍历listSku  把它的每一个对象（SkuHasStockTo）的 getSkuId 作为键 SkuHasStockTo的每一个hasStock属性作为值，做成map键值对


解释2：
 List<SkuInfoEntity> skus
    
 List<Long> skuIdList = skus.stream().map(SkuInfoEntity::getSkuId).collect(Collectors.toList());

//遍历 skus的每一个对象（SkuInfoEntity） 取出它的skuId 生成一个新的skuId的List

解释3：
 List<ProductAttrValueEntity> baseAttrs 
    
 List<Long> attrIds = baseAttrs.stream().map(attr -> { 
    return attr.getAttrId();
 }).collect(Collectors.toList());

//遍历 baseAttrs的每一个对象（ProductAttrValueEntity） AttrId 生成一个新的skuId的List

解释4：
 public static class Attrs{
   private Long  attrId;
   private String attrName;
   private String attrValue;
 }   
    
 Set<Long> idSet
 List<ProductAttrValueEntity> baseAttrs   
    
 List<Attrs> attrList = baseAttrs.stream().filter(item -> {
    return idSet.contains(item.getAttrId());
 }).map(item -> {
    Attrs attrs1 = new SkuEsModel.Attrs();
    BeanUtils.copyProperties(item, attrs1);
    return attrs1;
 }).collect(Collectors.toList());   

//遍历 baseAttrs的每一个对象（ProductAttrValueEntity） 
//filter 过滤筛选出集合idSet 包含 ProductAttrValueEntity属性值attrId的
//把过滤后的ProductAttrValueEntity 按照 Attrs的属性 生成  List<Attrs>



例子5：
    public Map<String, List<Catelog2Vo>>  getCatalogJson() {
       //1.查出所有1级分类
        List<CategoryEntity> level1Categorys = getLevel1Categorys();
        //封装数据
        Map<String, List<Catelog2Vo>> collect = level1Categorys.stream().collect(Collectors.toMap(k -> {
            return k.getCatId().toString();
        }, v -> {
            //每一个的一级分类 查到这个一级分类的所有二级分类
            List<CategoryEntity> categoryEntities = baseMapper.selectList(new QueryWrapper<CategoryEntity>().eq("parent_cid", v.getCatId()));
            List<Catelog2Vo> catelog2Vos = null;
            if(categoryEntities!=null){
                    catelog2Vos = categoryEntities.stream().map(level2 -> {

                    //查处当前二级分类下的所有三级分类
                    List<CategoryEntity> levl3Catelog = baseMapper.selectList(new QueryWrapper<CategoryEntity>().eq("parent_cid", level2.getCatId()));
                        List<Catelog2Vo.Catelog3Vo> catelog3VoList = null;
                        if(levl3Catelog!=null){
                            catelog3VoList = levl3Catelog.stream().map(level3 -> {
                                new  Catelog2Vo.Catelog3Vo("","","");
                                Catelog2Vo.Catelog3Vo catelog3Vo = new Catelog2Vo.Catelog3Vo(
                                    level2.getCatId().toString(),
                                    level3.getCatId().toString(),
                                    level3.getName()
                                );
                                return catelog3Vo;
                            }).collect(Collectors.toList());
                        }


                    Catelog2Vo catelog2Vo = new Catelog2Vo(
                        v.getCatId().toString(),
                        catelog3VoList,
                        level2.getCatId().toString(),
                        level2.getName()
                    );
                    return catelog2Vo;
                }).collect(Collectors.toList());
            }
                return catelog2Vos;
        }));
        return collect;
    }