SpringBoot中对LocalDateTime进行格式化并解析

本文涉及的产品
公共DNS(含HTTPDNS解析),每月1000万次HTTP解析
云解析 DNS,旗舰版 1个月
全局流量管理 GTM,标准版 1个月
简介: SpringBoot中对LocalDateTime进行格式化并解析

【1】格式化后台传给前端的日期

首先第一点需要知道的是springboot默认依赖的json框架是jackson。当使用@ResponseBody注解返回json格式数据时就是该框架在起作用。


① SpringBoot对Date/DateTime配置

如果字段属性是Date而非LocalDateTime时,通常我们会在application.properties里面配置如下:

spring.mvc.date-format=yyyy-MM-dd HH:mm:ss
spring.jackson.date-format=yyyy-MM-dd HH:mm:ss
spring.jackson.time-zone=GMT+8
spring.jackson.serialization.write-dates-as-timestamps=false

如下图所示,spring.jackson开头的配置会被JacksonProperties类获取进行使用。当返回json格式的时候,Jackson就会根据配置文件中日期格式化的配置对结果进行处理。


但是如果字段属性为LocalDateTime呢?这种配置就失去了作用。


② 第一种方式:配置localDateTimeSerializer

这时候建议配置如下:

/**
 * Created by jianggc at 2020/7/1.
 */
@Configuration
public class LocalDateTimeSerializerConfig {
    @Value("${spring.jackson.date-format:yyyy-MM-dd HH:mm:ss}")
    private String pattern;
    // localDateTime 序列化器
    @Bean
    public LocalDateTimeSerializer localDateTimeSerializer() {
        return new LocalDateTimeSerializer(DateTimeFormatter.ofPattern(pattern));
    }
    // localDateTime 反序列化器
    @Bean
    public LocalDateTimeDeserializer localDateTimeDeserializer() {
        return new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern(pattern));
    }
    @Bean
    public Jackson2ObjectMapperBuilderCustomizer jackson2ObjectMapperBuilderCustomizer() {
//        return new Jackson2ObjectMapperBuilderCustomizer() {
//            @Override
//            public void customize(Jackson2ObjectMapperBuilder jacksonObjectMapperBuilder) {
                jacksonObjectMapperBuilder.featuresToDisable(SerializationFeature.FAIL_ON_EMPTY_BEANS);
//                jacksonObjectMapperBuilder.serializerByType(LocalDateTime.class, localDateTimeSerializer());
//                jacksonObjectMapperBuilder.deserializerByType(LocalDateTime.class,localDateTimeDeserializer());
//            }
//        };
        //这种方式同上
        return builder -> {
            builder.serializerByType(LocalDateTime.class, localDateTimeSerializer());
            builder.deserializerByType(LocalDateTime.class,localDateTimeDeserializer());
            builder.simpleDateFormat(pattern);
        };
    }
}


其实上文除了序列化器之外还配置了反序列化器也支持了2023-02-19 17:40:26格式向LocalDateTime的转换。也就是支持对象和JSON之间相互转换,但是不支持单个字段比如string转换为LocalDateTime。

//支持
@RequestBody TbSysUser user --> JSON 字符串
//不支持
String --> LocalDateTime createTime

③ 第二种方式:@JsonFormat

这种配置方式自然是全局的,如果想针对某个字段特殊处理,可以在类字段上面添加注解@JsonFormat:

@JsonFormat( pattern = "yyyy-MM-dd HH:mm:ss",timezone="GMT+8")
private Date createdDate;
@JsonFormat( pattern = "yyyy-MM-dd HH:mm:ss")
private LocalDateTime createdTime;


【2】前台传String格式日期给后台

如下所示,前台传参2020-08-30 11:11:11,后台使用LocalDateTime 接收。通常会报错类似如下:

nestednested exception is org.springframework.core.convert.ConversionFailedException: 
Failed to convert from type [java.lang.String] to type [java.time.LocalDateTime ]


很显然是在参数绑定的时候没有找到合适的转换器把String转换为对应的格式。

① 配置全局的日期转换器localDateTimeConvert

根据需要进行修改:

@Bean
public Converter<String, LocalDateTime> localDateTimeConvert() {
    return new Converter<String, LocalDateTime>() {
        @Override
        public LocalDateTime convert(String source) {
            DateTimeFormatter df = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
            LocalDateTime dateTime = null;
            try {
                //2020-01-01 00:00:00
                switch (source.length()){
                    case 10:
                        logger.debug("传过来的是日期格式:{}",source);
                        source=source+" 00:00:00";
                        break;
                    case 13:
                        logger.debug("传过来的是日期 小时格式:{}",source);
                        source=source+":00:00";
                        break;
                    case 16:
                        logger.debug("传过来的是日期 小时:分钟格式:{}",source);
                        source=source+":00";
                        break;
                }
                dateTime = LocalDateTime.parse(source, df);
            } catch (Exception e) {
               logger.error(e.getMessage(),e);
            }
            return dateTime;
        }
    };
}

实现原理简要描述


在进行参数绑定的时候,会使用WebDataBinder对象。而创建WebDataBinder对象时,会遍历DefaultDataBinderFactory.initializer,使用其WebBindingInitializer initializer对WebDataBinder对象进行初始化。


初始化方法具体可见ConfigurableWebBindingInitializer.initBinder(WebDataBinder binder),源码如下:

 public void initBinder(WebDataBinder binder) {
        binder.setAutoGrowNestedPaths(this.autoGrowNestedPaths);
        if (this.directFieldAccess) {
            binder.initDirectFieldAccess();
        }
        //设置messageCodesResolver
        if (this.messageCodesResolver != null) {
            binder.setMessageCodesResolver(this.messageCodesResolver);
        }
        //设置bindingErrorProcessor
        if (this.bindingErrorProcessor != null) {
            binder.setBindingErrorProcessor(this.bindingErrorProcessor);
        }
        //设置validator
        if (this.validator != null && binder.getTarget() != null && this.validator.supports(binder.getTarget().getClass())) {
            binder.setValidator(this.validator);
        }
        //设置conversionService
        if (this.conversionService != null) {
            binder.setConversionService(this.conversionService);
        }
        if (this.propertyEditorRegistrars != null) {
            PropertyEditorRegistrar[] var2 = this.propertyEditorRegistrars;
            int var3 = var2.length;
            for(int var4 = 0; var4 < var3; ++var4) {
                PropertyEditorRegistrar propertyEditorRegistrar = var2[var4];
                propertyEditorRegistrar.registerCustomEditors(binder);
            }
        }
    }


而conversionService中包含了许多的convert-类型格式化器。在WebDataBinder进行参数绑定的时候就会使用不同的格式化器即不同的convert进行参数类型转换。


关于参数绑定的过程,有兴趣的可以跟踪DataBinder.doBind方法,在这个过程中会对前台传输的值进行类型转换为目标参数需要的类型。自定义的localDateTimeConvert也是在这里被用到的。


如下所示前台传String格式给后台参数endDate,参数类型为java.time.LocalDateTime

找到我们自定义的converter


调用convert进行类型转换:

可以看到转换后的结果为:


② 配置日期格式化器

/**
  * yyyy-MM-dd HH:mm:ss String-localDateTime
  * @return
  */
 @Bean
 public Formatter<LocalDateTime> localDateTimeFormatter() {
     return new Formatter<LocalDateTime>() {
         @Override
         public LocalDateTime parse(String text, Locale locale) throws ParseException {
             return LocalDateTime.parse(text, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
         }
         @Override
         public String print(LocalDateTime localDateTime, Locale locale) {
             DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
             return formatter.format(localDateTime);
         }
     };
 }

自定义的格式化器会在SpringBoot启动时自动化配置过程中被加入,具体可以参考如下代码。

WebMvcAutoConfiguration.mvcConversionService:

@Bean
@Override
public FormattingConversionService mvcConversionService() {
  WebConversionService conversionService = new WebConversionService(this.mvcProperties.getDateFormat());
  addFormatters(conversionService);
  return conversionService;
}

【3】convert是什么时候添加到ConversionService中的?

① SpringBoot启动的时候运行run方法

其会走到SpringApplication.configureEnvironment方法处:

protected void configureEnvironment(ConfigurableEnvironment environment, String[] args) {
    if (this.addConversionService) {
    //从这里跟踪
        ConversionService conversionService = ApplicationConversionService.getSharedInstance();
        environment.setConversionService((ConfigurableConversionService)conversionService);
    }
    this.configurePropertySources(environment, args);
    this.configureProfiles(environment, args);
}

② 尝试获取ConversionService

ApplicationConversionService.getSharedInstance如下所示,这里可以看到其使用了设计模式中的懒汉式之双重校验锁来获取单例。

public static ConversionService getSharedInstance() {
     ApplicationConversionService sharedInstance = sharedInstance;
     if (sharedInstance == null) {
         Class var1 = ApplicationConversionService.class;
         synchronized(ApplicationConversionService.class) {
             sharedInstance = sharedInstance;
             if (sharedInstance == null) {
                 sharedInstance = new ApplicationConversionService();
                 sharedInstance = sharedInstance;
             }
         }
     }
     return sharedInstance;
 }

③ 获取ApplicationConversionService

继续对象创建过程会发现其走到了configure处:

public ApplicationConversionService(StringValueResolver embeddedValueResolver) {
    if (embeddedValueResolver != null) {
        this.setEmbeddedValueResolver(embeddedValueResolver);
    }
//我们从这里继续跟进
    configure(this);
}

这里我们顺带看一下ApplicationConversionService的类继承示意图(其不只是可以作为ConversionService还可以作为ConverterRegistry与FormatterRegistry):


④ ApplicationConversionService.configure

创建ApplicationConversionService时会对其进行配置,这里很重要。其会注入默认的Converter和Formatter:

public static void configure(FormatterRegistry registry) {
      DefaultConversionService.addDefaultConverters(registry);
      DefaultFormattingConversionService.addDefaultFormatters(registry);
      addApplicationFormatters(registry);
      addApplicationConverters(registry);
  }

⑤ DefaultConversionService.addDefaultConverters

该方法执行完,会添加52个类型转换器:

public static void addDefaultConverters(ConverterRegistry converterRegistry) {
  addScalarConverters(converterRegistry);
  addCollectionConverters(converterRegistry);
  converterRegistry.addConverter(new ByteBufferConverter((ConversionService) converterRegistry));
  converterRegistry.addConverter(new StringToTimeZoneConverter());
  converterRegistry.addConverter(new ZoneIdToTimeZoneConverter());
  converterRegistry.addConverter(new ZonedDateTimeToCalendarConverter());
  converterRegistry.addConverter(new ObjectToObjectConverter());
  converterRegistry.addConverter(new IdToEntityConverter((ConversionService) converterRegistry));
  converterRegistry.addConverter(new FallbackObjectToStringConverter());
  converterRegistry.addConverter(new ObjectToOptionalConverter((ConversionService) converterRegistry));
}

addScalarConverters(converterRegistry);如下所示:

private static void addScalarConverters(ConverterRegistry converterRegistry) {
  converterRegistry.addConverterFactory(new NumberToNumberConverterFactory());
  converterRegistry.addConverterFactory(new StringToNumberConverterFactory());
  converterRegistry.addConverter(Number.class, String.class, new ObjectToStringConverter());
  converterRegistry.addConverter(new StringToCharacterConverter());
  converterRegistry.addConverter(Character.class, String.class, new ObjectToStringConverter());
  converterRegistry.addConverter(new NumberToCharacterConverter());
  converterRegistry.addConverterFactory(new CharacterToNumberFactory());
  converterRegistry.addConverter(new StringToBooleanConverter());
  converterRegistry.addConverter(Boolean.class, String.class, new ObjectToStringConverter());
  converterRegistry.addConverterFactory(new StringToEnumConverterFactory());
  converterRegistry.addConverter(new EnumToStringConverter((ConversionService) converterRegistry));
  converterRegistry.addConverterFactory(new IntegerToEnumConverterFactory());
  converterRegistry.addConverter(new EnumToIntegerConverter((ConversionService) converterRegistry));
  converterRegistry.addConverter(new StringToLocaleConverter());
  converterRegistry.addConverter(Locale.class, String.class, new ObjectToStringConverter());
  converterRegistry.addConverter(new StringToCharsetConverter());
  converterRegistry.addConverter(Charset.class, String.class, new ObjectToStringConverter());
  converterRegistry.addConverter(new StringToCurrencyConverter());
  converterRegistry.addConverter(Currency.class, String.class, new ObjectToStringConverter());
  converterRegistry.addConverter(new StringToPropertiesConverter());
  converterRegistry.addConverter(new PropertiesToStringConverter());
  converterRegistry.addConverter(new StringToUUIDConverter());
  converterRegistry.addConverter(UUID.class, String.class, new ObjectToStringConverter());
}

这里会添加23个类型转换器:

添加集合处理的类型转换器(这里会添加17个类型转换器):

public static void addCollectionConverters(ConverterRegistry converterRegistry) {
  ConversionService conversionService = (ConversionService) converterRegistry;
  converterRegistry.addConverter(new ArrayToCollectionConverter(conversionService));
  converterRegistry.addConverter(new CollectionToArrayConverter(conversionService));
  converterRegistry.addConverter(new ArrayToArrayConverter(conversionService));
  converterRegistry.addConverter(new CollectionToCollectionConverter(conversionService));
  converterRegistry.addConverter(new MapToMapConverter(conversionService));
  converterRegistry.addConverter(new ArrayToStringConverter(conversionService));
  converterRegistry.addConverter(new StringToArrayConverter(conversionService));
  converterRegistry.addConverter(new ArrayToObjectConverter(conversionService));
  converterRegistry.addConverter(new ObjectToArrayConverter(conversionService));
  converterRegistry.addConverter(new CollectionToStringConverter(conversionService));
  converterRegistry.addConverter(new StringToCollectionConverter(conversionService));
  converterRegistry.addConverter(new CollectionToObjectConverter(conversionService));
  converterRegistry.addConverter(new ObjectToCollectionConverter(conversionService));
  converterRegistry.addConverter(new StreamConverter(conversionService));
}

⑥ addDefaultFormatters添加格式化器

/**
 * Add formatters appropriate for most environments: including number formatters,
 * JSR-354 Money & Currency formatters, JSR-310 Date-Time and/or Joda-Time formatters,
 * depending on the presence of the corresponding API on the classpath.
 * @param formatterRegistry the service to register default formatters with
 */
public static void addDefaultFormatters(FormatterRegistry formatterRegistry) {
  // Default handling of number values
  formatterRegistry.addFormatterForFieldAnnotation(new NumberFormatAnnotationFormatterFactory());
  // Default handling of monetary values
  if (jsr354Present) {
    formatterRegistry.addFormatter(new CurrencyUnitFormatter());
    formatterRegistry.addFormatter(new MonetaryAmountFormatter());
    formatterRegistry.addFormatterForFieldAnnotation(new Jsr354NumberFormatAnnotationFormatterFactory());
  }
  // Default handling of date-time values
  // just handling JSR-310 specific date and time types
  new DateTimeFormatterRegistrar().registerFormatters(formatterRegistry);
  if (jodaTimePresent) {
    // handles Joda-specific types as well as Date, Calendar, Long
    new JodaTimeFormatterRegistrar().registerFormatters(formatterRegistry);
  }
  else {
    // regular DateFormat-based Date, Calendar, Long converters
    new DateFormatterRegistrar().registerFormatters(formatterRegistry);
  }
}

DateTimeFormatterRegistrar.registerFormatters

@Override
public void registerFormatters(FormatterRegistry registry) {
  DateTimeConverters.registerConverters(registry);
  DateTimeFormatter df = getFormatter(Type.DATE);
  DateTimeFormatter tf = getFormatter(Type.TIME);
  DateTimeFormatter dtf = getFormatter(Type.DATE_TIME);
  // Efficient ISO_LOCAL_* variants for printing since they are twice as fast...
  registry.addFormatterForFieldType(LocalDate.class,
      new TemporalAccessorPrinter(
          df == DateTimeFormatter.ISO_DATE ? DateTimeFormatter.ISO_LOCAL_DATE : df),
      new TemporalAccessorParser(LocalDate.class, df));
  registry.addFormatterForFieldType(LocalTime.class,
      new TemporalAccessorPrinter(
          tf == DateTimeFormatter.ISO_TIME ? DateTimeFormatter.ISO_LOCAL_TIME : tf),
      new TemporalAccessorParser(LocalTime.class, tf));
  registry.addFormatterForFieldType(LocalDateTime.class,
      new TemporalAccessorPrinter(
          dtf == DateTimeFormatter.ISO_DATE_TIME ? DateTimeFormatter.ISO_LOCAL_DATE_TIME : dtf),
      new TemporalAccessorParser(LocalDateTime.class, dtf));
  registry.addFormatterForFieldType(ZonedDateTime.class,
      new TemporalAccessorPrinter(dtf),
      new TemporalAccessorParser(ZonedDateTime.class, dtf));
  registry.addFormatterForFieldType(OffsetDateTime.class,
      new TemporalAccessorPrinter(dtf),
      new TemporalAccessorParser(OffsetDateTime.class, dtf));
  registry.addFormatterForFieldType(OffsetTime.class,
      new TemporalAccessorPrinter(tf),
      new TemporalAccessorParser(OffsetTime.class, tf));
  registry.addFormatterForFieldType(Instant.class, new InstantFormatter());
  registry.addFormatterForFieldType(Period.class, new PeriodFormatter());
  registry.addFormatterForFieldType(Duration.class, new DurationFormatter());
  registry.addFormatterForFieldType(Year.class, new YearFormatter());
  registry.addFormatterForFieldType(Month.class, new MonthFormatter());
  registry.addFormatterForFieldType(YearMonth.class, new YearMonthFormatter());
  registry.addFormatterForFieldType(MonthDay.class, new MonthDayFormatter());
  registry.addFormatterForFieldAnnotation(new Jsr310DateTimeFormatAnnotationFormatterFactory());
}

DateTimeConverters.registerConverters

public static void registerConverters(ConverterRegistry registry) {
  DateFormatterRegistrar.addDateConverters(registry);
  registry.addConverter(new LocalDateTimeToLocalDateConverter());
  registry.addConverter(new LocalDateTimeToLocalTimeConverter());
  registry.addConverter(new ZonedDateTimeToLocalDateConverter());
  registry.addConverter(new ZonedDateTimeToLocalTimeConverter());
  registry.addConverter(new ZonedDateTimeToLocalDateTimeConverter());
  registry.addConverter(new ZonedDateTimeToOffsetDateTimeConverter());
  registry.addConverter(new ZonedDateTimeToInstantConverter());
  registry.addConverter(new OffsetDateTimeToLocalDateConverter());
  registry.addConverter(new OffsetDateTimeToLocalTimeConverter());
  registry.addConverter(new OffsetDateTimeToLocalDateTimeConverter());
  registry.addConverter(new OffsetDateTimeToZonedDateTimeConverter());
  registry.addConverter(new OffsetDateTimeToInstantConverter());
  registry.addConverter(new CalendarToZonedDateTimeConverter());
  registry.addConverter(new CalendarToOffsetDateTimeConverter());
  registry.addConverter(new CalendarToLocalDateConverter());
  registry.addConverter(new CalendarToLocalTimeConverter());
  registry.addConverter(new CalendarToLocalDateTimeConverter());
  registry.addConverter(new CalendarToInstantConverter());
  registry.addConverter(new LongToInstantConverter());
  registry.addConverter(new InstantToLongConverter());
}

DateFormatterRegistrar.addDateConverters

public static void addDateConverters(ConverterRegistry converterRegistry) {
  converterRegistry.addConverter(new DateToLongConverter());
  converterRegistry.addConverter(new DateToCalendarConverter());
  converterRegistry.addConverter(new CalendarToDateConverter());
  converterRegistry.addConverter(new CalendarToLongConverter());
  converterRegistry.addConverter(new LongToDateConverter());
  converterRegistry.addConverter(new LongToCalendarConverter());
}

⑦ addApplicationFormatters(registry)

添加全局格式化器:

   public static void addApplicationFormatters(FormatterRegistry registry) {
        registry.addFormatter(new CharArrayFormatter());
        registry.addFormatter(new InetAddressFormatter());
        registry.addFormatter(new IsoOffsetFormatter());
    }

⑧ addApplicationConverters(registry)

添加全局类型转换器:

public static void addApplicationConverters(ConverterRegistry registry) {
       addDelimitedStringConverters(registry);
       registry.addConverter(new StringToDurationConverter());
       registry.addConverter(new DurationToStringConverter());
       registry.addConverter(new NumberToDurationConverter());
       registry.addConverter(new DurationToNumberConverter());
       registry.addConverter(new StringToDataSizeConverter());
       registry.addConverter(new NumberToDataSizeConverter());
       registry.addConverter(new StringToFileConverter());
       registry.addConverterFactory(new LenientStringToEnumConverterFactory());
       registry.addConverterFactory(new LenientBooleanToEnumConverterFactory());
   }
   public static void addDelimitedStringConverters(ConverterRegistry registry) {
       ConversionService service = (ConversionService)registry;
       registry.addConverter(new ArrayToDelimitedStringConverter(service));
       registry.addConverter(new CollectionToDelimitedStringConverter(service));
       registry.addConverter(new DelimitedStringToArrayConverter(service));
       registry.addConverter(new DelimitedStringToCollectionConverter(service));
   }
目录
相关文章
|
1月前
|
并行计算 Java 数据处理
SpringBoot高级并发实践:自定义线程池与@Async异步调用深度解析
SpringBoot高级并发实践:自定义线程池与@Async异步调用深度解析
150 0
|
1月前
|
人工智能 自然语言处理 前端开发
SpringBoot + 通义千问 + 自定义React组件:支持EventStream数据解析的技术实践
【10月更文挑战第7天】在现代Web开发中,集成多种技术栈以实现复杂的功能需求已成为常态。本文将详细介绍如何使用SpringBoot作为后端框架,结合阿里巴巴的通义千问(一个强大的自然语言处理服务),并通过自定义React组件来支持服务器发送事件(SSE, Server-Sent Events)的EventStream数据解析。这一组合不仅能够实现高效的实时通信,还能利用AI技术提升用户体验。
162 2
|
2月前
|
设计模式 Java 关系型数据库
【Java笔记+踩坑汇总】Java基础+JavaWeb+SSM+SpringBoot+SpringCloud+瑞吉外卖/谷粒商城/学成在线+设计模式+面试题汇总+性能调优/架构设计+源码解析
本文是“Java学习路线”专栏的导航文章,目标是为Java初学者和初中高级工程师提供一套完整的Java学习路线。
405 37
|
2月前
|
存储 缓存 Java
在Spring Boot中使用缓存的技术解析
通过利用Spring Boot中的缓存支持,开发者可以轻松地实现高效和可扩展的缓存策略,进而提升应用的性能和用户体验。Spring Boot的声明式缓存抽象和对多种缓存技术的支持,使得集成和使用缓存变得前所未有的简单。无论是在开发新应用还是优化现有应用,合理地使用缓存都是提高性能的有效手段。
38 1
|
3月前
|
前端开发 数据可视化 Java
SpringBoot的4中常见入参形式错误解析
在使用SpringBoot进行前后端接口对接时,常遇到如500、400等请求错误,本文总结了四个常见的复杂请求类型及其解决方案,包括实体嵌套List提交、普通文件上传、List提交及数组Array提交,详细展示了正确的前端与后端代码实现,帮助开发者避免常见错误,提高开发效率。
47 0
SpringBoot的4中常见入参形式错误解析
|
1月前
|
前端开发 JavaScript Java
【SpringBoot系列】视图解析器的搭建与开发
【SpringBoot系列】视图解析器的搭建与开发
23 0
|
3月前
|
XML Java 应用服务中间件
SpringBoot启动流程解析
SpringBoot启动流程解析
47 0
|
1月前
|
JavaScript 安全 Java
如何使用 Spring Boot 和 Ant Design Pro Vue 实现动态路由和菜单功能,快速搭建前后端分离的应用框架
本文介绍了如何使用 Spring Boot 和 Ant Design Pro Vue 实现动态路由和菜单功能,快速搭建前后端分离的应用框架。首先,确保开发环境已安装必要的工具,然后创建并配置 Spring Boot 项目,包括添加依赖和配置 Spring Security。接着,创建后端 API 和前端项目,配置动态路由和菜单。最后,运行项目并分享实践心得,包括版本兼容性、安全性、性能调优等方面。
143 1
|
17天前
|
JavaScript 安全 Java
如何使用 Spring Boot 和 Ant Design Pro Vue 构建一个具有动态路由和菜单功能的前后端分离应用。
本文介绍了如何使用 Spring Boot 和 Ant Design Pro Vue 构建一个具有动态路由和菜单功能的前后端分离应用。首先,创建并配置 Spring Boot 项目,实现后端 API;然后,使用 Ant Design Pro Vue 创建前端项目,配置动态路由和菜单。通过具体案例,展示了如何快速搭建高效、易维护的项目框架。
95 62
|
15天前
|
JavaScript 安全 Java
如何使用 Spring Boot 和 Ant Design Pro Vue 构建一个前后端分离的应用框架,实现动态路由和菜单功能
本文介绍了如何使用 Spring Boot 和 Ant Design Pro Vue 构建一个前后端分离的应用框架,实现动态路由和菜单功能。首先,确保开发环境已安装必要的工具,然后创建并配置 Spring Boot 项目,包括添加依赖和配置 Spring Security。接着,创建后端 API 和前端项目,配置动态路由和菜单。最后,运行项目并分享实践心得,帮助开发者提高开发效率和应用的可维护性。
34 2

推荐镜像

更多