国际化配置

已于 2022-08-13 23:40:29 修改
阅读量1.2k 收藏
点赞数
分类专栏： SpringBoot 文章标签： intellij-idea java spring boot
于 2022-05-28 22:43:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51691366/article/details/125023976
版权

1、编写国际化资源文件

在 src/main/resources 下创建一个 i18n 的目录，并在该目录中按照国际化资源文件命名格式分别创建以下三个文件，
login.properties：无语言设置时生效
login_en_US.properties ：英语时生效
login_zh_CN.properties：中文时生效

以上国际化资源文件创建完成后，IDEA 会自动识别它们，并转换成如下的模式：
在这里插入图片描述

然后就可以使用Resource Bundle进行可视化配置，如果没有这个插件，下载Resource Bundle插件
在这里插入图片描述
打开任意一个国际化资源文件，并切换为 Resource Bundle 模式，然后点击“+”号，创建所需的国际化属性，如下图。

2. 使用 ResourceBundleMessageSource 管理国际化资源文件

Spring Boot 已经对 ResourceBundleMessageSource 提供了默认的自动配置。

Spring Boot 通过 MessageSourceAutoConfiguration 对 ResourceBundleMessageSource 提供了默认配置，其部分源码如下。

/*
 * Copyright 2012-2019 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.springframework.boot.autoconfigure.context;

import java.time.Duration;

import org.springframework.boot.autoconfigure.AutoConfigureOrder;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.autoconfigure.condition.ConditionMessage;
import org.springframework.boot.autoconfigure.condition.ConditionOutcome;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.condition.SearchStrategy;
import org.springframework.boot.autoconfigure.condition.SpringBootCondition;
import org.springframework.boot.autoconfigure.context.MessageSourceAutoConfiguration.ResourceBundleCondition;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.MessageSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.context.annotation.Conditional;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ResourceBundleMessageSource;
import org.springframework.core.Ordered;
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.type.AnnotatedTypeMetadata;
import org.springframework.util.ConcurrentReferenceHashMap;
import org.springframework.util.StringUtils;

/**
 * {@link EnableAutoConfiguration Auto-configuration} for {@link MessageSource}.
 *
 * @author Dave Syer
 * @author Phillip Webb
 * @author Eddú Meléndez
 * @since 1.5.0
 */
@Configuration(proxyBeanMethods = false)
@ConditionalOnMissingBean(name = AbstractApplicationContext.MESSAGE_SOURCE_BEAN_NAME, search = SearchStrategy.CURRENT)
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
@Conditional(ResourceBundleCondition.class)
@EnableConfigurationProperties
public class MessageSourceAutoConfiguration {

	private static final Resource[] NO_RESOURCES = {};

	@Bean
	@ConfigurationProperties(prefix = "spring.messages")
	public MessageSourceProperties messageSourceProperties() {
		return new MessageSourceProperties();
	}

	@Bean
	public MessageSource messageSource(MessageSourceProperties properties) {
		ResourceBundleMessageSource messageSource = new ResourceBundleMessageSource();
		if (StringUtils.hasText(properties.getBasename())) {
			messageSource.setBasenames(StringUtils
					.commaDelimitedListToStringArray(StringUtils.trimAllWhitespace(properties.getBasename())));
		}
		if (properties.getEncoding() != null) {
			messageSource.setDefaultEncoding(properties.getEncoding().name());
		}
		messageSource.setFallbackToSystemLocale(properties.isFallbackToSystemLocale());
		Duration cacheDuration = properties.getCacheDuration();
		if (cacheDuration != null) {
			messageSource.setCacheMillis(cacheDuration.toMillis());
		}
		messageSource.setAlwaysUseMessageFormat(properties.isAlwaysUseMessageFormat());
		messageSource.setUseCodeAsDefaultMessage(properties.isUseCodeAsDefaultMessage());
		return messageSource;
	}

	protected static class ResourceBundleCondition extends SpringBootCondition {

		private static ConcurrentReferenceHashMap<String, ConditionOutcome> cache = new ConcurrentReferenceHashMap<>();

		@Override
		public ConditionOutcome getMatchOutcome(ConditionContext context, AnnotatedTypeMetadata metadata) {
			String basename = context.getEnvironment().getProperty("spring.messages.basename", "messages");
			ConditionOutcome outcome = cache.get(basename);
			if (outcome == null) {
				outcome = getMatchOutcomeForBasename(context, basename);
				cache.put(basename, outcome);
			}
			return outcome;
		}

		private ConditionOutcome getMatchOutcomeForBasename(ConditionContext context, String basename) {
			ConditionMessage.Builder message = ConditionMessage.forCondition("ResourceBundle");
			for (String name : StringUtils.commaDelimitedListToStringArray(StringUtils.trimAllWhitespace(basename))) {
				for (Resource resource : getResources(context.getClassLoader(), name)) {
					if (resource.exists()) {
						return ConditionOutcome.match(message.found("bundle").items(resource));
					}
				}
			}
			return ConditionOutcome.noMatch(message.didNotFind("bundle with basename " + basename).atAll());
		}

		private Resource[] getResources(ClassLoader classLoader, String name) {
			String target = name.replace('.', '/');
			try {
				return new PathMatchingResourcePatternResolver(classLoader)
						.getResources("classpath*:" + target + ".properties");
			}
			catch (Exception ex) {
				return NO_RESOURCES;
			}
		}

	}

}

从以上源码可知：
Spring Boot 将 MessageSourceProperties 以组件的形式添加到容器中；
MessageSourceProperties 的属性与配置文件中以“spring.messages”开头的配置进行了绑定；
Spring Boot 从容器中获取 MessageSourceProperties 组件，并从中读取国际化资源文件的 basename（文件基本名）、encoding（编码）等信息，将它们封装到 ResourceBundleMessageSource 中；
Spring Boot 将 ResourceBundleMessageSource 以组件的形式添加到容器中，进而实现对国际化资源文件的管理。

查看 MessageSourceProperties 类，其代码如下。

/*
 * Copyright 2012-2019 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.springframework.boot.autoconfigure.context;

import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.time.Duration;
import java.time.temporal.ChronoUnit;

import org.springframework.boot.convert.DurationUnit;

/**
 * Configuration properties for Message Source.
 *
 * @author Stephane Nicoll
 * @author Kedar Joshi
 * @since 2.0.0
 */
public class MessageSourceProperties {

	/**
	 * Comma-separated list of basenames (essentially a fully-qualified classpath
	 * location), each following the ResourceBundle convention with relaxed support for
	 * slash based locations. If it doesn't contain a package qualifier (such as
	 * "org.mypackage"), it will be resolved from the classpath root.
	 */
	private String basename = "messages";

	/**
	 * Message bundles encoding.
	 */
	private Charset encoding = StandardCharsets.UTF_8;

	/**
	 * Loaded resource bundle files cache duration. When not set, bundles are cached
	 * forever. If a duration suffix is not specified, seconds will be used.
	 */
	@DurationUnit(ChronoUnit.SECONDS)
	private Duration cacheDuration;

	/**
	 * Whether to fall back to the system Locale if no files for a specific Locale have
	 * been found. if this is turned off, the only fallback will be the default file (e.g.
	 * "messages.properties" for basename "messages").
	 */
	private boolean fallbackToSystemLocale = true;

	/**
	 * Whether to always apply the MessageFormat rules, parsing even messages without
	 * arguments.
	 */
	private boolean alwaysUseMessageFormat = false;

	/**
	 * Whether to use the message code as the default message instead of throwing a
	 * "NoSuchMessageException". Recommended during development only.
	 */
	private boolean useCodeAsDefaultMessage = false;

	public String getBasename() {
		return this.basename;
	}

	public void setBasename(String basename) {
		this.basename = basename;
	}

	public Charset getEncoding() {
		return this.encoding;
	}

	public void setEncoding(Charset encoding) {
		this.encoding = encoding;
	}

	public Duration getCacheDuration() {
		return this.cacheDuration;
	}

	public void setCacheDuration(Duration cacheDuration) {
		this.cacheDuration = cacheDuration;
	}

	public boolean isFallbackToSystemLocale() {
		return this.fallbackToSystemLocale;
	}

	public void setFallbackToSystemLocale(boolean fallbackToSystemLocale) {
		this.fallbackToSystemLocale = fallbackToSystemLocale;
	}

	public boolean isAlwaysUseMessageFormat() {
		return this.alwaysUseMessageFormat;
	}

	public void setAlwaysUseMessageFormat(boolean alwaysUseMessageFormat) {
		this.alwaysUseMessageFormat = alwaysUseMessageFormat;
	}

	public boolean isUseCodeAsDefaultMessage() {
		return this.useCodeAsDefaultMessage;
	}

	public void setUseCodeAsDefaultMessage(boolean useCodeAsDefaultMessage) {
		this.useCodeAsDefaultMessage = useCodeAsDefaultMessage;
	}

}

通过以上代码，我们可以得到以下 3 点信息：
MessageSourceProperties 为 basename、encoding 等属性提供了默认值；
basename 表示国际化资源文件的基本名，其默认取值为“message”，即 Spring Boot 默认会获取类路径下的 message.properties 以及 message_XXX.properties 作为国际化资源文件；
在 application.porperties/yml 等配置文件中，使用配置参数“spring.messages.basename”即可重新指定国际化资源文件的基本名。

通过以上源码分析可知，Spring Boot 已经对国际化资源文件的管理提供了默认自动配置，我们这里只需要在 Spring Boot 全局配置文件中，使用配置参数“spring.messages.basename”指定我们自定义的国际资源文件的基本名即可，代码如下（当指定多个资源文件时，用逗号分隔）。
在这里插入图片描述

3. 获取国际化内容

由于页面使用的是 Tymeleaf 模板引擎，因此我们可以通过表达式 #{…} 获取国际化内容。
在这里插入图片描述
但是这里需要注意的是，访问路径中的login.html是否存在，我直接再将其放在了config下的webConfig文件中进行访问，当然也可以随便命名
在这里插入图片描述
在这里插入图片描述

区域信息解析器自动配置

Spring MVC 进行国际化时有 2 个十分重要的对象：
Locale：区域信息对象
LocaleResolver：区域信息解析器，容器中的组件，负责获取区域信息对象

我们可以通过以上两个对象对区域信息的切换，以达到切换语言的目的。

Spring Boot 在 WebMvcAutoConfiguration 中为区域信息解析器（LocaleResolver）进行了自动配置，源码如下

       @Override
		@Bean
		@ConditionalOnMissingBean(name = DispatcherServlet.LOCALE_RESOLVER_BEAN_NAME)
		public LocaleResolver localeResolver() {
			if (this.webProperties.getLocaleResolver() == WebProperties.LocaleResolver.FIXED) {
				return new FixedLocaleResolver(this.webProperties.getLocale());
			}
			AcceptHeaderLocaleResolver localeResolver = new AcceptHeaderLocaleResolver();
			localeResolver.setDefaultLocale(this.webProperties.getLocale());
			return localeResolver;
		}

从以上源码可知：
该方法默认向容器中添加了一个区域信息解析器（LocaleResolver）组件，它会根据请求头中携带的“Accept-Language”参数，获取相应区域信息（Locale）对象。
该方法上使用了 @ConditionalOnMissingBean 注解，其参数 name 的取值为 localeResolver（与该方法注入到容器中的组件名称一致），该注解的含义为：当容器中不存在名称为 localResolver 组件时，该方法才会生效。换句话说，当我们手动向容器中添加一个名为“localeResolver”的组件时，Spring Boot 自动配置的区域信息解析器会失效，而我们定义的区域信息解析器则会生效

AcceptHeaderLocaleResolver中的源码如下

/*
 * Copyright 2002-2021 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.springframework.web.servlet.i18n;

import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import java.util.Locale;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.lang.Nullable;
import org.springframework.util.StringUtils;
import org.springframework.web.servlet.LocaleResolver;

/**
 * {@link LocaleResolver} implementation that simply uses the primary locale
 * specified in the "accept-language" header of the HTTP request (that is,
 * the locale sent by the client browser, normally that of the client's OS).
 *
 * <p>Note: Does not support {@code setLocale}, since the accept header
 * can only be changed through changing the client's locale settings.
 *
 * @author Juergen Hoeller
 * @author Rossen Stoyanchev
 * @since 27.02.2003
 * @see javax.servlet.http.HttpServletRequest#getLocale()
 */
public class AcceptHeaderLocaleResolver implements LocaleResolver {

	private final List<Locale> supportedLocales = new ArrayList<>(4);

	@Nullable
	private Locale defaultLocale;


	/**
	 * Configure supported locales to check against the requested locales
	 * determined via {@link HttpServletRequest#getLocales()}. If this is not
	 * configured then {@link HttpServletRequest#getLocale()} is used instead.
	 * @param locales the supported locales
	 * @since 4.3
	 */
	public void setSupportedLocales(List<Locale> locales) {
		this.supportedLocales.clear();
		this.supportedLocales.addAll(locales);
	}

	/**
	 * Return the configured list of supported locales.
	 * @since 4.3
	 */
	public List<Locale> getSupportedLocales() {
		return this.supportedLocales;
	}

	/**
	 * Configure a fixed default locale to fall back on if the request does not
	 * have an "Accept-Language" header.
	 * <p>By default this is not set in which case when there is no "Accept-Language"
	 * header, the default locale for the server is used as defined in
	 * {@link HttpServletRequest#getLocale()}.
	 * @param defaultLocale the default locale to use
	 * @since 4.3
	 */
	public void setDefaultLocale(@Nullable Locale defaultLocale) {
		this.defaultLocale = defaultLocale;
	}

	/**
	 * The configured default locale, if any.
	 * <p>This method may be overridden in subclasses.
	 * @since 4.3
	 */
	@Nullable
	public Locale getDefaultLocale() {
		return this.defaultLocale;
	}


	@Override
	public Locale resolveLocale(HttpServletRequest request) {
		Locale defaultLocale = getDefaultLocale();
		if (defaultLocale != null && request.getHeader("Accept-Language") == null) {
			return defaultLocale;
		}
		Locale requestLocale = request.getLocale();
		List<Locale> supportedLocales = getSupportedLocales();
		if (supportedLocales.isEmpty() || supportedLocales.contains(requestLocale)) {
			return requestLocale;
		}
		Locale supportedLocale = findSupportedLocale(request, supportedLocales);
		if (supportedLocale != null) {
			return supportedLocale;
		}
		return (defaultLocale != null ? defaultLocale : requestLocale);
	}

	@Nullable
	private Locale findSupportedLocale(HttpServletRequest request, List<Locale> supportedLocales) {
		Enumeration<Locale> requestLocales = request.getLocales();
		Locale languageMatch = null;
		while (requestLocales.hasMoreElements()) {
			Locale locale = requestLocales.nextElement();
			if (supportedLocales.contains(locale)) {
				if (languageMatch == null || languageMatch.getLanguage().equals(locale.getLanguage())) {
					// Full match: language + country, possibly narrowed from earlier language-only match
					return locale;
				}
			}
			else if (languageMatch == null) {
				// Let's try to find a language-only match as a fallback
				for (Locale candidate : supportedLocales) {
					if (!StringUtils.hasLength(candidate.getCountry()) &&
							candidate.getLanguage().equals(locale.getLanguage())) {
						languageMatch = candidate;
						break;
					}
				}
			}
		}
		return languageMatch;
	}

	@Override
	public void setLocale(HttpServletRequest request, @Nullable HttpServletResponse response, @Nullable Locale locale) {
		throw new UnsupportedOperationException(
				"Cannot change HTTP accept header - use a different locale resolution strategy");
	}

}

手动切换语言

（1）、修改 login.html 切换语言链接，在请求中携带国际化区域信息，代码如下。
在这里插入图片描述
（2）、模仿AcceptHeaderLocaleResolve写配置文件，命名为MyLocalResolver，实现接口LocaleResolver并重写LocaleResolver中的方法
在这里插入图片描述

package com.ma.ml.config;

import org.springframework.web.servlet.LocaleResolver;
import org.thymeleaf.util.StringUtils;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Locale;

public class MyLocalResolver implements LocaleResolver {

    /**
     * Resolve the current locale via the given request.
     * Can return a default locale as fallback in any case.
     *
     * @param request the request to resolve the locale for
     * @return the current locale (never {@code null})
     */

    @Override
    public Locale resolveLocale(HttpServletRequest request) {
        String language = request.getParameter("l");   //获得请求路径中的参数
        Locale locale = Locale.getDefault(); //获取默认的请求，如果没有我们自己配置的国际化设置，就使用默认spring默认的
        if(!StringUtils.isEmpty(language)){ //若请求的链接中含有国家化的参数
        //zh_CN
            String [] strings = language.split("_");
            locale = new Locale(strings[0],strings[1]);  //重新修改默认值
        }
        return locale;
    }


    /**
     * Set the current locale to the given one.
     *
     * @param request  the request to be used for locale modification
     * @param response the response to be used for locale modification
     * @param locale   the new locale, or {@code null} to clear the locale
     * @throws UnsupportedOperationException if the LocaleResolver
     *                                       implementation does not support dynamic changing of the locale
     */

    @Override
    public void setLocale(HttpServletRequest request, HttpServletResponse response, Locale locale) {

    }
}

（3）、将其像下面一样使用@Bean注册到spring Mvc中
在这里插入图片描述
在这里插入图片描述

4、启动项目即可正常切换访问

在这里插入图片描述
在这里插入图片描述

Q渡劫
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java 国际化 配置文件_spring国际化properties文件配置在数据库中
weixin_39846898的博客
02-24 2063
1.spring为java项目提供国际化支持message_zh_CN.properties(中文简体)message_en_US.properties(美国英文)等等中配置key=valuekey可以是错误提示信息，页面显示信息等等。使用配置的配置@Autowiredprivate MessageSource messageSource;messageSource.getMessage(key,...
Springboot开发-springboot的国际化配置.zip
05-09
在Spring Boot应用中，国际化配置是一项重要的功能，它允许我们为不同的地区和语言提供相应的界面和文本。Spring Boot简化了这个过程，使得开发者能够轻松地实现国际化。下面将详细介绍Spring Boot中实现国际化配置...
vue项目国际化配置
一只努力搬砖的打工妹纸
05-21 1155
国际化配置即多语言配置，使用到的插件是vue-i18n，本例中亦通过设置下拉选框，切换界面语言； 安装依赖 npm install vue-i18n@8.26.5 --save 亲测该版本有效～ 在main.js中引入并尝试打印看下是否引入成功； import VueI18n from 'vue-i18n' console.log(VueI18n, 'VueI18n'); 控制台输出则表明成功引入； 配置多语言文件 在项目asset目录下新建language/language文件夹，
spring-国际化配置i18n
ssehs的博客
04-06 1475
前言 业务发展到一定程度，会有国际化的需求。 思路 实现多语言的思路很简单，配置多个语言的properties文件，框架根据当前语言去对应属性文件里找到属性的值。 流程 创建属性文件 配置属性文件的路径和名称 spring默认属性名称 ...
idea修改国际化语言教程
renkai721的专栏
06-03 741
idea工具修改或增加新的语言，国际化增加语言
springboot国际化配置
修行者Java的博客
11-24 3145
springboot国际化配置 最近做了一个国际化项目，app后台需要国际化配置错误提示，今天总结分享一下 1.在yml文件的spring下加入下面代码： messages: encoding: UTF-8 basename: i18n/messages cache-second: 3600 2.在resource下创建i18n文件夹（internationalization国际化，共18个字母简称i18n）， 里面创建messages.properties（默认文件，非中、英文时读
vitepress多语言国际化配置
MW_WQ的博客
06-25 2517
activeMatch: "/zh/examples/about/", // // 当前页面处于匹配路径下时, 对应导航菜单将突出显示。{ text: "开始", link: "/zh/examples/introduction/markdown" },{ text: "功能", link: "/zh/examples/introduction/build" },{ text: "比较", link: "/zh/examples/api/test" },navigateText: "切换",
Spring Boot 国际化配置
扛麻袋的少年的博客
03-29 2310
Spring Boot学习笔记(十五)：目录1.编写国际化配置2.配置国际化文件所在路径3.页面代码修改支持国际化 1.编写国际化配置        首先需要在 resources 资源目录下创建国际化配置。我们创建一个文件夹 i18n，用来存储国际化配置（命名随意，一般为 i18n），然后在目录下分别创建i18n.properties、i18n_zh_CN.prop...
springboot国际化配置详细过程
一点光辉的博客
12-10 5599
因为我是纯小白来做的国际化，所以网上找了些资料，完成了国际化的开发，很多文章把大致过程都总结出来了，但是有些细节地方还不完整，所以这里做一个记录，并且把国际化的异常自己做了一个工具类封装，还从前端大神那里总结了一套对于很多国际化字符如何分类的问题。 目录 1、参考文章，此篇基本的代码都有了 2、详细操作步骤 1、在resource下新建文件夹i18n 2、在i18n下新建‘Resource Bundle’文件 2、文件编辑 3、在国际化配置文件中加上配置 4、添加国际化解析文件 在spri
Springboot 手把手实现国际化配置
qq_23000805的博客
08-24 1608
SpringBoot 手把手实现国际化
springboot+React实现国际化配置
wl_sqfn的博客
05-24 1437
在controller中。
MessageSource国际化配置
qq_41366052的博客
11-28 3035
引言 此文为springboot 配置国际化,会用到application.yml 文件,需要国际化文件的message.properties 。 创建 message.properties文件 在resource创建国际化文件 文件格式：文件名_language_country.properties，其中language和country为:Locale实体类 ---->baseLocale -------------------->language（语言）和region（国家）。
Springmvc国际化自动配置代码实现
08-19
Springmvc国际化自动配置代码实现 Springmvc国际化自动配置代码实现是指在Springmvc框架中实现国际化自动配置的方法和技术。国际化自动配置代码实现是指在Springmvc应用程序中，根据客户端的请求自动地选择适合的...
SpringBoot消息国际化配置实现过程解析
08-18
SpringBoot 消息国际化配置实现过程解析 SpringBoot 消息国际化配置实现过程解析是指在 SpringBoot 项目中实现消息国际化配置的过程。该过程主要涉及到消息配置文件的管理、语言信息的设置、LocaleContext 的使用、...
Java国际化配置
04-13
用Java写的一个国际化语言配置模块，可实现简单的国际化配置。
Idea2024 创建Meaven项目没有src文件夹
最新发布
weixin_46228563的博客
07-25 208
在file->new projects setup->Settings for New Projects...可以看到idea给出了快捷创建文件夹的选项，可以根据需要创建，这里点击src/main/java。的Runner的VM Options为-Darchetype=Internal。时会进行下载，等待下载完成，大约一两分钟左右，项目就会出现src目录了。新建maven项目，发现没有src/main/java。：右击项目名->new->Directory。回车，可以看到文件夹已经创建成功了。
IntelliJ IDEA 和 Eclipse的区别
qq_29751083的博客
07-18 849
如果你的机器性能足够强大，且追求更智能的开发体验，IntelliJ IDEA 可能是更好的选择。IntelliJ IDEA 和 Eclipse 都拥有庞大的插件生态系统，但 IntelliJ IDEA 的插件市场可能更集中，易于管理和发现新插件。这使得 Eclipse 在低配置的计算机上运行更为流畅。Eclipse 的插件生态系统非常成熟，有大量的插件可供选择，包括一些特定领域的插件，如 Mylyn 用于任务管理。IntelliJ IDEA 有免费的社区版和付费的专业版，专业版提供了更多的高级功能。
IDEA的详细设置
buyaotutou的博客
07-19 944
例如：第一章 Python 机器学习入门之pandas的使用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Q渡劫

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值