SpringBoot内置工具类（SpringBoot中内置的49个常用工具类使用

import org.springframework.util.StringUtils;

// 检查字符串是否为空
boolean isEmpty = StringUtils.isEmpty(null);  // true
boolean isEmpty2 = StringUtils.isEmpty("");  // true

// 检查字符串是否有文本内容
boolean hasText = StringUtils.hasText("  ");  // false
boolean hasText2 = StringUtils.hasText("hello");  // true

// 分割字符串
String[] parts = StringUtils.tokenizeToStringArray("a,b,c", ",");

// 清除首尾空白
String trimmed = StringUtils.trimWhitespace("  hello  ");  // "hello"

import org.springframework.util.AntPathMatcher;

AntPathMatcher matcher = new AntPathMatcher();
boolean match1 = matcher.match("/users/*", "/users/123");  // true
boolean match2 = matcher.match("/users/**", "/users/123/orders");  // true
boolean match3 = matcher.match("/user?", "/user1");  // true

// 提取路径变量
Map<String, String> vars = matcher.extractUriTemplateVariables(
    "/users/{id}", "/users/42");  // {id=42}

import org.springframework.util.PatternMatchUtils;

boolean matches1 = PatternMatchUtils.simpleMatch("user*", "username");  // true
boolean matches2 = PatternMatchUtils.simpleMatch("user?", "user1");  // true
boolean matches3 = PatternMatchUtils.simpleMatch(
    new String[]{"user*", "admin*"}, "username");  // true

import org.springframework.util.PropertyPlaceholderHelper;

PropertyPlaceholderHelper helper = new PropertyPlaceholderHelper("${", "}");
Properties props = new Properties();
props.setProperty("name", "World");
props.setProperty("greeting", "Hello ${name}!");

String result = helper.replacePlaceholders("${greeting}", props::getProperty);
// "Hello World!"

import org.springframework.util.CollectionUtils;

// 检查集合是否为空
boolean isEmpty = CollectionUtils.isEmpty(null);  // true
boolean isEmpty2 = CollectionUtils.isEmpty(Collections.emptyList());  // true

// 集合操作
List<String> list1 = Arrays.asList("a", "b", "c");
List<String> list2 = Arrays.asList("b", "c", "d");
Collection<String> intersection = CollectionUtils.intersection(list1, list2);  // [b, c]

// 合并集合
List<String> target = new ArrayList<>();
CollectionUtils.mergeArrayIntoCollection(new String[]{"a", "b"}, target);

import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;

MultiValueMap<String, String> map = new LinkedMultiValueMap<>();
map.add("colors", "red");
map.add("colors", "blue");
map.add("sizes", "large");

List<String> colors = map.get("colors");  // [red, blue]

import org.springframework.util.ConcurrentReferenceHashMap;

// 创建高并发场景下的引用Map (类似WeakHashMap但线程安全)
Map<String, Object> cache = new ConcurrentReferenceHashMap<>();
cache.put("key1", new LargeObject());

import org.springframework.util.SystemPropertyUtils;

// 解析含系统属性的字符串
String javaHome = SystemPropertyUtils.resolvePlaceholders("${java.home}");
String pathWithDefault = SystemPropertyUtils.resolvePlaceholders(
    "${unknown.property:default}");  // "default"

import org.springframework.util.ReflectionUtils;

// 获取类的字段
Field field = ReflectionUtils.findField(Person.class, "name");
ReflectionUtils.makeAccessible(field);
ReflectionUtils.setField(field, person, "John");

// 调用方法
Method method = ReflectionUtils.findMethod(Person.class, "setAge", int.class);
ReflectionUtils.makeAccessible(method);
ReflectionUtils.invokeMethod(method, person, 30);

// 字段回调
ReflectionUtils.doWithFields(Person.class, field -> {
    System.out.println(field.getName());
});

import org.springframework.util.ClassUtils;

// 获取类名
String shortName = ClassUtils.getShortName("org.example.MyClass");  // "MyClass"

// 检查类是否存在
boolean exists = ClassUtils.isPresent("java.util.List", null);  // true

// 获取所有接口
Class<?>[] interfaces = ClassUtils.getAllInterfaces(ArrayList.class);

// 获取用户定义的类加载器
ClassLoader classLoader = ClassUtils.getDefaultClassLoader();

import org.springframework.util.MethodInvoker;

MethodInvoker invoker = new MethodInvoker();
invoker.setTargetObject(new MyService());
invoker.setTargetMethod("calculateTotal");
invoker.setArguments(new Object[]{100, 0.2});
invoker.prepare();
Object result = invoker.invoke();

import org.springframework.beans.BeanUtils;

// 复制属性
Person source = new Person("John", 30);
Person target = new Person();
BeanUtils.copyProperties(source, target);

// 实例化类
Person newPerson = BeanUtils.instantiateClass(Person.class);

// 查找方法
Method method = BeanUtils.findMethod(Person.class, "setName", String.class);

import org.springframework.util.FileCopyUtils;

// 复制文件内容
byte[] bytes = FileCopyUtils.copyToByteArray(new File("input.txt"));
FileCopyUtils.copy(bytes, new File("output.txt"));

// 读取文本
String content = FileCopyUtils.copyToString(
    new InputStreamReader(new FileInputStream("input.txt"), "UTF-8"));

// 流复制
FileCopyUtils.copy(inputStream, outputStream);

import org.springframework.util.ResourceUtils;

// 获取文件
File file = ResourceUtils.getFile("classpath:config.properties");

// 检查是否是URL
boolean isUrl = ResourceUtils.isUrl("http://example.com");

// 获取URL
URL url = ResourceUtils.getURL("classpath:data.json");

import org.springframework.util.StreamUtils;

// 流操作
byte[] data = StreamUtils.copyToByteArray(inputStream);
String text = StreamUtils.copyToString(inputStream, StandardCharsets.UTF_8);
StreamUtils.copy(inputStream, outputStream);
StreamUtils.copy("Hello", StandardCharsets.UTF_8, outputStream);

import org.springframework.util.FileSystemUtils;

// 删除目录
boolean deleted = FileSystemUtils.deleteRecursively(new File("/tmp/test"));

// 复制目录
FileSystemUtils.copyRecursively(new File("source"), new File("target"));

import org.springframework.core.io.Resource;
import org.springframework.core.io.support.ResourcePatternUtils;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;

// 获取匹配资源
Resource[] resources = ResourcePatternUtils.getResourcePatternResolver(
    new PathMatchingResourcePatternResolver())
    .getResources("classpath*:META-INF/*.xml");

import org.springframework.web.util.WebUtils;
import javax.servlet.http.HttpServletRequest;

// 获取Cookie
Cookie cookie = WebUtils.getCookie(request, "sessionId");

// 获取请求路径
String path = WebUtils.getLookupPathForRequest(request);

// 从请求中获取参数
int pageSize = WebUtils.getIntParameter(request, "pageSize", 10);

import org.springframework.web.util.UriUtils;

// 编解码URI组件
String encoded = UriUtils.encodePathSegment("path with spaces", "UTF-8");
String decoded = UriUtils.decode(encoded, "UTF-8");

import org.springframework.web.util.UriComponentsBuilder;

// 构建URI
URI uri = UriComponentsBuilder.fromHttpUrl("http://example.com")
    .path("/products")
    .queryParam("category", "books")
    .queryParam("sort", "price")
    .build()
    .toUri();

import org.springframework.web.util.ContentCachingRequestWrapper;
import javax.servlet.http.HttpServletRequest;

ContentCachingRequestWrapper wrapper = new ContentCachingRequestWrapper(request);
// 请求处理后
byte[] body = wrapper.getContentAsByteArray();

import org.springframework.web.util.HtmlUtils;

// HTML转义
String escaped = HtmlUtils.htmlEscape("<script>alert('XSS')</script>");
// &lt;script&gt;alert('XSS')&lt;/script&gt;

// HTML反转义
String unescaped = HtmlUtils.htmlUnescape("&lt;b&gt;Bold&lt;/b&gt;");
// <b>Bold</b>

import org.springframework.util.Assert;

// 常用断言
Assert.notNull(object, "Object must not be null");
Assert.hasText(name, "Name must not be empty");
Assert.isTrue(amount > 0, "Amount must be positive");
Assert.notEmpty(items, "Items must not be empty");
Assert.state(isInitialized, "Service is not initialized");

import org.springframework.util.ObjectUtils;

// 对象工具
boolean isEmpty = ObjectUtils.isEmpty(null);  // true
boolean isEmpty2 = ObjectUtils.isEmpty(new String[0]);  // true

String nullSafe = ObjectUtils.nullSafeToString(null);  // "null"
boolean equals = ObjectUtils.nullSafeEquals(obj1, obj2);

// 默认值
String value = ObjectUtils.getOrDefault(null, "default");

import org.springframework.util.NumberUtils;

// 数字转换
Integer parsed = NumberUtils.parseNumber("42", Integer.class);
Double converted = NumberUtils.convertNumberToTargetClass(42, Double.class);

import org.springframework.format.datetime.DateTimeFormatUtils;
import java.util.Date;

// 格式化日期
String formatted = DateTimeFormatUtils.getDateTimeInstance().format(new Date());

import org.springframework.util.StopWatch;

// 计时工具
StopWatch watch = new StopWatch("TaskName");
watch.start("phase1");
// 执行任务1
Thread.sleep(100);
watch.stop();

watch.start("phase2");
// 执行任务2
Thread.sleep(200);
watch.stop();

// 输出报告
System.out.println(watch.prettyPrint());
System.out.println("Total time: " + watch.getTotalTimeMillis() + "ms");

import org.springframework.util.DigestUtils;

// MD5哈希
String md5 = DigestUtils.md5DigestAsHex("password".getBytes());

// 文件MD5
String fileMd5;
try (InputStream is = new FileInputStream("file.txt")) {
    fileMd5 = DigestUtils.md5DigestAsHex(is);
}

import org.springframework.util.Base64Utils;

// Base64编解码
byte[] data = "Hello World".getBytes();
String encoded = Base64Utils.encodeToString(data);
byte[] decoded = Base64Utils.decodeFromString(encoded);

import org.springframework.security.crypto.encrypt.Encryptors;
import org.springframework.security.crypto.encrypt.TextEncryptor;

// 文本加密
String password = "secret";
String salt = "deadbeef";
TextEncryptor encryptor = Encryptors.text(password, salt);
String encrypted = encryptor.encrypt("Message");
String decrypted = encryptor.decrypt(encrypted);

import org.springframework.boot.json.JsonParser;
import org.springframework.boot.json.JsonParserFactory;

// JSON解析
JsonParser parser = JsonParserFactory.getJsonParser();
Map<String, Object> parsed = parser.parseMap("{"name":"John", "age":30}");
List<Object> parsedList = parser.parseList("[1, 2, 3]");

import org.springframework.core.ResolvableType;

// 类型解析
ResolvableType type = ResolvableType.forClass(List.class);
ResolvableType elementType = type.getGeneric(0);

// 泛型类型处理
ResolvableType mapType = ResolvableType.forClassWithGenerics(
    Map.class, String.class, Integer.class);

import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import com.fasterxml.jackson.databind.ObjectMapper;

// 自定义JSON转换器
ObjectMapper mapper = new ObjectMapper();
// 配置mapper
MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter(mapper);

import org.apache.commons.lang3.RandomStringUtils;

// 随机字符串生成
String random = RandomStringUtils.randomAlphanumeric(10);
String randomLetters = RandomStringUtils.randomAlphabetic(8);
String randomNumeric = RandomStringUtils.randomNumeric(6);

import java.util.concurrent.CompletableFuture;
import java.util.List;
import java.util.stream.Collectors;

// 合并多个CompletableFuture结果
List<CompletableFuture<String>> futures = /* 多个异步操作 */;
CompletableFuture<List<String>> allResults = CompletableFuture.allOf(
    futures.toArray(new CompletableFuture[0]))
    .thenApply(v -> futures.stream()
        .map(CompletableFuture::join)
        .collect(Collectors.toList()));

import org.springframework.http.CacheControl;
import java.util.concurrent.TimeUnit;

// 缓存控制
CacheControl cacheControl = CacheControl.maxAge(1, TimeUnit.HOURS)
    .noTransform()
    .mustRevalidate();

String headerValue = cacheControl.getHeaderValue();

import org.springframework.core.annotation.AnnotationUtils;

// 查找注解
Component annotation = AnnotationUtils.findAnnotation(MyClass.class, Component.class);

// 获取注解属性
String value = AnnotationUtils.getValue(annotation, "value").toString();

// 合并注解
Component mergedAnnotation = AnnotationUtils.synthesizeAnnotation(
    annotation, MyClass.class);

import org.springframework.core.convert.support.DefaultConversionService;

// 类型转换
DefaultConversionService conversionService = new DefaultConversionService();
String strValue = "42";
Integer intValue = conversionService.convert(strValue, Integer.class);

import org.springframework.http.HttpHeaders;

// HTTP头处理
HttpHeaders headers = new HttpHeaders();
headers.add("Content-Type", "application/json");
headers.setContentLength(1024);
headers.setCacheControl("max-age=3600");

import org.springframework.http.MediaType;
import org.springframework.http.MediaTypeFactory;
import java.util.Optional;

// 根据文件名推断媒体类型
Optional<MediaType> mediaType = MediaTypeFactory.getMediaType("document.pdf");
// application/pdf

import org.springframework.util.MimeTypeUtils;

// MIME类型常量和解析
boolean isCompatible = MimeTypeUtils.APPLICATION_JSON.isCompatibleWith(
    MimeTypeUtils.APPLICATION_JSON_UTF8);

import org.springframework.web.reactive.function.client.WebClient;
import org.springframework.web.reactive.function.client.ExchangeFilterFunction;

// 创建WebClient
WebClient webClient = WebClient.builder()
    .baseUrl("https://api.example.com")
    .defaultHeader("Authorization", "Bearer token")
    .filter(ExchangeFilterFunction.ofRequestProcessor(
        clientRequest -> {
            // 请求处理
            return Mono.just(clientRequest);
        }))
    .build();

import org.springframework.core.env.PropertySource;
import org.springframework.core.env.StandardEnvironment;

// 添加属性源
StandardEnvironment env = new StandardEnvironment();
Map<String, Object> map = new HashMap<>();
map.put("app.name", "MyApp");
env.getPropertySources().addFirst(new MapPropertySource("my-properties", map));

import org.springframework.context.ApplicationEventPublisher;

// 发布事件
ApplicationEventPublisher publisher = /* 获取发布器 */;
publisher.publishEvent(new CustomEvent("Something happened"));

import org.springframework.context.i18n.LocaleContextHolder;
import java.util.Locale;

// 获取/设置当前语言环境
Locale currentLocale = LocaleContextHolder.getLocale();
LocaleContextHolder.setLocale(Locale.FRENCH);

import org.springframework.aop.support.AopUtils;

// AOP工具方法
boolean isAopProxy = AopUtils.isAopProxy(bean);
boolean isCglibProxy = AopUtils.isCglibProxy(bean);
Class<?> targetClass = AopUtils.getTargetClass(bean);

import org.springframework.aop.framework.ProxyFactory;

// 创建代理
ProxyFactory factory = new ProxyFactory(targetObject);
factory.addInterface(MyInterface.class);
factory.addAdvice(new MyMethodInterceptor());
MyInterface proxy = (MyInterface) factory.getProxy();

import org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider;

// 扫描类路径
ClassPathScanningCandidateComponentProvider scanner = 
    new ClassPathScanningCandidateComponentProvider(true);
scanner.addIncludeFilter(new AnnotationTypeFilter(Component.class));
Set<BeanDefinition> beans = scanner.findCandidateComponents("org.example");

import org.springframework.beans.factory.config.YamlPropertiesFactoryBean;
import org.springframework.core.io.ClassPathResource;

// 解析YAML文件
YamlPropertiesFactoryBean yaml = new YamlPropertiesFactoryBean();
yaml.setResources(new ClassPathResource("application.yml"));
Properties properties = yaml.getObject();