LU142857
LU142857

c# 使用NPOI按模板导出excel

 excel模板设置 

私车公用单  
 
 
申请信息  
申请单号： $header.ORDER_NO 申请日期： $header.CREATE_TIME $auotheight
申请部门： $header.APPLY_DEPT 申请人： $header.APPLY_USER $auotheight
项目： $header.PROJECT_RD_NAME 客户： $header.CUST_NAME $auotheight
出差单号： $header.BST_NO 　 　 $auotheight
用车信息  
派车日期 使用人 车辆类型车牌 用车事由 出发地  目的地 行驶路线  
$list.detail ASSIGN_DATE $CAR_OWNER $CAR_NUMBER $REASON $START_POINT $END_POINT $listend.ROUTE_NOTES $auotheight
签核信息  
序号 日期 步骤 签核部门 签核人 结果 签核意见  
$list.ad SEQ $EVENT_TIME $AUDIT_DESC $DEPT_NAME $USER_NAME $AUDIT_RESULT $listend.AUDIT_MARK $auotheight
　 　 　 　 　 　 　 　 　  

使用方式：

1.首先查询数据，DataSet ds=GetData(orderno);

2.然后调用，支持一个sheet模板导出多个数据sheet，多个sheet模板导出多个数据sheet

 
 
            string fpath =  "私车公用单.xls";

            ExcelHelper.Helper excel = new ExcelHelper.Helper();


            NPOI241.SS.UserModel.IWorkbook workbook = excel.Export(fpath, (book) =>
            {

                List sinfo = new List();
                ExcelHelper.Helper.ExcelHelperSheetInfo info = new ExcelHelper.Helper.ExcelHelperSheetInfo();
                sinfo.Add(info);

                info.ModelSheet = book.GetSheetAt(0);
                info.NewSheetData = new List();
               
                Hashtable ht = new Hashtable();
                info.NewSheetData.Add( ht);

                ht.Add("header", ds.Tables[0].Rows[0]);
                ht.Add("detail", ds.Tables[1].DefaultView);
                ht.Add("ad",ds.Tables[2].DefaultView);

                return sinfo;
            }, (book, sheet, info) => {
                sheet.ProtectSheet("123456");
            });
 
  
 
 
  
using Newtonsoft.Json;
using NPOI241.HSSF.Record;
using NPOI241.HSSF.UserModel;
using NPOI241.HSSF.Util;
using NPOI241.SS.UserModel;
using NPOI241.SS.UserModel.Charts;
using NPOI241.SS.Util;
using NPOI241.XSSF.UserModel;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Data;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Web;

namespace WebPortal.Common.ExcelHelper
{
    public struct SimpleCell
    {
        /// 
        /// 文本
        /// 
        public string T { get; set; }

        /// 
        /// colspan
        /// 
        public int C { get; set; }
        /// 
        /// rowspan
        /// 
        public int R { get; set; }

        /// 
        /// 样式 文本颜色，背景颜色，字体是否加粗,对齐,宽度
        /// 
        public string S { get; set; }

        /// 
        /// 备注
        /// 
        public string RK { get; set; }

    }


    public struct SimpleChart
    {
        /// 
        /// 标题
        /// 
        public string Title { get; set; }
        /// 
        /// 类型 chart类型  bar和line
        /// 
        public string Type { get; set; }
        /// 
        /// 数据起始单元格
        /// 
        public int Col1 { get; set; }
        /// 
        /// 数据起始行
        /// 
        public int Row1 { get; set; }

        /// 
        /// 数据结束单元格
        /// 
        public int Col2 { get; set; }
        /// 
        /// 数据结束行
        /// 
        public int Row2 { get; set; }

        /// 
        /// 是否应用右边Y轴，默认左边Y轴
        /// 
        public bool RightY { get; set; }
    }

    public class SimpleTable
    {
        /// 
        /// 行数据如
        /// 
        public List> Rows { get; set; }

        /// 
        /// 颜色
        /// 
        public List Colors { get; set; }

        /// 
        /// 样式
        /// 
        public List Styles { get; set; }

        /// 
        /// 冻结的行 只考虑冻结表头
        /// 
        public int FRow { get; set; }

        /// 
        /// 冻结的列
        /// 
        public int FCol { get; set; }

        /// 
        /// 图表信息
        /// 
        public List Chart { get; set; }

        /// 
        /// X轴数据起始单元格
        /// 
        public int Col1 { get; set; }
        /// 
        /// X轴数据起始行
        /// 
        public int Row1 { get; set; }

        /// 
        /// X轴数据结束单元格
        /// 
        public int Col2 { get; set; }
        /// 
        /// X轴数据结束行
        /// 
        public int Row2 { get; set; }

        /// 
        /// 是否设置右边Y轴
        /// 
        public bool RightY { get; set; }

        /// 
        /// 是否只读
        /// 
        public bool IsReadOnly { get; set; }

        public string PWD { get; set; }
    }

    public struct CellStyleWrap
    {
        public int? Width { get; set; }
        public ICellStyle CellStyle { get; set; }




        public CellStyleWrap(int? w, ICellStyle cs)
            : this()
        {
            this.Width = w;
            this.CellStyle = cs;
        }

    }


    public class Helper
    {


        void CreateChart(ISheet sheet, int col1, int col2, int row1, int row2, SimpleTable st)
        {
            IDrawing drawing = sheet.CreateDrawingPatriarch();
            IClientAnchor anchor = drawing.CreateAnchor(0, 0, 0, 0, col1, row1, col2, row2);

            var chart = drawing.CreateChart(anchor) as XSSFChart;

            //生成图例
            var legend = chart.GetOrCreateLegend();
            //图例位置
            legend.Position = LegendPosition.Top;


            // X轴.
            var bottomAxis = chart.ChartAxisFactory.CreateCategoryAxis(AxisPosition.Bottom);


            //Y轴
            IValueAxis leftAxis = chart.ChartAxisFactory.CreateValueAxis(AxisPosition.Left);
            leftAxis.Crosses = (AxisCrosses.AutoZero);



            //暂时不支持双y轴
            IValueAxis rigthAxis = leftAxis;
            //if (st.RightY)
            //{
            //    rigthAxis = chart.ChartAxisFactory.CreateValueAxis(AxisPosition.Right);
            //    rigthAxis.Crosses = (AxisCrosses.AutoZero);
            //}

            //x轴
            IChartDataSource xs = DataSources.FromNumericCellRange(sheet, new CellRangeAddress(st.Row1, st.Row2, st.Col1, st.Col2));


            IBarChartData bardata = null;
            ILineChartData linedata = null;
            IScatterChartData scatterdata = null;
            foreach (SimpleChart sc in st.Chart)
            {
                //图表
                var data = DataSources.FromNumericCellRange(sheet, new CellRangeAddress(sc.Row1, sc.Row2, sc.Col1, sc.Col1));
                SetDoubleData(sheet, sc.Col1, sc.Col2, sc.Row1, sc.Row2);
                switch (sc.Type)
                {
                    case "line":
                        if (linedata == null)
                            linedata = chart.ChartDataFactory.CreateLineChartData();

                        var sline = linedata.AddSeries(xs, data);
                        sline.SetTitle(sc.Title);
                        break;
                    case "bar":
                        if (bardata == null)
                            bardata = chart.ChartDataFactory.CreateBarChartData();

                        var sbar = bardata.AddSeries(xs, data);
                        sbar.SetTitle(sc.Title);
                        break;
                    case "scatter":
                        if (scatterdata == null)
                            scatterdata = chart.ChartDataFactory.CreateScatterChartData();

                        var stline = scatterdata.AddSeries(xs, data);
                        stline.SetTitle(sc.Title);
                        break;
                    default:
                        throw new Exception("暂不支持【" + sc.Type + "】类型的图表,只支持line、bar、scatter！");

                }
            }

            if (bardata != null)
                chart.Plot(bardata, bottomAxis, leftAxis);
            if (linedata != null)
                chart.Plot(linedata, bottomAxis, leftAxis);
            if (scatterdata != null)
                chart.Plot(scatterdata, bottomAxis, leftAxis);
        }

        public void SetDoubleData(ISheet sheet, int col1, int col2, int row1, int row2)
        {
            while (row1 <= row2)
            {
                IRow row = sheet.GetRow(row1);
                if (row == null)
                    continue;
                int begcol = col1;
                while (begcol <= col2)
                {
                    ICell cell = row.GetCell(begcol);
                    if (cell.CellType == CellType.String)
                    {
                        var value = cell.StringCellValue;
                        if (!string.IsNullOrWhiteSpace(value))
                        {
                            value = value.Replace(",", "").Trim();
                            double dbval;
                            if (double.TryParse(value, out dbval))
                            {
                                cell.SetCellType(CellType.Numeric);
                                cell.SetCellValue(dbval);
                            }
                        }
                    }


                    begcol += 1;
                }


                row1 += 1;
            }

        }


        private void aa(List listcolor, short color)
        {
            if (color > PaletteRecord.STANDARD_PALETTE_SIZE)
                return;
            if (listcolor.IndexOf(color) < 0)
            {
                listcolor.Add(color);
            }
        }

        private Dictionary CreateColor(HSSFWorkbook hssfWorkbook, List colors)
        {
            Dictionary dictret = new Dictionary();
            HSSFPalette palette = hssfWorkbook.GetCustomPalette();

            List listcolor = new List();

            short index = 0;
            IFont existsfont;
            while (index < hssfWorkbook.NumberOfFonts)
            {

                existsfont = hssfWorkbook.GetFontAt(index);
                aa(listcolor, existsfont.Color);

                index += 1;
            }
            index = 0;

            ICellStyle existscs;
            while (index < hssfWorkbook.NumCellStyles)
            {
                existscs = hssfWorkbook.GetCellStyleAt(index);
                aa(listcolor, existscs.FillBackgroundColor);
                aa(listcolor, existscs.FillForegroundColor);
                aa(listcolor, existscs.BottomBorderColor);
                aa(listcolor, existscs.TopBorderColor);
                aa(listcolor, existscs.LeftBorderColor);
                aa(listcolor, existscs.RightBorderColor);
                index += 1;
            }


            for (int i = 0; i < colors.Count; i++)
            {

                string color = colors[i];
                string[] colorstr = color.Replace("rgba(", "").Replace("rgb(", "").Replace(")", "").Split(',');

                byte r = Convert.ToByte(colorstr[0].Trim()), g = Convert.ToByte(colorstr[1].Trim()), b = Convert.ToByte(colorstr[2].Trim());


                HSSFColor hc = palette.FindColor(r, g, b);
                if (hc != null)
                {
                    dictret.Add(color, hc.Indexed);
                    listcolor.Add(hc.Indexed);
                    continue;
                }

                short colorindex = PaletteRecord.FIRST_COLOR_INDEX;
                short endcolorindex = PaletteRecord.STANDARD_PALETTE_SIZE;

                while (colorindex < endcolorindex)
                {
                    if (listcolor.IndexOf(colorindex) < 0)
                    {
                        palette.SetColorAtIndex(colorindex, r, g, b);
                        dictret.Add(color, colorindex);
                        listcolor.Add(colorindex);
                        break;
                    }
                    colorindex += 1;
                }

            }
            return dictret;
        }

        private Dictionary CreateColor(XSSFWorkbook hssfWorkbook, List colors)
        {
            Dictionary dictret = new Dictionary();


            List listcolor = new List();


            for (int i = 0; i < colors.Count; i++)
            {

                string color = colors[i];
                string[] colorstr = color.Replace("rgba(", "").Replace("rgb(", "").Replace(")", "").Split(',');

                byte r = Convert.ToByte(colorstr[0].Trim()), g = Convert.ToByte(colorstr[1].Trim()), b = Convert.ToByte(colorstr[2].Trim());

                dictret.Add(color, new XSSFColor(new byte[] { r, g, b }));

            }
            return dictret;
        }

        private Dictionary CreateCellStyle(IWorkbook book, ICellStyle df, List style, Dictionary diccolor)
        {
            Dictionary dicret = new Dictionary();

            foreach (string str in style)
            {
                string[] strs = str.Split(';');
                string fc = strs[0];
                string bc = strs[1];
                string fw = strs[2];
                string al = strs[3];
                string w = strs[4];

                if (fw == "bold")
                    fw = "400";
                ICellStyle cs;
                if (fc != "" || bc != "" || fw != "" || al != "")
                {
                    cs = book.CreateCellStyle();
                    cs.CloneStyleFrom(df);
                }
                else
                {
                    cs = df;
                }
                short color;

                if (bc != "" && diccolor.TryGetValue(bc, out color))
                {

                    cs.FillForegroundColor = color;
                    cs.FillPattern = FillPattern.SolidForeground;
                }
                color = 0;
                short fontcolor = 0;
                if (fw != "")
                    short.TryParse(fw, out color);
                if (fc != "")
                    diccolor.TryGetValue(fc, out fontcolor);
                if (color > 0 || fontcolor > 0)
                {
                    color *= 2;
                    IFont font = cs.GetFont(book);
                    IFont fontnew = book.CreateFont();
                    fontnew.Charset = font.Charset;
                    fontnew.Color = fontcolor == 0 ? font.Color : fontcolor;
                    fontnew.FontHeight = font.FontHeight;
                    fontnew.FontHeightInPoints = font.FontHeightInPoints;
                    fontnew.FontName = font.FontName;
                    fontnew.IsItalic = font.IsItalic;
                    fontnew.IsStrikeout = font.IsStrikeout;
                    fontnew.TypeOffset = font.TypeOffset;
                    fontnew.Underline = font.Underline;
                    fontnew.Boldweight = color == 0 ? font.Boldweight : color;
                    cs.SetFont(fontnew);
                }
                switch (al.ToLower())
                {
                    case "center":
                        cs.Alignment = HorizontalAlignment.Center;
                        break;
                    case "right":
                        cs.Alignment = HorizontalAlignment.Right;
                        break;
                }

                int? with = null;
                int widthtmp;
                if (int.TryParse(w, out widthtmp))
                    with = widthtmp;

                dicret.Add(str, new CellStyleWrap(with, cs));
            }

            return dicret;

        }

        private Dictionary CreateCellStyle(IWorkbook book, ICellStyle df, List style, Dictionary diccolor)
        {
            Dictionary dicret = new Dictionary();

            foreach (string str in style)
            {
                string[] strs = str.Split(';');
                string fc = strs[0];
                string bc = strs[1];
                string fw = strs[2];
                string al = strs[3];
                string w = strs[4];

                if (fw == "bold")
                    fw = "400";
                ICellStyle cs;
                if (fc != "" || bc != "" || fw != "" || al != "")
                {
                    cs = book.CreateCellStyle();
                    cs.CloneStyleFrom(df);
                }
                else
                {
                    cs = df;
                }
                short color;
                XSSFColor bcolor;

                if (bc != "" && diccolor.TryGetValue(bc, out bcolor))
                {
                    ((XSSFCellStyle)cs).SetFillForegroundColor(bcolor);
                    cs.FillPattern = FillPattern.SolidForeground;
                }
                color = 0;
                XSSFColor fontcolor = null;
                bool hasfc = false;
                if (fw != "")
                    short.TryParse(fw, out color);
                if (fc != "")
                    hasfc = diccolor.TryGetValue(fc, out fontcolor);
                if (color > 0 || hasfc)
                {
                    color *= 2;
                    IFont font = cs.GetFont(book);

                    IFont fontnew = book.CreateFont();
                    fontnew.Charset = font.Charset;
                    if (!hasfc)
                        fontnew.Color = font.Color;
                    else
                        ((XSSFFont)fontnew).SetColor(fontcolor);
                    fontnew.FontHeight = font.FontHeight;
                    fontnew.FontHeightInPoints = font.FontHeightInPoints;
                    fontnew.FontName = font.FontName;
                    fontnew.IsItalic = font.IsItalic;
                    fontnew.IsStrikeout = font.IsStrikeout;
                    fontnew.TypeOffset = font.TypeOffset;
                    fontnew.Underline = font.Underline;
                    fontnew.Boldweight = color == 0 ? font.Boldweight : color;
                    cs.SetFont(fontnew);
                }
                switch (al.ToLower())
                {
                    case "center":
                        cs.Alignment = HorizontalAlignment.Center;
                        break;
                    case "right":
                        cs.Alignment = HorizontalAlignment.Right;
                        break;
                }

                int? with = null;
                int widthtmp;
                if (int.TryParse(w, out widthtmp))
                    with = widthtmp;

                dicret.Add(str, new CellStyleWrap(with, cs));
            }

            return dicret;

        }


        public void ToExcel(string data, Stream stream, bool is2003)
        {
            try
            {
                SimpleTable st = JsonConvert.DeserializeObject(data);



                IWorkbook book = null;
                if (is2003)
                {
                    book = new HSSFWorkbook();
                }
                else
                {
                    book = new XSSFWorkbook();
                }

                ICellStyle dfcs = book.CreateCellStyle();
                dfcs.Alignment = HorizontalAlignment.Left;
                dfcs.VerticalAlignment = VerticalAlignment.Center;
                dfcs.BorderBottom = BorderStyle.Thin;
                dfcs.BorderLeft = BorderStyle.Thin;
                dfcs.BorderRight = BorderStyle.Thin;
                dfcs.BorderTop = BorderStyle.Thin;
                if (st.IsReadOnly)
                    dfcs.IsLocked = true;


                Dictionary dicstyle = null;
                if (is2003)
                {
                    Dictionary dicColor = CreateColor((HSSFWorkbook)book, st.Colors);
                    dicstyle = CreateCellStyle(book, dfcs, st.Styles, dicColor);
                }
                else
                {
                    Dictionary dicColor = CreateColor((XSSFWorkbook)book, st.Colors);
                    dicstyle = CreateCellStyle(book, dfcs, st.Styles, dicColor);
                }

                ISheet sheet = book.CreateSheet();

                IDrawing patr = sheet.CreateDrawingPatriarch();
                int rowindex = 0;
                foreach (List cells in st.Rows)
                {
                    IRow row = sheet.CreateRow(rowindex);
                    int cellindex = 0;
                    foreach (SimpleCell sc in cells)
                    {
                        ICell cell = row.CreateCell(cellindex);
                        if (!string.IsNullOrEmpty(sc.T))
                        {
                            cell.SetCellValue(sc.T);
                        }

                        CellStyleWrap csw = default(CellStyleWrap);
                        if (sc.S != null && dicstyle.TryGetValue(sc.S, out csw))
                        {
                            cell.CellStyle = csw.CellStyle;
                        }
                        else
                        {
                            cell.CellStyle = dfcs;
                        }

                        if (!string.IsNullOrEmpty(sc.RK))
                        {
                            IComment comment = null;
                            if (is2003)
                            {
                                comment = patr.CreateCellComment(new HSSFClientAnchor(255, 125, 1023, 150, cellindex, rowindex, cellindex + 2, rowindex + 4));
                                comment.String = new HSSFRichTextString(sc.RK);
                            }
                            else
                            {
                                comment = patr.CreateCellComment(new XSSFClientAnchor(255, 125, 1023, 150, cellindex, rowindex, cellindex + 2, rowindex + 4));
                                comment.String = new XSSFRichTextString(sc.RK);
                            }

                            cell.CellComment = comment;
                        }

                        if (sc.C > 0 || sc.R > 0)
                        {
                            sheet.AddMergedRegion(new NPOI241.SS.Util.CellRangeAddress(rowindex, rowindex + (sc.R == 0 ? 0 : sc.R - 1), cellindex, cellindex + (sc.C == 0 ? 0 : sc.C - 1)));
                        }

                        cellindex += 1;
                    }
                    rowindex += 1;
                }



                int lastrowindex = rowindex;



                List rows = st.Rows[st.FRow];
                int index = 0;
                foreach (SimpleCell sc in rows)
                {
                    CellStyleWrap csw = default(CellStyleWrap);
                    if (sc.S != null && dicstyle.TryGetValue(sc.S, out csw) && csw.Width != null)
                    {
                        sheet.SetColumnWidth(index, csw.Width.Value * 256);
                    }
                    index += 1;
                }

                if (st.FCol > 0 || st.FRow > 0)
                {
                    sheet.CreateFreezePane(st.FCol, st.FRow);
                }
                if (st.Chart != null && st.Chart.Count > 0)
                {
                    CreateChart(sheet, 0, 0 + 10, lastrowindex + 3, lastrowindex + 3 + 20, st);
                }

                if (st.IsReadOnly)
                {
                    sheet.ProtectSheet(st.PWD);
                }
                book.Write(stream);


            }
            catch
            {
                throw;
            }

        }



        public void ToExcel(Stream stream, DataTable[] dts, NameValueCollection[] titles, bool is2003)
        {
            try
            {
                IWorkbook book = null;
                if (is2003)
                {
                    book = new HSSFWorkbook();
                }
                else
                {
                    book = new XSSFWorkbook();
                }

                ICellStyle dfcs = book.CreateCellStyle();
                dfcs.Alignment = HorizontalAlignment.Left;
                dfcs.VerticalAlignment = VerticalAlignment.Center;
                dfcs.BorderBottom = BorderStyle.Thin;
                dfcs.BorderLeft = BorderStyle.Thin;
                dfcs.BorderRight = BorderStyle.Thin;
                dfcs.BorderTop = BorderStyle.Thin;

                int i = 0;

                foreach (DataTable dt in dts)
                {
                    ISheet sheet = book.CreateSheet(dt.TableName);

                    NameValueCollection nvc = titles[i];
                    int rowindex = 0;
                    int cellindex = 0;
                    IRow row;
                    ICell cell;
                    row = sheet.CreateRow(rowindex);
                    foreach (string key in nvc)
                    {
                        cell = row.CreateCell(cellindex);
                        cell.CellStyle = dfcs;
                        cell.SetCellValue(nvc[key]);
                        cellindex += 1;
                    }

                    foreach (DataRow dr in dt.Rows)
                    {
                        rowindex += 1;
                        row = sheet.CreateRow(rowindex);
                        cellindex = 0;
                        foreach (string key in nvc)
                        {
                            cell = row.CreateCell(cellindex);
                            cell.CellStyle = dfcs;
                            cell.SetCellValue(dr[key].ToString());
                            cellindex += 1;
                        }
                    }
                    i += 1;
                }
                book.Write(stream);
            }
            catch
            {
                throw;
            }
        }


        public class ExcelHelperSheetInfo
        {

            /// 
            /// 新sheet数据，每一个数据项生产一个sheet页
            /// 
            public List NewSheetData { get; set; }

            /// 
            /// 模板Sheet
            /// 
            public ISheet ModelSheet { get; set; }

        }

        /// 
        /// 绑定数据前缀,全部小写，默认$
        /// 
        public string Prefix
        {
            get;
            set;
        }

        /// 
        /// 列表开始前缀,,全部小写默认$list.
        /// 
        public string BeginListPrefix
        {
            get;
            set;
        }

        /// 
        /// 列表结束前缀,全部小写,默认$listend.
        /// 
        public string EndListPrefix
        {
            get;
            set;
        }

        /// 
        /// 自动行高前缀,全部小写 默认$auotheight,放到列后面
        /// 
        public string AutoHeightPrefix
        {
            get;
            set;
        }

        //列表序列号字符
        public string ListSeqNoStr
        {
            get;
            set;
        }

        /// 
        /// 
        /// 
        /// 绑定数据前缀，默认$
        /// 列表开始前缀,默认$list.
        /// 列表结束前缀,默认$listend.
        public Helper(string prefix = "$", string beglistprefix = "$list.", string endlistprefix = "$listend.", string seqnostr = "listseqno", string autoheight = "$auotheight")
        {
            this.Prefix = prefix;
            this.BeginListPrefix = beglistprefix;
            this.EndListPrefix = endlistprefix;
            this.ListSeqNoStr = seqnostr;
            this.AutoHeightPrefix = autoheight;
        }
        /// 
        /// 检查是否是2003以前的版本，根据后缀判断
        /// 
        /// 
        /// 
        public static bool Is2003(string file)
        {
            string ext = Path.GetExtension(file);

            return ext.ToLower() == ".xls";
        }


        /// 
        /// 返回正确的sheet名称
        /// 
        /// 
        /// 
        public static string GetSheetName(string sheetname)
        {
            sheetname = sheetname.Replace("//", "").Replace("\"", "").Replace("[", "").Replace("]", "");
            sheetname = sheetname.Replace("<", "").Replace(">", "").Replace("\r", "").Replace("\n", "");
            sheetname = sheetname.Replace("*", "").Replace("|", "").Replace(":", "");
            sheetname = sheetname.Replace("?", "").Replace("/", "");
            return sheetname;
        }


        /// 
        /// 按模板导出数据，保存到流
        /// 
        /// 模板路径
        /// 数据
        /// 根据数据创建sheet
        /// 保存到流
        /// 数据填充完成后执行的方法
        public IWorkbook Export(string modalfilepath, Func> fncreate, Action acend = null)
        {

            try
            {


                IWorkbook excel = null;

                using (FileStream fs = new FileStream(modalfilepath, FileMode.Open, FileAccess.Read, FileShare.Read))
                {
                    if (Is2003(modalfilepath))
                    {
                        excel = new HSSFWorkbook(fs);
                    }
                    else
                    {
                        excel = new XSSFWorkbook(fs);
                    }

                    List list = fncreate(excel);



                    foreach (ExcelHelperSheetInfo dr in list)
                    {
                        ISheet sheet = dr.ModelSheet;
                        int modelsheetindex = excel.GetSheetIndex(sheet);

                        foreach (object sheetData in dr.NewSheetData)
                        {
                            ISheet sheetnew = excel.CloneSheet(modelsheetindex);
                            ExprotGongYiBiao(sheetnew, sheetData);
                            if (acend != null)
                            {
                                acend(excel, sheetnew, dr);
                            }
                        }
                        excel.RemoveSheetAt(modelsheetindex);
                    }
                }

                return excel;

            }
            catch
            {

                throw;
            }

        }

        /// 
        /// 按模板导出单个sheet
        /// 
        /// 
        /// 
        public void ExprotGongYiBiao(ISheet sheetnew, object dicdata)
        {
            int maxrow = sheetnew.LastRowNum;

            int minrow = 0;
            int newrowno = 0;

            sheetnew.FitToPage = true;

            while (minrow <= maxrow)
            {
                IRow row = sheetnew.GetRow(minrow);
                if (row == null)
                {
                    minrow += 1;
                    continue;
                }


                int cellindex = 0;
                int maxcell = row.LastCellNum;

                bool islist = false, islistend = false;
                int listbegnum = 0;

                string listkey = "";
                List listkeys = null;
                bool hassetdata = false;
                bool autoheight = false;
                while (cellindex <= maxcell)
                {
                    var modelcell = row.GetCell(cellindex);
                    if (modelcell == null)
                    {
                        cellindex += 1;
                        continue;
                    }

                    string cellvalue = modelcell.ToString().Trim();
                    string cellvaluelower = cellvalue.ToLower();

                    if (cellvaluelower.StartsWith(BeginListPrefix))
                    {
                        islist = true;
                        listbegnum = cellindex;
                        cellvalue = cellvalue.Substring(BeginListPrefix.Length);
                        listkey = cellvalue.Split(' ')[0];
                        listkeys = new List();
                        listkeys.Add(cellvalue.Split(' ')[1]);
                    }
                    else if (islist)
                    {
                        if (cellvaluelower.StartsWith(EndListPrefix))
                        {
                            islistend = true;
                            cellvalue = cellvalue.Substring(EndListPrefix.Length);
                            listkeys.Add(cellvalue);
                        }
                        else if (cellvaluelower == AutoHeightPrefix)
                        {
                            autoheight = true;
                            row.RemoveCell(modelcell);
                        }
                        else if (cellvaluelower.StartsWith(Prefix))
                        {
                            listkeys.Add(cellvalue.Substring(Prefix.Length));
                        }
                        else if (!islistend)
                        {
                            listkeys.Add("");
                        }
                    }
                    else if (cellvaluelower == AutoHeightPrefix)
                    {
                        autoheight = true;
                        row.RemoveCell(modelcell);
                    }
                    else if (cellvaluelower.StartsWith(Prefix))
                    {
                        cellvalue = cellvalue.Substring(Prefix.Length);
                        SetCellValue(modelcell, cellvalue, dicdata);
                        hassetdata = true;
                    }
                    cellindex += 1;
                }
                if (islist)
                {
                    newrowno = SetList(sheetnew, row, minrow, listkey, listkeys, listbegnum, dicdata, ListSeqNoStr, autoheight);

                    minrow += newrowno == 0 ? 1 : newrowno;

                    maxrow += newrowno;



                }
                else
                {
                    if (hassetdata && autoheight)
                    {
                        SetRowHeight(row);
                    }
                    minrow += 1;

                }
            }







        }


        /// 
        /// 解析字符串转换成对象字符串例如Order.OrderNo,Order.Detail.ID，如果错误返回error
        /// 
        /// 
        /// 
        /// 
        public static object GetDataByKey(string key, object dicdata)
        {
            string[] keys = key.Split('.');
            object ret = dicdata;
            try
            {
                foreach (string str in keys)
                {

                    if (ret == null)
                        return null;

                    if (ret is IDictionary)
                    {
                        ret = (ret as IDictionary)[str];
                        continue;
                    }

                    if (ret is DataRow)
                    {
                        ret = (ret as DataRow)[str];
                        continue;
                    }
                    if (ret is DataRowView)
                    {
                        ret = (ret as DataRowView)[str];
                        continue;
                    }

                    PropertyInfo pi = ret.GetType().GetProperty(str, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
                    if (pi == null)
                    {
                        throw new Exception(ret.GetType().FullName + "不包含属性:" + str);
                    }
                    if (!pi.CanRead)
                    {
                        throw new Exception(ret.GetType().FullName + "属性:" + str + "不可以读");
                    }
                    ret = pi.GetValue(ret);
                }
            }
            catch (Exception ex)
            {
                return "Error:" + ex.Message;
            }
            return ret;
        }

        /// 
        /// 按模板设置单元格数据
        /// 
        /// 
        /// 
        /// 
        public static void SetCellValue(ICell cell, string key, object dicdata)
        {
            object value = GetDataByKey(key, dicdata);

            if (value != null && value != DBNull.Value)
            {
                switch (value.GetType().Name.ToLower())
                {
                    case "int":
                    case "int32":
                    case "int16":
                    case "short":
                    case "byte":
                    case "double":
                    case "float":
                    case "decimal":
                    case "long":
                        cell.SetCellValue(Convert.ToDouble(value));
                        break;
                    case "datetime":
                        cell.SetCellValue(Convert.ToDateTime(value));
                        break;
                    default:
                        cell.SetCellValue(value.ToString());
                        break;
                }
            }
            else
            {
                cell.SetCellValue("");
            }
        }


        public static int SetList(ISheet sheet, IRow row, int begrowindex, string listkey, List keys, int listbegcell, object dicdata, string seqnostr, bool autoheight)
        {

            bool has = false;
            int total = 0;
            object listdata = GetDataByKey(listkey, dicdata);

            if (listdata == null || listdata == DBNull.Value)
                goto lblend;
            if (!(listdata is IEnumerable))
                goto lblend;

            IEnumerator aa = (listdata as IEnumerable).GetEnumerator();
            aa.Reset();

            ICell cellnew;

            int newrowindex = begrowindex;
            for (int i = 0; aa.MoveNext(); i++)
            {
                total += 1;
                IRow newrow;

                if (i == 0)
                {
                    newrow = row;
                }
                else
                {
                    newrow = sheet.CopyRow(begrowindex, newrowindex);
                    newrow.Height = row.Height;
                }
                newrowindex += 1;
                has = true;

                int cellindex = listbegcell;
                object dr = aa.Current;

                foreach (string str in keys)
                {

                    if (str == "")
                    {
                        cellindex += 1;
                        continue;
                    }

                    cellnew = newrow.GetCell(cellindex);

                    if (str == seqnostr)
                    {
                        cellnew.SetCellValue(i + 1);

                    }
                    else
                    {
                        SetCellValue(cellnew, str, dr);
                    }
                    cellindex += 1;
                }
                if (autoheight)
                    SetRowHeight(newrow);
            }

        lblend:
            if (!has)
            {
                int cellindex = listbegcell;
                foreach (string key in keys)
                {
                    if (key == "")
                    {
                        cellindex += 1;
                        continue;
                    }
                    cellnew = row.GetCell(cellindex);
                    cellnew.SetCellValue("");
                }
                row.Height = row.Sheet.DefaultRowHeight;
            }
            return total;
        }


        public static float GetCellWidth(ICell cell)
        {
            if (cell == null)
                return 0;
            ISheet sheet = cell.Sheet;
            int mcount = sheet.NumMergedRegions;

            CellRangeAddress mergerange = null;

            for (int i = 0; i < mcount; i++)
            {
                CellRangeAddress range = sheet.GetMergedRegion(i);

                if (range.FirstColumn <= cell.ColumnIndex
                    && range.LastColumn >= cell.ColumnIndex
                    && range.FirstRow <= cell.RowIndex
                    && range.LastRow >= cell.RowIndex)
                {

                    if (range.FirstColumn == cell.ColumnIndex && range.FirstRow == cell.RowIndex)
                    {
                        mergerange = range;
                    }
                    else
                    {
                        break;
                    }
                }
            }

            if (mergerange != null)
            {
                float width = 0;
                for (int i = mergerange.FirstColumn; i <= mergerange.LastColumn; i++)
                {
                    width += sheet.GetColumnWidthInPixels(i);
                }
                return width;
            }
            return sheet.GetColumnWidthInPixels(cell.ColumnIndex);
        }

        /// 
        /// 
        /// 
        /// 
        /// 从0开始
        /// 从0开始
        /// 从0开始，请比真实位置多一行
        /// 从0开始，请比真实位置多一列
        /// 
        public static void AddImg(ISheet sheet, int begrow, int begcol, int endrow, int endcol, string filepath)
        {

            IWorkbook excel = sheet.Workbook;
            byte[] imgdata = File.ReadAllBytes(filepath);

            PictureType imgtype = PictureType.None;
            switch (Path.GetExtension(filepath).ToLower())
            { 
                case ".png":
                    imgtype = PictureType.PNG;
                    break;
                case ".jpg":
                    imgtype = PictureType.JPEG;
                    break;
                case ".gif":
                    imgtype = PictureType.GIF;
                    break;
            }

            int pictureIdx = excel.AddPicture(imgdata, imgtype);
            IDrawing patriarch = sheet.CreateDrawingPatriarch();
            // 插图片的位置  HSSFClientAnchor（dx1,dy1,dx2,dy2,col1,row1,col2,row2) 后面再作解释
            IClientAnchor anchor = null;
            if (excel is HSSFWorkbook)

                anchor = new HSSFClientAnchor(0, 0, 0, 0, begcol, begrow, endcol, endrow);
            else
                anchor = new XSSFClientAnchor(0, 0, 0, 0, begcol, begrow, endcol, endrow);


            //把图片插到相应的位置
            IPicture pict = (IPicture)patriarch.CreatePicture(anchor, pictureIdx);

        }


        public static void SetRowHeight(IRow row)
        {


            ICell cell = null;

            ISheet sheet = row.Sheet;
            IWorkbook book = sheet.Workbook;
            IFont font = null;

            float rowheight = row.HeightInPoints;

            int begnum = row.FirstCellNum;

            StringFormat sf = new StringFormat(StringFormat.GenericDefault);
            sf.Trimming = StringTrimming.Word;

            for (; begnum <= row.LastCellNum; begnum++)
            {
                cell = row.GetCell(begnum);
                if (cell == null)
                    continue;
                string value = cell.ToString();
                if (cell.CellStyle != null)
                    font = cell.CellStyle.GetFont(book);
                if (font == null || string.IsNullOrWhiteSpace(value))
                    continue;
                float width = GetCellWidth(cell);

                if (width >= 0 && width <= 0)
                    continue;


                Font newfont = new Font(font.FontName, (float)(font.FontHeightInPoints), GraphicsUnit.Point);

                SizeF maxsize = new SizeF(width, float.MaxValue);
                int c0, lc;
                //需要每次重新生成位图进行测量
                using (var graphics = Graphics.FromHwnd(IntPtr.Zero))
                {
                    var size1 = graphics.MeasureString(value, newfont, maxsize, sf, out c0, out lc);
                    rowheight = Math.Max(rowheight, size1.Height);//(float)( lc * Math.Max(sheet.DefaultRowHeightInPoints, font.FontHeightInPoints))
                }
            }

            row.HeightInPoints = rowheight;// beishu* rowheight;

        }
    }
} 
  
 
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(excel,npoi)

        

            

                
    
                    
  • pyecharts——绘制柱形图折线图
                        2224070247
信息可视化pythonjava数据可视化
                        
    一、pyecharts概述自2013年6月百度EFE(ExcellentFrontEnd）数据可视化团队研发的ECharts1.0发布到GitHub网站以来，ECharts一直备受业界权威的关注并获得广泛好评，成为目前成熟且流行的数据可视化图表工具，被应用到诸多数据可视化的开发领域。Python作为数据分析领域最受欢迎的语言，也加入ECharts的使用行列，并研发出方便Python开发者使用的数据
    
                    
    • 
                    
  • 《Python数据分析实战终极指南》
                        xjt921122
python数据分析开发语言
                        
    对于分析师来说，大家在学习Python数据分析的路上，多多少少都遇到过很多大坑**，有关于技能和思维的**：Excel已经没办法处理现有的数据量了，应该学Python吗？找了一大堆Python和Pandas的资料来学习，为什么自己动手就懵了？跟着比赛类公开数据分析案例练了很久，为什么当自己面对数据需求还是只会数据处理而没有分析思路？学了对比、细分、聚类分析，也会用PEST、波特五力这类分析法，为啥
    
                    
    • 
                    
  • 【Golang】实现 Excel 文件下载功能
                        RumIV
Golanggolangexcel开发语言
                        
    在当今的网络应用开发中，提供数据导出功能是一项常见的需求。Excel作为一种广泛使用的电子表格格式，通常是数据导出的首选格式之一。在本教程中，我们将学习如何使用Go语言和GinWeb框架来创建一个Excel文件，并允许用户通过HTTP请求下载该文件。准备工作在开始之前，请确保您的开发环境中已经安装了Go语言和相关的开发工具。此外，您还需要安装GinWeb框架和excelize包，这两个包都将用于我
    
                    
    • 
                    
  • 【Golang】使用 Golang 语言和 excelize 库将数据写入Excel
                        不爱洗脚的小滕
golangexcel开发语言
                        
    文章目录前言一、Excelize简介二、代码实现1.获取依赖2.示例代码三、总结前言在数据处理和分析中，Excel作为一种常见的电子表格格式，被广泛应用于各种场景。然而，如何在Go语言中有效地处理Excel文件呢？在这篇博客中，我将介绍如何使用Go语言和excelize库将数据写入Excel文件。一、Excelize简介Excelize是一个用于读取和写入MicrosoftExcel™(XLSX)
    
                    
    • 
                    
  • python编写直方图和饼图
                        2301_80421078
python开发语言
                        
    1.直方图#直方图的绘制#语法格式：plt.hist(x,bins),其中x:数据集；bins:统计数据的分布区间importmatplotlib.pyplotaspltimportpandasaspd#导入文件excel=pd.read_excel('成绩.xlsx')#print(excel)#避免乱码plt.rcParams['font.sans-serif']=['SimHei']x=ex
    
                    
    • 
                    
  • 如何在Excel中使用COLUMN函数
                        Excel客旅

                        
    一、COLUMN函数介绍1.COLUMN函数是用来得到指定单元格的列号。比如“=COLUMN(B1)”，得到的就是B1的列号为“2”。2.如果括号里面为空，什么都不引用，则默认引用公式所在单元格的列号。3.COLUMN函数还可以引用区域。首先我们选中B1至F1的单元格区域，然后输入公式“=COLUMN(B:F)”或者“=COLUMN(B1:F1)”，然后按Ctrl+Shift+Enter键。二、用
    
                    
    • 
                    
  • 听学长学姐录音有感
                        dd7ac5aef048

                        
    在听学长学姐的录音时，我记下了一些关键词来帮助自己做出总结。首先，办公软件的应用能力是个高频词，无论是税务部门还是企业、银行等，都需要对办公软件的熟练应用来提升办事效率，比较常规的Excel、PS其实是有基础在的，但要更加重视，不要慢慢丢失了这些能力，还要加强使用能力。读写能力、沟通能力也是不断被强调。对于这方面的能力，大学就是最好的训练场，重视每一次写作的锻炼机会，在过程中，你的检索能力、自我学
    
                    
    • 
                    
  • Python办公自动化案例（二）：对比两个Excel数据内容并标出不同
                        衍生星球
pythonexcel高阶办公办公自动化
                        
    案例：对比两个word文档并找出不同。在数据处理和分析的日常工作中，我们经常需要比较两个Excel文件的差异。这可能是为了验证数据的一致性、检查数据的准确性，或者在版本控制中追踪更改。手动比较这些文件不仅耗时，而且容易出错。幸运的是，Python的openpyxl库提供了一种自动化这一过程的方法。步骤1：安装openpyxl在命令行中输入以下命令来安装pipinstallopenpyxl步骤2:编
    
                    
    • 
                    
  • 【python版】示波器输出的csv文件（时间与电压数据）如何转换为频率与幅值【方法②】
                        cxylay
pythonpython开发语言示波器csv文件频谱频域时域
                        
    要将示波器输出的CSV文件中包含的时间与电压数据转换为频率与幅值数据，你可以按照以下步骤进行处理。这里假设你的数据是一个周期性信号，可以通过傅里叶变换来实现这种转换。1、准备数据①导入CSV文件首先，使用Python、Excel或任何数据处理工具导入你的CSV文件。CSV文件中应该有两列数据，分别为时间（time）和电压（voltage）。②检查数据确保时间列的单位是一致的（例如秒），电压列是以伏
    
                    
    • 
                    
  • 用html打开dbf文件,dbf文件怎么打开？dbf是什么文件？
                        今天也要开心呢
用html打开dbf文件
                        
    dbf文件怎么打开？dbf文件是一种数据库格式文件，用于存储数据库的数据。一些用户在工作的过程中，可能会碰到后缀名为dbf的文件，正常双击是无法打开的，我们需要借助软件才能打开dbf文件。下面给大家推荐一些软件来打开dbf文件，具体请看下文。工具/原料：1、Exceldbf是什么文件？dbf文件是一种数据库格式文件，Foxbase，Dbase，VisualFoxPro等数据库处理系统会运用到dbf
    
                    
    • 
                    
  • excel打开html非常慢,解决EXCEL表格打开缓慢，文件异常臃肿庞大
                        史文林
excel打开html非常慢
                        
    相信很多每天在操作EXCEL的朋友，会觉得自己的表格一天比一天大，一天比一天打开慢，但表格里面实际也没多少内容。这其中的主要原因之一，就是你喜欢在多个表格之间互相复制来复制去，粘贴的时候也不是使用选择性粘贴。把原来表格里面的所有样式设置内容和不必要的数据都复制过来了，导致整个工作薄变得异常臃肿庞大。接下来我们就来分析下具体发生了什么情况和如何解决这个问题吧！1.看这个“源文件”，文件大小居然达到了
    
                    
    • 
                    
  • html打开本地excel文件夹,html使用excel表格数据库-html读取本地excel文件并展示
                        睿理

                        
    html表格如何导入到excel中在vs里面用添加数据源就可以啊,再使用数据控件,就可以操作.添加数据源可以用odbc数据源,两种方式1,是在控制面板的管理工具里在ODBC里先设置好.2,是使用连接字符串.用vs的添加数据源向导做.html中有没有类似excel表格，可以填数的表格控件？首先html不能读取本地excel文件其次就算是javascript也是不允许的这是为了安全考虑如果前端脚本可以
    
                    
    • 
                    
  • Java在Controller生成Excel供前端直接下载
                        pengjunlee
SpringBoot重点详解导出文件POIexcelController
                        
    在许多企业办公系统中，经常会有用户要求，需要对数据进行统计并且可以直接下载Excel文件，这样子的话，既然客户提出了要求，我们就应该去满足吖，毕竟客户是上帝嘛，那么我们如何去实现呢？且看我为你一一道来。POI简介JakartaPOI是一套用于访问微软格式文档的JavaAPI。JakartaPOI有很多组件组成，其中有用于操作Excel格式文件的HSSF和用于操作Word的HWPF，在各种组件中目前
    
                    
    • 
                    
  • 解决前端导出excel文件，打开为乱码
                        荔枝，你让我拿什么荔枝！
vue前端elementuivue.js
                        
    前端开发中，导入和导出文件是比较常见的业务场景，常见的情况是：后端返回一个二进制的流文件，前端将其转化为excel文件即可。但是往往会出现转化后的excel文件内容位乱码的情况，本文中提供了两个解决方案：方案一：用户自定义上传方法添加附件添加附件代码解读：上述代码采用了element-ui的el-upload文件上传的组件。改组件有两种文件上传的方式：1.组件自带的上传方法，只需要给其设置acti
    
                    
    • 
                    
  • SpringBoot2：web开发常用功能实现及原理解析-整合EasyExcel实现Excel导入导出功能
                        生产队队长
SpringAllexcelspringboot
                        
    1、工程包结构主要是这5个Java类2、导入EasyExcel包这里同时贴出其他相关springboot的基础包org.springframework.bootspring-boot-starter-weborg.springframework.bootspring-boot-devtoolsruntimetrueorg.springframework.bootspring-boot-config
    
                    
    • 
                    
  • 大数据新视界 --大数据大厂之揭秘大数据时代 Excel 魔法：大厂数据分析师进阶秘籍
                        青云交
大数据新视界Excel数据分析函数公式数据透视表图表功能规划求解数据分析工具库大数据新视界数据库
                        
    亲爱的朋友们，热烈欢迎你们来到青云交的博客！能与你们在此邂逅，我满心欢喜，深感无比荣幸。在这个瞬息万变的时代，我们每个人都在苦苦追寻一处能让心灵安然栖息的港湾。而我的博客，正是这样一个温暖美好的所在。在这里，你们不仅能够收获既富有趣味又极为实用的内容知识，还可以毫无拘束地畅所欲言，尽情分享自己独特的见解。我真诚地期待着你们的到来，愿我们能在这片小小的天地里共同成长，共同进步。本博客的精华专栏：Ja
    
                    
    • 
                    
  • Python进阶之Openpyxl详解
                        夏天Aileft
Pythonpython开发语言openpyxl
                        
    ✨前言openpyxl是一个用于读取和编辑Excel文件（即.xlsx格式文件）的Python库。以下是openpyxl的详细介绍及常见操作示例✨安装在使用openpyxl之前，需要先安装它。可以通过以下命令安装：pipinstallopenpyxl✨加载工作簿#加载已经存在的工作簿wb=openpyxl.load_workbook('example.xlsx')#创建一个新的工作簿wb=open
    
                    
    • 
                    
  • python 标准库之openpyxl的常规操作
                        真的学不了一点。。。
Python学习python
                        
    目录openpyxl（Excel文件处理模块）读sheet读sheet中单元格合并单元格openpyxl模块基本用法安装方法基本使用读取Excel文档（一）获取工作表（二）获取单元格（三）获取行和列写入Excel文档（一）写入单元格（二）保存文件设置单元格样式（一）字体（二）对齐方式（三）边框（四）设置行高和列宽（五）合并和拆分单元格openpyxl(Excel文件处理模块)读sheet读取Exc
    
                    
    • 
                    
  • EasyExcel实现复杂Excel的导入
                        小卡车555
java处理excelexcel
                        
    最近项目中遇到一个复杂的Excel的导入，并且数据量较大。因为数据不规则，所以只能使用POI进行自定义读取，但是发现数据量大之后，读取数据非常耗时。后面换成EasyExcel，性能起飞。1.Excel样板如上图，需要导入学校学生信息。前面三列，固定为学校班级信息，可以理解为主表。从第四列开始，为学生信息，其中一列为一条子表信息。2.具体实现引入EasyExcel的依赖com.alibabaeasy
    
                    
    • 
                    
  • pandas读取xlsx文件使用sqlachemy写到数据库
                        hzw0510
pandaspandas数据库
                        
    pandas读取xlsx文件使用sqlachemy写到数据库要使用pandas和SQLAlchemy将Excel文件中的数据读取到数据库中，你可以按照以下步骤进行操作：安装必要的库：确保你已经安装了pandas、SQLAlchemy和openpyxl（用于读取Excel文件）。可以使用以下命令安装：pipinstallpandassqlalchemyopenpyxl如果你使用的是特定的数据库（如S
    
                    
    • 
                    
  • Apache POI用法
                        JH3073
apache
                        
    一、ApachePOI是什么ApachePOI是用Java编写的免费开源的跨平台的JavaAPI，ApachePOI提供API给Java程序对MicrosoftOffice格式档案读和写的功能，其中使用最多的就是使用POI操作Excel文件。二、POI结构HSSF－提供读写MicrosoftExcelXLS格式档案的功能XSSF－提供读写MicrosoftExcelOOXMLXLSX格式档案的功能
    
                    
    • 
                    
  • python 问题 ‘list‘ object cannot be interpreted as an integer 和‘int‘ object is not iterable
                        annekqiu
python
                        
    访问同一个excel表格（含有多个sheet）importnumpyasnpimportpandasaspdimportxlrd#读取excel的库importxlwt#写excel的库data=xlrd.open_workbook('./161005.xlsx')#打开excel文件读取数据table=data.sheets()[0]#读取sheet1h=table.ncols#获得列表数目a1
    
                    
    • 
                    
  • 2021-07-31
                        阿诗玛_6209

                        
    姓名：赵丽娟【日精进打卡第1262天】【知～学习】《六项精进》大纲0遍，共407遍；《六项精进》通篇0遍，共172遍；《大学》0遍；共607遍【今年计划读6本书】《从总帐到总监》结束《理解人性》26《“偷懒”的技术，财务excel》26《活法》ok.《干法》ok《可复制的领导力》ok《把信送给加西亚》008-011《避税：无限接近但不逾越》076【经典名句】向日葵说，只要你朝着阳光努力向上，生活便
    
                    
    • 
                    
  • 多表逐级关联报表，使用poi方法导出excel
                        LCF_全博

                        
    难点要求多表关联导出，简单介绍：有A1表，A2表，B表，C表，A1和A2是一对多的关系，B表和A1表也是一对多的关系，C表和B表是一对多的关系。这是简化的业务逻辑，表之间的关系就类似这种。完成对关联导出。实现思路熟悉poi导出的可能会知道，报表的导出总体思路是将数据按照excel的每一行去写入数据的，假如是有序的数据还好说点，比如单表的导出，直接单表查询出来，循环写入每一个excel行就行，这种做
    
                    
    • 
                    
  • 查找与替换那些你不知道的事
                        我是荷叶田田

                        
    今天学习的内容是查找和替换，又get到不少新知识。接着我先向大家介绍下今天的复盘成果。回顾目标：1、查找和替换的不同玩法2、晚上的分享做两张图3、联系小伙伴做逐字稿评估结果：Excel学习实践完成、图片提前做了出来、跟小伙伴的沟通也很愉快分析过程：1、查找和替换的应用又有新的收获，比如快速制作目录，不用借助超链接哦！比如查找新神器everthing，我用了一下，简直不要太好用。有一点耽误了太多时间
    
                    
    • 
                    
  • excel表格解析数据
                        摸鱼的张三
exceljava前端
                        
    varpersons=[];functionexcelChange(e){varfiles=e.filesvarfileReader=newFileReader();fileReader.onload=function(ev){console.log(ev);vardata=ev.target.resultvarworkbook=XLSX.read(data,{type:'binary'})var
    
                    
    • 
                    
  • 我的两周~E战到底训练营
                        花睡

                        
    Office职场大学的EXCEL训练营，已经两周了，这短短的十几天，我真是冰火两重天，抓狂后的欣喜，想要放弃后的坚持，并且深深的体会了一把"学渣"的感受……从这么几个方面来说吧。首先，是制度。开始建群的时候，各种规则，各种改名等一堆的事情，队长每次耐心沟通。我那两天正好忙的翻天，一肚子火，心想安安静静学知识就好了呗，想要直接放弃，不学了，又觉得这个群这样叽叽歪歪，喊口号啥的，到底是个啥名堂，还有点
    
                    
    • 
                    
  • vba把excel导入mysql_VBA将Excel数据表格直接导入SQL Server数据库
                        weixin_39757040

                        
    [vb]代码库'把当前Excel工作簿的所有工作表的数据表格转换为Insert语句并导入SQLServer数据库中。OptionExplicitPublicSubCreateAllSheetsInsertScript()OnErrorGoToErrorHandler'recordsetandconnectionvariablesDimRowAsLongDimColAsInteger'Tostore
    
                    
    • 
                    
  • VBA 把Excel表当做一个大数据库来操作
                        码猩
excelVBA专栏excel数据库
                        
    VBA把Excel表当做一个大数据库来操作SubSqlQueryBJD(strBillNoAsString)DimstrSqlAsStringDimarrCol()AsStringDimstrLineWhereDimarrWhere()AsStringDimstrWhereValAsStringDimstrResultShowRngAsStringDimstrWhereRngAsStringDim
    
                    
    • 
                    
  • Excel插件，批量生成含二维码和条形码的产品标签
                        罗刚君

                        
    Excel插件，批量生成含二维码和条形码的产品标签Excel中批量生成产品标签，标签中同时包含二维码和条形码。工厂出货时必备，有了此标签可以扫码入库，效率提升数几倍。
    
                    
    • 
                                
  • tomcat基础与部署发布
                                    暗黑小菠萝
Tomcat java web
                                    
    从51cto搬家了，以后会更新在这里方便自己查看。 
做项目一直用tomcat，都是配置到eclipse中使用，这几天有时间整理一下使用心得，有一些自己配置遇到的细节问题。 
Tomcat：一个Servlets和JSP页面的容器，以提供网站服务。 
一、Tomcat安装 
    安装方式：①运行.exe安装包 
     &n
    
                                
    • 
                                
  • 网站架构发展的过程
                                    ayaoxinchao
数据库应用服务器网站架构
                                    
    1.初始阶段网站架构：应用程序、数据库、文件等资源在同一个服务器上 
2.应用服务和数据服务分离：应用服务器、数据库服务器、文件服务器 
3.使用缓存改善网站性能：为应用服务器提供本地缓存，但受限于应用服务器的内存容量，可以使用专门的缓存服务器，提供分布式缓存服务器架构 
4.使用应用服务器集群改善网站的并发处理能力：使用负载均衡调度服务器，将来自客户端浏览器的访问请求分发到应用服务器集群中的任何
    
                                
    • 
                                
  • [信息与安全]数据库的备份问题
                                    comsci
数据库
                                    
     
 
      如果你们建设的信息系统是采用中心-分支的模式,那么这里有一个问题 
  
 如果你的数据来自中心数据库,那么中心数据库如果出现故障,你的分支机构的数据如何保证安全呢? 
 
   是否应该在这种信息系统结构的基础上进行改造,容许分支机构的信息系统也备份一个中心数据库的文件呢? 
 
 &n
    
                                
    • 
                                
  • 使用maven tomcat plugin插件debug关联源代码
                                    商人shang
mavendebug查看源码tomcat-plugin
                                    
    *首先需要配置好'''maven-tomcat7-plugin'''，参见[[Maven开发Web项目]]的'''Tomcat'''部分。 
*配置好后，在[[Eclipse]]中打开'''Debug Configurations'''界面，在'''Maven Build'''项下新建当前工程的调试。在'''Main'''选项卡中点击'''Browse Workspace...'''选择需要开发的
    
                                
    • 
                                
  • 大访问量高并发
                                    oloz
大访问量高并发
                                    
    大访问量高并发的网站主要压力还是在于数据库的操作上，尽量避免频繁的请求数据库。下面简 
 
要列出几点解决方案： 
 
01、优化你的代码和查询语句，合理使用索引 
 
02、使用缓存技术例如memcache、ecache将不经常变化的数据放入缓存之中 
 
03、采用服务器集群、负载均衡分担大访问量高并发压力 
 
04、数据读写分离 
 
05、合理选用框架，合理架构(推荐分布式架构)。 
 
    
                                
    • 
                                
  • cache 服务器
                                    小猪猪08
cache
                                    
    Cache   即高速缓存.那么cache是怎么样提高系统性能与运行速度呢？是不是在任何情况下用cache都能提高性能？是不是cache用的越多就越好呢？我在近期开发的项目中有所体会，写下来当作总结也希望能跟大家一起探讨探讨，有错误的地方希望大家批评指正。 
　　1.Cache   是怎么样工作的? 
　　Cache   是分配在服务器上
    
                                
    • 
                                
  • mysql存储过程
                                    香水浓
mysql
                                    
    Description:插入大量测试数据 
 
use xmpl;

drop procedure if exists mockup_test_data_sp;

create procedure mockup_test_data_sp(
	in number_of_records int
)
begin
	declare cnt int;
	declare name varch
    
                                
    • 
                                
  • CSS的class、id、css文件名的常用命名规则
                                    agevs
JavaScriptUI框架Ajaxcss
                                    
      CSS的class、id、css文件名的常用命名规则 
    (一)常用的CSS命名规则 
　　头：header 
　　内容：content/container 
　　尾：footer 
　　导航：nav 
　　侧栏：sidebar 
　　栏目：column 
　　页面外围控制整体布局宽度：wrapper 
　　左右中：left right 
    
                                
    • 
                                
  • 全局数据源
                                    AILIKES
javatomcatmysqljdbcJNDI
                                    
    实验目的：为了研究两个项目同时访问一个全局数据源的时候是创建了一个数据源对象，还是创建了两个数据源对象。 
1：将diuid和mysql驱动包（druid-1.0.2.jar和mysql-connector-java-5.1.15.jar）copy至%TOMCAT_HOME%/lib下；2：配置数据源，将JNDI在%TOMCAT_HOME%/conf/context.xml中配置好,格式如下：&l
    
                                
    • 
                                
  • MYSQL的随机查询的实现方法
                                    baalwolf
mysql
                                    
    MYSQL的随机抽取实现方法。举个例子，要从tablename表中随机提取一条记录，大家一般的写法就是：SELECT * FROM tablename ORDER BY RAND() LIMIT 1。但是，后来我查了一下MYSQL的官方手册，里面针对RAND()的提示大概意思就是，在ORDER BY从句里面不能使用RAND()函数，因为这样会导致数据列被多次扫描。但是在MYSQL 3.23版本中，
    
                                
    • 
                                
  • JAVA的getBytes()方法
                                    bijian1013
javaeclipseunixOS
                                    
        在Java中，String的getBytes()方法是得到一个操作系统默认的编码格式的字节数组。这个表示在不同OS下，返回的东西不一样！  
    String.getBytes(String decode)方法会根据指定的decode编码返回某字符串在该编码下的byte数组表示，如： 
    byte[] b_gbk = "
    
                                
    • 
                                
  • AngularJS中操作Cookies
                                    bijian1013
JavaScriptAngularJSCookies
                                    
            如果你的应用足够大、足够复杂，那么你很快就会遇到这样一咱种情况：你需要在客户端存储一些状态信息，这些状态信息是跨session(会话)的。你可能还记得利用document.cookie接口直接操作纯文本cookie的痛苦经历。 
        幸运的是，这种方式已经一去不复返了，在所有现代浏览器中几乎
    
                                
    • 
                                
  • [Maven学习笔记五]Maven聚合和继承特性
                                    bit1129
maven
                                    
    Maven聚合 
  
在实际的项目中，一个项目通常会划分为多个模块，为了说明问题，以用户登陆这个小web应用为例。通常一个web应用分为三个模块：   
1. 模型和数据持久化层user-core, 
2. 业务逻辑层user-service以 
3. web展现层user-web， 
user-service依赖于user-core 
user-web依赖于user-core和use
    
                                
    • 
                                
  • 【JVM七】JVM知识点总结
                                    bit1129
jvm
                                    
      1. JVM运行模式 
1.1 JVM运行时分为-server和-client两种模式，在32位机器上只有client模式的JVM。通常，64位的JVM默认都是使用server模式，因为server模式的JVM虽然启动慢点，但是，在运行过程，JVM会尽可能的进行优化 
1.2 JVM分为三种字节码解释执行方式：mixed mode, interpret mode以及compiler 
    
                                
    • 
                                
  • linux下查看nginx、apache、mysql、php的编译参数
                                    ronin47

                                    
    在linux平台下的应用，最流行的莫过于nginx、apache、mysql、php几个。而这几个常用的应用，在手工编译完以后，在其他一些情况下（如：新增模块），往往想要查看当初都使用了那些参数进行的编译。这时候就可以利用以下方法查看。 
1、nginx 
[root@361way ~]# /App/nginx/sbin/nginx -V
nginx: nginx version: nginx/
    
                                
    • 
                                
  • unity中运用Resources.Load的方法？
                                    brotherlamp
unity视频unity资料unity自学unityunity教程
                                    
    问：unity中运用Resources.Load的方法？ 
答：Resources.Load是unity本地动态加载资本所用的方法,也即是你想动态加载的时分才用到它,比方枪弹,特效,某些实时替换的图像什么的,主张此文件夹不要放太多东西,在打包的时分,它会独自把里边的一切东西都会集打包到一同,不论里边有没有你用的东西,所以大多数资本应该是自个建文件放置 
1、unity实时替换的物体即是依据环境条件
    
                                
    • 
                                
  • 线段树-入门
                                    bylijinnan
java算法线段树
                                    
    


/**
 * 线段树入门
 * 问题：已知线段[2,5] [4,6] [0,7]；求点2,4,7分别出现了多少次
 * 以下代码建立的线段树用链表来保存，且树的叶子结点类似[i,i]
 * 
 * 参考链接：http://hi.baidu.com/semluhiigubbqvq/item/be736a33a8864789f4e4ad18
 * @author lijinna
    
                                
    • 
                                
  • 全选与反选
                                    chicony
全选
                                    
      
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>全选与反选</title>

    
                                
    • 
                                
  • vim一些简单记录
                                    chenchao051
vim
                                    
    mac在/usr/share/vim/vimrc linux在/etc/vimrc 
  
1、问：后退键不能删除数据，不能往后退怎么办？ 
      答：在vimrc中加入set backspace=2 
  
2、问：如何控制tab键的缩进？ 
      答：在vimrc中加入set tabstop=4 (任何
    
                                
    • 
                                
  • Sublime Text 快捷键
                                    daizj
快捷键sublime
                                    
    [size=large][/size]Sublime Text快捷键：Ctrl+Shift+P：打开命令面板Ctrl+P：搜索项目中的文件Ctrl+G：跳转到第几行Ctrl+W：关闭当前打开文件Ctrl+Shift+W：关闭所有打开文件Ctrl+Shift+V：粘贴并格式化Ctrl+D：选择单词，重复可增加选择下一个相同的单词Ctrl+L：选择行，重复可依次增加选择下一行Ctrl+Shift+L：
    
                                
    • 
                                
  • php 引用(&)详解
                                    dcj3sjt126com
PHP
                                    
    在PHP 中引用的意思是：不同的名字访问同一个变量内容. 与Ｃ语言中的指针是有差别的．Ｃ语言中的指针里面存储的是变量的内容在内存中存放的地址 变量的引用 PHP 的引用允许你用两个变量来指向同一个内容   复制代码代码如下:   
<?  
$a="ABC";  
$b =&$a;  
echo
    
                                
    • 
                                
  • SVN中trunk,branches,tags用法详解
                                    dcj3sjt126com
SVN
                                    
    Subversion有一个很标准的目录结构，是这样的。比如项目是proj，svn地址为svn://proj/，那么标准的svn布局是svn://proj/|+-trunk+-branches+-tags这是一个标准的布局，trunk为主开发目录，branches为分支开发目录，tags为tag存档目录（不允许修改）。但是具体这几个目录应该如何使用，svn并没有明确的规范，更多的还是用户自己的习惯。
    
                                
    • 
                                
  • 对软件设计的思考
                                    e200702084
设计模式数据结构算法ssh活动
                                    
    软件设计的宏观与微观  
 
   软件开发是一种高智商的开发活动。一个优秀的软件设计人员不仅要从宏观上把握软件之间的开发，也要从微观上把握软件之间的开发。宏观上，可以应用面向对象设计，采用流行的SSH架构，采用web层，业务逻辑层，持久层分层架构。采用设计模式提供系统的健壮性和可维护性。微观上，对于一个类，甚至方法的调用，从计算机的角度模拟程序的运行情况。了解内存分配，参数传
    
                                
    • 
                                
  • 同步、异步、阻塞、非阻塞
                                    geeksun
非阻塞
                                    
    同步、异步、阻塞、非阻塞这几个概念有时有点混淆，在此文试图解释一下。 
  
同步：发出方法调用后，当没有返回结果，当前线程会一直在等待（阻塞）状态。 
场景：打电话，营业厅窗口办业务、B/S架构的http请求-响应模式。 
  
异步：方法调用后不立即返回结果，调用结果通过状态、通知或回调通知方法调用者或接收者。异步方法调用后，当前线程不会阻塞，会继续执行其他任务。 
实现：
    
                                
    • 
                                
  • Reverse SSH Tunnel 反向打洞實錄
                                    hongtoushizi
ssh
                                    
    實際的操作步驟：  
# 首先，在客戶那理的機器下指令連回我們自己的 Server，並設定自己 Server 上的 12345 port 會對應到幾器上的 SSH port
ssh -NfR 12345:localhost:22 [email protected]

# 然後在 myhost 的機器上連自己的 12345 port，就可以連回在客戶那的機器
ssh localhost -p 1
    
                                
    • 
                                
  • Hibernate中的缓存
                                    Josh_Persistence
一级缓存Hiberante缓存查询缓存二级缓存
                                    
    Hibernate中的缓存 
  
一、Hiberante中常见的三大缓存：一级缓存，二级缓存和查询缓存。 
Hibernate中提供了两级Cache，第一级别的缓存是Session级别的缓存，它是属于事务范围的缓存。这一级别的缓存是由hibernate管理的，一般情况下无需进行干预；第二级别的缓存是SessionFactory级别的缓存，它是属于进程范围或群集范围的缓存。这一级别的缓存
    
                                
    • 
                                
  • 对象关系行为模式之延迟加载
                                    home198979
PHP架构延迟加载
                                    
    形象化设计模式实战     HELLO!架构 
  
一、概念 
Lazy Load：一个对象，它虽然不包含所需要的所有数据，但是知道怎么获取这些数据。 
延迟加载貌似很简单，就是在数据需要时再从数据库获取，减少数据库的消耗。但这其中还是有不少技巧的。 
  
  
二、实现延迟加载 
实现Lazy Load主要有四种方法：延迟初始化、虚
    
                                
    • 
                                
  • xml 验证
                                    pengfeicao521
xmlxml解析
                                    
    有些字符，xml不能识别，用jdom或者dom4j解析的时候就报错 
 
public static void testPattern() { 
 
 // 含有非法字符的串 
 String str =       "Jamey&#52828;&#01;&#02;&#209;&#1282
    
                                
    • 
                                
  • div设置半透明效果
                                    spjich
css半透明
                                    
    为div设置如下样式： 
  
div{filter:alpha(Opacity=80);-moz-opacity:0.5;opacity: 0.5;}  
  
  
  
 说明： 
1、filter：对win IE设置半透明滤镜效果，filter:alpha(Opacity=80)代表该对象80%半透明，火狐浏览器不认2、-moz-opaci
    
                                
    • 
                                
  • 你真的了解单例模式么？
                                    w574240966
java单例设计模式jvm
                                    
        单例模式，很多初学者认为单例模式很简单，并且认为自己已经掌握了这种设计模式。但事实上，你真的了解单例模式了么。 
  
一，单例模式的5中写法。（回字的四种写法，哈哈。） 
    1，懒汉式 
          （1）线程不安全的懒汉式 
    public cla
    
                                
    •