宝诗单证使用手册，并使用抽象和反射做通用抽象类，节省开发成本

单证示例

1024最适合写blog了，别说了，别说了，建议变成法定节假日。

宝诗单证的官网：宝诗官网
(@宝诗团队记得给我打广告费)

宝诗单证的使用步骤
使用抽象类将获取字段的步骤抽象出来，极大的省略了代码量。节省开发成本。
抽象类在文章最下面，需要的自取。

步骤

1.创建报表
2.配置参数
3.创建数据源对象（javaBean）
4.创建DataSet实现类
5.在com.basksoft.report.core.model.dataset.BeanDataset配置文件中添加DataSet实现类的路径
6.加载自定义bean数据集
7.添加数据库报表记录

创建报表

右键创建一个报表文件

在这里插入图片描述

配置参数

在这里插入图片描述

这里的参数作用是获取数据使用的参数。

创建数据源对象

需要定义一个空参构造器和一个带一个Boolean参数的构造器，并在这个构造器中给属性赋值默认数据。
Boolean构造器的类型需要是装箱类型（boolean的装箱类型Boolean）
添加Boolean构造器的目的是为了获取默认数据的对象。

@Data
public class AccountStatementVo {

    // 结算单位
    private String clientName;

    // 计费日期截至
    private Date reconcDeadline;

    // 折合币金额币制
    private String cyCode;

    // 折合币金额
    private BigDecimal amt;

    // 对账方式
    private String reconcMethod;

    // 说明
    private String actstmDesc;

    // 银行账户
    private String bankacctName;

    // 对账单号
    private String actstmNo;

    public AccountStatementVo() {}

    public AccountStatementVo(Boolean defaultValue) {
        this.clientName = "客户名称";
        this.reconcDeadline = new Date();
        this.cyCode = "CNY";
        this.amt = BigDecimal.ZERO;
        this.reconcMethod = "测试方法";
        this.actstmDesc = "文件备注";
        this.bankacctName = "中国银行";
        this.actstmNo = "HJ23424";
    }
}

创建DataSet实现类

添加一个DateSet类并继承AbstractBeanDataSet抽象类
抽象类需要指定两个泛型，如果返回结果是List类型，第一个泛型类型指定为List<T>,第二个类型指定为T。否则都指定为T

@Slf4j
public class BillDataset extends AbstractBeanDataSet<BillDocVo,BillDocVo> {

    @Override
    protected boolean getReturnDefaultData(BeanContext beanContext) {
        return false;
    }

    @Override
    public Result<BillDocVo> getDocVo(BeanContext beanContext) {
       return null;
    }

    @Override
    protected String name() {
        return "";
    }
}

返回List的接口

public class DemoDataSet extends AbstractBeanDataSet<List<BillDetailVo>,BillDataset> {
    @Override
    protected boolean getReturnDefaultData(BeanContext beanContext) {
        return false;
    }

    @Override
    public Result<List<BillDetailVo>> getDocVo(BeanContext beanContext) {
        return null;
    }

    @Override
    protected String name() {
        return null;
    }
}

重写AbstractBeanDataSet中的三个方法

`boolean getReturnDefaultData(BeanContext beanContext)`

通过beanContext.getReportParameter("billId")获取在第二步中定义的参数

返回boolean值，是否获取默认数据。

在这个方法中写自己获取默认数据的条件。

	@Override
    protected boolean getReturnDefaultData(BeanContext beanContext) {
        Long billId = ParameterUtils.parseLong(beanContext.getReportParameter("billId"));

        // 如果参数为空或为0，则获取默认数据
        if (Objects.isNull(billId) || Objects.equals(billId, 0L)) {
            return true;
        }
        return false;
    }

`Result<BillDocVo> getDocVo(BeanContext beanContext)`

获取数据源的方法。

在这个方法中通过http的方式调用fms项目中的接口获取数据源。（后面有必要的话可以在report项目中配置fms的数据源，直接从report项目获取数据）

返回的数据是在第三步中创建的数据源对象

最后在fms写这个获取数据源的接口返回所需要的数据对象

	@Override
    public Result<BillDocVo> getDocVo(BeanContext beanContext) {
        Long billId = ParameterUtils.parseLong(beanContext.getReportParameter("billId"));
        String token = (String) beanContext.getReportParameter("token");

        // 在FmsUrlConstants常量类中配置访问地址
        String url = FmsUrlConstants.api + FmsUrlConstants.BILL_DOC;
        if (!StringUtils.hasText(url)) {
            return null;
        }

        // 使用hutool工具包发送get请求，如果在fms写的是post请求，则发送post请求
        HttpResponse httpResponse = HttpRequest.get(url)
                .form("billId", billId)
                .header("token", token)
                .execute();
        
        // 将返回结果转换类型
        Result<BillDocVo> result = JSONUtil.toBean(httpResponse.body(), new TypeReference<Result<BillDocVo>>() { }, false);

        return result;
    }

`String name()`

返回数据源对象名称，在报表中显示的名称在这个方法中定义

	@Override
    protected String name() {
        return "账单";
    }

添加dataSet类配置

在这里插入图片描述

加载自定义bean数据集

在这里插入图片描述

可以添加多个数据集

添加数据库报表记录

uni_acv_doc（单证主表）

uni_acv_docmodel（单证明细模板表）

一对多的关系

在这两张表中添加报表数据

在这里插入图片描述

添加单证主表（uni_acv_doc）,按各自的需求进行设置字段。
doccode,tab_code需要唯一

添加单证明细模板表（uni_acv_docmodel）记录时。

将docid设置为单证主表（uni_acv_doc）的id,

将file_id和sys_file_id设置为模板的fileId，

将is_default设置为1

其他数据按需求的要求设置

AbstractBeanDataSet抽象类

这个抽象类的功能：
如果是获取默认数据，调用Boolean构造器创建一个带有默认数据的对象。
否则获取从fms获取的数据。
将数据对象的所有字段封装成一个List<Map<String,Object>>对象。

package com.yunwuyun.easy.baskreport.dataset;

import com.basksoft.report.core.model.dataset.BeanDataset;
import com.basksoft.report.core.model.dataset.impl.BeanContext;
import com.basksoft.report.core.model.dataset.impl.Field;
import com.basksoft.report.core.model.dataset.impl.FieldType;
import com.yunwuyun.easy.baskreport.common.Result;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.*;

/**
 * 单证抽象类
 * @param <T>
 */
@Slf4j
public abstract class AbstractBeanDataSet<T,E> extends BeanDataset {

    protected Class<E> clazz;

    public AbstractBeanDataSet() {
        Type genericSuperclass = getClass().getGenericSuperclass();

        if (genericSuperclass instanceof ParameterizedType) {
            ParameterizedType parameterizedType = (ParameterizedType) genericSuperclass;
            Type[] typeArguments = parameterizedType.getActualTypeArguments();

            if (typeArguments.length > 0) {
                Type typeArgument = typeArguments[1];

                if (typeArgument instanceof Class) {
                    this.clazz = (Class<E>) typeArgument;
                }
            }
        }
    }

    @SneakyThrows
    @Override
    public List<?> getData(BeanContext beanContext) {

        boolean returnDefaultData = false;
        returnDefaultData = this.getReturnDefaultData(beanContext);
        if(returnDefaultData) {
            return getDefaultData();
        }

        Result<T> result = this.getDocVo(beanContext);
        if (result == null || result.getCode() != 200) {
            return Collections.emptyList();
        }

        T t = result.getResult();

        List<Map<String,Object>> datas = getDatas(t);

        return datas;
    }

    protected abstract boolean getReturnDefaultData(BeanContext beanContext);

    private List<Map<String, Object>> getDatas(T t) {
        List<Map<String,Object>> datas = new ArrayList<>();

        if(isListType()) {
            List<E> list = (List<E>) t;
            for (E obj: list) {
                Map<String, Object> dataMap = getDataMap(obj);
                datas.add(dataMap);
            }
        } else {
            E obj = (E) t;
            Map<String, Object> data = getDataMap(obj);
            datas.add(data);
        }

        return datas;
    }


    /**
     * 获取所有字段属性的map
     * @param t
     * @return
     */
    private Map<String, Object> getDataMap(E t) {

        List<Field> fields = this.getFields();
        Map<String, Object> data = new HashMap<>();

        for (Field field : fields) {
            String fieldName = field.getName();

            try {
                java.lang.reflect.Field fieldVo = this.clazz.getDeclaredField(fieldName);
                fieldVo.setAccessible(true);

                data.put(field.getName(), fieldVo.get(t));
            } catch (Exception e) {
                // 忽略异常，继续处理下一个字段
                log.error("Dataset error,fieldName:{}, message:{}", fieldName, e.getMessage());
            }
        }

        return data;
    }

    /**
     * 泛型类型是否为列表
     * @return
     */
    private Boolean isListType() {
        Type genericSuperclass = getClass().getGenericSuperclass();

        if (genericSuperclass instanceof ParameterizedType) {

            ParameterizedType parameterizedType = (ParameterizedType) genericSuperclass;

            Type[] typeArguments = parameterizedType.getActualTypeArguments();

            if (typeArguments.length > 0) {
                Type typeArgument = typeArguments[0];

                if (typeArgument instanceof ParameterizedType) {
                    return true;
                } else if (typeArgument instanceof Class) {
                    return false;
                }
            }
        }

        return false;
    }

    /**
     * 通过id获取数据
     * @param beanContext
     * @return
     */
    public abstract Result<T> getDocVo(BeanContext beanContext);

    @Override
    public List<String> getDependCells() {
        List<String> list = new ArrayList<>();
        return list;
    }

    @Override
    protected abstract String name();

    @Override
    public List<Field> getFields() {
        List<Field> fields = new ArrayList<>();

        java.lang.reflect.Field[] allFields = this.clazz.getDeclaredFields();
        for (java.lang.reflect.Field fieldVo : allFields) {
            Class<?> type = fieldVo.getType();
            String typeName = type.getSimpleName();
            Field field = new Field(fieldVo.getName(), FieldType.valueOf(typeName));
            fields.add(field);
        }

        return fields;
    }



    /**
     * 获取默认数据
     * @return 默认数据
     */
    private List<Map<String, Object>> getDefaultData() throws IllegalAccessException, NoSuchMethodException, InvocationTargetException, InstantiationException {
        Constructor<E> constructor = this.clazz.getDeclaredConstructor(Boolean.class);
        E e = constructor.newInstance(true);

        List<Map<String,Object>> datas = new ArrayList<>();
        Map<String,Object> data = new HashMap<>();

        java.lang.reflect.Field[] allFields = this.clazz.getDeclaredFields();

        for (java.lang.reflect.Field field : allFields) {
            field.setAccessible(true);

            data.put(field.getName(), field.get(e));
        }
        datas.add(data);
        return datas;
    }
}