导出Excel的工具类

最新推荐文章于 2024-07-26 12:28:02 发布
最新推荐文章于 2024-07-26 12:28:02 发布
阅读量230 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/L905128009/article/details/131709223
版权

package jjgk.erms.excelTemplate;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.math.BigDecimal;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.Properties;

import org.apache.commons.lang.StringUtils;
import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFCellStyle;
import org.apache.poi.hssf.usermodel.HSSFFont;

import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.util.Region;
import org.apache.poi.poifs.filesystem.POIFSFileSystem;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellStyle;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

/**
 * Excel操作以及相关的公共方法
 * @author ChenPingFan
 *
 */
public class ExcelUtil {
    /* Excel文档 */
    public static HSSFWorkbook workbook;
    public static XSSFWorkbook workbooks;
    
    public static final ExcelUtil excelutil = new ExcelUtil();
    
    public static ExcelUtil getInstance()
    {
        return excelutil;
    }

//    private Object sheet;
    /**加载相应的EXCEL模板**/    
    public HSSFWorkbook loadexcel(String pa,POIFSFileSystem poifile)
    {
        InputStream input = null;
        try {
            input = new FileInputStream(new File(pa));
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        try {
            poifile = new POIFSFileSystem(input);
            workbook = new HSSFWorkbook(poifile);
        } catch (IOException e) {
            e.printStackTrace();
        }
        finally{
            try {
                input.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return workbook;
    }
    
    
    /**给Excel字符串赋值**/
    public void setStringValue(HSSFCell cell, String value) {
        cell.setCellValue(value);
    }
    /**给Excel数值赋值**/
    public void setDoubleValue(double value,int rownum,int cellnum,Sheet sheet) {
        Cell cell  = sheet.getRow(rownum).getCell(cellnum);        
        cell.setCellValue(value);
    }
    /**给Excel数值赋值**/
    public void setIntValue(int value,int rownum,int cellnum,Sheet sheet) {
        Cell cell  = sheet.getRow(rownum).getCell(cellnum);        
        cell.setCellValue(value);
    }
        
    /**给单元格赋值**/
    public  void setCellValue(String value, int rownum, int cellnum,Sheet sheet) {
        Cell cell = sheet.getRow(rownum).getCell(cellnum); 
        cell.setCellValue(value);
    }
    
    /**
     * rownum 需要创建的行数，  cellnum  需要创建的列数，，ksrow 从哪一行开始，，
     * @param rownum
     * @param cellnum
     * @param ksrow
     */
    public void creatCell(int rownum, int cellnum, int ksrow,Sheet sheet) {
        for (int i = ksrow; i < rownum + ksrow; i++) {
            Row row = sheet.createRow(i);
            for (int j = 0; j < cellnum; j++) {
                row.createCell(j);
            }
        }
    }
    
    /**创建字体样式**/
    public HSSFCellStyle getHssfFont() {
        HSSFFont font = workbook.createFont();
        font.setFontHeightInPoints((short) 16);// 字号
        font.setBoldweight(HSSFFont.BOLDWEIGHT_BOLD);// 加粗
        font.setColor(HSSFFont.COLOR_NORMAL);
        HSSFCellStyle style = workbook.createCellStyle();
        style.setBorderBottom(HSSFCellStyle.BORDER_THIN);
        style.setBorderLeft(HSSFCellStyle.BORDER_THIN);
        style.setBorderRight(HSSFCellStyle.BORDER_THIN);
        style.setBorderTop(HSSFCellStyle.BORDER_THIN);
        style.setAlignment(HSSFCellStyle.ALIGN_CENTER);
        style.setFont(font);
        style.setBorderBottom(HSSFCellStyle.BORDER_THIN);
        return style;
    }
       /**创建字体样式**/
     public HSSFCellStyle getHssfFontDz(Workbook workbook) {
        HSSFFont font = (HSSFFont) workbook.createFont();
        font.setFontHeightInPoints((short) 16);// 字号
        font.setBoldweight(HSSFFont.BOLDWEIGHT_BOLD);// 加粗
        font.setColor(HSSFFont.COLOR_NORMAL);
        HSSFCellStyle style = (HSSFCellStyle) workbook.createCellStyle();
        style.setAlignment(HSSFCellStyle.ALIGN_CENTER);
        style.setFont(font);
        return style;
    }
       
       
       /** 创建样式 */
        public void createYS(int rownum, int cellnum, int ksrow,Workbook workbook,int sheetnum) {
            CellStyle style = workbook.createCellStyle();
            style.setBorderBottom(HSSFCellStyle.BORDER_THIN);
            style.setBorderLeft(HSSFCellStyle.BORDER_THIN);
            style.setBorderRight(HSSFCellStyle.BORDER_THIN);
            style.setBorderTop(HSSFCellStyle.BORDER_THIN);
            style.setAlignment(HSSFCellStyle.ALIGN_CENTER);
            style.setVerticalAlignment(HSSFCellStyle.ALIGN_LEFT);
            style.setWrapText(true);
            // 设置单元格字体
//            HSSFFont font = (HSSFFont) workbook.createFont();
//            font.setFontName("宋体");
//            font.setFontHeightInPoints((short) 11);
//            style.setFont(font); 
            Sheet sheet = workbook.getSheetAt(sheetnum);
            for (int i = ksrow; i < rownum + ksrow; i++) {
                Row row = sheet.createRow(i);
                for (int j = 0; j < cellnum; j++) {
                    Cell cell = row.createCell(j);
                    cell.setCellStyle(style);
                    cell = null;
                }
            }

        }
        
        
        public static HSSFCellStyle getHssfFontforaqyb(){ 
            HSSFFont font  = workbook.createFont(); 
            HSSFCellStyle style = workbook.createCellStyle();
            style.setBorderBottom(HSSFCellStyle.BORDER_THIN);
            style.setBorderLeft(HSSFCellStyle.BORDER_THIN);
            style.setBorderRight(HSSFCellStyle.BORDER_THIN);
            style.setBorderTop(HSSFCellStyle.BORDER_THIN);
            //style.setAlignment(HSSFCellStyle.ALIGN_LEFT);
            style.setVerticalAlignment(HSSFCellStyle.ALIGN_LEFT);
            //style.setAlignment(HSSFCellStyle.ALIGN_CENTER);
            style.setWrapText(true);//自动换行
            style.setFont(font);
            return style;
        }
        
    /**
     * 合并单元格的方法
     * 
     * @param sheet一个HSSFSheet对象
     * @param row一个行对象
     * @param rowindex行索引
     * @param name单元格的值
     * @param a1从第几行开始
     * @param a2从第几个单元格开始
     * @param a3到第几行结束
     * @param a4到第几个单元格结束
     * 
     */

    @SuppressWarnings("deprecation")
    public void createCells(int indexRow, int rowindex, String name, int a1,
            int a2, int a3, int a4, HSSFCellStyle cellStyle, HSSFFont font,
            int flag, HSSFSheet sheet) {
        Row row = sheet.createRow(indexRow);
        Cell cel0 = row.createCell(rowindex);
        if (flag == 0) {
            cellStyle.setBorderBottom((short) 1);
            cellStyle.setBorderLeft((short) 1);
            cellStyle.setBorderRight((short) 1);
            cellStyle.setBorderTop((short) 1);
            cellStyle.setBottomBorderColor((short) 64);
            cellStyle.setAlignment((short) 1);
            cellStyle.setVerticalAlignment((short) 1);
            cellStyle.setDataFormat((short) 49);
        }
        cel0.setCellStyle(cellStyle);
        // cel0.setEncoding(HSSFCell.ENCODING_UTF_16);
        cel0.setCellValue(name);
        sheet.addMergedRegion(new Region(a1, (short) a2, a3, (short) a4));
        if (cellStyle != null) {
            if (font != null) {
                cellStyle.setFont(font);
            }
        }
    }
        
    //************************系统基础的公共方法（为了图方便，不单独起一个类）*****************************// 
    
    /**
     * 获取当前年份
     * @return
     */
    public static String NowYear() {
        Calendar claender = Calendar.getInstance();
        int year = claender.get(Calendar.YEAR);
        int month = claender.get(Calendar.MONTH);
        //当 月份为0时是因为跨年，年度为当前年度，所以要减去1
        if(month == 0){
            year = year -1;
        }
        return String.valueOf(year);
    }
    /**
     * 获取当前的月份(实际是上月，因为本月调用的数据都是上个月的数据)
     * @return
     */
    public static String NowMonth(){
        Calendar claender = Calendar.getInstance();
        int month = claender.get(Calendar.MONTH);
        //跨年时1月份的上个月是12月
        if(month == 0){
            month = 12;
        }
        return String.valueOf(month);
    }
    /**
     * 该月当天的日期
     * @return
     */
    public static String NowDay(){
        Calendar claender = Calendar.getInstance();
        String day = String.valueOf(claender.get(Calendar.DAY_OF_MONTH));
        return day;
    }
    /**获取当前时间（年月日）**/
    public static String sysDate(){
        Date today = new Date();
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        return format.format(today);
    }
    
    public static String nowYear_today(){
        Date today = new Date();
        SimpleDateFormat format = new SimpleDateFormat("yyyy");        
        return format.format(today);    
    }
    public static String nowMonth_today(){
        Date today = new Date();
        SimpleDateFormat format = new SimpleDateFormat("MM");        
        return format.format(today);    
    }
    
    /**
     * 获取上个月的年份和月份(实际是倒退了两个月，因为本月调用的数据都是上个月的数据)
     * @return
     */
    public static String sysOldDate()
    {
        Calendar calendar = Calendar.getInstance();
        calendar.getTime();
        calendar.add(Calendar.MONTH, -2);
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy.MM");    
        return dateFormat.format(calendar.getTime());        
    }
    /**取得下个月的年份和月份(实际上这才是本月)**/
    public static String sysNextDate()
    {
        Calendar calendar = Calendar.getInstance();
        calendar.getTime();
        calendar.add(Calendar.MONTH, 0);
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy.MM");    
        return dateFormat.format(calendar.getTime());        
    }
    /**将字符串格式化成时间**/
    public String formatTime(String time) throws ParseException
    {
        if(null != StringUtils.trimToNull(time)){
            SimpleDateFormat simp = new SimpleDateFormat("yyyy-mm-dd");
            Date t = simp.parse(time);
            String date = simp.format(t);
            return date;
        }
        return "";
    }
    
    /**
     * 精确小数点为N位
     */
    private double RoundToN(double num, int weishu) {
        String strr_db = String.valueOf(num);
        return RoundToN(strr_db, weishu);
    }

    /**
     * 大数据类型四舍五入
     * 
     * @param str
     * @return
     */
    private String decimalConvert(String strNum) {
        BigDecimal d = new BigDecimal(0);
        // 根据小数点进行切割
        if (!"".equals(strNum)) {
            String[] strArray = strNum.split("\\.");
            if (strArray.length > 1) {
                d = new BigDecimal(strArray[0]);
                double dNum = Long.parseLong(strArray[1])
                        / Math.pow(10, strArray[1].length());
                if (dNum >= 0.5) {
                    d = d.add(new BigDecimal(1));
                }
            } else {
                d = new BigDecimal(strNum);
            }
        }

        return d.toString();
    }

    /**
     * 精确小数点为N位
     */
    private double RoundToN(String num, int weishu) {
        String strr_db = num;
        double db = 0;
        if (strr_db == null || "".equalsIgnoreCase(strr_db.trim())) {
            return db;
        }
        if (strr_db.indexOf(".") == -1) {

        } else {
            db = Float.parseFloat(strr_db);
            if (db > 0) {
                db = db * Math.pow(10, weishu);
                db = db + Double.parseDouble("0.5");
                db = Double.parseDouble(String.valueOf((int) db));
                db = db / Math.pow(10, weishu);
                return db;
            } else if (db < 0) {
                db = 0 - db;
                db = db * Math.pow(10, weishu);
                db = db + Double.parseDouble("0.5");
                db = Double.parseDouble(String.valueOf((int) db));
                db = db / Math.pow(10, weishu);
                db = 0 - db;
                return db;
            }
        }
        db = Double.parseDouble(strr_db);
        return db;
    }
    
    
    
    /**新建相应的文件夹路径**/
    public String createDir(String new_path) {        
        File newFile = new File(new_path);
        if(!newFile.exists()) {
            newFile.mkdirs();
        }
        return new_path;
    }
    
    public String getSysPath(String Dirname) {
        SimpleDateFormat match = new SimpleDateFormat("yyyy-MM-dd");
        String new_path = ExcelUtil.getSystemPath() + "/"
                + match.format(new Date()) + "/" + Dirname;
        return new_path;
    }
    
    /**读取配置文件，获取模板的路径**/
    @SuppressWarnings("unchecked")
    public  String getXmlConfig(String mkmc) throws Exception {
        String path_excel = null;
        
        String path = ExcelUtil.getSystemPath() + "/config/"+ "templete.xml";
        String xmlPath = path.replace("/", File.separator);
        SAXReader sax = new SAXReader();
        Document doc = sax.read(new File(xmlPath));
        Element rootElement = doc.getRootElement();
        Element element = rootElement.element("monthTemplete");
        List<Element> list = element.elements();
        for (Element ele : list) {
            ele.attributeValue("name");
            if (mkmc.equals(ele.attributeValue("name"))) {
                path_excel = ele.attributeValue("path");
            }
        }
        return path_excel;
    }
    
    /**
     * 获取系统的WebContent路径
     * @return
     */
    public static String getSystemPath() {
        String path = ExcelUtil.class.getClassLoader().getResource("/").getPath().toString();
        Properties prop = System.getProperties();
        String osname =  prop.getProperty("os.name");
        if(osname.startsWith("Win")|| osname.startsWith("win")){
            path = path.substring(path.indexOf("/")+1, path.indexOf("WEB-INF")-1);
        }else{
            path = path.substring(path.indexOf("/"), path.indexOf("WEB-INF")-1);
        }
        return path;
    }
    
    /**
     * 输出两端日期中间的时间，以年月格式输出
     * @param startTime
     * @param endTime
     * @return
     */
    public  static List<String> getListTime(String startTime,String endTime){
        List<String> time_list = new ArrayList<String>();
        
        if(startTime.equals(endTime)){
            //如果两个时间相等
            time_list.add(startTime);
        }else
        {
            String startYear = startTime.substring(0, 4);
            String endYear = endTime.substring(0, 4);
            //取月份
            String start_Month = startTime.substring(4);
            String end_Month = endTime.substring(4);    
            int mistake = Integer.parseInt(endYear)-Integer.parseInt(startYear);
            // 201105--201203
            if(mistake>=1) {
                if(mistake == 1) {
                    for(int i = Integer.parseInt(start_Month);i <=12;i++){
                        String rq = startYear+getFormatString(String.valueOf(i));
                        time_list.add(rq);
                    }
                    for(int i = 1;i<=Integer.parseInt(end_Month);i++){
                        String rq = endYear+getFormatString(String.valueOf(i));
                        time_list.add(rq);
                    }
                }                
            }else {
                //同一年的只算月份                                
                for(int i = Integer.parseInt(start_Month); i<=Integer.parseInt(end_Month);i++){
                    String rq = startYear + getFormatString(String.valueOf(i));
                    time_list.add(rq);
                }                                
            }
        }
                
        return time_list;            
    }
    
    public static String getFormatString(String number){        
        return number.length()>1?number:"0"+number;
    }
    
    /**
     * 获取上个月第一天的时间
     * @return
     */
    public String lastMonFirstDay(){  
        Calendar cal = Calendar.getInstance();  
        int year = cal.get(Calendar.YEAR);  
        int month = cal.get(Calendar.MONTH) + 1;  
        cal.set(Calendar.DAY_OF_MONTH, 1);  
        cal.add(Calendar.DAY_OF_MONTH, -1);  
        int day = cal.get(Calendar.DAY_OF_MONTH);  
        String months = "";  
        String days = "";  
        if (month > 1) {  
            month--;  
        } else {  
            year--;  
            month = 12;  
        }  
        if (!(String.valueOf(month).length() > 1)) {  
            months = "0" + month;  
        } else {  
            months = String.valueOf(month);  
        }  
        if (!(String.valueOf(day).length() > 1)) {  
            days = "0" + day;  
        } else {  
            days = String.valueOf(day);  
        }  
        String firstDay = "" + year + "-" + months + "-01";  
        String[] lastMonth = new String[2];  
        lastMonth[0] = firstDay;  
        return firstDay;  
    } 
    
    /**
     * 获取上个月最后一天的时间
     * @return
     */
    public  String lastMonLastDay(){  
        Calendar cal = Calendar.getInstance();  
        int year = cal.get(Calendar.YEAR);  
        int month = cal.get(Calendar.MONTH) + 1;  
        cal.set(Calendar.DAY_OF_MONTH, 1);  
        cal.add(Calendar.DAY_OF_MONTH, -1);  
        int day = cal.get(Calendar.DAY_OF_MONTH);  
        String months = "";  
        String days = "";  
        if (month > 1) {  
            month--;  
        } else {  
            year--;  
            month = 12;  
        }  
        if (!(String.valueOf(month).length() > 1)) {  
            months = "0" + month;  
        } else {  
            months = String.valueOf(month);  
        }  
        if (!(String.valueOf(day).length() > 1)) {  
            days = "0" + day;  
        } else {  
            days = String.valueOf(day);  
        }  
        String lastDay = "" + year + "-" + months + "-" + days;  
        String[] lastMonth = new String[2];  
        lastMonth[1] = lastDay;  
        return lastDay; 
        }
}
 

把每天当成生命中的最后一天
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java导入导出Excel工具类ExcelUtil
qq_34994627的博客
05-16 302
导入导出中会出现各种各样的问题，比如：数据源为空、有重复行等，我自定义了一个ExcelException异常类，用来处理这些问题。导出就是将List转化为Excel（listToExcel）导入就是将Excel转化为List（excelToList）
POI导出Excel工具类（简单看完就会）
热门推荐
zeng_ll的博客
03-08 1万+
（一）POI介绍 Apache POI是Apache软件基金会的开源项目，POI提供API给Java程序对Microsoft Office格式档案读和写的功能。 .NET的开发人员则可以利用NPOI (POI for .NET) 来存取 Microsoft Office文档的功能。 本文介绍的是用POI做一个导出excel报表的工具类，相当实用也相当简单。 （二）POI导出报表要用到的包 1...
导出excel工具类
ourLang
07-07 1万+
1、excel工具类代码如下 package com.senta.mdt.common.util; import com.senta.mdt.api.mdtvisit.controller.ExcelController; import org.apache.poi.hssf.usermodel.*; import org.apache.poi.ss.usermodel.HorizontalAl...
封装java导出Excel工具类使用（一）
东岳的博客
07-20 558
自己封装了一个excel工具类，方便以后使用和部分可能有相同需求的朋友使用
java 导出excel工具类
weixin_57581505的博客
02-22 2240
Excel相关处理,导出调用exportExcel(response, list, "用户数据"); public class ExcelUtil<T> { private static final Logger log = LoggerFactory.getLogger(ExcelUtil.class); /** * Excel sheet最大行数，默认65536 */ public static final int sheetSize =.
【工具篇】java导出excel工具类，多种模式自动配置，绝对值得你收藏
笑小枫
05-09 1万+
小伙伴们工作中有没有导出excel需求呀，这里为大家献上一个风骚的导出excel的工具类。具体怎么风骚，请看文章详情。
java Excel导出工具类
jiu_mu_mu的博客
11-10 1626
自己学习一下，Excel导出工具类
Excel导出工具类
rxhcsdn的博客
02-18 1244
excel导出工具类及使用方法，可以自定义列宽，自定义表头样式，实现了多sheet页导出
java导出excel工具类(贼好用)
皮卡丘踢球
07-11 2332
项目中自用的导出excel工具: 实体类: package com.mapuni.survey.entity; public class ExcelEntity { private String field; private String title; public String getField() { return field; } public void setF...
java按照模板导出Excel工具类
gaohengTime的博客
06-22 2849
准备模板:模板中使用jxls表达式，详细的jxls表达式使用可以到网上查找。一下给出简单的说明&lt;jx:forEach items="${results.list}" var="v" varStatus="vs"&gt;${v.JIGOUID}&lt;/jx:forEach&gt;jxls的循环方法，使用此方法，根据规定要放在要显示数据的第一列，items进行列表循环取值使用el表达式取值。1...
Poi导出Excel工具类
01-07
在这个场景中，"Poi导出Excel工具类"是一个已经封装好的Java类，设计用于高效地导出大量数据到Excel文件中，并且支持多sheet页的布局。这个工具类简化了开发过程，使得开发者无需关心底层细节，只需调用预定义的方法...
导出Excel工具类
10-11
在IT行业中，导出Excel工具类是经常被用于数据处理和报告生成的场景。这个工具类通常包含了多种方法，能够方便地将程序中的数据结构转换为Excel格式的文件，便于用户下载、查看或进一步分析。这里我们将深入探讨导出...
java使用POI导出 Excel工具类
08-14
java使用POI导出 Excel+图片工具类 ，里面含有poi jar包，只调用接口即可直接保存Excel。使用的时候需先把数据封装，具体包装需根据实际导出数据进行处理。文件demo中只提供包装格式。
12. Hibernate 模板设计模式
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1258
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
golang 接口
m0_70982551的博客
07-24 807
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
最新发布
a1058926697的博客
07-26 364
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
springboot之自动装配
weixin_50153914的博客
07-23 491
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
淘客返利系统中的服务发现与注册机制详解
技术研究中心
07-22 2393
通过服务注册中心，服务提供者可以将自己注册到注册中心，服务消费者可以从注册中心获取服务提供者的地址，以实现服务调用。本文详细介绍了淘客返利系统中服务发现与注册机制的实现，包括Eureka的配置与代码示例。通过Eureka，我们可以轻松实现服务的注册与发现，确保分布式系统中各个服务之间的通信。在本文中，我们将深入探讨淘客返利系统中的服务发现与注册机制，并结合Java代码进行详细讲解。在我们的淘客返利系统中，我们采用Eureka作为服务发现与注册的工具。在我们的淘客返利系统中，首先需要配置Eureka服务器。
springboot导出excel工具类
07-28
- *2* [SpringBoot导出Excel工具类](https://blog.csdn.net/qq_41341640/article/details/109067688)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值