springboot使用AOP+反射实现Excel数据的读取

如果我们遇到把excel表格中的数据导入到数据库，首先我们要做的是：将excel中的数据先读取出来。
因此，今天就给大家分享一个读取excel表格数据的代码示例：

为了演示方便，首先我们创建一个spring boot项目；具体创建过程这里不再详细介绍；

示例代码主要使用了apache下的poi的jar包及api；因此，我们需要在pom.xml文件中导入以下依赖：

        <dependency>
            <groupid>org.apache.poi</groupid>
            <artifactid>poi</artifactid>
            <version>3.13</version>
        </dependency>
        <dependency>
            <groupid>org.apache.poi</groupid>
            <artifactid>poi-ooxml</artifactid>
            <version>3.13</version>
        </dependency>

主要代码：

excelutils.java

import com.example.springbatch.xxkfz.annotation.excelfield;
import lombok.extern.slf4j.slf4j;
import org.apache.poi.hssf.usermodel.hssfrow;
import org.apache.poi.hssf.usermodel.hssfsheet;
import org.apache.poi.hssf.usermodel.hssfworkbook;

import java.io.file;
import java.io.fileinputstream;
import java.io.filenotfoundexception;
import java.io.ioexception;
import java.lang.reflect.field;
import java.lang.reflect.method;
import java.math.bigdecimal;
import java.util.arraylist;
import java.util.list;
import java.util.objects;

/**
 * @author xxkfz
 * excel工具类
 */

@slf4j
public class excelutils {

    private hssfworkbook workbook;

    public excelutils(string filedir) {
        file file = new file(filedir);
        try {
            workbook = new hssfworkbook(new fileinputstream(file));
        } catch (filenotfoundexception e) {
            e.printstacktrace();
        } catch (ioexception e) {
            e.printstacktrace();
        }
    }

    /**
     * 读取excel数据
     *
     * @param sheetname
     * @param object
     * @return
     */
    public list readfromexceldata(string sheetname, object object) {
        list result = new arraylist();

        // 获取该对象的class对象
        class class_ = object.getclass();

        // 获得该类的所有属性
        field[] fields = class_.getdeclaredfields();

        // 读取excel数据  获得指定的excel表
        hssfsheet sheet = workbook.getsheet(sheetname);

        // 获取表格的总行数
        int rowcount = sheet.getlastrownum() + 1; // 需要加一
        if (rowcount < 1) {
            return result;
        }

        // 获取表头的列数
        int columncount = sheet.getrow(0).getlastcellnum();

        // 读取表头信息,确定需要用的方法名---set方法
        // 用于存储方法名
        string[] methodnames = new string[columncount]; // 表头列数即为需要的set方法个数

        // 用于存储属性类型
        string[] fieldtypes = new string[columncount];

        // 获得表头行对象
        hssfrow titlerow = sheet.getrow(0);

        // 遍历表头列
        for (int columnindex = 0; columnindex < columncount; columnindex++) {

            // 取出某一列的列名
            string colname = titlerow.getcell(columnindex).tostring();
/*
            // 将列名的首字母字母转化为大写
            string ucolname = character.touppercase(colname.charat(0)) + colname.substring(1, colname.length());

            // set方法名存到methodnames
            methodnames[columnindex] = "set" + ucolname;
*/
            //
            string fieldname = fields[columnindex].getname();
            string upperfieldname = character.touppercase(fieldname.charat(0)) + fieldname.substring(1, fieldname.length());
            methodnames[columnindex] = "set" + upperfieldname;

            // 遍历属性数组
            for (int i = 0; i < fields.length; i++) {

                // 获取属性上的注解name值
                string name = fields[i].getannotation(excelfield.class).name();

                // 属性与表头相等
                if (objects.nonnull(name) && colname.equals(name)) {
                    //  将属性类型放到数组中
                    fieldtypes[columnindex] = fields[i].gettype().getname();
                }
            }
        }

        // 逐行读取数据 从1开始 忽略表头
        for (int rowindex = 1; rowindex < rowcount; rowindex++) {
            // 获得行对象
            hssfrow row = sheet.getrow(rowindex);
            if (row != null) {
                object obj = null;
                // 实例化该泛型类的对象一个对象
                try {
                    obj = class_.newinstance();
                } catch (exception e1) {
                    e1.printstacktrace();
                }

                // 获得本行中各单元格中的数据
                for (int columnindex = 0; columnindex < columncount; columnindex++) {
                    string data = row.getcell(columnindex).tostring();
                    // 获取要调用方法的方法名
                    string methodname = methodnames[columnindex];

                    obj = this.valueconvert(fieldtypes[columnindex], methodname, class_, obj, data);
                }
                result.add(obj);
            }
        }
        return result;
    }

    /**
     * @param fieldtype  字段类型
     * @param methodname 方法名
     * @param class_
     * @param data
     * @return
     */
    private object valueconvert(string fieldtype, string methodname, class class_, object obj, string data) {
        method method = null;
        if (objects.isnull(fieldtype) || objects.isnull(methodname) || objects.isnull(class_) || objects.isnull(obj)) {
            return obj;
        }
        try {
            switch (fieldtype) {
                case "java.lang.string":
                    method = class_.getdeclaredmethod(methodname, string.class);
                    method.invoke(obj, data); // 执行该方法
                    break;
                case "java.lang.integer":
                    method = class_.getdeclaredmethod(methodname, integer.class);
                    integer value = integer.valueof(data);
                    method.invoke(obj, value); // 执行该方法
                    break;
                case "java.lang.boolean":
                    method = class_.getdeclaredmethod(methodname, boolean.class);
                    boolean booleanvalue = boolean.getboolean(data);
                    method.invoke(obj, booleanvalue); // 执行该方法
                    break;
                case "java.lang.double":
                    method = class_.getdeclaredmethod(methodname, double.class);
                    double doublevalue = double.parsedouble(data);
                    method.invoke(obj, doublevalue); // 执行该方法
                    break;
                case "java.math.bigdecimal":
                    method = class_.getdeclaredmethod(methodname, bigdecimal.class);
                    bigdecimal bigdecimal = new bigdecimal(data);
                    method.invoke(obj, bigdecimal); // 执行该方法
                    break;
            }
        } catch (exception e) {
            e.printstacktrace();
        }
        return obj;
    }
}

excelfield.java

import java.lang.annotation.*;

/**
 * @author xxkfz
 */
@target({elementtype.method, elementtype.field, elementtype.type}) //注解放置的目标位置,method是可注解在方法级别上
@retention(retentionpolicy.runtime) //注解在哪个阶段执行
@documented
public @interface excelfield {
    string name() default "";
}

实体类 excelfilefield.java

@data
@allargsconstructor
@noargsconstructor
@tostring
public class excelfilefield {

    @excelfield(name = "id")
    private string id;

    @excelfield(name = "code")
    private string code;

    @excelfield(name = "type")
    private string type;

    @excelfield(name = "version")
    private string version;
}

函数测试

 @test
    void readexcel() {
        excelutils utils = new excelutils("e:/test.xls");
        excelfilefield interfacefield = new excelfilefield();
        list list = utils.readfromexceldata("sheet1", interfacefield);
        for (int i = 0; i < list.size(); i++) {
            excelfilefield item = (excelfilefield) list.get(i);
            system.out.println(item.tostring());
        }
    }

excel表格数据

测试结果：

excelfilefield(id=x0001, code=x0001, type=x0001, version=x0001)
excelfilefield(id=x0002, code=x0002, type=x0002, version=x0002)

process finished with exit code 0

 到此这篇关于springboot使用aop+反射实现excel数据的读取的文章就介绍到这了,更多相关springboot实现excel读取内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！