关于我在工作中遇到的一些问题

参数校验

public class ParamsCheck{
    private static ThreadLocal<String> param = new ThreadLocal<>();

    public static void main(String[] args) {
        JiuShiBoy jiuShiBoy = new JiuShiBoy();
        Cat cat=new Cat();
        List<Cat> list=new ArrayList<>();
        list.add(cat);
        jiuShiBoy.setCats(list);
        try {
            ParamsIsNotNull(jiuShiBoy, "name", "age", "cats", "catName");
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }

    private static void ParamsIsNotNull(Object object, String... argsName) throws Exception {
        // 获取类中所有的字段
        List<String> nameArgs = Arrays.asList(argsName);
        try {
            for (Field field : object.getClass().getDeclaredFields()) {
                field.setAccessible(true);
                // 非空判断
                checkParamsNotNull(nameArgs, object, field, argsName);
            }
        } catch (Exception e) {
            String isNullFromParam = param.get();
            param.remove();
            StringBuffer stringBuffer = new StringBuffer();
            stringBuffer.append("参数:{");
            stringBuffer.append(isNullFromParam);
            stringBuffer.append("}不能为空");
            throw new Exception(stringBuffer.toString());
        }

    }

    private static void checkParamsNotNull(List<String> nameArgs, Object object, Field field, String[] argsName) throws Exception {
        // 当你需要校验的参数名 在对象属性中存在则进入判断
        if (nameArgs.contains(field.getName())) {
            // 判断当前传入的属性值是否为List
            if (field.getType().equals(List.class) && CollectionUtils.isNotEmpty((List) field.get(object))) {
                for (Object o : (List) field.get(object)) {
                    ParamsIsNotNull(o, argsName);
                }
            } else if (null == field.get(object) || "".equals(field.get(object))) {
                // 判断当前传入的属性值 是否为空
                param.set(field.getName());
                throw new Exception("参数异常");
            }
        }
    }


}

class JiuShiBoy {
    private String name;
    private int age;
    private List<Cat> cats;

    public List<Cat> getCats() {
        return cats;
    }

    public void setCats(List<Cat> cats) {
        this.cats = cats;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

class Cat {
    private String catName;

    public String getCatName() {
        return catName;
    }

    public void setCatName(String catName) {
        this.catName = catName;
    }
}

关于JSON转换

import com.alibaba.fastjson.JSON;
//注意这里用的是阿里云的fastJson 当然你也可以选择Google的Gson
class JiuShiTest{
    public static void main(String[] args){
        //集合对象List<JiuSHi>转成json字符串
        String jsonString=JSON.toJSONString(List<JiuShi>);
        //json字符串转集合对象 --> 参数1:需要转换的字符串   参数2:要转换成类型
        List<JiuShi> jiushiList=JSON.parseArray(jsonString,JiuShi.class);
    }
}

关于分页

//1.说到分页,肯定得抽取共通的属性
public class PageEntity{
    // 当前页
    private Integer currentPage;
    // 每页条数
    private Integer pageSize;
    private Integer start;
    private Integer end;
}
//2.抽取之后子类继承PageEntity可达到共用的效果

关于批量

//这里主要讲的是Mybatis的各种批量操作
//1.批量查询  
<!--通用的返回结果映射-->
<resultMap id="JiuShiBaseResultMap" type="com.jiushiboy.entity.JiuShi">
    <result property="jiushi" column="JIUSHI" />
    <result property="boy" column="BOY" />
</resultMap>

<!-- 通用的查询字段 -->
<sql id="JiuShiFind">
    JIUSHI,
    BOY
</sql>
<select id="queryJiuShiList" resultType="String" resultMap="JiuShiBaseResultMap">
    SELECT <include refid="JiuShiFind" />
    FROM jiushi_table
    WHERE DEL_FLAG = 0
    <if test="list != null and list.size>0 ">
        AND  JIUSHI in
        <foreach collection="list" item="jiushi" index="index"
                 open="(" close=")" separator=",">
            #{jiushi}
        </foreach>
    </if>
</select>

//2.批量插入
<insert id="insertAll" parameterType="java.util.List">
    insert into jiushi (
       JIUSHI,
       BOY
    ) values
    <foreach collection="list" item="item" index="index" separator=",">
        <trim prefix="(" suffix=")" suffixOverrides=",">
            #{item.jiushi},
            #{item.boy}
        </trim>
    </foreach>
</insert>

//3.批量更新
<update id="batchUpdate" parameterType="java.util.List">
    <foreach collection="list" item="item" index="index" separator=";">
        UPDATE jiushi_table
        <set>
            <if test="item.boy != null">
                BOY = #{item.boy},
            </if>
        </set>
        WHERE DEL_FLAG = 0
        <if test="item.jiushi != null">
            JIUSHI = #{item.jiushi}
        </if>
    </foreach>
</update>

关于在IDEA操作Git时需要将dev分支代码同步到test分支

1.使用Beyond Compare工具(软件)

在两边分别设置dev分支的项目路径和test分支路径

当开始比较之后文件夹的颜色会发生变化就代码代码不同,这时可以点进代码进行往右移动或者是左

但是你经过Beyond Compare工具操作之后代码并不会真正的同步,因为他只是修改了你本地的代码,并没有帮你提交代码;
所以你还是得自己去idea或者git进行commit和push;

2.使用IDEA中Git操作

一、关于git分支合并代码

1.首先要分清除的是假如你的dev分支的代码需要同步到test分支,那么你应该切换到test分支;
2.我懒得新建test分支直接拿master分支演示;
3.首先你得清除你什么文件需要从哪个分支同步过来,我的话就比较直接我全都要;

3.1 直接在项目根目录右键选择git选项
3.2 然后选择Compare with Branch 这个选项是什么意思呢? 拿你当前的分支与其他分支比较

3.3 然后会出现一个弹框,上面显示了你这个项目所有的分支,你需要跟哪个分支比较
3.4 我这里演示是将dev分支代码同步到master分支,所以我当前分支是master分支所以我要跟dev分支比较

3.5 然后就是进行代码同步了,右边是你当前分支的代码,左边是dev的代码,要同步直接点那个箭头,箭头往哪个方向就是把代码同步到哪个分支

二、关于git分支合并代码时java类变灰色

1.比如dev同步test的代码,但是有些类是test新建的,那么在dev同步代码时那些类是没法同步过来的那么现在开始解决
2.解决方案1 –> 你一个一个的比对分支的代码复制过来
3.解决方案2 –> 这个时候就该展现idea的强大了

3.3 首选我们通过idea右下角的分支,你要从哪个分支拉代码过来就选择哪个分支,点击Show Diff with Working Tree

3.4 然后将代码get到当前分支

遇到的一些问题

使用了BigDecimal接收金额类型

BigDecimal当你定义了变量而不初始化值去使用则会报空指针异常

// 正确使用方法
BigDecimal money = BigDecimal.ZERO;
// 当你初始化值之后使用它的累加方法就不会空指针了

当前端操作是假操作时所带来的问题

//1.假设我要保存数据,数据结构是这样的
{
  "tableUniqueCode":"唯一编号",
  "name": "九世",
  "age": "未知",
  "listDatas": [
    {
      "fieldUniqueCode":"字段表唯一编号",
      "fieldCode":"字段编号",
      "fieldName":"字段名称"
    }
  ]
}
//当我们那这个数据做修改时,如果前端突然在listDatas中添加了一条数据;
//注意是添加,在修改时做添加的操作,这时候这条新的数据是没有字段表唯一编号的;
//还有一个要注意的地方,就是这组数据的关系;
//外层是信息表,信息表这一条数据下,又有多条字段数据;
//也就是说在listDatas的数据中,其实每一条都会有tableUniqueCode;
//当字段表存入tableUniqueCode就相当于他们之间有了一个外键关系;
//解决方案其实就是在更新的时候在字段表把tableUniqueCode编号的数据全部删掉;
//因为编辑的时候会将数据重新全部带入进来;
//然后重新进行添加,可以选择批量;
//但是要注意的是因为是编辑,所以之前的字段数据是会有自己的唯一编号;
//除非是在编辑时新增的字段数据,否则肯定是有fieldUniqueCode唯一编号的;
//这时则需要在后端进行校验;
//当fieldUniqueCode为空,则生成一个唯一编号,也就意味着这条数据是在编辑的时候新增的;

当我遇到了一个很奇怪的场景

下面我来模仿一下业务场景
新增方法的json数据

// 表设计为,假设你找九世借钱,那么在添加的时候
// 会添加两条记录,price字段要根据priceType金额类型
// 来判断price是什么金额,如果priceType是0
// 那么price就是你实际找九世借了多少钱
// 如果priceType是1那么price就表示你借钱要多少利息
// 因为添加的时候两条数据其实对应的是一个人的,那么rowUniCode就应该公用一个编号
{
  "jiushiboy": [
    {
      "CustomerName": "九世",
      "price": "1000",
      "priceType": "0",
      "rowUniCode": "1111xxxxxxxx",
      "qq":"1450495810"
    },
    {
      "CustomerName": "九世",
      "price": "1000",
      "priceType": "1",
      "rowUniCode": "1111xxxxxxxx",
      "qq":"1450495810"
    }
  ]
}
//那么在查询的时候,我们首先按照qq来查询
//可以查出两条记录,但是传给前端的时候需要整合成一条数据
//这时你会如何去对这个数据进行整合呢?
//查出这个qq下的所有记录
List<JiuShiBoy> jiushi = jiuShiMapper.queryListByQQ("1450495810");
//然后一个qq下对应的所有记录根据rowUniqueCode进行分组
//为什么要分组? 因为qq为条件的意思是有很多人找这个qq号主借钱
//那么这个qq为条件可以查出很多条数据
//但是在添加的时候,我们是一个借钱的人添加数据会添加两条
//所以就需要用到rowUniqueCode 来分辨一个人的两条记录
Map<String,List<JiuShiBoy>> collect = jiushi.stream().collect(Collectors.groupBy(jiushi -> jiushi.getRowUniqueCode()));
//分完组之后那么map里面装的数据就是对应的,某个人的两条数据
//开始循环遍历,因为是按照rowUniqueCode分组那么map的key就是rowUniqueCode
for(String key:collect.keySet()){
    //然后通过分组之后的key获取到rowUniqueCode对应的多条数据
    //这步get操作其实就已经是获取了两条记录
    List<JiuShiBoy> jiushiboy=collect.get(key);
    //之后就可以为所欲为的操作你的数据进行整合了
    //整合已省略
}

关于git

# IDEA在提交时一般需要忽略的文件
.settings/
.idea/
target/
*.project
*.class
*.classpath
*.iml
*.uml
.metadata/
*.uml
*.bak
*.log*

关于node

# npm 设置镜像

关于nacos

# 当我使用nacos持久化sentinel数据时爆出了错误
# caused by: java.lang.ClassNotFoundException:com.alibaba.csp.sentinel.datasource.nacos.NacosDataSource
# 这个错的原因是使用nacos持久化sentinel必须添加依赖
# maven中导入sentinel-datasource-nacos

对象Copy

sourceToTarget 入参一数据源,也就是查询出来的参数,入参二转成什么对象类型

import com.github.pagehelper.Page;
import com.github.pagehelper.PageInfo;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeanUtils;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

public class ConvertUtils {

    private static Logger logger = LoggerFactory.getLogger(ConvertUtils.class);

    public static <T> T sourceToTarget(Object source, Class<T> target) {
        if (source == null) {
            return null;
        }
        T targetObject = null;
        try {
            targetObject = target.newInstance();
            BeanCopierUtil.copy(source, targetObject);
        } catch (Exception e) {
            logger.error("convert error ", e);
        }

        return targetObject;
    }

    public static <T> List<T> sourceToTarget(Collection<?> sourceList, Class<T> target) {
        if (sourceList == null) {
            return null;
        }

        List targetList = new ArrayList<>(sourceList.size());
        try {
            for (Object source : sourceList) {
                T targetObject = target.newInstance();
                BeanCopierUtil.copy(source, targetObject);
                targetList.add(targetObject);
            }
        } catch (Exception e) {
            logger.error("convert error ", e);
        }
        return targetList;
    }

    public static  <P, D> PageInfo<D> pageInfo2PageInfoVO(PageInfo<P> pageInfoPO, Class<D> dClass) {
        Page<D> page = new Page<>(pageInfoPO.getPageNum(), pageInfoPO.getPageSize());
        page.setTotal(pageInfoPO.getTotal());
        for (P p : pageInfoPO.getList()) {
            D d = null;
            try {
                d = dClass.newInstance();
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
            BeanUtils.copyProperties(p, d);
            page.add(d);
        }
        return new PageInfo<>(page);
    }
}

List javaBean = ConvertUtils.sourceToTarget(mybatisMapper.selectList(null),JavaBean.class);