java常用代码整理

整理一下常用的代码，可以支持后续的直接拿过来使用，不需要慢慢再去百度搜索了， 后续不间断更新

1.List转List

　　将一个类型的List转为另一个类型的List

public static void main(String[] args) {
        List<TbUser> userList = Lists.newArrayList();
        TbUser user = new TbUser();
        user.setId(1).setName("小王").setTel("12345");
        TbUser user2 = new TbUser();
        user2.setId(1).setName("小李").setTel("56789");
        userList.add(user);
        userList.add(user2);

        //1.转为name的list
        List<String> nameList = userList.stream().map(TbUser::getName).collect(Collectors.toList());
        //2.转为另外一种对象的集合
        List<TestUser> testUserList = userList.stream().map(u -> {
            TestUser testUser = new TestUser();
            //使用spring中的BeanUtils
            BeanUtils.copyProperties(u, testUser);
            return testUser;
        }).collect(Collectors.toList());
    }

 

 

2.List转Map

　　一般用于将数据库中的一部分数据取出来，然后转为map，方便后续的操作

public static void main(String[] args) {
        List<TbUser> userList = Lists.newArrayList();
        TbUser user = new TbUser();
        user.setId(1).setName("小王").setTel("12345");
        TbUser user2 = new TbUser();
        user2.setId(1).setName("小李").setTel("56789");
        userList.add(user);
        userList.add(user2);


        //1.将userList转为Map<Integer,TbUser>, 前提是userList中key不重复
        Map<Integer, TbUser> map = userList.stream().collect(Collectors.toMap(TbUser::getId, u -> u));
        //2. 将userList转为Map<Integer,String>，前提是userList中key不重复
        Map<Integer, String> map2 = userList.stream().collect(Collectors.toMap(TbUser::getId, TbUser::getTel));
        //3. 将userList转为Map<Integer,TbUser>，userList中key重复的话，后一个覆盖前面一个
        Map<Integer, TbUser> map3 = userList.stream().collect(Collectors.toMap(TbUser::getId, Function.identity(), (key1, key2) -> key2));

    }

 

3. List重复校验

public static void main(String[] args) {
        List<TbUser> userList = Lists.newArrayList();
        TbUser user = new TbUser();
        user.setId(1).setName("小王").setTel("12345");
        TbUser user2 = new TbUser();
        user2.setId(1).setName("小李").setTel("56789");
        userList.add(user);
        userList.add(user2);


        //1.从userList找到每个名字对应数量的map
        Map<String, Long> countMap = userList.stream().collect(Collectors.groupingBy(TbUser::getName, Collectors.counting()));
        //2. 找到存在重复的名字，只需要遍历countMap的key，然后根据key再从countMap找到值大于1的就行了
        List<String> repeatNameList = countMap.keySet().stream().filter(key -> countMap.get(key) > 1).collect(Collectors.toList());
        //3.如果要对userList中去除名字和性别同时都相同的人, 如果只是简单的List<String>去重，可以直接使用distinct()
        List<TbUser> uniqueList = userList.stream().collect(
                Collectors. collectingAndThen(
                        Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(o -> o.getName() + "-" + o.getSex()))), ArrayList::new)
        );
        //4. 只是想看看List中是否包含一个名字叫做“小王”的人, 如果想返回user对象就用filter，如果只返回true和false，用anyMatch
        boolean anyMatch = userList.stream().anyMatch(u -> Objects.equals(u.getName(), "小王"));
    }

 

 

4.List中先分组，然后多次排序

　　通常对List处理的时候，肯定有分组的，再分组之后，对每一组数据首先对A字段排序，然后对B字段进行排序

public static void main(String[] args) {
        List<TbUser> userList = Lists.newArrayList();
        TbUser user = new TbUser();
        user.setId(1).setName("小王").setTel("12345");
        TbUser user2 = new TbUser();
        user2.setId(2).setName("小李").setTel("56789");
        TbUser user3 = new TbUser();
        user3.setId(3).setName("小李").setTel("56789");
        userList.add(user);
        userList.add(user2);
        userList.add(user3);

        //1. 根据集合中名字进行分组
        Map<String, List<TbUser>> usernameGroupMap = userList.stream().collect(Collectors.groupingBy(TbUser::getName));
        //2. 按照名字分组之后，每一组根据电话号码进行从小到大排序， 顺序
        HashMap<String, List<TbUser>> groupThenOrderByIdAscMap = userList.stream()
                .collect(Collectors.groupingBy(TbUser::getName,
                                                HashMap::new,
                                                Collectors.collectingAndThen(Collectors.toList(),
                                                list -> list.stream()
                                                        .sorted(Comparator.comparing(TbUser::getTel))
                                                        .collect(Collectors.toList()))));
        //3.  按照名字分组之后，每一组根据电话号码进行从大到小排序， 也就是逆序， 和上一个相比，就是多了一个reversed()
        HashMap<String, List<TbUser>> groupThenOrderByIdDescMap = userList.stream()
                .collect(Collectors.groupingBy(TbUser::getName,
                                                HashMap::new,
                                                Collectors.collectingAndThen(Collectors.toList(),
                                                list -> list.stream()
                                                        .sorted(Comparator.comparing(TbUser::getTel).reversed())
                                                        .collect(Collectors.toList()))));

        //4， 按照名字分组之后，然后先根据i根据电话号码进行从小到大排序， 号码一样的再根据id从小到大排序
        HashMap<String, List<TbUser>> ordersMap = userList.stream()
                .collect(Collectors.groupingBy(TbUser::getName,
                                                HashMap::new,
                                                Collectors.collectingAndThen(Collectors.toList(),
                                                list -> list.stream()
                                                        .sorted(Comparator.comparing(TbUser::getTel)
                                                                .thenComparing(TbUser::getId))
                                                        .collect(Collectors.toList()))));
    }

 

 

5. excel导出的时候，设置序列，实现的效果如下所示，还有其他的一些数据校验

 

 

//设置数字范围
public void excelRuleNumberBetween(Sheet sheet, int min, int max, int firstRow, int lastRow, int firstCol, int lastCol){
        DataValidationHelper helper = sheet.getDataValidationHelper();
        CellRangeAddressList addressList = new CellRangeAddressList(firstRow, lastRow, firstCol, lastCol);//设置行列范围
        //设置数据
        DataValidationConstraint constraint = helper.createIntegerConstraint(DataValidationConstraint.OperatorType.BETWEEN,
                String.valueOf(min),String.valueOf(max));
        DataValidation dataValidation = helper.createValidation(constraint, addressList);
        dataValidation.createErrorBox("输入值类型或大小有误", String.format("请输入%s~%s之间的数值",min,max));
        //处理Excel兼容性问题
        if(dataValidation instanceof XSSFDataValidation) {
            dataValidation.setSuppressDropDownArrow(true);
            dataValidation.setShowErrorBox(true);
        }else {
            dataValidation.setSuppressDropDownArrow(false);
        }
        sheet.addValidationData(dataValidation);
    }


//设置校验序列
public void excelRuleSelect(Sheet sheet, String[] rule, int firstRow, int lastRow, int firstCol, int lastCol) {
        DataValidationHelper helper = sheet.getDataValidationHelper();
        CellRangeAddressList addressList = new CellRangeAddressList(firstRow, lastRow, firstCol, lastCol);
        DataValidationConstraint constraint = helper.createExplicitListConstraint(rule);
        DataValidation dataValidation = helper.createValidation(constraint, addressList);
        dataValidation.createErrorBox("输入有误", "请选择下拉参数");
        if (dataValidation instanceof XSSFDataValidation) {
            dataValidation.setSuppressDropDownArrow(true);
            dataValidation.setShowErrorBox(true);
        } else {
            dataValidation.setSuppressDropDownArrow(false);
        }
 
        sheet.addValidationData(dataValidation);
    }


//列数据每个数据唯一
public void excelRuleUniqueue(Sheet sheet, int firstRow, int lastRow, int firstCol, int lastCol) {
        Row row = sheet.getRow(0);
        Cell cell = row.getCell(firstCol);
        String r = ((XSSFCell) cell).getCTCell().getR();
        r = r.substring(0, 1);
        DataValidationHelper helper = sheet.getDataValidationHelper();
        CellRangeAddressList addressList = new CellRangeAddressList(firstRow, lastRow, firstCol, lastCol);
        //唯一
        DataValidationConstraint constraint = helper.createCustomConstraint(MessageFormat.format("COUNTIF({0}:{0},{0}2)=1",r));
        DataValidation dataValidation = helper.createValidation(constraint, addressList);
        dataValidation.createErrorBox("错误：", "赋值属性列不允许重复");
        dataValidation.setShowErrorBox(true);
        dataValidation.setEmptyCellAllowed(true);
        dataValidation.setSuppressDropDownArrow(true);
        dataValidation.setShowPromptBox(true);
        dataValidation.setErrorStyle(DataValidation.ErrorStyle.STOP);
 
        sheet.addValidationData(dataValidation);
    }

 

6. springboot项目文件上传的单元测试

　　有的时候单元测试比直接用postman等工具方便点，看实际的情况

   //单元测试，Excel上传：
   //@Autowired
    TestUploadController testUploadController;

    @Test
    public void uploadStayOutTest() throws Exception {

        File file = new File("C:\\Users\\c\\Downloads\\测试文件导入.xlsx");
        FileInputStream fileInputStream = new FileInputStream(file);
        MockMultipartFile multipartFile = new MockMultipartFile(file.getName(), file.getName(),
                ContentType.APPLICATION_OCTET_STREAM.toString(), fileInputStream);
        WageOrderInfoRequestDto infoDto = new WageOrderInfoRequestDto();
        infoDto.setIncmType(1);
        infoDto.setBusiYm("201906");
        infoDto.setWageDate("20190614");
        infoDto.setChangeFlag(2);
        infoDto.setEmpName("张三");
        infoDto.setIdCode("1304211989707080323");
        infoDto.setProbDesc("");
        infoDto.setRemark("验证");
        infoDto.setWageReaSendDate(DateUtil.getDate(new Date()));
        testUploadController.uploadStayOut(multipartFile,infoDto);

    }

 

7. mybatis  xml文件使用foreach实现批量更新

　　如果多笔数据的字段都要更新一样的，就没必要用下面这种方式，去掉<trim>直接写setxxx=#{xxx}就行了

   <update id="updateBatch" parameterType="java.util.List">
        update mydata_table
        <trim prefix="set" suffixOverrides=",">
            <trim prefix="status =case" suffix="end,">
                 <foreach collection="list" item="item" index="index">
                     <if test="item.status !=null ">
                         when id=#{item.id} then #{item.status}
                     </if>                    
                 </foreach>
            </trim>
        </trim>
        where id in
        <foreach collection="list" index="index" item="item" separator="," open="(" close=")">
            #{item.id,jdbcType=BIGINT}
        </foreach>
    </update>

 

 

8. mybatis的xml中批量新增

<insert id="insertList" parameterType="java.util.List">
        insert into t_enterprise_water_ele
        (
        WATER_ELE_ID,
        ENTERPRISE_ID,
        ENTERPRISE_USCC,
        ENTERPRISE_NAME,
        YEARMONTH,
        WATER_SIZE,
        WATER_AMOUNT,
        ELE_SIZE,
        ELE_AMOUNT,
        STATUS,
        OPERATOR,
        OPERATE_TIME
        )
        VALUES
        <foreach collection="list" item="item" index="index" separator=",">
            (
            #{item.waterEleId,jdbcType=VARCHAR},
            #{item.enterpriseId,jdbcType=VARCHAR},
            #{item.enterpriseUscc,jdbcType=VARCHAR},
            #{item.enterpriseName,jdbcType=VARCHAR},
            #{item.yearmonth,jdbcType=VARCHAR},
            #{item.waterSize,jdbcType=DECIMAL},
            #{item.waterAmount,jdbcType=VARCHAR},
            #{item.eleSize,jdbcType=DOUBLE},
            #{item.eleAmount,jdbcType=VARCHAR},
            #{item.status,jdbcType=INTEGER},
            #{item.operator,jdbcType=VARCHAR},
            #{item.operateTime,jdbcType=TIMESTAMP}
            )
        </foreach>
    </insert>

 

 

9 使用mybatis-plus进行单表查询/更新

尽量使用LambdaQueryWrapper/LambdaUpdateWrapper  去做条件拼接，这样拼接条件的key使用的是类似TestUser::getAge的方式，减少硬编码，防止直接写字符串“age”拼错了，要排查好半天

@Slf4j
@Service
public class TestUserServiceImpl extends ServiceImpl<TestUserMapper, TestUser> implements TestUserService {
    @Override
    public String testMethod() {
        String userName = "王";
        Integer age = 18;
        LambdaQueryWrapper<TestUser> queryWrapper = Wrappers.<TestUser>lambdaQuery()
                .eq(TestUser::getAge, age)
                .like(StringUtils.isNotBlank(userName),TestUser::getUserNmae, userName);//%王%
        List<TestUser> userList = list(queryWrapper);
        //做后续处理
        
        return null;
    }
}

 

 10. 使用反射操作对象的List属性

public class Reflact {
    public static void main(String[] args) throws Exception {

//测试方法
        List<Room> rooms = new ArrayList<Room>();
        rooms.add(new Room(1,"大浪",100.0));
        rooms.add(new Room(2,"xiao浪",101.0));
        User u =new User("zhangsan", 18, rooms);
        doWithR(u);
    }
    static void doWithR(Object obj) throws Exception{
        Field[] fields = obj.getClass().getDeclaredFields();
        for (Field f : fields) {
            if(!f.isAccessible()){
                f.setAccessible(true);//赋权使用，否则private类型是无法操作的
            }
            if(List.class.isAssignableFrom(f.getType())){//判断是否为list
                Type t = f.getGenericType();
                if(t instanceof ParameterizedType){
                    //ParameterizedType pt = (ParameterizedType)t;
                    //Class clz = (Class)pt.getActualTypeArguments()[0];
                    Class clazz = f.get(obj).getClass();//获取对象list属性的class
                    Method m = clazz.getDeclaredMethod("size");//获取list属性的size方法
                    int  size = (Integer)m.invoke(f.get(obj));//调用size方法
                    for(int i = 0; i < size; i++){//根据size大小循环
                        Method getM = clazz.getDeclaredMethod("get", int.class);//获取list属性的get方法
                        //System.out.println(getM);
                        Object u = getM.invoke(f.get(obj), i);//调用get方法获取list中的对象
                        doWithR(u);//若list中还有list可以递归调用
                        //测试是否可以获取到list中对象的属性的值
                        Field[] uf = u.getClass().getDeclaredFields();
                        for (Field fu : uf) {
                            if(!fu.isAccessible())
                                fu.setAccessible(true);
                            System.out.println(fu.get(u));
                        }
                    }
                }
            }
        }
    }
}

 

11. 获取ip的工具类方法

/**
 * IP地址
 */
public class IPUtils {

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

    /**
     * 获取IP地址
     * 使用Nginx等反向代理软件， 则不能通过request.getRemoteAddr()获取IP地址
     * 如果使用了多级反向代理的话，X-Forwarded-For的值并不止一个，而是一串IP地址，X-Forwarded-For中第一个非unknown的有效IP字符串，则为真实IP地址
     */
    public static String getIpAddr(HttpServletRequest request) {
        String ip = null;
        try {
            ip = request.getHeader("x-forwarded-for");
            if (StringUtils.isEmpty(ip) || "unknown".equalsIgnoreCase(ip)) {
                ip = request.getHeader("Proxy-Client-IP");
            }
            if (StringUtils.isEmpty(ip) || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
                ip = request.getHeader("WL-Proxy-Client-IP");
            }
            if (StringUtils.isEmpty(ip) || "unknown".equalsIgnoreCase(ip)) {
                ip = request.getHeader("HTTP_CLIENT_IP");
            }
            if (StringUtils.isEmpty(ip) || "unknown".equalsIgnoreCase(ip)) {
                ip = request.getHeader("HTTP_X_FORWARDED_FOR");
            }
            if (StringUtils.isEmpty(ip) || "unknown".equalsIgnoreCase(ip)) {
                ip = request.getRemoteAddr();
            }
        } catch (Exception e) {
            logger.error("IPUtils ERROR ", e);
        }
        // 使用代理，则获取第一个IP地址
        if (StringUtils.isEmpty(ip) && ip.length() > 15) {
            if (ip.indexOf(",") > 0) {
                ip = ip.substring(0, ip.indexOf(","));
            }
        }
        return ip;
    }
}

 

 12. 获取当前方法的名字

String methodName = Thread.currentThread().getStackTrace()[1].getMethodName();

 

13. 使用nio进行文件的快速拷贝

public static void fileCopy( File in, File out )  
            throws IOException  
    {  
        FileChannel inChannel = new FileInputStream( in ).getChannel();  
        FileChannel outChannel = new FileOutputStream( out ).getChannel();  
        try 
        {  
//          inChannel.transferTo(0, inChannel.size(), outChannel);      // original -- apparently has trouble copying large files on Windows  

            // magic number for Windows, 64Mb - 32Kb)  
            int maxCount = (64 * 1024 * 1024) - (32 * 1024);  
            long size = inChannel.size();  
            long position = 0;  
            while ( position < size )  
            {  
               position += inChannel.transferTo( position, maxCount, outChannel );  
            }  
        }  
        finally 
        {  
            if ( inChannel != null )  
            {  
               inChannel.close();  
            }  
            if ( outChannel != null )  
            {  
                outChannel.close();  
            }  
        }  
    }

 

14.创建文件的缩略图

private void createThumbnail(String filename, int thumbWidth, int thumbHeight, int quality, String outFilename)  
        throws InterruptedException, FileNotFoundException, IOException  
    {  
        // load image from filename  
        Image image = Toolkit.getDefaultToolkit().getImage(filename);  
        MediaTracker mediaTracker = new MediaTracker(new Container());  
        mediaTracker.addImage(image, 0);  
        mediaTracker.waitForID(0);  
        // use this to test for errors at this point: System.out.println(mediaTracker.isErrorAny());  

        // determine thumbnail size from WIDTH and HEIGHT  
        double thumbRatio = (double)thumbWidth / (double)thumbHeight;  
        int imageWidth = image.getWidth(null);  
        int imageHeight = image.getHeight(null);  
        double imageRatio = (double)imageWidth / (double)imageHeight;  
        if (thumbRatio < imageRatio) {  
            thumbHeight = (int)(thumbWidth / imageRatio);  
        } else {  
            thumbWidth = (int)(thumbHeight * imageRatio);  
        }  

        // draw original image to thumbnail image object and  
        // scale it to the new size on-the-fly  
        BufferedImage thumbImage = new BufferedImage(thumbWidth, thumbHeight, BufferedImage.TYPE_INT_RGB);  
        Graphics2D graphics2D = thumbImage.createGraphics();  
        graphics2D.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);  
        graphics2D.drawImage(image, 0, 0, thumbWidth, thumbHeight, null);  

        // save thumbnail image to outFilename  
        BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(outFilename));  
        JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(out);  
        JPEGEncodeParam param = encoder.getDefaultJPEGEncodeParam(thumbImage);  
        quality = Math.max(0, Math.min(quality, 100));  
        param.setQuality((float)quality / 100.0f, false);  
        encoder.setJPEGEncodeParam(param);  
        encoder.encode(thumbImage);  
        out.close();  
    }

 

15. spring中bean初始化之后，获取注解标注的一些Bean, 然后获取到了这些Bean后我们可以保存到我们自己设置的Map中，后续业务层去调用

@Component
public class BeanListener implements ApplicationListener<ContextRefreshedEvent> {

    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        // 根容器为Spring容器
        if (event.getApplicationContext().getParent() == null) {
            Map<String, Object> beans = event.getApplicationContext().getBeansWithAnnotation(TestSheet.class);
            for (Object bean : beans.values()) {
                System.err.println(bean == null ? "null" : bean.getClass().getName());
            }
            System.err.println("=====ContextRefreshedEvent=====" + event.getSource().getClass().getName());
        }
    }
}

 

 

16. 基于POI的excel的导出功能，包含一级标题，二级标题，表头，统计列，对某几列进行码值转换

注解ExcelSheet：

package com.example.demo.excel;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface ExcelSheet {

    /**
    * @Description:  sheet名称
    * @Param: []
    * @return: java.lang.String
    * @Date: 2023/6/29
    */
    String sheetName();
    /**
    * @Description:  标题名称
    * @Param: []
    * @return: java.lang.String
    * @Date: 2023/6/29
    */
    String titleName();
    /*
    是否显示序号列，默认显示
    */
    boolean showIndexColumn() default true;

}

 

注解ExcelColumn：

package com.example.demo.excel;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface ExcelColumn {
    /**
     * @Title: title
     * @Description: 表头列名 必填
     */
    String columnName();

    /**
     * 列的序号，意思就是把添加这个注解的属性要放到excel的第几列，从1开始
     * 需要注意的是：这个值必须连续，比如：各个属性的sort必须是：1，3，2，4，6，5（可以乱序）
     * 但是不能出现：1，3，4，6，5（少了2）
     */
    int sort();

    /**
     * @Title: width
     * @Description: 列宽 默认15
     */
    short width() default 20;

    enum Alignment {
        LEFT(0x1), CENTER(0x2), RIGHT(0x3);
        private int value;

        private Alignment(int value) {
            this.value = value;
        }

        public int getValue() {
            return value;
        }
    }

    ;

    /**
     * @Title: alignment
     * @Description: 文字样式 默认居中(Alignment.CENTER)
     */
    Alignment alignment() default Alignment.CENTER;

    /**
     * @Title: boder
     * @Description: 单元格是否需要边框 环绕包围 默认true
     */
    boolean boder() default true;

    enum StyleColor {
        WHITE(0x9), BLACK(0x8), BLUE(0xc), RED(0xa), YELLOW(0xd);
        private int value;

        private StyleColor(int value) {
            this.value = value;
        }

        public int getValue() {
            return value;
        }
    }

    ;

    /**
     * @Title: styleColor
     * @Description: 单元格背景色 默认白色
     */
    StyleColor styleColor() default StyleColor.WHITE;

    enum FontColor {
        BLACK(0x8), BLUE(0xc), RED(0xa), YELLOW(0xd);
        private int value;

        private FontColor(int value) {
            this.value = value;
        }

        public int getValue() {
            return value;
        }
    }

    ;

    /**
     * @Title: fontColor
     * @Description: 文字颜色 默认黑色(FontColor.BLACK) 暂支持 BLACK BLUE RED YELLO
     */
    FontColor fontColor() default FontColor.BLACK;

    /**
     * @Title: fontSize
     * @Description: 字号大小 默认12
     */
    short fontSize() default 12;

    /**
     * @Title: fontName
     * @Description: 字体 默认微软雅黑
     */
    String fontName() default "微软雅黑";

    /**
     * 操作类型
     * @return
     */
    OperatorType opertorType() default OperatorType.BLANK;

    enum OperatorType {
        SUM("sum"),BLANK("blank");
        private String value;

        private OperatorType(String value) {
            this.value = value;
        }

        public String getValue() {
            return value;
        }
    }

    String operatorDescription() default "总计";


    /**
     * 枚举类型的class
     * 取值：getValue, getCode, getStatus, name
     * 描述：getDesc
     *
     * @return 字典类型
     */
    Class<? extends Enum<?>> convertEnumType() default Void.class;
    enum Void {}

    /*
    枚举中转换的方法名称
     */
    String convertEnumMethodName() default "";
}

 

　　ExcelFieldMetadata类：

package com.example.demo.excel;

import java.lang.reflect.Field;
import java.text.SimpleDateFormat;

/**
 * @author
 * @title ExcelFieldType
 * @date 2023/7/1 1:00
 * @description 对于导出的列的元数据描述
 */
public class ExcelFieldMetadata {
    /*
    序号列, 后续扩展
     */
    private boolean index;

    /*
    列号 从0开始
     */
    private Integer sort;
    /**
     * 列名
     */
    private String columnName;

    /*
    列宽
     */
    private Short columnWidth;
    /*
    文本样式，左对齐，右对齐，居中
     */
    private Integer align;

    /*
    是否需要边框
     */
    private Boolean border;

    /*
    字体颜色
     */
    private int fontColor;

    /*
    字体名字
     */
    private String fontName;

    /*
    字号
     */
    private Short fontSize;

    /*
    单元格背景颜色
     */
    private int styleColor;

    /*
    属性值
     */
    private Field field;
    /*
    excelColumn注解
     */
    private ExcelColumn excelColumn;

    /*
     日期格式化对象
     */
    private SimpleDateFormat dateFormat;


    /*
    转换的枚举类
     */
    private Class<? extends Enum<?>> convertEnumType;
    /*
    用于转换的枚举类的指定方法
     */
    private String convertEnumMethodName;

    public ExcelFieldMetadata() {
    }

    public boolean isIndex() {
        return index;
    }

    public ExcelFieldMetadata setIndex(boolean index) {
        this.index = index;
        return this;
    }

    public Integer getSort() {
        return sort;
    }

    public ExcelFieldMetadata setSort(Integer sort) {
        this.sort = sort;
        return this;
    }

    public String getColumnName() {
        return columnName;
    }

    public ExcelFieldMetadata setColumnName(String columnName) {
        this.columnName = columnName;
        return this;
    }

    public Short getColumnWidth() {
        return columnWidth;
    }

    public ExcelFieldMetadata setColumnWidth(Short columnWidth) {
        this.columnWidth = columnWidth;
        return this;
    }

    public Integer getAlign() {
        return align;
    }

    public ExcelFieldMetadata setAlign(Integer align) {
        this.align = align;
        return this;
    }

    public Boolean getBorder() {
        return border;
    }

    public ExcelFieldMetadata setBorder(Boolean border) {
        this.border = border;
        return this;
    }

    public int getFontColor() {
        return fontColor;
    }

    public ExcelFieldMetadata setFontColor(int fontColor) {
        this.fontColor = fontColor;
        return this;
    }

    public String getFontName() {
        return fontName;
    }

    public ExcelFieldMetadata setFontName(String fontName) {
        this.fontName = fontName;
        return this;
    }

    public Short getFontSize() {
        return fontSize;
    }

    public ExcelFieldMetadata setFontSize(Short fontSize) {
        this.fontSize = fontSize;
        return this;
    }

    public int getStyleColor() {
        return styleColor;
    }

    public ExcelFieldMetadata setStyleColor(int styleColor) {
        this.styleColor = styleColor;
        return this;
    }

    public Field getField() {
        return field;
    }

    public ExcelFieldMetadata setField(Field field) {
        this.field = field;
        return this;
    }

    public ExcelColumn getExcelColumn() {
        return excelColumn;
    }

    public ExcelFieldMetadata setExcelColumn(ExcelColumn excelColumn) {
        this.excelColumn = excelColumn;
        return this;
    }

    public Class<? extends Enum<?>> getConvertEnumType() {
        return convertEnumType;
    }

    public ExcelFieldMetadata setConvertEnumType(Class<? extends Enum<?>> convertEnumType) {
        this.convertEnumType = convertEnumType;
        return this;
    }

    public String getConvertEnumMethodName() {
        return convertEnumMethodName;
    }

    public ExcelFieldMetadata setConvertEnumMethodName(String convertEnumMethodName) {
        this.convertEnumMethodName = convertEnumMethodName;
        return this;
    }

    public SimpleDateFormat getDateFormat() {
        return dateFormat;
    }

    public ExcelFieldMetadata setDateFormat(SimpleDateFormat dateFormat) {
        this.dateFormat = dateFormat;
        return this;
    }
}

　　

MallExcelUtils工具类：

package com.example.demo.excel;

import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import org.apache.commons.codec.binary.Base64;
import org.apache.commons.collections4.MapUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.poi.hssf.usermodel.HSSFRichTextString;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.ss.util.CellRangeAddress;
import org.apache.poi.xssf.streaming.SXSSFWorkbook;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.CollectionUtils;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.net.URLEncoder;
import java.text.SimpleDateFormat;
import java.util.*;


/**
 * @param <T>
 * @Description excel导出工具类
 * <p>
 * 使用示例:
 * List<User> list = getList();
 * new MallExcelUtils<User>()
 * .setClazz(User.class)//实体类类型
 * .setSecondRowLeftAndRight("操作时间：2023-06-12至2023-06-30","导出人：小王")
 * .setSecondLevelHeader(Collections.singletonList("二级标题#3,4,1,3"))//二级标题  内容#firstRow,lastRow,firstColumn,lastColumn
 * .setDataList(list)//实际的数据集合
 * .setFullFileName("test.xls")//导出文件的名称
 * .initlization()//开始初始化
 * .exportExcel(request,response);//实际以流的方式导出
 * @Date: 2023年6月28日 11:03:31
 * @Author: 
 */
public class MallExcelUtils<T> {

    public static Logger log = LoggerFactory.getLogger(MallExcelUtils.class);//日志记录

    /*
    导出目标类的Class对象
     */
    private Class<T> clazz;
    /*
    sheet名称
     */
    private String sheetName;
    /*
    标题内容
     */
    private String titleName;
    /**
     * 统计的开始和结束时间
     */
    private String leftData;
    /**
     * 填表人
     */
    private String rightData;

    /*
    实际的业务数据
     */
    private List<T> dataList;

    /*
    导出的文件名称
     */
    private String fullFileName;
    /*
    文件扩展名
     */
    private String ext;
    /*
    要合并的表头数组
     */
    private List<String> secondLevelHeader = Collections.emptyList();
    /*
    导出列的元数据类型
     */
    private final List<ExcelFieldMetadata> excelFieldMetadataList = Lists.newArrayList();

    /*
    fieldName->Annotation, 当注解中opertorType不为BLANK的时候需要收集起来，后续对该列做处理，例如累加
     */
    private final Map<String, ExcelColumn> fieldNameToAnnOperatorMap = Maps.newHashMap();
    /*
    fieldName->finallyValue， 将对字段的特殊操作的值存放起来
     */
    private final Map<String, Object> fieldNameToFinalValueMap = Maps.newHashMap();//求和
    /**
     * 当前的行
     */
    private Integer currentRowIndex = 0;

    /*
    支持的文件扩展名
     */
    public static List<String> allowExtList = Arrays.asList(".xls", ".xlsx");
    /*
    是否显示序号列标志
     */
    private boolean showIndexColumn = false;

    public MallExcelUtils() {
    }

    public MallExcelUtils<T> setClazz(Class<T> clazz) {
        this.clazz = clazz;
        return this;
    }

    /*
   设置第二行两个靠边的单元格的值，可以存放时间和操作人信息
   */
    public MallExcelUtils<T> setSecondRowLeftAndRight(String leftData, String rightData) {
        this.leftData = leftData;
        this.rightData = rightData;
        return this;
    }

    public MallExcelUtils<T> setSecondLevelHeader(List<String> secondLevelHeader) {
        this.secondLevelHeader = secondLevelHeader;
        return this;
    }


    public MallExcelUtils<T> setDataList(List<T> dataList) {
        this.dataList = dataList;
        return this;
    }

    public MallExcelUtils<T> setFullFileName(String fullFileName) {
        if (StringUtils.isEmpty(fullFileName)) {
            throw new IllegalArgumentException("文件名称为空");
        }
        if (!fullFileName.contains(".")) {
            throw new IllegalArgumentException("文件名称格式不对:" + fullFileName);
        }
        int index = fullFileName.indexOf(".");
        ext = fullFileName.substring(index);//excel后缀名
        if (!allowExtList.contains(ext)) {
            throw new IllegalArgumentException("文件扩展名只能为[.xls]或[.xlsx]");
        }
        this.fullFileName = fullFileName;
        return this;
    }


    public MallExcelUtils<T> initlization() {
        //初始化sheet名称和sheet中大标题
        initSheetNameAndTitle();
        //初始化元数据
        initMetadataList();
        return this;
    }


    /**
     * @Description: 初始化sheetName名称和标题
     * @Param: []
     * @return: void
     * @Date: 2023/7/1
     */
    private void initSheetNameAndTitle() {
        if (!this.clazz.isAnnotationPresent(ExcelSheet.class)) {
            throw new IllegalStateException("实体类中导出Excel没有配置ExcelSheet注解，实体类为:" + this.clazz.getName());
        }
        ExcelSheet excelSheet = this.clazz.getAnnotation(ExcelSheet.class);
        //sheet名称
        String sheetName = excelSheet.sheetName();
        //一级标题名称
        String titleName = excelSheet.titleName();
        if (StringUtils.isEmpty(sheetName)) {
            this.sheetName = "sheet1";
        } else {
            this.sheetName = sheetName;
        }
        if (StringUtils.isEmpty(titleName)) {
            this.titleName = "";
        } else {
            this.titleName = titleName;
        }

        //是否显示序号列标志
        this.showIndexColumn = excelSheet.showIndexColumn();
    }

    /**
     * @Description: 初始化元数据
     * @Param: []
     * @return: void
     * @Date: 2023/7/1
     */
    private void initMetadataList() {
        ExcelFieldMetadata excelFieldMetadata = null;
        //如果有序号列，第一个就是序号的Metadata
        if (showIndexColumn){
            excelFieldMetadata = new ExcelFieldMetadata()
                    .setIndex(true)
                    .setSort(0)
                    .setColumnName("序号")
                    .setColumnWidth((short) 20)
                    .setAlign(ExcelColumn.Alignment.CENTER.getValue())
                    .setBorder(true)
                    .setFontColor(ExcelColumn.FontColor.BLACK.getValue())
                    .setFontName("微软雅黑")
                    .setFontSize((short) 12)
                    .setStyleColor(ExcelColumn.StyleColor.WHITE.getValue());
            excelFieldMetadataList.add(excelFieldMetadata);
        }

        //实际遍历每个属性
        for (Field field : clazz.getDeclaredFields()) {
            if (!field.isAnnotationPresent(ExcelColumn.class)) {
                continue;
            }
            //设置field访问权限
            field.setAccessible(true);
            ExcelColumn excelColumn = field.getAnnotation(ExcelColumn.class);
            excelFieldMetadata = new ExcelFieldMetadata()
                    .setField(field)
                    .setColumnName(excelColumn.columnName())
                    .setColumnWidth(excelColumn.width())
                    .setAlign(excelColumn.alignment().getValue())
                    .setBorder(excelColumn.boder())
                    .setFontColor(excelColumn.fontColor().getValue())
                    .setFontName(excelColumn.fontName())
                    .setFontSize(excelColumn.fontSize())
                    .setStyleColor(excelColumn.styleColor().getValue())
                    .setConvertEnumType(excelColumn.convertEnumType())//用于转换的枚举类
                    .setConvertEnumMethodName(excelColumn.convertEnumMethodName());//用于转换的枚举类的指定方法
            //日期格式化
            if (StringUtils.isNotBlank(excelColumn.dateFormat())){
                excelFieldMetadata.setDateFormat(new SimpleDateFormat(excelColumn.dateFormat()));
            }

            //是否展示序号列来判断其他字段的列号
            if (showIndexColumn){
                excelFieldMetadata.setSort(excelColumn.sort());
            }else{
                excelFieldMetadata.setSort(excelColumn.sort()-1);
            }

            excelFieldMetadataList.add(excelFieldMetadata);
            //这里新增对列的操作，除了Blank的都保存起来
            ExcelColumn.OperatorType operatorType = excelColumn.opertorType();
            if (!ExcelColumn.OperatorType.BLANK.getValue().equals(operatorType.getValue())) {
                fieldNameToAnnOperatorMap.put(field.getName(), excelColumn);
            }
            //排序
            Collections.sort(excelFieldMetadataList, new Comparator<ExcelFieldMetadata>() {
                @Override
                public int compare(ExcelFieldMetadata o1, ExcelFieldMetadata o2) {
                    return o1.getSort() - o2.getSort();
                }
            });
        }
    }


    /**
     * @Description: 导出excel的方法
     * @Param: [dataList 实际的数据, request 请求, response 响应, fullFileName 文件全名称]
     * @return: void
     * @Date: 2023/7/1
     */
    public void exportExcel(HttpServletRequest request, HttpServletResponse response) {
        if (StringUtils.isEmpty(fullFileName)) {
            throw new IllegalArgumentException("未初始化导出文件名称，请首先初始化");
        }
        //根据后缀名得到工作簿对象
        Workbook workbook = getWorkBook();
        //创建sheet页
        creatSheet(workbook, dataList);
        //下载文件
        downloadFile(workbook, request, response, fullFileName);

    }

    /**
     * 创建sheet
     */
    private void creatSheet(Workbook workbook, List<T> dataList) {
        if (CollectionUtils.isEmpty(dataList)) {
            return;
        }
        //1. 新建一个sheet
        Sheet sheet = workbook.createSheet(sheetName);

        // 2. 循环设置列宽
        for (int i = 0; i < excelFieldMetadataList.size(); i++) {
            sheet.setColumnWidth(i, excelFieldMetadataList.get(i).getColumnWidth() * 256);
        }

        // 3. 产生表格标题行，标题行是第一行
        createTitle(workbook, sheet);

        //4. 设置附加信息，有设置的话就在第二行
        if (StringUtils.isNotBlank(leftData) || StringUtils.isNotBlank(rightData)) {
            createAttachRow(workbook, sheet);
        }

        // 5. 合并表头行设置
        if (!CollectionUtils.isEmpty(secondLevelHeader)) {
            createSecondHeader(workbook, sheet);
        }

        //生6. 成表头行，用的header中的数据
        createHeader(workbook, sheet);

        // 7. 遍历集合数据，产生数据行
        parseDataListToSheet(workbook, sheet, dataList);
    }


    /**
     * @Description: 创建一行是时间和导出人
     * @Param: [startAndEndDate, fillFormatPerson]
     * @return: void
     * @Date: 2023/6/29
     */
    private void createAttachRow(Workbook workbook, Sheet sheet) {
        Row row = sheet.createRow(currentRowIndex);
        //创建一个边框的样式
        CellStyle borderStyle = createBorderCellStyle(workbook);
        //如果只有两列，就不要做什么合并单元格了
        int totalColumn = excelFieldMetadataList.size();
        for (int i = 0; i < totalColumn; i++) {
            Cell dateCell = row.createCell(i);
            dateCell.setCellStyle(borderStyle);
        }

        if (totalColumn <= 4) {
            Cell dateCell = row.getCell(0);
            dateCell.setCellValue(leftData);
            Cell personCell = row.getCell(totalColumn - 1);
            personCell.setCellValue(rightData);
            return;
        }
        Cell dateCell = row.getCell(0);
        dateCell.setCellValue(leftData);
        Cell personCell = row.getCell(totalColumn - 2);
        personCell.setCellValue(rightData);
        CellRangeAddress dateAddress = new CellRangeAddress(currentRowIndex, currentRowIndex, 0, 1);

        sheet.addMergedRegion(dateAddress);//设置合并
        CellRangeAddress personAddress = new CellRangeAddress(currentRowIndex, currentRowIndex, totalColumn - 2, totalColumn - 1);

        sheet.addMergedRegion(personAddress);//设置合并
        currentRowIndex++;
    }

    /*
    创建有边框的样式
     */
    private CellStyle createBorderCellStyle(Workbook workbook) {
        // 生成一个通用样式 默认背景为白色
        CellStyle borderStyle = workbook.createCellStyle();
        borderStyle.setFillForegroundColor((short) ExcelColumn.StyleColor.WHITE.getValue());

        // 单元格内容样式
        borderStyle.setAlignment(HorizontalAlignment.CENTER);
        borderStyle.setVerticalAlignment(VerticalAlignment.CENTER);

        // 单元格是否需要边框
        borderStyle.setFillPattern(FillPatternType.SOLID_FOREGROUND);
        borderStyle.setBorderBottom(BorderStyle.THIN);
        borderStyle.setBorderLeft(BorderStyle.THIN);
        borderStyle.setBorderRight(BorderStyle.THIN);
        borderStyle.setBorderTop(BorderStyle.THIN);
        return borderStyle;
    }

    /**
     * @Description: 根据表头数组信息合并行
     * @Param: [workbook, sheet]
     * @return: void
     * @Date: 2023/7/1
     */
    private void createSecondHeader(Workbook workbook, Sheet sheet) {
        Row row = sheet.createRow(currentRowIndex++);//第二行是合并表头的行，行号为1
        CellStyle borderStyle = createBorderCellStyle(workbook);//创建一个样式
        Font font = createFont(workbook, (short) 20, true);
        borderStyle.setFont(font);// 把字体应用到当前的样式

        String[] zuoBiaoArr;
        int colIndex = 0;//列起始行号
        Cell cell = null;
        //影响的行数
        int effectRowNum = 0;
        for (String s : secondLevelHeader) {
            String[] valueArr = s.split("#");
            String cellValue = valueArr[0];//单元格内容
            //二级标题内容#int firstRow, int lastRow, int firstCol, int lastCol
            zuoBiaoArr = valueArr[1].split(",");
            String firstRow = zuoBiaoArr[0];
            String lastRow = zuoBiaoArr[1];
            String firstColumn = zuoBiaoArr[2];
            String lastColumn = zuoBiaoArr[3];
            if (Integer.parseInt(firstRow) > Integer.parseInt(lastRow)) {
                throw new IllegalArgumentException("二级标题参数有误，起始行序号大于结束行序号");
            }
            if (Integer.parseInt(firstColumn) > Integer.parseInt(lastColumn)) {
                throw new IllegalArgumentException("二级标题参数有误，起始列序号大于结束列序号");
            }
            for (int i = Integer.parseInt(firstRow) - 1; i < Integer.parseInt(lastRow); i++) {
                Row newRow = sheet.getRow(i);
                if (newRow == null) {
                    sheet.createRow(i);
                    currentRowIndex++;
                }
            }

            colIndex = Integer.parseInt(firstColumn) - 1;
            cell = row.createCell(colIndex);//得到列
            cell.setCellStyle(borderStyle);//设置样式
            cell.setCellValue(cellValue);//设置内容
            CellRangeAddress cellAddresses = new CellRangeAddress(Integer.parseInt(firstRow) - 1,
                    Integer.parseInt(lastRow) - 1, Integer.parseInt(firstColumn) - 1, Integer.parseInt(lastColumn) - 1);
            //合并单元格
            mergeColumnsStyle(sheet, cellAddresses, borderStyle);
            sheet.addMergedRegion(cellAddresses);
        }
    }

    /**
     * 循环遍历，把数据设置到表格中的方法
     *
     * @param workbook 工作簿
     * @param sheet    sheet对象
     * @param dataList 数据集合
     */
    private void parseDataListToSheet(Workbook workbook, Sheet sheet, List<T> dataList) {
        Row row = null;
        Cell cell = null;
        for (int m = 0; m < dataList.size(); m++) {
            T t = dataList.get(m);
            row = sheet.createRow(currentRowIndex++);
            for (int i = 0; i < excelFieldMetadataList.size(); i++) {
                cell = row.createCell(i);
                ExcelFieldMetadata excelFieldMetadata = excelFieldMetadataList.get(i);
                boolean index = excelFieldMetadata.isIndex();
                //序号列
                if (index) {
                    styleToCell(workbook, cell, excelFieldMetadata, false);
                    cell.setCellValue(m+1);
                    continue;
                }
                Field field = excelFieldMetadata.getField();//获取属性
                //1. 调用方法进行样式设置
                styleToCell(workbook, cell, excelFieldMetadata, false);
                String fieldName = field.getName();//得到属性名称
                String fieldValue = null;//属性值
                try {
                    if (Date.class.equals(field.getType())) {
                        //日期转换
                        fieldValue = convertDate(t, field, excelFieldMetadata);
                    }else{
                        fieldValue = field.get(t) == null ? "" : field.get(t).toString();
                    }
                } catch (IllegalAccessException e) {
                    log.error("反射获取属性值失败" + fieldName);
                    e.printStackTrace();
                }

                //2. 处理对列的求和等操作
                try {
                    dealOpertorTypeToColunm(t, field);
                } catch (IllegalAccessException e) {
                    log.error("对Column的操作失败：" + fieldName);
                    e.printStackTrace();
                }

                //如果没有转换码值的列，就直接设置值返回啦
                if (excelFieldMetadata.getConvertEnumType().getSimpleName().equalsIgnoreCase("Void")) {
                    //向cell设置值
                    cell.setCellValue(fieldValue);
                    continue;
                }
                //3. 存在码值转换的场景
                try {
                    fieldValue = dealColumnConvert(t, excelFieldMetadata);
                } catch (Exception e) {
                    log.error("对Column的转换失败：" + fieldName);
                    e.printStackTrace();
                }
                cell.setCellValue(fieldValue);
            }
        }
        if (MapUtils.isEmpty(fieldNameToFinalValueMap)) {
            return;
        }
        //4. 处理最后统计行
        dealStaticRow(workbook, sheet);
    }

    /**
     * 日期转换
     * @param t
     * @param field
     * @return
     */
    private String convertDate(T t, Field field,ExcelFieldMetadata excelFieldMetadata) throws IllegalAccessException {
        SimpleDateFormat dateFormat = excelFieldMetadata.getDateFormat();
        Object o = field.get(t);
        if (o!=null && dateFormat!=null) {
            return dateFormat.format(field.get(t));
        }
        return "";
    }

    /**
     * @Description: 处理统计行
     * @Param: [workbook, sheet]
     * @return: void
     * @Date: 2023/7/1
     */
    private void dealStaticRow(Workbook workbook, Sheet sheet) {
        Row row = sheet.createRow(currentRowIndex++);
        //创建统计行的样式
        CellStyle staticCellStyle = createStaticCellStyle(workbook, true);
        //写入excel数据
        for (Map.Entry<String, Object> entry : fieldNameToFinalValueMap.entrySet()) {
            String fieldName = entry.getKey();
            //列号码和sort一样，sort从1开始
            ExcelColumn excelColumn = fieldNameToAnnOperatorMap.get(fieldName);
            int columnNum = 0;
            if (showIndexColumn){
                columnNum = excelColumn.sort();
            }else{
                columnNum = excelColumn.sort() - 1;
            }
            //"统计行"第一个单元格的值
            String operatorDescription = excelColumn.operatorDescription();
            Cell cell = null;
            for (int i = 0; i < excelFieldMetadataList.size(); i++) {
                Field field = excelFieldMetadataList.get(i).getField();
                cell = row.createCell(i);
                cell.setCellStyle(staticCellStyle);
                //首列单元格设置值
                if (i == 0) {
                    cell.setCellValue(operatorDescription);
                    continue;
                }
                //对指定列设置统计值
                if (i == columnNum) {
                    cell.setCellValue(fieldNameToFinalValueMap.get(field.getName()).toString());
                }
            }
        }
    }

    /**
     * @Description: 对列进行码值转换
     * @Param: [t, field]
     * @return: java.lang.String
     * @Date: 2023/7/1
     */
    private String dealColumnConvert(T t, ExcelFieldMetadata excelFieldMetadata) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
        Field field = excelFieldMetadata.getField();
        Class<? extends Enum<?>> convertEnumType = excelFieldMetadata.getConvertEnumType();
        String convertEnumMethodName = excelFieldMetadata.getConvertEnumMethodName();
        if (Integer.class.equals(field.getType())) {
            Method method = convertEnumType.getDeclaredMethod(convertEnumMethodName, Integer.class);
            Object[] ec = convertEnumType.getEnumConstants();
            Object obj = field.get(t);
            if (obj != null) {
                Integer fieldValueInt = (Integer) field.get(t);//属性值
                Object description = method.invoke(ec[0], fieldValueInt);
                return (String) description;
            }
        } else if (String.class.equals(field.getType())) {
            Method method = convertEnumType.getDeclaredMethod(convertEnumMethodName, String.class);
            Object[] ec = convertEnumType.getEnumConstants();
            Object obj = field.get(t);
            if (obj != null) {
                String fieldValueStr = field.get(t).toString();//属性值
                Object description = method.invoke(ec[0], fieldValueStr);
                return (String) description;
            }
        }
        return "";
    }

    /**
     * @Description: 对特殊的列进行特殊处理，比如对某列进行求和
     * @Param: [t, field, fieldName]
     * @return: void
     * @Date: 2023/7/1
     */
    private void dealOpertorTypeToColunm(T t, Field field) throws IllegalAccessException {
        String fieldName = field.getName();
        //对列做累加求和等操作，并把每次求和的操作保存到fieldNameToFinalValueMap中
        if (fieldNameToAnnOperatorMap.containsKey(fieldName)) {
            ExcelColumn excelColumn = fieldNameToAnnOperatorMap.get(fieldName);
            //累加操作, 现在至此String, Bigdecimal,Integer
            if (ExcelColumn.OperatorType.SUM.getValue().equals(excelColumn.opertorType().getValue())) {
                Object obj = field.get(t);
                if (obj == null) {
                    return;
                }
                //判断当前是数字还是金额
                if (BigDecimal.class.equals(field.getType())) {
                    if (fieldNameToFinalValueMap.containsKey(fieldName)) {
                        BigDecimal bd = (BigDecimal) fieldNameToFinalValueMap.get(fieldName);
                        BigDecimal v = (BigDecimal) obj;
                        bd = bd.add(v);
                        fieldNameToFinalValueMap.put(fieldName, bd);
                    } else {
                        BigDecimal bd = (BigDecimal) obj;
                        fieldNameToFinalValueMap.put(fieldName, bd);
                    }
                }
                //数字类型
                if (Integer.class.equals(field.getType())) {
                    if (fieldNameToFinalValueMap.containsKey(fieldName)) {
                        Integer bd = (Integer) fieldNameToFinalValueMap.get(fieldName);
                        bd = bd + (Integer) obj;
                        fieldNameToFinalValueMap.put(fieldName, bd);
                    } else {
                        Integer bd = (Integer) obj;
                        fieldNameToFinalValueMap.put(fieldName, bd);
                    }
                }

                //数字类型的字符串
                //数字类型
                if (String.class.equals(field.getType())) {
                    if (fieldNameToFinalValueMap.containsKey(fieldName)) {
                        Long bd = (Long) fieldNameToFinalValueMap.get(fieldName);
                        String s = String.valueOf(obj);
                        if (StringUtils.isEmpty(s)) {
                            return;
                        }
                        Long addInt = 0L;
                        try {
                            addInt = Long.parseLong(s);
                        } catch (Exception e) {
                            e.printStackTrace();
                            throw new IllegalArgumentException("当前行" + field.getName() + "的数据无法转换为数字类型");

                        }
                        bd = bd + addInt;
                        fieldNameToFinalValueMap.put(fieldName, bd);
                    } else {
                        try {
                            String bd = (String) obj;
                            Long bdInt = Long.parseLong(bd);
                            fieldNameToFinalValueMap.put(fieldName, bdInt);
                        } catch (Exception e) {
                            e.printStackTrace();
                            throw new IllegalArgumentException("当前行[" + field.getName() + "]的数据无法转换为数字类型");

                        }

                    }
                }
            }


        }
    }

    /**
     * @Description: 创建实际数据行的样式，包括文字居中，字号, 边框
     * @Param: []
     * @return: org.apache.poi.ss.usermodel.CellStyle
     * @Date: 2023/6/30
     */
    private CellStyle createStaticCellStyle(Workbook workbook, boolean blod) {
        CellStyle cellStyle = createBorderAndCenterCellStyle(workbook);
        Font font = createFont(workbook, (short) 12, blod);
        cellStyle.setFont(font);
        return cellStyle;
    }

    /**
     * @Description: 创建一个有边框，内容居中的样式
     * @Param: [workbook]
     * @return: org.apache.poi.ss.usermodel.CellStyle
     * @Date: 2023/7/1
     */
    private CellStyle createBorderAndCenterCellStyle(Workbook workbook) {
        // 生成一个通用样式 默认背景为白色
        CellStyle borderStyle = workbook.createCellStyle();
        borderStyle.setFillForegroundColor((short) ExcelColumn.StyleColor.WHITE.getValue());
        // 单元格内容样式
        borderStyle.setAlignment(HorizontalAlignment.CENTER);
        // 单元格是否需要边框
        borderStyle.setFillPattern(FillPatternType.SOLID_FOREGROUND);
        borderStyle.setBorderBottom(BorderStyle.THIN);
        borderStyle.setBorderLeft(BorderStyle.THIN);
        borderStyle.setBorderRight(BorderStyle.THIN);
        borderStyle.setBorderTop(BorderStyle.THIN);
        borderStyle.setVerticalAlignment(VerticalAlignment.CENTER);
        borderStyle.setAlignment(HorizontalAlignment.CENTER); // 创建一个居中格式
        return borderStyle;
    }

    /**
     * 生成表头行
     */
    private void createHeader(Workbook workbook, Sheet sheet) {
        Row row = sheet.createRow(currentRowIndex++);//内容开始行的上一行是表头行
        Cell cell = null;
        for (int i = 0; i < excelFieldMetadataList.size(); i++) {
            cell = row.createCell(i);
            ExcelFieldMetadata excelFieldMetadata = excelFieldMetadataList.get(i);
            //调用方法设置样式
            styleToCell(workbook, cell, excelFieldMetadata, true);
            HSSFRichTextString text = new HSSFRichTextString(excelFieldMetadata.getColumnName());
            cell.setCellValue(text);
        }
    }

    /**
     * 创建标题行的方法
     *
     * @param workbook
     * @param sheet
     */
    private void createTitle(Workbook workbook, Sheet sheet) {
        Row row = sheet.createRow(currentRowIndex++);//标题行
        row.setHeightInPoints(50);//设置行高
        Cell titleCell = row.createCell(0);//得到标题列

        //创建一个有边框的样式
        CellStyle cellStyle = createBorderAndCenterCellStyle(workbook);
        // 生成一个字体 默认字体微软雅黑
        Font font = createFont(workbook, (short) 25, true);
        cellStyle.setFont(font);
        titleCell.setCellStyle(cellStyle);//设置样式
        titleCell.setCellValue(titleName);//设置内容

        CellRangeAddress cellAddresses = new CellRangeAddress(row.getRowNum(),
                row.getRowNum(), row.getRowNum(), excelFieldMetadataList.size() - 1);
        //合并单元格
        mergeColumnsStyle(sheet, cellAddresses, cellStyle);
        sheet.addMergedRegion(cellAddresses);
    }

    /**
     * @Description: 创建一个字体
     * @Param: [workbook wb, fontSize 字体大小, blod 是否加粗]
     * @return: org.apache.poi.ss.usermodel.Font
     * @Date: 2023/7/1
     */
    private Font createFont(Workbook workbook, short fontSize, boolean blod) {
        Font font = workbook.createFont();
        // 设置字体大小
        font.setFontHeightInPoints(fontSize);
        // 字体加粗
        font.setBold(blod);
        return font;
    }

    /**
     * @Description: 先设置样式然后再合并单元格
     * @Param: [workbook, sheet, region, borderCellStyle]
     * @return: void
     * @Date: 2023/6/29
     */
    private void mergeColumnsStyle(Sheet sheet, CellRangeAddress region, CellStyle borderCellStyle) {
        int firstColumn = region.getFirstColumn();
        int lastColumn = region.getLastColumn();
        int firstRow = region.getFirstRow();
        int lastRow = region.getLastRow();
        for (int i = firstRow; i <= lastRow; i++) {
            for (int j = firstColumn; j <= lastColumn; j++) {
                Cell cell = sheet.getRow(i).getCell(j);
                if (cell == null) {
                    cell = sheet.getRow(i).createCell(j);
                }
                cell.setCellStyle(borderCellStyle);

            }
        }
    }

    /**
     * @param workbook 工作簿
     * @param cell     要配置的单元格
     * @param isBold   表头是否加粗
     * @Title: 设置单元格样式的方法
     * @Description: 设置单元格以及字体的整体样式
     */
    private void styleToCell(Workbook workbook, Cell cell, ExcelFieldMetadata excelFieldMetadata, boolean isBold) {
        // 生成一个通用样式 默认背景为白色
        CellStyle style = workbook.createCellStyle();
        style.setFillForegroundColor((short) excelFieldMetadata.getStyleColor());

        // 单元格内容样式
        style.setAlignment(HorizontalAlignment.CENTER);

        // 单元格是否需要边框
        if (excelFieldMetadata.getBorder()) {
            style.setFillPattern(FillPatternType.SOLID_FOREGROUND);
            style.setBorderBottom(BorderStyle.THIN);
            style.setBorderLeft(BorderStyle.THIN);
            style.setBorderRight(BorderStyle.THIN);
            style.setBorderTop(BorderStyle.THIN);
        }

        // 生成一个字体 默认字体微软雅黑
        Font font = workbook.createFont();
        font.setFontName(excelFieldMetadata.getFontName());
        font.setColor((short) excelFieldMetadata.getFontColor());
        // 设置字体大小
        font.setFontHeightInPoints(excelFieldMetadata.getFontSize());
        // 字体是否加粗
        if (isBold) {
            font.setBold(true);
        }
        // 把字体应用到当前的样式
        style.setFont(font);
        cell.setCellStyle(style);
    }

    /**
     * 根据后缀名得到工作簿对象
     *
     * @return 返回wk对象
     */
    private Workbook getWorkBook() {
        if (".xls".equals(ext)) {
            return new HSSFWorkbook();
        } else if (".xlsx".equals(ext)) {
            return new SXSSFWorkbook();
        }
        return null;
    }

    /**
     * @Description: 将excel返回给前端
     * @Param: [workbook wb, request 请求, response 响应, filename 导出的文件全名称]
     * @return: void
     * @Author: java小新人
     * @Date: 2023/7/1
     */
    public static void downloadFile(Workbook workbook, HttpServletRequest request, HttpServletResponse response, String filename) {
        try {
            //从请求头中获取User-Agent判断当前使用的是否是火狐浏览器
            String agent = request.getHeader("User-Agent");
            //根据不同浏览器进行不同的编码
            String realFilename = "";
            if (agent.contains("MSIE")) {
                // IE浏览器
                realFilename = URLEncoder.encode(filename, "utf-8");
                realFilename = realFilename.replace("+", " ");
            } else if (agent.contains("Firefox")) {
                // 火狐浏览器，此处使用java8
                realFilename = "=?utf-8?B?" + Base64.encodeBase64String(filename.getBytes("utf-8")) + "?=";
            } else {
                // 其它浏览器
                realFilename = URLEncoder.encode(filename, "utf-8");
            }
            //设置要被下载的文件名
            response.setHeader("Content-Disposition", "attachment;filename=" + realFilename);
            response.setContentType("application/octet-stream;charset=UTF-8");
            response.setCharacterEncoding("UTF-8"); // 设置文件流编码格式 不然中文会乱码
            response.setHeader("filename", filename);
            ServletOutputStream os = response.getOutputStream();
            workbook.write(os);
            os.flush();
            os.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 

 　

测试案例：

User实体类：

package com.example.demo.entity;

import com.example.demo.enums.SexEnum;
import com.example.demo.enums.UserStatusEnum;
import com.example.demo.excel.ExcelColumn;
import com.example.demo.excel.ExcelSheet;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;

import java.io.Serializable;
import java.util.Date;

@Data
@NoArgsConstructor
@Accessors(chain = true)
@ExcelSheet(sheetName = "测试sheetNme", titleName = "测试标题")
public class User implements Serializable {
    @ExcelColumn(columnName = "性别", sort = 4, convertEnumType = SexEnum.class, convertEnumMethodName = "getDescription")
    private Integer sex;
    /**
     * 用户姓名
     */
    @ExcelColumn(columnName = "姓名", sort = 2)
    private String username;

    @ExcelColumn(columnName = "密码", sort = 3)
    private String password;


    @ExcelColumn(columnName = "邮件", sort = 5)
    private String email;

    /**
     * 主键id
     */
    @ExcelColumn(columnName = "编号", sort = 1)
    private Integer id;

    //零花钱进行累加操作
    @ExcelColumn(columnName = "零花钱", sort = 6, opertorType = ExcelColumn.OperatorType.SUM)
    private String money;


    //数据状态
    @ExcelColumn(columnName = "状态", sort = 7, convertEnumType = UserStatusEnum.class, convertEnumMethodName = "getDescription")
    private String status;
    private Date createTime;

    private String updateTime;


}

　　

码值转换枚举：

package com.example.demo.enums;

import lombok.*;
import org.apache.commons.lang3.StringUtils;

/**
 * @author java小新人
 * @title SexEnum 
 * @date 2023/6/29 12:35
 * @description TODO
 */
@AllArgsConstructor
@NoArgsConstructor
@Getter
public enum SexEnum {
    men(0,"女"),
    man(1,"男");
    private Integer code;
    private String description;

    /**
    * @Description:   根据码值遍历获取对应的中文
    * @Param: [code]
    * @return: java.lang.String
    * @Date: 2023/6/30
    */
    public static String getDescription(Integer code){
        if (code==null){
            return "";
        }
        for(SexEnum e : SexEnum.values()){
            if(e.code.equals(code)){
                return e.description;
            }
        }
        return "";
    }
}








package com.example.demo.enums;

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import org.apache.commons.lang3.StringUtils;

/**
 * @author java小新人
 * @title UserStatusEnum
 * @date 2023/6/29 12:35
 * @description TODO
 */
@AllArgsConstructor
@NoArgsConstructor
@Getter
public enum UserStatusEnum {
    men("0","删除"),
    man("1","正常");
    private String code;
    private String description;

    /**
    * @Description:   根据码值遍历获取对应的中文
    * @Param: [code]
    * @return: java.lang.String
    * @Date: 2023/6/30
    */
    public static String getDescription(String code){
        if (StringUtils.isBlank(code)){
            return "";
        }
        for(UserStatusEnum e : UserStatusEnum.values()){
            if(e.code.equals(code)){
                return e.description;
            }
        }
        return "";
    }
}

 

controller:

@RequestMapping("/testExcel")
    @ResponseBody
    public void testExcel(HttpServletRequest request, HttpServletResponse response){
        List<User> list = getList();
        new MallExcelUtils<User>()
                .setClazz(User.class)//实体类类型
                .setSecondRowLeftAndRight("操作时间：2023-06-12至2023-06-30","导出人：小王")
                .setSecondLevelHeader(Collections.singletonList("二级标题#3,4,1,3"))//二级标题  内容#firstRow,lastRow,firstColumn,lastColumn
                .setDataList(list)//实际的数据集合
                .setFullFileName("test.xls")//导出文件的名称
                .initlization()//开始初始化
                .exportExcel(request,response);//实际以流的方式导出
    }


    private List<User> getList(){
        List<User> userList = Lists.newArrayList();
        User user = new User();
        user.setUsername("wang")
                .setPassword("111")
                .setId(123)
                .setSex(1)
                .setEmail("wang@gmail.com")
                .setMoney("100")
                .setStatus("1");

        User user2 = new User();
        user2.setUsername("li").
                setPassword("222")
                .setId(456)
                .setSex(0)
                .setEmail("li@gmail.com")
                .setMoney("20")
                .setStatus("0");;

        userList.add(user);
        userList.add(user2);
        return userList;
    }

 

效果：

 

17. mybatis分页插件(针对一些特别老的项目，不想引入依赖或者jar包, 暂时只支持mysql，可以自己扩展oracle，就改一下limit分页语句就好啦)

import org.apache.commons.lang3.StringUtils;
import org.apache.ibatis.executor.parameter.ParameterHandler;
import org.apache.ibatis.executor.resultset.ResultSetHandler;
import org.apache.ibatis.executor.statement.StatementHandler;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.plugin.*;
import org.apache.ibatis.reflection.MetaObject;
import org.apache.ibatis.reflection.SystemMetaObject;
import org.apache.ibatis.scripting.defaults.DefaultParameterHandler;
import org.apache.log4j.Logger;

import java.sql.*;
import java.util.List;
import java.util.Objects;
import java.util.Properties;

/**
 * @Description 自定义mybatis分页插件, 暂时只支持msql， 需要的可以扩展
 * @Author 
 * @Date 2023年4月12日 17:20:34
 */
@Intercepts({
        @Signature(type = StatementHandler.class, method = "prepare", args = {Connection.class}),
        @Signature(type = ResultSetHandler.class, method = "handleResultSets", args = {Statement.class})
})
public class PageHelper implements Interceptor {

    private static final Logger log = Logger.getLogger(PageHelper.class);

    /**
     * 数据库方言
     */
    private String dbDialet;

    /**
     * 默认查询条数
     */
    public static final Integer DEFAULT_PAGE_SIZE = 10;

    /**
     * 数据库方言-MySQL
     */
    private static final String DB_DIALET_MYSQL = "mysql";
    //private static final String DB_DIALET_ORACLE = "oracle";

    /**
     * 存Page对象的线程局部变量
     */
    public static final ThreadLocal<Page> localPage = new ThreadLocal<>();


    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        if (localPage.get() == null) {
            return invocation.proceed();
        }
        try {
            if (invocation.getTarget() instanceof StatementHandler) {
                StatementHandler statementHandler = (StatementHandler) invocation.getTarget();
                MetaObject metaObject = SystemMetaObject.forObject(statementHandler);
                //对象可能被多次代理，使用下面两次循环拿到原始对象
                while (metaObject.hasGetter("h")) {
                    Object object = metaObject.getValue("h");
                    metaObject = SystemMetaObject.forObject(object);
                }
                while (metaObject.hasGetter("target")) {
                    Object object = metaObject.getValue("target");
                    metaObject = SystemMetaObject.forObject(object);
                }

                MappedStatement mappedStatement = (MappedStatement) metaObject.getValue("delegate.mappedStatement");
                BoundSql boundSql = (BoundSql) metaObject.getValue("delegate.boundSql");
                Page page = localPage.get();
                String sql = boundSql.getSql();

                //重写sql，添加Mysql分页参数
                String pageSql = buildPageSql(sql, page);
                metaObject.setValue("delegate.boundSql.sql", pageSql);
                Connection connection = (Connection) invocation.getArgs()[0];
                //使用jdbc查询并设置记录总数
                setPageParameter(sql, connection, mappedStatement, boundSql, page);
                //将执行器交给下一个拦截器
                return invocation.proceed();
            } else if (invocation.getTarget() instanceof ResultSetHandler) {
                Object result = invocation.proceed();
                Page page = localPage.get();
                //设置实际的List数据
                page.setRecords((List) result);
                return result;
            }
        } catch (Throwable ignore) {
            //发生异常的时候清空localPage，防止内存泄漏
            localPage.remove();
            log.error("查询数据库失败", ignore);
        }
        return invocation.proceed();
    }

    /**
     * 获取记录总数和最大的页数
     *
     * @param sql             原始sql语句
     * @param connection      连接
     * @param MappedStatement mappedStatement对象
     * @param boundSql        sql的封装对象 原始sql语句
     * @param page            Page对象
     */
    private void setPageParameter(String sql, Connection connection, MappedStatement mappedStatement, BoundSql boundSql, Page page) {
        String countSql = "SELECT count(0) from (" + sql + ") as total";
        PreparedStatement countStmt = null;
        ResultSet rs = null;
        try {
            countStmt = connection.prepareStatement(countSql);
            BoundSql countBS = new BoundSql(mappedStatement.getConfiguration(), countSql, boundSql.getParameterMappings(), boundSql.getParameterObject());
            setParameter(countStmt, mappedStatement, countBS, boundSql.getParameterObject());
            rs = countStmt.executeQuery();
            int totalCount = 0;
            if (rs.next()) {
                totalCount = rs.getInt(1);
            }
            //设置最大条数和最大页数
            page.setItemCount(totalCount);
            int totalPage = totalCount / page.getPageSize() + ((totalCount % page.getPageSize() == 0) ? 0 : 1);
            page.setPageCount(totalPage);
        } catch (SQLException e) {
            e.printStackTrace();
            log.error("自定义分页组件PageHelper，查询条数异常",e);
        } finally {
            try {
                if (rs != null) {
                    rs.close();
                }
            } catch (SQLException ignore) {
                log.error("自定义分页插件PageHelper关闭ResultSet失败", ignore);
            }
            try {
                countStmt.close();
            } catch (SQLException ignore) {
                log.error("自定义分页插件PageHelper关闭PreparedStatement失败", ignore);
            }
        }


    }

    /**
     * 设置参数值
     *
     * @param countStmt
     * @param mappedStatement
     * @param countBS         原始sql
     * @param parameterObject
     * @throws SQLException
     */
    private void setParameter(PreparedStatement countStmt, MappedStatement mappedStatement, BoundSql countBS, Object parameterObject) throws SQLException {
        ParameterHandler parameterHandler = new DefaultParameterHandler(mappedStatement, parameterObject, countBS);
        parameterHandler.setParameters(countStmt);
    }

    /**
     * 重写sql
     *
     * @param sql  原始sql
     * @param page 分页对象
     * @return 返回包装的sql
     */
    private String buildPageSql(String sql, Page page) {
        long startRow = (page.getPageNum() - 1) * page.getPageSize();
        long endRow = page.getPageNum() * page.getPageSize();
        //拼接sql的分页语句--MySQL
        if (Objects.equals(dbDialet, DB_DIALET_MYSQL)) {
            return new StringBuilder().append(sql)
                    .append(" LIMIT ")
                    .append(startRow)
                    .append(",")
                    .append(endRow - startRow)
                    .toString();
        }
        return "";

    }


    @Override
    public Object plugin(Object target) {
        //把自定义的插件加入到mybatis中去执行
        //只拦截StatementHandler和ResultSetHandler这两种类型
        if (target instanceof StatementHandler || target instanceof ResultSetHandler) {
            return Plugin.wrap(target, this);
        }
        return target;

    }

    //启动的时候初始化时调用
    @Override
    public void setProperties(Properties properties) {
        //获取配置中的参数，适配不同的数据库
        String dbDialet = properties.getProperty("pageHelper.db.type", DB_DIALET_MYSQL);
        if (Objects.equals(dbDialet, DB_DIALET_MYSQL)) {
            this.dbDialet = dbDialet;
        } else {
            log.error("自定义的分页插件不支持当前配置的数据库类型:" + dbDialet);
        }

    }


    /**
     * 开始分页
     *
     * @param pageNum  页码
     * @param pageSize 每一页数据量
     */
    public static void startPage(int pageNum, int pageSize) throws IllegalArgumentException {
        checkPageParam(pageNum,pageSize);
        localPage.set(new Page(pageNum, pageSize));
    }

    /**
     * 开始分页
     *
     * @param pageNum  页码
     * @param pageSize 每一页数据量
     */
    public static void startPage(String pageNumStr, String pageSizeStr) throws IllegalArgumentException {
        int pageNum = 1;
        int pageSize = DEFAULT_PAGE_SIZE;
        if (StringUtils.isNotBlank(pageNumStr)){
            try {
                pageNum = Integer.parseInt(pageNumStr);
            } catch (NumberFormatException e) {
                pageNum = 1;
            }
        }
        if (StringUtils.isNotBlank(pageSizeStr)){
            try {
                pageSize= Integer.parseInt(pageSizeStr);
            } catch (NumberFormatException e) {
                pageSize = DEFAULT_PAGE_SIZE;
            }
        }
        checkPageParam(pageNum,pageSize);
        localPage.set(new Page(pageNum, pageSize));
    }

    /**
     * 校验分页参数是否合规
     * @param pageNum
     * @param pageSize
     * @throws IllegalArgumentException
     */
    private static void checkPageParam(int pageNum, int pageSize) throws IllegalArgumentException {
        if (pageNum<1){
            throw new IllegalArgumentException("自定义分页插件PageHelper,分页参数pageNum不合规："+pageNum);
        }
        if (pageSize<0){
            throw new IllegalArgumentException("自定义分页插件PageHelper,分页参数pageSize不合规："+pageSize);
        }
    }

    /**
     * 结束分页
     *
     * @param <T>
     * @return
     */
    public static <T> Page<T> endPage() {
        Page<T> page = localPage.get();
        localPage.remove();
        return page;
    }
}


















import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * 分页参数
 *
 * @param <T>
 */
public class Page<T> implements Serializable {
    /**
     * 当前页
     */
    private Integer pageNum = 0;
    /**
     * 每页的条数,默认10条
     */
    private Integer pageSize = PageHelper.DEFAULT_PAGE_SIZE;
    /**
     * 总条数
     */
    private Integer itemCount = 0;
    /**
     * 总的页数
     */
    private Integer pageCount = 0;
    /**
     * 封装的数据
     */
    private List<T> records = Collections.emptyList();

    /**
     * 翻页页码列表
     */
    private List<Integer> pageNumList = Collections.emptyList();

    public Page(Integer pageNum, Integer pageSize) {
        this.pageNum = pageNum;
        this.pageSize = pageSize;
    }

    public Page() {
    }

    public Integer getPageNum() {
        return pageNum;
    }

    public Page<T> setPageNum(Integer pageNum) {
        this.pageNum = pageNum;
        return this;
    }

    public Integer getPageSize() {
        return pageSize;
    }

    public Page<T> setPageSize(Integer pageSize) {
        this.pageSize = pageSize;
        return this;
    }

    public Integer getItemCount() {
        return itemCount;
    }

    public Page<T> setItemCount(Integer itemCount) {
        this.itemCount = itemCount;
        return this;
    }

    public Integer getPageCount() {
        return pageCount;
    }

    public Page<T> setPageCount(Integer pageCount) {
        this.pageCount = pageCount;
        return this;
    }

    public List<T> getRecords() {
        return records;
    }

    public Page<T> setRecords(List<T> records) {
        this.records = records;
        return this;
    }

    public List<Integer> getPageNumList() {
        return pageNumList;
    }

    public Page<T> setPageNumList(List<Integer> pageNumList) {
        this.pageNumList = pageNumList;
        return this;
    }
}

 

使用前注意将此自定义的PageHelper配置到mybatis的xml文件中，或者注解的方式，看项目的实际配置

使用示例：

PageHelper.startPage(1,10);

userDao.selectList(xxx);

Page<User> page = PageHelper.endPage();

List<User> userList = page.getRecords();

 

 

18.

 

后续更新