开发技能总结

1、一般对外提供的接口，为了方便实体的转换，都会在本工程创建一个实体，对外返回时又创建一个vo类，本工程操作完后，需要转换成vo类对外提供。Spring框架自带的属性拷贝工具类

BeanUtils.copyProperties

就能很好的解决大量的set.属性(get.属性)，遇到实体属性特别多的时候，是不是感觉很爽，有个前提是实体里有的属性，vo要有，因为这个是根据反射原理来实现，属性匹配不上，肯定没法转换，还有一种就是实体里嵌套了的，这个需要手动处理，另外一种情况就是属性为泛型的。

属性拷贝的公爵也有不少，这里推荐两个。一个是Spring框架自带的属性拷贝工具类

BeanUtils.copyProperties,二是MapStruct，在处理类型不一致、字段名不一致、枚举类型，要比Spring自带的强。

之前有大佬已经对工具转换耗时做了测试了，直接借用下大佬的图

个人在开发中还是 BeanUtils.copyProperties用的比较多，如果说是对性能要求高一些的话，建议使用MapStruct。

@Mapper(componentModel = "spring")
public interface ArtxxleConvertor {

    @Mappings({})
    ArxxInfo artixx2ArtxxInfo(Arxxcle arxxcle);

    @Mappings({})
    Arxxle artixxeInfo2Arxxcle(ArtixxeInfo artixxeInfo);

    @Mappings({@Mapping(target="authorId", source="userNo")})
    QueryArxxicle queryArtixxeList2QueryAxxcle(QueryArxxcleList queryArxxcleList);
}

 BeanUtils.copyProperties还可以简单封装成工具类，平时写起来也比较简洁。

package cn.xx.xx.xx.util;


import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.util.CollectionUtils;

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

/**
 * @author xx
 * @Description: 拷贝工具类，基于spring自带拷贝工具进行封装
 * @date xx/xx/xx
 */
@Slf4j
public class CopyUtil{

    /**
     * 单体复制
     */
    public static <T> T copy(Object source, Class<T> clazz) {
        if (source == null) {
            return null;
        }
        T obj = null;
        try {
            obj = clazz.newInstance();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
        BeanUtils.copyProperties(source, obj);
        return obj;
    }

    /**
     * 列表复制
     */
    public static <T> List<T> copyList(List source, Class<T> clazz) {
        List<T> target = new ArrayList<>();
        if (!CollectionUtils.isEmpty(source)){
            for (Object c: source) {
                T obj = copy(c, clazz);
                target.add(obj);
            }
        }
        return target;
    }


}

参考：

   BeanUtils.copyProperties: 使用BeanUtils.copyProperties引发的问题_马小瑄的博客-CSDN博客_beanutils.copyproperties报错

mapstruct:mapstruct使用详解 - 淼淼之森 - 博客园

2、常用设计模式在项目里使用

①、单例

创建一个私有静态的方法，在里面创建一个私有静态的常量类，创建一个私有的构造方法，在定义一个公共静态常量方法来获取这个类，通常用在自定义返回类或者结合工厂方法生成某个类。

 ②、策略

首先定义一个策略接口，然后有实现策略接口，创建策略的简单工厂，根据传入的类型返回不同策略。

package cn.xx.service.axxcxxer.strategy.banner.contentinfo;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import org.springframework.beans.BeansException;
import org.springframework.stereotype.Component;

import cn.xx.common.arxxnter.enums.BANNER_GROUP_TAB;
import cn.xx.service.artxxter.strategy.AbstractBuildInfoFactory;

@Component
public class BxxoListBuildInfoFactory extends AbstractBuildInfoFactory {

private static final Map<Integer, AbstractxxListBuildInfo> BUILDINFO_MAP = new ConcurrentHashMap<>(16);
	
	public static AbstractxxListBuildInfo getBuildInfos(BANNER_GROUP_TAB type) {
		if (type == null) {
			return null;
		}
		return BUILDINFO_MAP.get(type.getValue());
	}

	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		if (! (bean instanceof AbstractxxBuildInfo)) {
			return bean;
		}
		AbstractxxListBuildInfo buildInfo = (AbstractxxBuildInfo) bean;
		if (buildInfo.key() == null) {
			return bean;
		}
		BUILDINFO_MAP.put(buildInfo.key().getValue(), buildInfo);
		return bean;
	}

}

package cn.xx.service.articlecenter.strategy;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

public abstract class AbstractBuildInfoFactory implements BeanPostProcessor {
	
	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		return bean;
	}

}

package cn.xx.service.articlecenter.strategy.banner.contentinfo;

import cn.xx.common.articlecenter.enums.BANNER_GROUP_TAB;
import cn.xx.common.result.PageResultObject;
import cn.xx.dao.articlecenter.entity.BannerGroupContent;
import cn.xx.service.articlecenter.dto.banner.BannerContentInfoListAdminParam;
import cn.xx.service.articlecenter.strategy.BuildInfo;

/**
 * xx
 */
public abstract class AbstractxxBuildInfo implements BuildInfo<xxAdminParam, PageResultObject<?>> {
	
	private ThreadLocal<xx> local = new ThreadLocal<>();
	
	@Override
	public abstract BANNER_GROUP_TAB key();
	
	public void setExtra(xx extra) {
		local.set(extra);
	}
	
	public xx getExtra() {
		return local.get();
	}
	
}

package cn.xx.service.articlecenter.strategy;

public interface BuildInfo<S, T> {
	
	T build(S source);
	
	Object key();
	
}

参考：原来使用 Spring 实现策略模式可以这么简单！_Hollis Chuang的博客-CSDN博客

3、java8在项目里的使用

主要还是java8的流Stream

筛选，过滤出符合条件的

过滤出符合条件
List<TagInfoResult> results = d.getGroupIds().stream().filter(item ->ObjectUtil.isNotNull(item.getIsConfig())).collect(Collectors.toList());
List<EventMeetingApply> list = applyList.stream().filter(e -> !CollUtil.contains(activityIds, e.getActivityId())).collect(Collectors.toList());
对数据进行排序
					Collections.sort(results, Comparator.comparing(TagInfoResult::getIsConfig));
					d.setGroupIds(results);

截断流，返回一个不超过给定长度的流。

跳过元素，返回一个扔掉了前n个元素的流；如果流中元素不足n个，则返回一个空流。

 

转换成新的对象

流支持 map 方法，它会接受一个函数作为参数。这个函数会被应用到每个元素上，并将其映
射成一个新的元素（使用映射一词，是因为它和转换类似，但其中的细微差别在于它是“创建一
个新版本”而不是去“修改”）。

转换成新的对象
List<PhoneDto> phones = pushSettings.stream().map(s -> new PhoneDto(s.getArea(), s.getPhone())).collect(Collectors.toList());
Set<Long> ridList = subRoadshowIds.stream().map(Long::parseLong).collect(Collectors.toSet());

 flatmap 方法让你把一个流中的每个值都换成另一个流，然后把所有的流连接
起来成为一个流。

查找和匹配

    anyMatch：至少匹配一个元素。

   allMatch：是否匹配所有元素。

  noneMatch：没有任何元素匹配。

短路求值：有些操作不需要处理整个流就能拿到结果。

 findAny ：返回当前流中的任意元素。

findFirst：查找第一个元素。

reduce：元素求和。

生成Map，并去重

https://www.cnblogs.com/linliquan/p/14171803.html

toMap()的第一个参数就是用来生成key值的，第二个参数就是用来生成value值的。
第三个参数用在key值冲突的情况下：如果新元素产生的key在Map中已经出现过了，第三个参数就会定义解决的办法。
在你的例子中
 .collect(Collectors.toMap(UserBo::getUserId, x -> x, (x, y) -> x));
第一个参数UserBo::getUserId 表示选择UserBo的getUserId作为map的key值；
第二个参数x -> x表示选择将原来的对象作为map的value值；
第三个参数(x, y) -> x中，如果x与y的key值相同，选择x作为那个key所对应的value值

 


types.parallelStream().collect(Collectors.toMap(AgencyType::getName, t -> t, (v1, v2) -> v1));
 Map<Long, UserApplyInfoCheckResp> map = result.stream().collect(Collectors.toMap(UserApplyInfoCheckResp::getId, t -> t, (t1, t2) -> t1));

基本上项目里常用的就这些了了，还想拓展的话可以看下Java8实战这本书。

上面排版有些乱，看看这个链接：轻松玩转Java Stream，写代码效率飞升

4、使用hutool工具类

①、使用hutool工具的时间类，将date类型转换为long类型

 String formateType = "yyyy-MM-dd HH:mm";
 Long time = DateUtil.parse(DateUtil.format(new Date(), formateType),formateType).getTime();

DateUtil.formatDateTime(new Date(rxxow.getStime()))

 ②、集合工具类

CollUtil：

hutool中CollUtil工具类的常用方法_pipizhen_的博客-CSDN博客_hutool list 交集

③、验证码

未完，待续