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();